Remove a collector.

 @param collector_class [Array, Class]

 @raise [ArgumentError] if `collector_class' is not a Class or if this collector is not registered.
176506
def remove_collector(collector_class)
      return collector_class.each { |c| remove_collector(c) } if collector_class.is_a? Array

      raise ArgumentError, "`collector_class' must be a class" unless collector_class.is_a? Class
      raise ArgumentError, "No collector found with class \“#{collector_class}\"" unless @collectors[collector_class]

      @collectors.delete(collector_class)

      sort_collectors!
    end
67535
def delete(
        collection_name, spec, safe, last_error_args, opts, flags=0, ctx=None):
    
    if ctx:
        return _delete_compressed(collection_name, spec, opts, flags, ctx)
    return _delete_uncompressed(
        collection_name, spec, safe, last_error_args, opts, flags)
78254
def remove(self, db):
        
        assert self.collection
        assert self.id

        db[self.collection].remove(self.id)
1094805
def add_collector(collector_class)
      return collector_class.each { |c| add_collector(c) } if collector_class.is_a? Array


      raise ArgumentError, "`collector_class' must be a class" unless collector_class.is_a? Class

      unless collector_class.included_modules.include?(Rack::WebProfiler::Collector::DSL)
        raise ArgumentError, "#{collector_class.class.name} must be an instance of \"Rack::WebProfiler::Collector::DSL\""
      end

      definition = collector_class.definition

      if definition_by_identifier(definition.identifier)
        raise ArgumentError, "A collector with identifier \“#{definition.identifier}\" already exists"
      end

      return false unless definition.is_enabled?

      @collectors[collector_class] = definition

      sort_collectors!
    end
904957
def get_versioned_delete_collector_class():
    
    key = 'VERSIONED_DELETE_COLLECTOR'
    try:
        cls = _cache[key]
    except KeyError:
        collector_class_string = getattr(settings, key)
        cls = import_from_string(collector_class_string, key)
        _cache[key] = cls
    return cls
127827
def removeClass(self, *classes: str) -> None:
        """"""
        _remove_cl = []
        for class_ in classes:
            if class_ not in self.classList:
                if class_ in self.get_class_list():
                    logger.warning(
                        'tried to remove class-level class: '
                        '{}'.format(class_)
                    )
                else:
                    logger.warning(
                        'tried to remove non-existing class: {}'.format(class_)
                    )
            else:
                _remove_cl.append(class_)
        self.classList.remove(*_remove_cl)
1150219
def _delete(collection_name, spec, opts, flags):
    """"""
    encoded = _dict_to_bson(spec, False, opts)  # Uses extensions.
    return b"".join([
        _ZERO_32,
        _make_c_string(collection_name),
        _pack_int(flags),
        encoded]), len(encoded)
99806
def clear_collection(self, *classes):
		''' '''
		for c in classes:
			self.queue.append(ClearCollectionOp(self.transaction_id, self, c))
		if self.autoflush:
			self.flush()
368066
def RemoveClass(self, class_name):
    
    if class_name not in self._class_mapping:
      raise problems.NonexistentMapping(class_name)
    del self._class_mapping[class_name]
981463
def delete_filter(filter_class)
      index = @filters.index { |f| f.class.name == filter_class.name }
      @filters.delete_at(index) if index
    end
701176
def stop_class(self, class_):
        ""
        matches = filter(lambda svc: isinstance(svc, class_), self)
        map(self.stop, matches)
879055
def remove(cls, name):
        

        client = Client.instance()

        new_current_database = None

        if client.database != name:
            new_current_database = name

        # Deletions are only possible from the system database
        client.set_database(name=SYSTEM_DATABASE)

        api = client.api
        api.database(name).delete()

        if new_current_database:
            client.set_database(name=new_current_database)
1316197
def delete(v)
      return unless include? v
      raise ArgumentError, "Item is protected and cannot be deleted" if protected? index(v)
      @list.delete v
    end
1284057
def remove_by_id(class_name, *ids)
      ids.flatten!
      @connection.delete_by_id(
        ids.map { |id| Adapters::InstanceAdapter.index_id_for(class_name, id) }
      )
    end
397466
def unregister(self, filter_name):
        
        if filter_name in self.filter_list:
            self.filter_list.pop(filter_name)
725144
def remove(self, resource, **kwargs):
        
        log.info(
            "Removing {} '{}'...".format(self._model_name, resource.name))
        resource.remove(**kwargs)
        self._ids.remove(resource.id)
89603
def remove_class(rem_class)
      @modules.each do |m|
        if m.name == rem_class.name
          m.classes.delete(rem_class)
          break
        end
      end
    end