Deletes the named entry.
        :param name: the entry.
        :return: the deleted entry.
328822
def delete(self, name):
        
        i, entry = next(((i, x) for i, x in enumerate(self._uploadCache) if x['name'] == name), (None, None))
        if entry is not None:
            logger.info("Deleting " + name)
            os.remove(str(entry['path']))
            del self._uploadCache[i]
            return entry
        else:
            logger.info("Unable to delete " + name + ", not found")
            return None
714092
def remove_parameter(self, name):
		
		if name in self.__query:
			self.__query.pop(name)
178173
final public function delete($name) {

        if ( array_key_exists($name, $this->rpc_methods) ) {

            unset($this->rpc_methods[$name]);

            $this->logger->debug("Deleted method $name");

            return true;

        } else {

            $this->logger->warning("Cannot delete method $name: entry not found");

            return false;

        }

    }
364041
async def delete(self, *names):
        
        count = 0

        for arg in names:
            count += await self.execute_command('DEL', arg)

        return count
1358358
def delete_file(self, name):
        
        if self.local_store:
            lock = self.lock_manager.lock_for(name)
            lock.lock_exclusive()
            try:
                self.local_store.delete_file(name)
            finally:
                lock.close()
        if self.remote_store:
            self.remote_store.delete_file(name)
230307
def remove_cluster(self, name):
        
        cluster = self.get_cluster(name)
        clusters = self.get_clusters()
        clusters.remove(cluster)
1154173
def remove_user(self, name):
        
        user = self.get_user(name)
        users = self.get_users()
        users.remove(user)
738974
def RemoveKeywordsForName(self, name, keywords):
    
    data_store.DB.IndexRemoveKeywordsForName(self.urn, name, keywords)
519240
def remove(name: str) -> bool:
    
    db = TinyDB(corpus_db_path())
    temp = Query()
    data = db.search(temp.name == name)

    if len(data) > 0:
        path = get_corpus_path(name)
        os.remove(path)
        db.remove(temp.name == name)
        return True

    return False
493927
def storage_delete(self, name, timeout=10):
        
        result = Result(*self.perform_request(**{
            'method': 'DELETE',
            'url': '/storage/{0}.json'.format(name),
            'params': {
                'request_timeout': timeout
            }
        }))
        return result
51526
def delete_identity(self, identity):
        
        if isinstance(identity, zobjects.Identity):
            self.request(
                'DeleteIdentity', {'identity': identity.to_selector()})
        else:
            self.request('DeleteIdentity', {'identity': {'name': identity}})
1134349
protected void deleteRecursively(DirContext ctx, Name name) {

		NamingEnumeration enumeration = null;
		try {
			enumeration = ctx.listBindings(name);
			while (enumeration.hasMore()) {
				Binding binding = (Binding) enumeration.next();
				LdapName childName = LdapUtils.newLdapName(binding.getName());
				childName.addAll(0, name);
				deleteRecursively(ctx, childName);
			}
			ctx.unbind(name);
			if (LOG.isDebugEnabled()) {
				LOG.debug("Entry " + name + " deleted");
			}
		}
		catch (javax.naming.NamingException e) {
			throw LdapUtils.convertLdapException(e);
		}
		finally {
			try {
				enumeration.close();
			}
			catch (Exception e) {
				// Never mind this
			}
		}
	}
561231
def unregister_header(self, name):
        

        self._node.unregister_feature(
            "#".join([namespaces.xep0131_shim, name])
        )
927772
def remove_foreign_key(self, name):
        
        name = self._normalize_identifier(name)

        if not self.has_foreign_key(name):
            raise ForeignKeyDoesNotExist(name, self._name)

        del self._fk_constraints[name]
69199
def delete(self, name):
        
        try:
            result = self._uploadController.delete(name)
            return None, 200 if result is not None else 404
        except Exception as e:
            return str(e), 500
617417
def delete(self, name):
    '''
    
    '''
    # TODO: confirm that this does not use the combo index and determine
    # performance implications.
    num_deleted = 0
    for interval,config in self._intervals.items():
      # TODO: use write preference settings if we have them
      num_deleted += self._client[interval].remove( {'name':name} )['n']
    return num_deleted
394778
def delete_connection(self, name):
        
        name = quote(name, '')
        path = Client.urls['connections_by_name'] % name
        self._call(path, 'DELETE')
        return True