Unsubscribe the socket from the specified topic.

        :param topic: The topic to unsubscribe from.
490597
async def unsubscribe(self, topic):
        
        if self.socket_type not in {SUB, XSUB}:
            raise AssertionError(
                "A %s socket cannot unsubscribe." % self.socket_type.decode(),
            )

        # Do this **BEFORE** awaiting so that new connections created during
        # the execution below honor the setting.
        self._subscriptions.remove(topic)
        tasks = [
            asyncio.ensure_future(
                peer.connection.local_unsubscribe(topic),
                loop=self.loop,
            )
            for peer in self._peers
            if peer.connection
        ]

        if tasks:
            try:
                await asyncio.wait(tasks, loop=self.loop)
            finally:
                for task in tasks:
                    task.cancel()
923302
def unsubscribe(self, message, handler):
        '''
        
        '''
        with self._lock:
            self._subscribers[message].remove(WeakCallable(handler))
348183
def unbind(self):
        
        self.connected = False
        self.queue_manager.disconnect(self.connection)
        self.topic_manager.disconnect(self.connection)
934296
protected void sendSubscribe(String topic) {
    assert topic != null : "topic shouldn't be null";
    JsonObject msg = Json.createObject().set(TYPE, "register").set(TOPIC, topic);
    send(msg);
  }
591111
def remove_commented_topic(self, topic_id):
        
        return [self.remove_comment(topic_id, item['id']) for item in self.list_user_comments(topic_id)]
692202
def remove_topic(self, topic_id):
        
        comment_start = 0
        while comment_start is not None:
            comments = self.list_comments(topic_id, comment_start)
            for comment in comments['results']:
                self.remove_comment(topic_id, comment['id'])
            comment_start = comments['next_start']
        return self.api.req(API_GROUP_REMOVE_TOPIC % topic_id, params={'ck': self.api.ck()})
1340869
def unsubscribe_multi(self, topics):
        """"""
        if self.sock == NC.INVALID_SOCKET:
            return NC.ERR_NO_CONN
        
        self.logger.info("UNSUBSCRIBE: %s", ', '.join(topics))
        return self.send_unsubscribe(False, [utf8encode(topic) for topic in topics])
948714
public void unsubscribeFromTopic() {
        try {
            HttpGet request = new HttpGet(unsubscribeUrl.toURI());
            HttpResponse response = httpClient.execute(request);
            if (!ApacheUtils.isRequestSuccessful(response)) {
                throw new SdkClientException(String.format("Could not unsubscribe from %s: %d %s.%n%s",
                                                           getTopicArn(),
                                                           response.getStatusLine().getStatusCode(),
                                                           response.getStatusLine().getReasonPhrase(),
                                                           IOUtils.toString(response.getEntity().getContent())));
            }
        } catch (Exception e) {
            throw new SdkClientException(e);
        }

    }
133764
def unregister_subscriber(topic)
      code, message,val = @proxy.unregisterSubscriber(@caller_id,
                                                      topic,
                                                      @slave_uri)
      if code == 1
        return true
      elsif code == 0
        puts message
        return true
      else
        raise message
      end
    end
618981
def publish(self, topic, message):
        
        if not self.connections:
            raise NSQNoConnections()
        conn = random.choice(list(self.connections))
        conn.publish(topic, message)
959368
def unsubscribe(self, channel, *channels):
        
        conn = self._pool_or_conn
        return conn.execute_pubsub(b'UNSUBSCRIBE', channel, *channels)
127111
def post(self, request, *args, **kwargs):
        
        return self.unsubscribe(request, *args, **kwargs)
171111
def delete(options = {})
      options = options.merge(topic_arn: @arn)
      resp = @client.delete_topic(options)
      resp.data
    end
228284
void removeRegistrations(String topic) {
        Collection<Registration> all = registrations.remove(topic);
        if (all == null) {
            return;
        }
        for (Registration reg : all) {
            registrationIdMap.remove(reg.getId());
            pingNotifiableEventListener(topic, reg, false);
        }
    }
741696
def _unbind_topics(self, topics):
        

        self.client.unsubscribe(topics.status)
        self.client.unsubscribe(topics.tracing)
        self.client.unsubscribe(topics.streaming)
        self.client.unsubscribe(topics.response)
1076703
def topic(self, channel, topic=None):
        
        with self.lock:
            self.is_in_channel(channel)

            if topic:
                self.send('TOPIC %s :%s' % (channel, topic))
                if self.readable():
                    msg = self._recv(expected_replies=('TOPIC',))
                    if msg[0] == 'TOPIC' and self.hide_called_events:
                        channel = msg[1]
                        self.channels[channel]['TOPIC'] = \
                        msg[2].replace(':', '', 1)
                        if not self.hide_called_events:
                            self.stepback()
            else:
                topic = ''
                set_by = ''
                time_set = ''
                self.send('TOPIC %s' % channel)
                while self.readable():
                    msg = self._recv(expected_replies=('332', '333', '331'))
                    if msg[0] == '332':
                        topic = msg[2].split(':', 1)[1]
                    elif msg[0] == '333':
                        set_by, time_set = msg[2].split()[1:]
                        if self.UTC == False:
                            time_set = self._m_time.localtime(int(time_set))
                        else:
                            time_set = self._m_time.gmtime(int(time_set))
                        set_by = self._from_(set_by)
                    elif msg[0] == '331':
                        topic = ''

                return topic, set_by, time_set
520649
protected void removeSubscription(SIBUuid12 topicSpace,
                                    String topic)
  {
    // Generate a key for the topicSpace/topic
    final String key = BusGroup.subscriptionKey(topicSpace, topic);

    iProxies.remove(key);
  }