Deletes the document at the specified URI from the store

 @param document_uri [String] the URI of the document to delete.
 relative to the collection specified on initialization otherwise '/db'.
 @return [HTTParty::Response] the response object
554778
def delete(document_uri)
			validate_uri(document_uri)
			res = HTTParty.delete(document_uri, @default_opts)
			res.success? ? res : handle_error(res)
		end
83174
def delete(path)
      uri = build_uri(path)

      request = Net::HTTP::Delete.new(uri.request_uri)
      set_authorisation_header(request)

      response = https_client(uri).request(request)
    end
74490
def get_document(self, doc_uri):
        
        return self._docs.get(doc_uri) or self._create_document(doc_uri)
245707
def delete(self, method, uri, params=None, data=None, headers=None, auth=None, timeout=None,
               allow_redirects=False):
        
        response = self.request(
            method,
            uri,
            params=params,
            data=data,
            headers=headers,
            auth=auth,
            timeout=timeout,
            allow_redirects=allow_redirects,
        )

        if response.status_code < 200 or response.status_code >= 300:
            raise self.exception(method, uri, response, 'Unable to delete record')

        return response.status_code == 204
1196668
def delete(self, uri):
        
        try:
            self.connect(uri, method='DELETE')
            return True
        except urllib.error.HTTPError:
            return False
107001
def delete_many(self, uris):
        
        deleted_nodes = {}

        for uri in uris:
            node = self.delete(uri)
            if node:
                deleted_nodes[uri] = node

        return deleted_nodes
407843
function DELETE(uri, params) {
	const requestURL = `${uri}${url.format({ query: params })}`;
  log(`request URL: ${requestURL}`);

	return fetch(requestURL, { method: 'DELETE', compress: compress })
    .then(function handleRequest(res) {
      const statusText = res.statusText;
			const status = res.status;
			if (status != 200) {
				const error = new Error(`Request failed: ${statusText}`);
				error.status = status;
				throw error;
			}
			return res.json();
		})
		.catch(error => {
			log(`error: ${error}`);
			throw error;
		});
}
979420
def delete_many(cls, documents):
        """"""

        # Ensure all documents have been converted to frames
        frames = cls._ensure_frames(documents)

        all_count = len(documents)
        assert len([f for f in frames if '_id' in f._document]) == all_count, \
                "Can't delete documents without `_id`s"

        # Send delete signal
        signal('delete').send(cls, frames=frames)

        # Prepare the documents to be deleted
        ids = [f._id for f in frames]

        # Delete the documents
        cls.get_collection().delete_many({'_id': {'$in': ids}})

        # Send deleted signal
        signal('deleted').send(cls, frames=frames)
497864
def blob_delete(table, digest)
      uri = blob_path(table, digest)
      @logger.debug("BLOB DELETE #{uri}")
      req = Net::HTTP::Delete.new(uri, headers)
      response = request(req)
      case response.code
      when '200'
        true
      else
        @logger.info("Response #{response.code}: #{response.body}")
        false
      end
    end
260290
def put(document_uri, document)
			validate_uri(document_uri)
			res = put_document(document_uri, document, "application/xml")
			res.success? ? res : handle_error(res)
		end
599199
def get_document(user_name, intra_hash, file_name)
      response = @conn.get get_document_href(user_name, intra_hash, file_name)
      if response.status == 200
        return [response.body, response.headers['content-type']]
      end
      return nil, nil
    end
623559
def delete(uri)
      headers = { 'Content-Type' => 'application/json' }
      res = Excon.delete(@base_url + uri.to_s,
                         headers: headers,
                         user: username,
                         password: password,
                         ssl_verify_peer: false)
      api_response res
    end
1288765
public DeleteDocumentResponse deleteDocument(String documentId) {
        DeleteDocumentRequest request = new DeleteDocumentRequest();
        request.setDocumentId(documentId);
        return this.deleteDocument(request);
    }
154008
def DeleteItem(self, document_link, options=None):
        
        if options is None:
            options = {}

        path = base.GetPathFromLink(document_link)
        document_id = base.GetResourceIdOrFullNameFromLink(document_link)
        return self.DeleteResource(path,
                                   'docs',
                                   document_id,
                                   None,
                                   options)
1231955
def delete(self, uri, query=None, **kwargs):
        """"""
        return self.fetch('delete', uri, query, **kwargs)
745242
def delete(self, uri_relative, custom_headers):
        

        return self._request(
            self._METHOD_DELETE,
            uri_relative,
            self._BYTES_EMPTY,
            {},
            custom_headers
        )
865935
protected function doStoreDocument($method, $uri, $urlParameters, Document $document)
    {
        $request = $this->requestHandler->createRequest(
            $method,
            $uri,
            $urlParameters,
            $this->documentDataSerializer->serializeDocumentData($document->getData())
        );
        $this->requestHandler->executeRequest($request, array(204));
    }