OpenQuizz
Une application de gestion des contenus pédagogiques
requests.utils Namespace Reference

Functions

def proxy_bypass_registry (host)
 
def proxy_bypass (host)
 
def dict_to_sequence (d)
 
def super_len (o)
 
def get_netrc_auth (url, raise_errors=False)
 
def guess_filename (obj)
 
def extract_zipped_paths (path)
 
def from_key_val_list (value)
 
def to_key_val_list (value)
 
def parse_list_header (value)
 
def parse_dict_header (value)
 
def unquote_header_value (value, is_filename=False)
 
def dict_from_cookiejar (cj)
 
def add_dict_to_cookiejar (cj, cookie_dict)
 
def get_encodings_from_content (content)
 
def get_encoding_from_headers (headers)
 
def stream_decode_response_unicode (iterator, r)
 
def iter_slices (string, slice_length)
 
def get_unicode_from_response (r)
 
def unquote_unreserved (uri)
 
def requote_uri (uri)
 
def address_in_network (ip, net)
 
def dotted_netmask (mask)
 
def is_ipv4_address (string_ip)
 
def is_valid_cidr (string_network)
 
def set_environ (env_name, value)
 
def should_bypass_proxies (url, no_proxy)
 
def get_environ_proxies (url, no_proxy=None)
 
def select_proxy (url, proxies)
 
def default_user_agent (name="python-requests")
 
def default_headers ()
 
def parse_header_links (value)
 
def guess_json_utf (data)
 
def prepend_scheme_if_needed (url, new_scheme)
 
def get_auth_from_url (url)
 
def check_header_validity (header)
 
def urldefragauth (url)
 
def rewind_body (prepared_request)
 

Variables

 NETRC_FILES
 
 DEFAULT_CA_BUNDLE_PATH
 
 DEFAULT_PORTS
 
 UNRESERVED_SET
 

Function Documentation

◆ add_dict_to_cookiejar()

def requests.utils.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()

def requests.utils.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

◆ check_header_validity()

def requests.utils.check_header_validity (   header)
Verifies that header value is a string which doesn't contain
leading whitespace or return characters. This prevents unintended
header injection.

:param header: tuple, in the format (name, value).

◆ default_headers()

def requests.utils.default_headers ( )
:rtype: requests.structures.CaseInsensitiveDict

◆ default_user_agent()

def requests.utils.default_user_agent (   name = "python-requests")
Return a string representing the default user agent.

:rtype: str

◆ dict_from_cookiejar()

def requests.utils.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()

def requests.utils.dict_to_sequence (   d)
Returns an internal sequence dictionary update.

◆ dotted_netmask()

def requests.utils.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()

def requests.utils.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()

def requests.utils.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()

def requests.utils.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()

def requests.utils.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()

def requests.utils.get_encodings_from_content (   content)
Returns encodings from given content string.

:param content: bytestring to extract encodings from.

◆ get_environ_proxies()

def requests.utils.get_environ_proxies (   url,
  no_proxy = None 
)
Return a dict of environment proxies.

:rtype: dict

◆ get_netrc_auth()

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

◆ get_unicode_from_response()

def requests.utils.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()

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

◆ guess_json_utf()

def requests.utils.guess_json_utf (   data)
:rtype: str

◆ is_ipv4_address()

def requests.utils.is_ipv4_address (   string_ip)
:rtype: bool

◆ is_valid_cidr()

def requests.utils.is_valid_cidr (   string_network)
Very simple check of the cidr format in no_proxy variable.

:rtype: bool

◆ iter_slices()

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

◆ parse_dict_header()

def requests.utils.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_header_links()

def requests.utils.parse_header_links (   value)
Return a list of parsed link headers proxies.

i.e. Link: <http:/.../front.jpeg>; rel=front; type="image/jpeg",<http://.../back.jpeg>; rel=back;type="image/jpeg"

:rtype: list

◆ parse_list_header()

def requests.utils.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()

def requests.utils.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

◆ proxy_bypass()

def requests.utils.proxy_bypass (   host)
Return True, if the host should be bypassed.

Checks proxy settings gathered from the environment, if specified,
or the registry.

◆ proxy_bypass_registry()

def requests.utils.proxy_bypass_registry (   host)

◆ requote_uri()

def requests.utils.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

◆ rewind_body()

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

◆ select_proxy()

def requests.utils.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()

def requests.utils.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()

def requests.utils.should_bypass_proxies (   url,
  no_proxy 
)
Returns whether we should bypass proxies or not.

:rtype: bool

◆ stream_decode_response_unicode()

def requests.utils.stream_decode_response_unicode (   iterator,
  r 
)
Stream decodes a iterator.

◆ super_len()

def requests.utils.super_len (   o)

◆ to_key_val_list()

def requests.utils.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()

def requests.utils.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()

def requests.utils.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()

def requests.utils.urldefragauth (   url)
Given a url remove the fragment and the authentication part.

:rtype: str

Variable Documentation

◆ DEFAULT_CA_BUNDLE_PATH

DEFAULT_CA_BUNDLE_PATH

◆ DEFAULT_PORTS

DEFAULT_PORTS

◆ NETRC_FILES

NETRC_FILES

◆ UNRESERVED_SET

UNRESERVED_SET