*Function
Unsubscribe from a node.

Parameters:
(String) node       - The name of the pubsub node.
(Function) success  - callback function for successful node creation.
(Function) error    - error callback function.
497782
function(node, jid, subid, success, error) {
        var that = this._connection;
        var iqid = that.getUniqueId("pubsubunsubscribenode");

        var iq = $iq({from:this.jid, to:this.service, type:'set', id:iqid})
          .c('pubsub', { xmlns:Strophe.NS.PUBSUB })
          .c('unsubscribe', {'node':node, 'jid':jid});
        if (subid) iq.attrs({subid:subid});

        that.sendIQ(iq.tree(), success, error);
        this.removeHandler(node);
        return iqid;
    }
667598
def unsubscribe_from_hub(self, event, callback):
        
        return self._hub("unsubscribe", event, callback, github.GithubObject.NotSet)
1347162
public void clientUnsubscribedFromNode (int cloid)
    {
        _suboids.remove(cloid);
        for (LockHandler handler : _locks.values().toArray(new LockHandler[_locks.size()])) {
            if (Objects.equal(handler.getNodeName(), _nodeName)) {
                handler.clientUnsubscribed(cloid);
            }
        }
    }
959368
def unsubscribe(self, channel, *channels):
        
        conn = self._pool_or_conn
        return conn.execute_pubsub(b'UNSUBSCRIBE', channel, *channels)
954927
def remove(self, node):
        
        if node is None or node._prev == -1:
            return
        if node._next is None:
            self._last = node._prev  # last node
        else:
            node._next._prev = node._prev
        if node._prev is None:
            self._first = node._next  # first node
        else:
            node._prev._next = node._next
        node._prev = node._next = -1
        self._size -= 1
522515
function unsubscribeRecursively( self, node, parts, subscriber ) {
   if( parts.length === 0 && Array.isArray( node[ SUBSCRIBER_FIELD ] ) ) {
      const subscribers = node[ SUBSCRIBER_FIELD ];
      for( let i = subscribers.length - 1; i >= 0; --i ) {
         if( subscribers[ i ].subscriber === subscriber ) {
            notifyInspectors( self, {
               action: 'unsubscribe',
               source: subscribers[ i ].subscriberName,
               target: '-',
               event: subscribers[ i ].name,
               cycleId: self.currentCycle_
            } );
            subscribers.splice( i, 1 );
         }
      }
   }

   const [ part, ...rest ] = parts;
   const searchPart = part || WILDCARD;
   if( searchPart in node ) {
      unsubscribeRecursively( self, node[ searchPart ], rest, subscriber );
   }
}
1320757
def unsubscribe(self, *args):
        
        if args:
            args = list_or_args(args[0], args[1:])
            channels = self._normalize_keys(dict.fromkeys(args))
        else:
            channels = self.channels
        self.pending_unsubscribe_channels.update(channels)
        return self.execute_command('UNSUBSCRIBE', *args)
309071
def disconnect(self, node):
        
        rel = _rel_helper(lhs='a', rhs='b', ident='r', **self.definition)
        q = "MATCH (a), (b) WHERE id(a)={self} and id(b)={them} " \
            "MATCH " + rel + " DELETE r"
        self.source.cypher(q, {'them': node.id})
1169540
function (node, callback) {
			// important note!
			// starts paused
			//
			var bHandle = on(node.ownerDocument.documentElement, 'click', function (e) {
				var target = e.target;
				if (target.nodeType !== 1) {
					target = target.parentNode;
				}
				if (target && !node.contains(target)) {
					callback(e);
				}
			});

			var handle = {
				state: 'resumed',
				resume: function () {
					setTimeout(function () {
						bHandle.resume();
					}, 100);
					this.state = 'resumed';
				},
				pause: function () {
					bHandle.pause();
					this.state = 'paused';
				},
				remove: function () {
					bHandle.remove();
					this.state = 'removed';
				}
			};
			handle.pause();

			return handle;
		}
494018
def unsubscribe(self, subscription):
        
        params = {'ContentType' : 'JSON',
                  'SubscriptionArn' : subscription}
        response = self.make_request('Unsubscribe', params, '/', 'GET')
        body = response.read()
        if response.status == 200:
            return json.loads(body)
        else:
            boto.log.error('%s %s' % (response.status, response.reason))
            boto.log.error('%s' % body)
            raise self.ResponseError(response.status, response.reason, body)
824101
def remove_node(self, node):
        
        try:
            self._nodes.remove(node)
            del self._weights[node]
        except (KeyError, ValueError):
            pass
        self._hashring = dict()
        self._sorted_keys = []

        self._build_circle()
638170
function unsubscribeError(message, exceptionMessage, exceptionType) {
		reply(proto.writeUnsubscribeException(
			message.id, exceptionMessage, exceptionType));
		dequeueSubUnsubRequest(message.itemName);
		fireFirstSubUnsubEvent(message.itemName);
	}
1103888
function unsubscribe(handler) {
        for (var i = handlers.length - 1; i >= 0; --i) {
            if (handlers[i] === handler) {
                handlers.splice(i, 1);
            }
        }

        if (handlers.length === 0) {
            window.onerror = _oldOnerrorHandler;
            _onErrorHandlerInstalled = false;
        }
    }
1180213
def handle_unsubscribe(self, request):
        # type: (Unsubscribe) -> CallbackResponses
        """"""
        subscribe = self._subscription_keys.pop(request.generate_key())
        ret = self._tree.handle_unsubscribe(subscribe, subscribe.path[1:])
        return ret
617942
def prune_node(self, node, remove_backrefs=False):
        
        if not remove_backrefs:
            for fro, connections in self.edges.items():
                if node in self.edges[fro]:
                    raise ValueError("""Attempting to remove a node with
                                     backrefs. You may consider setting
                                     `remove_backrefs` to true.""")

        # OK. Otherwise, let's do our removal.

        self.nodes.remove(node)
        if node in self.edges:
            # Remove add edges from this node if we're pruning it.
            self.edges.pop(node)

        for fro, connections in self.edges.items():
            # Remove any links to this node (if they exist)
            if node in self.edges[fro]:
                # If we should remove backrefs:
                self.edges[fro].remove(node)
782786
def delete(val = nil, &block)
      if val.respond_to?(:to_node)
        node = val.to_node
        __unlink_node(node)
        return node.data
      end

      each_node.find(&__to_matcher(val, &block)).tap do |node_to_delete|
        return unless node_to_delete
        __unlink_node(node_to_delete)
      end.data
    end
945486
function(node, success, error, timeout) {
        //ask for all items
        var iq = $iq({from:this.jid, to:this.service, type:'get'})
          .c('pubsub', { xmlns:Strophe.NS.PUBSUB })
          .c('items', {node:node});

        return this._connection.sendIQ(iq.tree(), success, error, timeout);
    }