requests.delete

Here are the examples of the python api requests.delete taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

182 Examples 7

Example 1

Project: bunt Source File: apiai.py
    def _remove_intent_byid(self, entity_id):
        logging.debug('[ApiAi] remove_intent_byid: id={id}'.format(id=entity_id))

        r = requests.delete(
            '{url}intents/{id}'.format(url=self._base_url, id=entity_id),
            headers=self._headers,
        )

        result = r.json()

        if r.status_code != 200:
            raise ApiAiException(result['status'])

Example 2

Project: craftar-python Source File: _common.py
Function: delete_object
def _delete_object(api_key, object_type, uuid):
    "Update a single object"
    _validate(object_type=object_type, uuid=uuid)
    response = requests.delete(
        url=_get_url(api_key, object_type, uuid),
    )
    _validate_response(response)
    return (response.status_code == 204)

Example 3

Project: estester Source File: __init__.py
Function: delete_index
    def delete_index(self):
        """
        Deletes test index. Uses class attribute:
            index: name of the index to be deleted
        """
        url = "{0}{1}/".format(self.host, self.index)
        requests.delete(url, proxies=self.proxies)

Example 4

Project: HaoGist Source File: api.py
Function: delete
    def delete(self, url):
        try:
            self.res = requests.delete(url, headers=self.headers, proxies=self.proxies)
        except requests.exceptions.RequestException as e:
            if self.settings["debug_mode"]:
                print ("requests request exception: " + str(e))
            return
        return self.res

Example 5

Project: Kippt-for-Python Source File: clips.py
Function: delete
    def delete(self):
        """ Delete a clip.

        """
        r = requests.delete(
            "https://kippt.com/api/clips/%s" (self.id),
            headers=self.kippt.header
        )
        return (r.json())

Example 6

Project: pygerrit Source File: __init__.py
Function: delete
    def delete(self, endpoint, **kwargs):
        """ Send HTTP DELETE to the endpoint.

        :arg str endpoint: The endpoint to send to.

        :returns:
            JSON decoded result.

        :raises:
            requests.RequestException on timeout or connection error.

        """
        kwargs.update(self.kwargs.copy())
        response = requests.delete(self.make_url(endpoint), **kwargs)
        return _decode_response(response)

Example 7

Project: python-consul Source File: conftest.py
@pytest.yield_fixture
def consul_port(consul_instance):
    yield consul_instance
    # remove all data from the instance, to have a clean start
    base_uri = 'http://127.0.0.1:%s/v1/' % consul_instance
    requests.delete(base_uri + 'kv/?recurse=1')

Example 8

Project: threatshell Source File: passivetotal.py
    def rm_tags(self, params):
        resp = requests.delete(
            self.action_tags,
            auth=self.auth,
            headers=self.post_headers,
            data=json.dumps(params)
        )

        if resp.status_code != requests.codes.ok:
            return self._error(
                "DELETE",
                self.action_tags,
                resp.status_code,
                resp.content
            )

        return {"DELETE": resp.json()}

Example 9

Project: coding-skills-sample-code Source File: manage-users.py
Function: delete_user
def deleteUser(username, ticket):
	print("\nRemoving user: " + username)
	# URL for a specified user REST API call.
	url = "https://" + controller + "/api/v1/user/" + username

	#Content type as well as the ticket must be included in the header 
	header = {"content-type": "application/json", "X-Auth-Token":ticket}

	# this statement performs a Delete on the specified user url
	response = requests.delete(url, headers=header, verify=False)
	print (response.text)

Example 10

Project: nailgun Source File: client.py
Function: delete
def delete(url, **kwargs):
    """A wrapper for ``requests.delete``. Sends a DELETE request."""
    _set_content_type(kwargs)
    if _content_type_is_json(kwargs) and kwargs.get('data') is not None:
        kwargs['data'] = dumps(kwargs['data'])
    _log_request('DELETE', url, kwargs)
    response = requests.delete(url, **kwargs)
    _log_response(response)
    return response

Example 11

Project: webrecorder Source File: redisman.py
Function: send_delete
    def _send_delete(self, type_, user, coll='*', rec='*'):
        delete_url = self.delete_url_templ.format(record_host=os.environ['RECORD_HOST'],
                                                  user=user,
                                                  coll=coll,
                                                  rec=rec,
                                                  type=type_)

        res = requests.delete(delete_url)

        return res.json() == {}

Example 12

Project: cabu Source File: bucket.py
    def delete(self, filename):
        """Delete the file on the distant S3 bucket with the given filename.

        Args:
            filename (str): A string representing the name of the file to delete.
        Returns:
            response (object): The object returned by requests.
        """
        url = 'http://' + self.bucket + '.s3.amazonaws.com/' + filename
        return requests.delete(url, auth=S3Auth(self.access_key, self.secret_key))

Example 13

Project: Highton Source File: highton.py
    def _delete_request(self, endpoint, params={}):
        url = 'https://{}.highrisehq.com/{}.xml'.format(
            self.user, endpoint, params)
        request = requests.delete(
            url,
            auth=HTTPBasicAuth(self.api_key, self.api_key_password),
            headers={
                'User-Agent': 'Highton-API: ([email protected])',
            },
            params=params,
        )

        if 'text/html' in request.headers['content-type']:
            raise XMLRequestException(url)

        return request

Example 14

Project: callsign Source File: client.py
    def record_del(self, zone, host):
        response = requests.delete("%s/%s/%s" % (self.base_url, zone, host))
        if response.status_code != 204:
            self.handle_error(response, {
                404: "Error: Record not found",
            })

Example 15

Project: gremlinsdk-python Source File: failuregenerator.py
    def clear_rules_from_all_proxies(self):
        """
            Clear fault injection rules from all known service proxies.
        """
        self._queue = []        
        if self.debug:
            print 'Clearing rules'
        for service in self.app.get_services():
            for instance in self.app.get_service_instances(service):
                if self.debug:
                    print 'Clearing rules for %s - instance %s' % (service, instance)
                resp = requests.delete("http://{}/gremlin/v1/rules".format(instance))
                if resp.status_code != 200:
                    print 'Failed to clear rules for %s - instance %s' % (service, instance)

Example 16

Project: aem-cmd Source File: jcr.py
def rm_node(server, options, path):
    url = server.url(path)
    resp = requests.delete(url, auth=server.auth)
    if resp.status_code != 204:
        sys.stderr.write("error: Failed to delete path {}, request returned {}\n".format(path, resp.status_code))
        return SERVER_ERROR
    if options.raw:
        sys.stdout.write("{}\n".format(resp.content))
    else:
        sys.stdout.write("{}\n".format(path))
    return OK

Example 17

Project: django-thumborstorage Source File: storages.py
    def delete(self):
        url = "%s%s" % (settings.THUMBOR_RW_SERVER, self.name)
        response = requests.delete(url)
        if response.status_code == 405:
            raise exceptions.MethodNotAllowedException
        elif response.status_code == 404:
            raise exceptions.NotFoundException
        elif response.status_code == 204:
            return

Example 18

Project: skipper Source File: instances.py
Function: unregister
    def unregister(self):
        """
        Removes the machine from etcd's list of peers.

        Taken from:
        https://coreos.com/docs/distributed-configuration/etcd-api/
        """
        with self.tunnel_params(port=7001) as port:
            requests.delete(
                "http://127.0.0.1:{}/v2/admin/machines/{}".format(
                    port, self.uuid))

Example 19

Project: pyrdm Source File: zenodo.py
   def delete_deposition(self, deposition_id):
      """ Delete a deposition with a given ID (deposition_id). """

      url = self.api_url + "deposit/depositions/%d" % deposition_id
      url = self._append_suffix(url)

      response = requests.delete(url)
      response.raise_for_status()
      return

Example 20

Project: python-mailchimp Source File: mailchimpclient.py
Function: delete
    @_enabled_or_noop
    def _delete(self, url):
        """
        Handle authenticated DELETE requests

        :param url: The url for the endpoint including path parameters
        :type url: :py:class:`str`
        :returns: The JSON output from the API
        """
        url = urljoin(self.base_url, url)
        try:
            r = requests.delete(url, auth=self.auth)
        except requests.exceptions.RequestException as e:
            raise e
        else:
            r.raise_for_status()
            if r.status_code == 204:
                return
            return r.json()

Example 21

Project: defend_against_fruit Source File: _artifactory_test_helper.py
Function: flush_caches
    def flush_caches(self):
        url = '/'.join((self.base_url, self.pypi_cache_repo_id))
        result = requests.delete(url, auth=self.clean_credentials)

        # 404 is returned when there are no artifacts to remove - this is okay.
        if result.status_code != 404:
            # Otherwise, check the return status for an error.
            result.raise_for_status()

Example 22

Project: django-bulbs Source File: mixins.py
    def delete(self, *args, **kwargs):
        response = requests.delete(
            SODAHEAD_DELETE_POLL_ENDPOINT.format(
                self.sodahead_id,
                self.get_sodahead_token(),
            )
        )
        if response.status_code > 499:
            raise SodaheadResponseError(response.text)
        elif response.status_code > 399:
            raise SodaheadResponseFailure(response.text)
        super(PollMixin, self).delete(*args, **kwargs)

Example 23

Project: pyrdm Source File: zenodo.py
Function: delete_file
   def delete_file(self, deposition_id, file_id):
      """ Deletes a file (with a given file_id) in a deposition (with a given deposition_id) on Zenodo. """

      url = self.api_url + "deposit/depositions/%d/files/%d" % (deposition_id, file_id)
      url = self._append_suffix(url)

      response = requests.delete(url)
      results = json.loads(response.content)
      return results

Example 24

Project: Kippt-for-Python Source File: clips.py
    def unfavorite(self):
        """ Unfavorite a clip.

        """
        r = requests.delete(
            "https://kippt.com/api/clips/%s/favorite" % (self.id),
            headers=self.kippt.header
        )
        return (r.json())

Example 25

Project: neo4django Source File: benchmarks.py
def cleandb():
    host = settings.NEO4J_DATABASES['default']['HOST']
    port = settings.NEO4J_DATABASES['default']['PORT']
    key = getattr(settings, 'NEO4J_DELETE_KEY', None)
    if key:
        requests.delete('http://%s:%s/cleandb/%s' % (host, port, key))

Example 26

Project: pyvcloud Source File: __init__.py
Function: delete
    @staticmethod
    def delete(url, data=None, logger=None, **kwargs):
        if logger is not None:
            Http._log_request(logger, data=data, headers=kwargs.get('headers', None))
        response = requests.delete(url, data=data, **kwargs)
        Http._log_response(logger, response)
        return response

Example 27

Project: pyschedule Source File: docloud.py
Function: init
	def __init__(self, base_url, api_key, msg=0):
		self.url = '%sjobs' % base_url
		self.auth = {'X-IBM-Client-ID' : api_key}
		self.headers_post = {'X-IBM-Client-ID' : api_key, 'Content-Type' : 'application/json'}
		self.headers_put = {'X-IBM-Client-ID' : api_key, 'Content-Type' : 'application/octet-stream'}
		self.msg = msg
		requests.delete(self.url, headers=self.auth)

Example 28

Project: python-scrapinghub Source File: conftest.py
def unset_testbotgroup(hsproject):
    hsproject.settings.apidelete('botgroups')
    hsproject.settings.expire()
    # Additional step to delete botgroups in JobQ
    url = urlpathjoin(TEST_ENDPOINT, 'botgroups', TEST_BOTGROUP)
    requests.delete(url, auth=hsproject.auth)

Example 29

Project: django-facetools Source File: testusers.py
def _delete_test_user_on_facebook(test_user):
    delete_url_template = "https://graph.facebook.com/%s?method=delete&access_token=%s"
    delete_user_url = delete_url_template % (test_user.facebook_id, _get_app_access_token())
    r = requests.delete(delete_user_url)
    if not isinstance(r.content, basestring):
        raise DeleteTestUserError("Error deleting user %s (%s) from facebook: Facebook returned invalid response" % (test_user.name, test_user.facebook_id, r.content))
    if r.content.strip().lower() != "true":
        if r.content.strip().lower() == "false":
            raise DeleteTestUserError("Error deleting user %s (%s) from facebook: Facebook returned false" % (test_user.name, test_user.facebook_id, r.content))
        else:
            try:
                raise DeleteTestUserError("Error deleting user %s (%s) from facebook: %s" % (test_user.name, test_user.facebook_id, json.loads(r.content)['error']['message']))
            except:
                raise DeleteTestUserError("Error deleting user %s (%s) from facebook: %s" % (test_user.name, test_user.facebook_id, r.content))

Example 30

Project: bashhub-client Source File: rest_client.py
Function: delete_command
def delete_command(uuid):
    url = BH_URL + "/api/v1/command/{0}".format(uuid)
    try:
        response = requests.delete(url, headers=base_auth_headers())
        response.raise_for_status()
        return uuid

    except ConnectionError as error:
        pass
    except HTTPError as error:
        print(error)

    return None

Example 31

Project: callsign Source File: client.py
Function: zone_del
    def zone_del(self, name):
        response = requests.delete("%s/%s" % (self.base_url, name))
        if response.status_code != 204:
            self.handle_error(response, {
                404: "Error: Zone %r is not managed by callsign" % name,
            })

Example 32

Project: smarthome Source File: __init__.py
Function: delete
    def delete(self, pushid, apikey=None):
        if apikey is None:
            apikey = self._apikey

        try:
            response = requests.delete(self._apiurl + "/" + pushid, headers={"User-Agent": "SmartHome.py", "Content-Type": "application/json"}, auth=(apikey,""))
            if self._is_response_ok(response):
                return response.json()

            logger.error("Could not delete Pushbullet notification. Error: {0}".format(response.text))
        except Exception as exception:
            logger.error("Could not delete Pushbullet notification. Error: {0}".format(exception))

        return False

Example 33

Project: bunt Source File: apiai.py
    def _remove_entity_byid(self, entity_id):
        logging.debug('[ApiAi] remove_entity_byid: id={id}'.format(id=entity_id))

        r = requests.delete(
            '{url}entities/{id}'.format(url=self._base_url, id=entity_id),
            headers=self._headers,
        )

        result = r.json()

        if r.status_code != 200:
            raise ApiAiException(result['status'])

Example 34

Project: commissaire-mvp Source File: hosts.py
@given('we have deleted host {host}')
def impl(context, host):
    request = requests.delete(
        context.SERVER + '/api/v0/host/{0}'.format(host),
        auth=(VALID_USERNAME, VALID_PASSWORD))
    assert_status_code(request.status_code, 200)

Example 35

Project: bitcodin-python Source File: rest.py
Function: delete
    @staticmethod
    def delete(url=None, headers=None):
        result = requests.delete(url, headers=headers)

        if result.status_code == 204:
            return True
        elif result.status_code == 200:
            return result.json()
        else:
            RestClient._raise_error(result)

Example 36

Project: st2 Source File: httpclient.py
Function: delete
    @add_ssl_verify_to_kwargs
    @add_auth_token_to_headers
    def delete(self, url, **kwargs):
        response = requests.delete(self.root + url, **kwargs)
        response = self._response_hook(response=response)
        return response

Example 37

Project: io-client-python Source File: client.py
Function: delete
    def _delete(self, path):
        response = requests.delete(self._compose_url(path),
                                   headers=self._headers({'X-AIO-Key': self.key,
                                            'Content-Type': 'application/json'}),
                                   proxies=self.proxies)
        self._handle_error(response)

Example 38

Project: hostthedocs Source File: host_my_docs.py
Function: delete
def delete(host, metadata, deleteall=False):
    address = _makeaddr(host)
    address += '?name=%s&version=%s' % (
        metadata['name'], metadata['version'])
    if deleteall:
        address += '&entire_project=True'
    L.info('DELETING to %s', address)
    got = requests.delete(address)
    return got

Example 39

Project: python-consul Source File: conftest.py
@pytest.yield_fixture
def acl_consul(acl_consul_instance):
    ACLConsul = collections.namedtuple('ACLConsul', ['port', 'token'])
    port, token = acl_consul_instance
    yield ACLConsul(port, token)
    # remove all data from the instance, to have a clean start
    base_uri = 'http://127.0.0.1:%s/v1/' % port
    requests.delete(base_uri + 'kv/?recurse=1')

Example 40

Project: taiga-ncurses Source File: client.py
Function: delete
    def _delete(self, url, params):
        response = requests.delete(url, params=params, headers=self._headers)

        if response.status_code == 204:
            return True

        data = json.loads(response.content.decode())

        self.last_error = {
            "status_code": response.status_code,
            "detail": data.get("detail", "")
        }
        return None

Example 41

Project: bit9platform Source File: bit9api.py
Function: delete
    def delete(self, api_obj, data=None, obj_id=0, url_params=''):
        if not obj_id and data:
            obj_id = data['id']
        if url_params:
            url_params = '?' + url_params.lstrip("?")
        if not obj_id:
            raise TypeError("Missing object data or id.")
        url = self.server + '/' + api_obj + '/' + str(obj_id) + url_params
        r = requests.delete(url, headers=self.tokenHeaderJson, verify=self.sslVerify)
        return self.__check_result(r)

Example 42

Project: zipa Source File: resource.py
Function: delete
    def delete(self, **kwargs):
        response = requests.delete(self.url, params=kwargs,
                                   auth=self.config['auth'],
                                   verify=self.config['verify'])
        entity = self._prepare_entity(response)
        return entity

Example 43

Project: tile-generator Source File: opsmgr.py
Function: delete
def delete(url, check=True):
	creds = get_credentials()
	url = creds.get('opsmgr').get('url') + url
	response = requests.delete(url, auth=auth(creds), verify=False)
	check_response(response, check=check)
	return response

Example 44

Project: estester Source File: __init__.py
Function: delete_index
    def delete_index(self, index_name=""):
        """
        Deletes test index. Uses class attribute:
            index: name of the index to be deleted
        """
        index = index_name or self.index
        url = "{0}{1}/".format(self.host, self.index)
        requests.delete(url, proxies=self.proxies)

Example 45

Project: threatshell Source File: umbrella.py
    def delete_blocked_domain(self, domain):

        params = {
            "customerKey": self.api_token,
            "where[name]": domain
        }

        res = requests.delete(
            self.query_endpoint,
            params=params,
            headers={"Content-Type": "application/json"}
        )

        if res.status_code != requests.codes.ok:
            return {
                "error": "[%s]: %s" % (res.status_code, res.content)
            }

        return res.json()

Example 46

Project: auth0-python Source File: rest.py
Function: delete
    def delete(self, url):
        headers = self.base_headers.copy()
        headers.update({
            'Authorization': 'Bearer %s' % self.jwt,
        })

        response = requests.delete(url, headers=headers)
        return self._process_response(response)

Example 47

Project: commissaire-mvp Source File: cluster.py
@given('we have removed host {host} from cluster {cluster}')
def impl(context, host, cluster):
    request = requests.delete(
        context.SERVER + '/api/v0/cluster/{0}/hosts/{1}'.format(cluster, host),
        auth=(VALID_USERNAME, VALID_PASSWORD))
    assert_status_code(request.status_code, 200)

Example 48

Project: allianceauth Source File: discord_manager.py
    @staticmethod
    def delete_user(user_id):
        try:
            custom_headers = {'accept': 'application/json', 'authorization': 'Bot ' + settings.DISCORD_BOT_TOKEN}
            path = DISCORD_URL + "/guilds/" + str(settings.DISCORD_GUILD_ID) + "/members/" + str(user_id)
            r = requests.delete(path, headers=custom_headers)
            logger.debug("Got status code %s after removing Discord user ID %s" % (r.status_code, user_id))
            if r.status_code == 404:
                logger.warn("Discord user ID %s already left the server." % user_id)
                return True
            r.raise_for_status()
            return True
        except:
            logger.exception("Failed to remove Discord user ID %s" % user_id)
            return False

Example 49

Project: python-hubstorage Source File: hstestcase.py
    @classmethod
    def _unset_testbotgroup(cls):
        cls.project.settings.apidelete('botgroups')
        cls.project.settings.expire()
        # Additional step to delete botgroups in JobQ
        for botgroup in cls.testbotgroups:
            url = urlpathjoin(cls.endpoint, 'botgroups', botgroup)
            requests.delete(url, auth=cls.project.auth)

Example 50

Project: docklet Source File: proxytool.py
Function: delete_route
def delete_route(path):
    path='/'+path.strip('/')
    try:
        resp = requests.delete(proxy_control+path)
    except:
        return [False, 'Connect Failed']
    # if exist and delete, status_code=204, if not exist, status_code=404
    return [True, 'delete ok']
See More Examples - Go to Next Page
Page 1 Selected Page 2 Page 3 Page 4