utils

module requests.utils in requests

Description

requests.utils
~~~~~~~~~~~~~~

This module provides utility functions that are used within Requests
that are also useful for external consumption.

Functions

add_dict_to_cookiejar

add_dict_to_cookiejar(cj, cookie_dict)
    Returns a CookieJar from a key/value dictionary.
    
    :param cj: CookieJar to insert cookies into.
    :param cookie_dict: Dict of key/values to insert into CookieJar.
    :rtype: CookieJar

address_in_network

address_in_network(ip, net)
    This function allows you to check if an IP belongs to a network subnet
    
    Example: returns True if ip = 192.168.1.1 and net = 192.168.1.0/24
             returns False if ip = 192.168.1.1 and net = 192.168.100.0/24
    
    :rtype: bool

atomic_open

atomic_open(filename)
    Write a file to the disk in an atomic fashion

check_header_validity

check_header_validity(header)
    Verifies that header parts don't contain leading whitespace
    reserved characters, or return characters.
    
    :param header: tuple, in the format (name, value).

default_headers

default_headers()
    :rtype: requests.structures.CaseInsensitiveDict

default_user_agent

default_user_agent(name='python-requests')
    Return a string representing the default user agent.
    
    :rtype: str

dict_from_cookiejar

dict_from_cookiejar(cj)
    Returns a key/value dictionary from a CookieJar.
    
    :param cj: CookieJar object to extract cookies from.
    :rtype: dict

dict_to_sequence

dict_to_sequence(d)
    Returns an internal sequence dictionary update.

dotted_netmask

dotted_netmask(mask)
    Converts mask from /xx format to xxx.xxx.xxx.xxx
    
    Example: if mask is 24 function returns 255.255.255.0
    
    :rtype: str

extract_zipped_paths

extract_zipped_paths(path)
    Replace nonexistent paths that look like they refer to a member of a zip
    archive with the location of an extracted copy of the target, or else
    just return the provided path unchanged.

from_key_val_list

from_key_val_list(value)
    Take an object and test to see if it can be represented as a
    dictionary. Unless it can not be represented as such, return an
    OrderedDict, e.g.,
    
    ::
    
        >>> from_key_val_list([('key', 'val')])
        OrderedDict([('key', 'val')])
        >>> from_key_val_list('string')
        Traceback (most recent call last):
        ...
        ValueError: cannot encode objects that are not 2-tuples
        >>> from_key_val_list({'key': 'val'})
        OrderedDict([('key', 'val')])
    
    :rtype: OrderedDict

get_auth_from_url

get_auth_from_url(url)
    Given a url with authentication components, extract them into a tuple of
    username,password.
    
    :rtype: (str,str)

get_encoding_from_headers

get_encoding_from_headers(headers)
    Returns encodings from given HTTP Header Dict.
    
    :param headers: dictionary to extract encoding from.
    :rtype: str

get_encodings_from_content

get_encodings_from_content(content)
    Returns encodings from given content string.
    
    :param content: bytestring to extract encodings from.

get_environ_proxies

get_environ_proxies(url, no_proxy=None)
    Return a dict of environment proxies.
    
    :rtype: dict

get_netrc_auth

get_netrc_auth(url, raise_errors=False)
    Returns the Requests tuple auth for a given url from netrc.

get_unicode_from_response

get_unicode_from_response(r)
    Returns the requested content back in unicode.
    
    :param r: Response object to get unicode content from.
    
    Tried:
    
    1. charset from content-type
    2. fall back and replace all unicode characters
    
    :rtype: str

guess_filename

guess_filename(obj)
    Tries to guess the filename of the given object.

guess_json_utf

guess_json_utf(data)
    :rtype: str

is_ipv4_address

is_ipv4_address(string_ip)
    :rtype: bool

is_valid_cidr

is_valid_cidr(string_network)
    Very simple check of the cidr format in no_proxy variable.
    
    :rtype: bool

iter_slices

iter_slices(string, slice_length)
    Iterate over slices of a string.

parse_dict_header

parse_dict_header(value)
    Parse lists of key, value pairs as described by RFC 2068 Section 2 and
    convert them into a python dict:
    
    >>> d = parse_dict_header('foo="is a fish", bar="as well"')
    >>> type(d) is dict
    True
    >>> sorted(d.items())
    [('bar', 'as well'), ('foo', 'is a fish')]
    
    If there is no value for a key it will be `None`:
    
    >>> parse_dict_header('key_without_value')
    {'key_without_value': None}
    
    To create a header from the :class:`dict` again, use the
    :func:`dump_header` function.
    
    :param value: a string with a dict header.
    :return: :class:`dict`
    :rtype: dict

parse_list_header

parse_list_header(value)
    Parse lists as described by RFC 2068 Section 2.
    
    In particular, parse comma-separated lists where the elements of
    the list may include quoted-strings.  A quoted-string could
    contain a comma.  A non-quoted string could have quotes in the
    middle.  Quotes are removed automatically after parsing.
    
    It basically works like :func:`parse_set_header` just that items
    may appear multiple times and case sensitivity is preserved.
    
    The return value is a standard :class:`list`:
    
    >>> parse_list_header('token, "quoted value"')
    ['token', 'quoted value']
    
    To create a header from the :class:`list` again, use the
    :func:`dump_header` function.
    
    :param value: a string with a list header.
    :return: :class:`list`
    :rtype: list

prepend_scheme_if_needed

prepend_scheme_if_needed(url, new_scheme)
    Given a URL that may or may not have a scheme, prepend the given scheme.
    Does not replace a present scheme with the one provided as an argument.
    
    :rtype: str

requote_uri

requote_uri(uri)
    Re-quote the given URI.
    
    This function passes the given URI through an unquote/quote cycle to
    ensure that it is fully and consistently quoted.
    
    :rtype: str

resolve_proxies

resolve_proxies(request, proxies, trust_env=True)
    This method takes proxy information from a request and configuration
    input to resolve a mapping of target proxies. This will consider settings
    such a NO_PROXY to strip proxy configurations.
    
    :param request: Request or PreparedRequest
    :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs
    :param trust_env: Boolean declaring whether to trust environment configs
    
    :rtype: dict

rewind_body

rewind_body(prepared_request)
    Move file pointer back to its recorded starting position
    so it can be read again on redirect.

select_proxy

select_proxy(url, proxies)
    Select a proxy for the url, if applicable.
    
    :param url: The url being for the request
    :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs

set_environ

set_environ(env_name, value)
    Set the environment variable 'env_name' to 'value'
    
    Save previous value, yield, and then restore the previous value stored in
    the environment variable 'env_name'.
    
    If 'value' is None, do nothing

should_bypass_proxies

should_bypass_proxies(url, no_proxy)
    Returns whether we should bypass proxies or not.
    
    :rtype: bool

stream_decode_response_unicode

stream_decode_response_unicode(iterator, r)
    Stream decodes an iterator.

super_len

super_len(o)

to_key_val_list

to_key_val_list(value)
    Take an object and test to see if it can be represented as a
    dictionary. If it can be, return a list of tuples, e.g.,
    
    ::
    
        >>> to_key_val_list([('key', 'val')])
        [('key', 'val')]
        >>> to_key_val_list({'key': 'val'})
        [('key', 'val')]
        >>> to_key_val_list('string')
        Traceback (most recent call last):
        ...
        ValueError: cannot encode objects that are not 2-tuples
    
    :rtype: list

unquote_header_value

unquote_header_value(value, is_filename=False)
    Unquotes a header value.  (Reversal of :func:`quote_header_value`).
    This does not use the real unquoting but what browsers are actually
    using for quoting.
    
    :param value: the header value to unquote.
    :rtype: str

unquote_unreserved

unquote_unreserved(uri)
    Un-escape any percent-escape sequences in a URI that are unreserved
    characters. This leaves all reserved, illegal and non-ASCII bytes encoded.
    
    :rtype: str

urldefragauth

urldefragauth(url)
    Given a url remove the fragment and the authentication part.
    
    :rtype: str