Deletes the Key

        Parameters:
            key (str): Key to delete
        Response:
            bool: ``True`` on success
17817
async def delete(self, key):
        
        response = await self._discard(key)
        return response.body is True
180121
async def delete(self, key):
        
        try:
            async with self._client.delete(self.path_keys(key)) as r:
                if r.status not in [204, 404]:
                    return False
                return True
        except ContentEncodingError:
            """ Not error really """
            return True
        except:
            raise
466973
def delete(self):
        
        return self.bucket.delete_key(self.name, version_id=self.version_id)
357606
def delete(self, key: str) -> None:
        
        if key in self._write_cache():
            self._write_cache()[key].delete()
            del self._write_cache()[key]

        if key in self._cache():
            del self._cache()[key]

        self._flush_external_cache()
930113
def delete(key, service=None, profile=None):  # pylint: disable=W0613
    '''
    
    '''
    client = _get_conn(profile)
    try:
        client.delete(key)
        return True
    except Exception:
        return False
391717
def destroy_ssh_key(self, ssh_key_id):
        
        json = self.request('/ssh_keys/%s/destroy' % ssh_key_id, method='GET')
        status = json.get('status')
        return status
243373
def delete( key )
        v = super( key )
        if String === v
            v = YAML.load( v )
        end
        v
    end
1294591
def delete(key)
      header = self[key]
      @headers.reject! { |header| header.key == key } ? header : nil
    end
149019
def delete(self, key):
        
        obj = self._get_content()
        obj.pop(key, None)

        self.write_data(self.path, obj)
1068939
def delete(self, key_id=None):
        
        url = self.bitbucket.url('DELETE_SSH_KEY', key_id=key_id)
        return self.bitbucket.dispatch('DELETE', url, auth=self.bitbucket.auth)
493402
def _pop(self, key, default=None):
        
        value = default
        if key in self:
            value = self[key]
            del self[key]
        return value
1118081
def delete(key)
      if exists?(key)
        value = value(key)
        data(key).delete
      end
      value
    end
730400
def delete(self, bucket: str, key: str):
        
        bucket_obj = self._ensure_bucket_loaded(bucket)
        try:
            bucket_obj.delete_blob(key)
        except NotFound:
            return False
847763
def remove(self, *keys):
        
        keys = list(map(self.get_key, keys))
        return self._client.delete(*keys)
991125
def removeSessionWithKey(self, key):
        
        self.store.query(
            PersistentSession,
            PersistentSession.sessionKey == key).deleteFromStore()
1257699
def delete(key)
      file = filename key
      File.delete file if File.exist? file
    end
1268455
def delete(self, key):
        
        if key in self.cache:
            self.cache.pop(key, None)