Disconnect links connected to the cell `model`.
975513
function(model, opt) {

        this.getConnectedLinks(model).forEach(function(link) {

            link.set((link.source().id === model.id ? 'source' : 'target'), { x: 0, y: 0 }, opt);
        });
    }
849536
def disconnect():
    
    post_save.disconnect(node_created_handler, sender=Node)
    node_status_changed.disconnect(node_status_changed_handler)
    pre_delete.disconnect(node_deleted_handler, sender=Node)
351360
def disconnect(self):
        """"""

        # when __del__() is invoked in response to a module being deleted,
        # e.g., when execution of the program is done, other globals referenced
        # by the __del__() method may already have been deleted.
        # this causes CardConnection.disconnect to except with a TypeError
        try:
            CardConnection.disconnect(self)
        except TypeError:
            pass
        if None != self.hcard:
            hresult = SCardDisconnect(self.hcard, self.disposition)
            if hresult != 0:
                raise CardConnectionException(
                    'Failed to disconnect: ' + \
                    SCardGetErrorMessage(hresult))
            self.hcard = None
697617
def unconnect(self, *funcs):
        """"""
        for func in funcs:
            for callbacks in self._callbacks.values():
                if func in callbacks:
                    callbacks.remove(func)
1345842
void disconnectInvalidVertices() {
		// add elements with 1 or 2 edges
		openVertexes.clear();
		for (int idxVert = 0; idxVert < vertexes.size; idxVert++) {
			Vertex n = vertexes.get(idxVert);
			if( n.connections.size() == 1 || n.connections.size()==2) {
				openVertexes.add(n);
			}
		}

		// continue until there are no changes
		while( !openVertexes.isEmpty() ) {
			dirtyVertexes.clear();
			for (int idxVert = 0; idxVert < openVertexes.size(); idxVert++) {
				boolean remove = false;
				Vertex n = openVertexes.get(idxVert);
				if( n.connections.size() == 1 ) {
					remove = true;
				} else if( n.connections.size() == 2 ) {
					Edge ea = n.connections.get(0);
					Edge eb = n.connections.get(1);

					// Look for a common vertex that isn't 'n'
					remove = true;
					for (int i = 0; i < ea.dst.connections.size(); i++) {
						Vertex va = ea.dst.connections.get(i).dst;
						if( va == n )
							continue;
						for (int j = 0; j < eb.dst.connections.size(); j++) {
							Vertex vb = ea.dst.connections.get(j).dst;
							if( va == vb ) {
								remove = false;
								break;
							}
						}
					}
				}

				if( remove ) {
					// only go through the subset referenced the disconnected. Yes there could be duplicates
					// not worth the time to fix that
					for (int i = 0; i < n.connections.size(); i++) {
						dirtyVertexes.add( n.connections.get(i).dst );
					}
					removeReferences(n,EdgeType.CONNECTION);
				}
			}
			openVertexes.clear();
			openVertexes.addAll(dirtyVertexes);
		}

	}
815672
def disconnect(self):
        """"""
        try:
            self._link.disconnect()
            self._protocol = None
            self._invalidate_cached_registers()
        except DAPAccess.Error as exc:
            six.raise_from(self._convert_exception(exc), exc)
1085478
function disconnect(cb) {
  if (connection) {
    log.logger.debug('Mongoose disconnected');
    connection.close(cb);
  } else {
    cb();
  }
}
1243770
def disconnect(self):
        """"""
        for signal, kwargs in self.connections:
            signal.disconnect(self, **kwargs)
644007
def disconnect(self):
        """"""

        if not self.connected:
            return
        self.connected = False

        self.connection.disconnect()

        if self._heartbeat_loop:
            self._heartbeat_loop.kill()
        self._recv_loop.kill()

        self._reset_attributes()

        self.emit(self.EVENT_DISCONNECTED)
131588
def disconnect(self):
        
        all_conns = chain(
            self._available_connections.values(),
            self._in_use_connections.values(),
        )

        for node_connections in all_conns:
            for connection in node_connections:
                connection.disconnect()
858917
async def drop_model_tables(models, **drop_table_kwargs):
    """"""
    for m in reversed(sort_models_topologically(models)):
        await m.drop_table(**drop_table_kwargs)
910152
def _cleanupConnections(senderkey, signal):
    """"""
    try:
        receivers = connections[senderkey][signal]
    except:
        pass
    else:
        if not receivers:
            # No more connected receivers. Therefore, remove the signal.
            try:
                signals = connections[senderkey]
            except KeyError:
                pass
            else:
                del signals[signal]
                if not signals:
                    # No more signal connections. Therefore, remove the sender.
                    _removeSender(senderkey)
575324
def disconnect(self, slot):
        """"""
        if self.is_connected(slot):
            self.slots.remove(slot)
276891
def disconnect(self):
        """"""

        if not self.connected:
            raise HardwareError("Cannot disconnect when we are not connected")

        # Close the streaming and tracing interfaces when we disconnect
        self._reports = None
        self._traces = None

        self._loop.run_coroutine(self.adapter.disconnect(0))
        self.connected = False
        self.connection_interrupted = False
        self.connection_string = None
821383
def disconnect_from(network)
      connection = @connections.delete connection_to(network)
      connection.tap(&:stop).tap(&:join) unless connection.nil?
    end
674503
def unlink(self, subj=None, predicate=None):
        
        self.graph.remove((subj, predicate, self.asNode()))
418791
def unbind(cell1, transform, moduleDimensions):
  
  cell1Coords = np.unravel_index(cell1, moduleDimensions)
  transformCoords = np.unravel_index(transform, moduleDimensions)
  cell2Coords = [(t + c1) % m
                 for c1, t, m in itertools.izip(cell1Coords, transformCoords,
                                                moduleDimensions)]
  return np.ravel_multi_index(cell2Coords, moduleDimensions)