Remove an object identified by the given ``obj_id`` (and
        optionally ``obj_type``) from the search index.

        :param obj_id: The object's unique identifier.
        :param obj_type: The object's type.
338810
def remove(self, obj_id, obj_type=None):
        
        if not self.exists(obj_id, obj_type):
            raise KeyError('Object not found.')

        combined_id = self.object_key(obj_id, obj_type)
        title = self._title_data[combined_id]

        for word in self.tokenize_title(title):
            for substring in self.substrings(word):
                key = self.word_key(substring)
                if not self.database.zrange(key, 1, 2):
                    self.database.delete(key)
                else:
                    self.database.zrem(key, combined_id)

        del self._data[combined_id]
        del self._title_data[combined_id]
        del self._boosts[combined_id]
174629
def delete_obj_by_id(id)
      if (pos = find_obj_addr_by_id(id))
        delete_obj_by_address(pos, id)
        return true
      end

      return false
    end
1214582
def delete_object!(objectID, request_options = {})
      res = delete_object(objectID, request_options)
      wait_task(res['taskID'], WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY, request_options)
      res
    end
534241
def delete(self, id):
        
        url = self._url('%s' % (id))
        return self.client.delete(url)
127165
def remove_object(self, obj):
        """"""
        obj_id = self.generate_id(obj)
        es_obj = self.document_class.get(obj_id, ignore=[404])
        # Object may not exist in this index.
        if es_obj:
            es_obj.delete(refresh=True)
545875
def container_remove_objects(object_id, input_params={}, always_retry=False, **kwargs):
    
    return DXHTTPRequest('/%s/removeObjects' % object_id, input_params, always_retry=always_retry, **kwargs)
720251
def delete_model(self, model_or_type, id_=None):
    
    if not id_:
      constraints = get_model_id_constraints(model_or_type)
    else:
      constraints = get_id_constraints(model_or_type.primary_key_name, id_)
    self.delete(model_or_type.table_name, constraints)

    return model_or_type
956433
def clear(self, obj):
        
        self.proxy_for(obj).restore_original_object()
        del self._proxies[id(obj)]
594628
def delete(self, obj, id):
        
        self.url = '{}{}/{}'.format(self.base_url, obj, id)
        self.method = 'DELETE'
        self.resp = requests.delete(url=self.url,
                                    auth=self.auth,
                                    headers=self.headers, cert=self.ca_cert)
        return self.__process_resp__(obj)
626552
def delete(self, obj):
        """"""
        del_id = obj.get_id()
        if not del_id:
            return

        cur = self._conn().cursor()

        tabname = obj.__class__.get_table_name()
        query = 'delete from {0} where id = %s;'.format(tabname)

        with self._conn() as conn:
            with conn.cursor() as cur:
                cur.execute(query, (del_id,))
223802
def delete(self, index, doc_type, id, bulk=False, **query_params):
        
        if bulk:
            cmd = {"delete": {"_index": index, "_type": doc_type,
                              "_id": id}}
            self.bulker.add(json.dumps(cmd, cls=self.encoder))
            return self.flush_bulk()

        path = make_path(index, doc_type, id)
        return self._send_request('DELETE', path, params=query_params)
174405
def delete(self):
        
        with rconnect() as conn:
            # Can't delete an object without an ID.
            if self.id is None:
                raise FrinkError("You can't delete an object with no ID")
            else:
                if isinstance(self.id, uuid.UUID):
                    self.id = str(self.id)

                try:
                    query = r.db(
                        self._db
                    ).table(
                        self._table
                    ).get(
                        self.id
                    ).delete()
                    log.debug(query)
                    rv = query.run(conn)
                except Exception as e:
                    log.warn(e)
                    raise
                else:
                    return True
1287501
def delete(self, id):
        
        id = self.key_name(id)
        self.redis.delete(id)
1366246
def remove_prefix(self, id):
        

        try:
            p = Prefix.get(int(id))
            p.remove()

        except NipapError, e:
            return json.dumps({'error': 1, 'message': e.args, 'type': type(e).__name__})

        return json.dumps(p, cls=NipapJSONEncoder)
916578
protected synchronized void remove(Object id) {
        // final String methodName = "remove(Object)";
        if (id == null) {
            return;
        }
        this.explicitBuffer.remove(id);
        this.scanBuffer.remove(id);
        // this.garbageCollectorBuffer.remove(id);
        // if (id instanceof HTODDynacache.EvictionTableEntry)
        // cod.htod.evictionEntryPool.add(id);

        // traceDebug(methodName, "id=" + id);
    }
686507
private void removeObjectId(int dtx, int dty)
    {
        final int tw = transformable.getWidth() / map.getTileWidth();
        final int th = transformable.getHeight() / map.getTileHeight();
        for (int tx = dtx; tx < dtx + tw; tx++)
        {
            for (int ty = dty; ty < dty + th; ty++)
            {
                if (mapPath.getObjectsId(tx, ty).contains(id))
                {
                    mapPath.removeObjectId(tx, ty, id);
                }
            }
        }
    }
646757
def delete_resource(self, session, data, api_type, obj_id):
        
        resource = self._fetch_resource(session, api_type, obj_id,
                                        Permissions.VIEW)
        self._check_instance_relationships_for_delete(resource)

        session.delete(resource)
        session.commit()

        response = JSONAPIResponse()
        response.status_code = 204

        return response