Unregisters a given source with this server. If the given source is a
        remote source, then its local copy will be removed from disk.

        Raises:
            KeyError: if the given source is not registered with this server.
769716
def remove(self, source: Source) -> None:
        
        self.unload(source)
        if isinstance(source, RemoteSource):
            shutil.rmtree(source.location, ignore_errors=True)
        self.save()
1116427
def unregister(self, obj=None):
        
        if obj is None:
            self.__databases.clear()
            self.__schemas.clear()
        elif isinstance(obj, orb.Schema):
            self.__schemas.pop(obj.name(), None)
        elif isinstance(obj, orb.Database):
            if obj == self.__current_db:
                self.__current_db = None
            self.__databases.pop(obj.name(), None)
        else:
            self.__current_db = None
            self.__schemas.pop(obj, None)
            self.__databases.pop(obj, None)
307139
def unregister_file(path, pkg=None, conn=None):  # pylint: disable=W0612
    '''
    
    '''
    close = False
    if conn is None:
        close = True
        conn = init()

    conn.execute('DELETE FROM files WHERE path=?', (path, ))
    if close:
        conn.close()
665156
def unregisterSds(self, sdsObj):
        
        self.conn.connection._check_login()
        response = self.conn.connection._do_post("{}/{}{}/{}".format(self.conn.connection._api_url, "instances/Sds::", sdsObj.id, 'action/removeSds'))    
        return response
325703
def delete(self, uuid):
        # type: (UUID) -> None
        
        dest = self.abs_path(uuid)
        if not dest.exists():
            raise KeyError("No file can be found for this uuid", uuid)

        dest.unlink()
1225958
private static void unregister(ObjectName objectName) {
    MBeanServer server = ManagementFactory.getPlatformMBeanServer();
    try {
      for (ObjectName name : server.queryNames(objectName, null)) {
        server.unregisterMBean(name);
      }
    } catch (MBeanRegistrationException | InstanceNotFoundException e) {
      throw new CacheException("Error unregistering " + objectName, e);
    }
  }
1133831
def unregister(self, token_to_remove):
        
        for i, (_, token, _) in enumerate(self._filter_order):
            if token == token_to_remove:
                break
        else:
            raise ValueError("unregistered token: {!r}".format(
                token_to_remove))
        del self._filter_order[i]
678545
function unregister (o) {
    _chain = _chain.filter(function(a) {
      return !(a.key in o);
    });

    for(var key in o)
      delete _keysIndex[key];
  }
573134
def unpublish(self, daap_server):
        

        if daap_server not in self.daap_servers:
            return

        self.zeroconf.unregister_service(self.daap_servers[daap_server])

        del self.daap_servers[daap_server]
204559
def __unregister_services(self):
        
        # Copy the services list, as it will be modified during the process
        with self.__registration_lock:
            registered_services = self.__registered_services.copy()

        for registration in registered_services:
            try:
                registration.unregister()
            except BundleException:
                # Ignore errors at this level
                pass

        if self.__registered_services:
            _logger.warning("Not all services have been unregistered...")

        with self.__registration_lock:
            # Clear the list, just to be clean
            self.__registered_services.clear()
1291884
def unregister(self, model_or_iterable):
        
        if isinstance(model_or_iterable, ModelBase):
            model_or_iterable = [model_or_iterable]
        for model in model_or_iterable:
            if model not in self._registry:
                raise NotModerated("The model '%s' is not currently being moderated" % model._meta.module_name)
            del self._registry[model]
397466
def unregister(self, filter_name):
        
        if filter_name in self.filter_list:
            self.filter_list.pop(filter_name)
888686
def unregister(self, command):
        
        if command not in self._commands.keys():
            self.log.warning("Can not unregister command %s" % command)
        else:
            # Click does not have any kind of a function to unregister/remove/deactivate already added commands.
            # So we need to delete the related objects manually from the click internal commands dictionary for
            # our root command.
            del(self._click_root_command.commands[command])
            # Finally lets delete the command from our internal dictionary too.
            del(self._commands[command])
            self.log.debug("Command %s got unregistered" % command)
667422
def unload(self, source: Source) -> None:
        
        logger.info('unloading source: %s', source.name)
        try:
            contents = self.contents(source)
            del self.__contents[source.name]
            del self.__sources[source.name]

            for name in contents.bugs:
                bug = self.__installation.bugs[name]
                self.__installation.bugs.remove(bug)
            for name in contents.blueprints:
                blueprint = self.__installation.build[name]
                self.__installation.build.remove(blueprint)
            for name in contents.tools:
                tool = self.__installation.tools[name]
                self.__installation.tools.remove(tool)
        except KeyError:
            pass
        logger.info('unloaded source: %s', source.name)
102051
def remove_source(self, source):
        
        geocode_service = self._get_service_by_name(source[0])
        self._sources.remove(geocode_service(**source[1]))
1126225
def unregister(self, event):
        
        if self.running:
            raise RuntimeError("Can't unregister while running")
        self._handlers.pop(event, None)
1052454
function unregister() {
  let list = [];

  // removes module and all its children from the node's require cache
  let unload = (id) => {
    let module = require.cache[id];

    if (!module) return;

    module.children.forEach((child) => unload(child.id));
    delete require.cache[id];
    list.push(id);
  };

  let sourceMapSupport = require.resolve('source-map-support');

  Object.keys(require.cache).forEach((key) => {
    if (path.extname(key) === VUE_EXT || key === sourceMapSupport) {
      unload(key);
    }
  });

  if (has(require.extensions, VUE_EXT)) {
    delete require.extensions[VUE_EXT];
  }

  if (has(Error, 'prepareStackTrace')) {
    delete Error.prepareStackTrace;
  }

  sourceMapsCache.clear();

  return list;
}