urllib3.util package — urllib3 1.25.6 documentation

# urllib3.util package

Useful methods for working with `httplib`, completely decoupled from code specific to urllib3.

At the very core, just like its predecessors, `urllib3` is built on top of `httplib` – the lowest level HTTP library included in the Python standard library.

To aid the limited functionality of the `httplib` module, `urllib3` provides various helper methods which are used with the higher level components but can also be used independently.

## urllib3.util.connection module

`urllib3.util.connection.` `allowed_gai_family`()

  This function is designed to work in the context of getaddrinfo, where family=socket.AF_UNSPEC is the default and will perform a DNS search for both IPv6 and IPv4 records.

`urllib3.util.connection.` `create_connection`(address, timeout=<object object>, source_address=None, socket_options=None)

  Connect to address and return the socket object.

  Convenience function. Connect to address (a 2-tuple `(host, port)`) and return the socket object. Passing the optional timeout parameter will set the timeout on the socket instance before attempting to connect. If no timeout is supplied, the global default timeout setting returned by `getdefaulttimeout()` is used. If source_address is set it must be a tuple of (host, port) for the socket to bind as a source address before making the connection. An host of ‘’ or port 0 tells the OS to use the default.

`urllib3.util.connection.` `is_connection_dropped`(conn)

  Returns True if the connection is dropped and should be closed.

  Parameters: | conn – `httplib.HTTPConnection` object.

  Note: For platforms like AppEngine, this will always return `False` to let the platform handle connection recycling transparently for us.

## urllib3.util.request module

`urllib3.util.request.` `make_headers`(keep_alive=None, accept_encoding=None, user_agent=None, basic_auth=None, proxy_basic_auth=None, disable_cache=None)

  Shortcuts for generating request headers.

  Parameters: | keep_alive – If `True`, adds ‘connection: keep-alive’ header. accept_encoding – Can be a boolean, list, or string. `True` translates to ‘gzip,deflate’. List will get joined by comma. String will be used as provided. user_agent – String representing the user-agent you want, such as “python-urllib3/0.6” basic_auth – Colon-separated username:password string for ‘authorization: basic …’ auth header. proxy_basic_auth – Colon-separated username:password string for ‘proxy-authorization: basic …’ auth header. disable_cache – If `True`, adds ‘cache-control: no-cache’ header.

  Example:

      >>> make_headers(keep_alive=True, user_agent="Batman/1.0")
      {'connection': 'keep-alive', 'user-agent': 'Batman/1.0'}
      >>> make_headers(accept_encoding=True)
      {'accept-encoding': 'gzip,deflate'}

`urllib3.util.request.` `rewind_body`(body, body_pos)

  Attempt to rewind body to a certain position. Primarily used for request redirects and retries.

  Parameters: | body – File-like object that supports seek. pos (int) – Position to seek to in file.

`urllib3.util.request.` `set_file_position`(body, pos)

  If a position is provided, move file to that point. Otherwise, we’ll attempt to record a position for future use.

## urllib3.util.response module

`urllib3.util.response.` `assert_header_parsing`(headers)

  Asserts whether all headers have been successfully parsed. Extracts encountered errors from the result of parsing headers.

  Only works on Python 3.

  Parameters: | headers (httplib.HTTPMessage.) – Headers to verify.
  Raises: | urllib3.exceptions.HeaderParsingError – If parsing errors are found.

`urllib3.util.response.` `is_fp_closed`(obj)

  Checks whether a given file-like object is closed.

  Parameters: | obj – The file-like object to check.

`urllib3.util.response.` `is_response_to_head`(response)

  Checks whether the request of a response has been a HEAD-request. Handles the quirks of AppEngine.

  Parameters: | conn (`httplib.HTTPResponse`) –

## urllib3.util.retry module

class `urllib3.util.retry.` `RequestHistory`(method, url, error, status, redirect_location)

  Bases: `tuple`

  `error`

    Alias for field number 2

  `method`

    Alias for field number 0

  `redirect_location`

    Alias for field number 4

  `status`

    Alias for field number 3

  `url`

    Alias for field number 1

class `urllib3.util.retry.` `Retry`(total=10, connect=None, read=None, redirect=None, status=None, method_whitelist=frozenset(['HEAD', 'TRACE', 'GET', 'PUT', 'OPTIONS', 'DELETE']), status_forcelist=None, backoff_factor=0, raise_on_redirect=True, raise_on_status=True, history=None, respect_retry_after_header=True, remove_headers_on_redirect=frozenset(['Authorization']))

  Bases: `object`

  Retry configuration.

  Each retry attempt will create a new Retry object with updated values, so they can be safely reused.

  Retries can be defined as a default for a pool:

      retries = Retry(connect=5, read=2, redirect=5)
      http = PoolManager(retries=retries)
      response = http.request('GET', 'http://example.com/')

  Or per-request (which overrides the default for the pool):

      response = http.request('GET', 'http://example.com/', retries=Retry(10))

  Retries can be disabled by passing `False`:

      response = http.request('GET', 'http://example.com/', retries=False)

  Errors will be wrapped in `MaxRetryError` unless retries are disabled, in which case the causing exception will be raised.

  - Parameters: | total (int) – Total number of retries to allow. Takes precedence over other counts. Set to `None` to remove this constraint and fall back on other counts. It’s a good idea to set this to some sensibly-high value to account for unexpected edge cases and avoid infinite retry loops. Set to `0` to fail on the first retry. Set to `False` to disable and imply `raise_on_redirect=False`. connect (int) – How many connection-related errors to retry on. These are errors raised before the request is sent to the remote server, which we assume has not triggered the server to process the request. Set to `0` to fail on the first retry of this type. read (int) – How many times to retry on read errors. These errors are raised after the request was sent to the server, so the request may have side-effects. Set to `0` to fail on the first retry of this type. redirect (int) – How many redirects to perform. Limit this to avoid infinite redirect loops. A redirect is a HTTP response with a status code 301, 302, 303, 307 or 308. Set to `0` to fail on the first retry of this type. Set to `False` to disable and imply `raise_on_redirect=False`. status (int) – How many times to retry on bad status codes. These are retries made on responses, where status code matches `status_forcelist`. Set to `0` to fail on the first retry of this type. method_whitelist (iterable) – Set of uppercased HTTP method verbs that we should retry on. By default, we only retry on methods which are considered to be idempotent (multiple requests with the same parameters end with the same state). See `Retry.DEFAULT_METHOD_WHITELIST`. Set to a `False` value to retry on any verb. status_forcelist (iterable) – A set of integer HTTP status codes that we should force a retry on. A retry is initiated if the request method is in `method_whitelist` and the response status code is in `status_forcelist`. By default, this is disabled with `None`. backoff_factor (float) – A backoff factor to apply between attempts after the second try (most errors are resolved immediately by a second try without a delay). urllib3 will sleep for:
        {backoff factor} * (2 ** ({number of total retries} - 1))
  seconds. If the backoff_factor is 0.1, then `sleep()` will sleep for [0.0s, 0.2s, 0.4s, …] between retries. It will never be longer than `Retry.BACKOFF_MAX`. By default, backoff is disabled (set to 0). raise_on_redirect (bool) – Whether, if the number of redirects is exhausted, to raise a MaxRetryError, or to return a response with a response code in the 3xx range. raise_on_status (bool) – Similar meaning to `raise_on_redirect`: whether we should raise an exception, or return a response, if status falls in `status_forcelist` range and retries have been exhausted. history (tuple) – The history of the request encountered during each call to `increment()`. The list is in the order the requests occurred. Each list item is of class `RequestHistory`. respect_retry_after_header (bool) – Whether to respect Retry-After header on status codes defined as `Retry.RETRY_AFTER_STATUS_CODES` or not. remove_headers_on_redirect (iterable) – Sequence of headers to remove from the request when a response indicating a redirect is returned before firing off the redirected request.

  `BACKOFF_MAX` = 120

    Maximum backoff time.

  `DEFAULT` = Retry(total=3, connect=None, read=None, redirect=None, status=None)
  `DEFAULT_METHOD_WHITELIST` = frozenset(['HEAD', 'TRACE', 'GET', 'PUT', 'OPTIONS', 'DELETE'])
  `DEFAULT_REDIRECT_HEADERS_BLACKLIST` = frozenset(['Authorization'])
  `RETRY_AFTER_STATUS_CODES` = frozenset([503, 413, 429])
  classmethod `from_int`(retries, redirect=True, default=None)

    Backwards-compatibility for the old retries format.

  `get_backoff_time`()

    Formula for computing the current backoff

    Return type: | float

  `get_retry_after`(response)

    Get the value of Retry-After in seconds.

  `increment`(method=None, url=None, response=None, error=None, _pool=None, _stacktrace=None)

    Return a new Retry object with incremented retry counters.

    Parameters: | response (`HTTPResponse`) – A response object, or None, if the server did not return a response. error (Exception) – An error encountered during the request, or None if the response was received successfully.
    Returns: | A new `Retry` object.

  `is_exhausted`()

    Are we out of retries?

  `is_retry`(method, status_code, has_retry_after=False)

    Is this method/status code retryable? (Based on whitelists and control variables such as the number of total retries to allow, whether to respect the Retry-After header, whether this header is present, and whether the returned status code is on the list of status codes to be retried upon on the presence of the aforementioned header)

  `new`(**kw)
  `parse_retry_after`(retry_after)
  `sleep`(response=None)

    Sleep between retry attempts.

    This method will respect a server’s `Retry-After` response header and sleep the duration of the time requested. If that is not present, it will use an exponential backoff. By default, the backoff factor is 0 and this method will return immediately.

  `sleep_for_retry`(response=None)

## urllib3.util.timeout module

class `urllib3.util.timeout.` `Timeout`(total=None, connect=<object object>, read=<object object>)

  Bases: `object`

  Timeout configuration.

  Timeouts can be defined as a default for a pool:

      timeout = Timeout(connect=2.0, read=7.0)
      http = PoolManager(timeout=timeout)
      response = http.request('GET', 'http://example.com/')

  Or per-request (which overrides the default for the pool):

      response = http.request('GET', 'http://example.com/', timeout=Timeout(10))

  Timeouts can be disabled by setting all the parameters to `None`:

      no_timeout = Timeout(connect=None, read=None)
      response = http.request('GET', 'http://example.com/, timeout=no_timeout)

  Parameters: | total (integer, float, or None) – This combines the connect and read timeouts into one; the read timeout will be set to the time leftover from the connect attempt. In the event that both a connect timeout and a total are specified, or a read timeout and a total are specified, the shorter timeout will be applied. Defaults to None. connect (integer, float, or None) – The maximum amount of time (in seconds) to wait for a connection attempt to a server to succeed. Omitting the parameter will default the connect timeout to the system default, probably the global default timeout in socket.py. None will set an infinite timeout for connection attempts. read (integer, float, or None) – The maximum amount of time (in seconds) to wait between consecutive read operations for a response from the server. Omitting the parameter will default the read timeout to the system default, probably the global default timeout in socket.py. None will set an infinite timeout.

  Note

  Many factors can affect the total amount of time for urllib3 to return an HTTP response.

  For example, Python’s DNS resolver does not obey the timeout specified on the socket. Other factors that can affect total request time include high CPU load, high swap, the program running at a low priority level, or other behaviors.

  In addition, the read and total timeouts only measure the time between read operations on the socket connecting the client and the server, not the total amount of time for the request to return a complete response. For most requests, the timeout is raised because the server has not sent the first byte in the specified time. This is not always the case; if a server streams one byte every fifteen seconds, a timeout of 20 seconds will not trigger, even though the request will take several minutes to complete.

  If your goal is to cut off any request after a set amount of wall clock time, consider having a second “watcher” thread to cut off a slow request.

  `DEFAULT_TIMEOUT` = <object object>

    A sentinel object representing the default timeout value

  `clone`()

    Create a copy of the timeout object

    Timeout properties are stored per-pool but each request needs a fresh Timeout object to ensure each one has its own start/stop configured.

    Returns: | a copy of the timeout object
    Return type: | `Timeout`

  `connect_timeout`

    Get the value to use when setting a connection timeout.

    This will be a positive float or integer, the value None (never timeout), or the default system timeout.

    Returns: | Connect timeout.
    Return type: | int, float, `Timeout.DEFAULT_TIMEOUT` or None

  classmethod `from_float`(timeout)

    Create a new Timeout from a legacy timeout value.

    The timeout value used by httplib.py sets the same timeout on the connect(), and recv() socket requests. This creates a `Timeout` object that sets the individual timeouts to the `timeout` value passed to this function.

    Parameters: | timeout (integer, float, sentinel default object, or None) – The legacy timeout value.
    Returns: | Timeout object
    Return type: | `Timeout`

  `get_connect_duration`()

    Gets the time elapsed since the call to `start_connect()`.

    Returns: | Elapsed time in seconds.
    Return type: | float
    Raises: | urllib3.exceptions.TimeoutStateError – if you attempt to get duration for a timer that hasn’t been started.

  `read_timeout`

    Get the value for the read timeout.

    This assumes some time has elapsed in the connection timeout and computes the read timeout appropriately.

    If self.total is set, the read timeout is dependent on the amount of time taken by the connect timeout. If the connection time has not been established, a `TimeoutStateError` will be raised.

    Returns: | Value to use for the read timeout.
    Return type: | int, float, `Timeout.DEFAULT_TIMEOUT` or None
    Raises: | urllib3.exceptions.TimeoutStateError – If `start_connect()` has not yet been called on this object.

  `start_connect`()

    Start the timeout clock, used during a connect() attempt

    Raises: | urllib3.exceptions.TimeoutStateError – if you attempt to start a timer that has been started already.

## urllib3.util.url module

class `urllib3.util.url.` `Url`

  Bases: `urllib3.util.url.Url`

  Data structure for representing an HTTP URL. Used as a return value for `parse_url()`. Both the scheme and host are normalized as they are both case-insensitive according to RFC 3986.

  `hostname`

    For backwards-compatibility with urlparse. We’re nice like that.

  `netloc`

    Network location including host and port

  `request_uri`

    Absolute path including the query string.

  `url`

    Convert self into a url

    This function should more or less round-trip with `parse_url()`. The returned url may not be exactly the same as the url inputted to `parse_url()`, but it should be equivalent by the RFC (e.g., urls with a blank port will have : removed).

    Example:

        >>> U = parse_url('http://google.com/mail/')
        >>> U.url
        'http://google.com/mail/'
        >>> Url('http', 'username:password', 'host.com', 80,
        ... '/path', 'query', 'fragment').url
        'http://username:password@host.com:80/path?query#fragment'

`urllib3.util.url.` `get_host`(url)

  Deprecated. Use `parse_url()` instead.

`urllib3.util.url.` `parse_url`(url)

  Given a url, return a parsed `Url` namedtuple. Best-effort is performed to parse incomplete urls. Fields not provided will be None. This parser is RFC 3986 compliant.

  The parser logic and helper functions are based heavily on work done in the `rfc3986` module.

  Parameters: | url (str) – URL to parse into a `Url` namedtuple.

  Partly backwards-compatible with `urlparse`.

  Example:

      >>> parse_url('http://google.com/mail/')
      Url(scheme='http', host='google.com', port=None, path='/mail/', ...)
      >>> parse_url('google.com:80')
      Url(scheme=None, host='google.com', port=80, path=None, ...)
      >>> parse_url('/foo?bar')
      Url(scheme=None, host=None, port=None, path='/foo', query='bar', ...)

`urllib3.util.url.` `split_first`(s, delims)

  Deprecated since version 1.25.

  Given a string and an iterable of delimiters, split on the first found delimiter. Return two split parts and the matched delimiter.

  If not found, then the first part is the full input string.

  Example:

      >>> split_first('foo/bar?baz', '?/=')
      ('foo', 'bar?baz', '/')
      >>> split_first('foo/bar?baz', '123')
      ('foo/bar?baz', '', None)

  Scales linearly with number of delims. Not ideal for large number of delims.

## Module contents

`urllib3.util.` `SSLContext`

  alias of `urllib3.contrib.pyopenssl.PyOpenSSLContext`

class `urllib3.util.` `Retry`(total=10, connect=None, read=None, redirect=None, status=None, method_whitelist=frozenset(['HEAD', 'TRACE', 'GET', 'PUT', 'OPTIONS', 'DELETE']), status_forcelist=None, backoff_factor=0, raise_on_redirect=True, raise_on_status=True, history=None, respect_retry_after_header=True, remove_headers_on_redirect=frozenset(['Authorization']))

  Bases: `object`

  Retry configuration.

  Each retry attempt will create a new Retry object with updated values, so they can be safely reused.

  Retries can be defined as a default for a pool:

      retries = Retry(connect=5, read=2, redirect=5)
      http = PoolManager(retries=retries)
      response = http.request('GET', 'http://example.com/')

  Or per-request (which overrides the default for the pool):

      response = http.request('GET', 'http://example.com/', retries=Retry(10))

  Retries can be disabled by passing `False`:

      response = http.request('GET', 'http://example.com/', retries=False)

  Errors will be wrapped in `MaxRetryError` unless retries are disabled, in which case the causing exception will be raised.

  - Parameters: | total (int) – Total number of retries to allow. Takes precedence over other counts. Set to `None` to remove this constraint and fall back on other counts. It’s a good idea to set this to some sensibly-high value to account for unexpected edge cases and avoid infinite retry loops. Set to `0` to fail on the first retry. Set to `False` to disable and imply `raise_on_redirect=False`. connect (int) – How many connection-related errors to retry on. These are errors raised before the request is sent to the remote server, which we assume has not triggered the server to process the request. Set to `0` to fail on the first retry of this type. read (int) – How many times to retry on read errors. These errors are raised after the request was sent to the server, so the request may have side-effects. Set to `0` to fail on the first retry of this type. redirect (int) – How many redirects to perform. Limit this to avoid infinite redirect loops. A redirect is a HTTP response with a status code 301, 302, 303, 307 or 308. Set to `0` to fail on the first retry of this type. Set to `False` to disable and imply `raise_on_redirect=False`. status (int) – How many times to retry on bad status codes. These are retries made on responses, where status code matches `status_forcelist`. Set to `0` to fail on the first retry of this type. method_whitelist (iterable) – Set of uppercased HTTP method verbs that we should retry on. By default, we only retry on methods which are considered to be idempotent (multiple requests with the same parameters end with the same state). See `Retry.DEFAULT_METHOD_WHITELIST`. Set to a `False` value to retry on any verb. status_forcelist (iterable) – A set of integer HTTP status codes that we should force a retry on. A retry is initiated if the request method is in `method_whitelist` and the response status code is in `status_forcelist`. By default, this is disabled with `None`. backoff_factor (float) – A backoff factor to apply between attempts after the second try (most errors are resolved immediately by a second try without a delay). urllib3 will sleep for:
        {backoff factor} * (2 ** ({number of total retries} - 1))
  seconds. If the backoff_factor is 0.1, then `sleep()` will sleep for [0.0s, 0.2s, 0.4s, …] between retries. It will never be longer than `Retry.BACKOFF_MAX`. By default, backoff is disabled (set to 0). raise_on_redirect (bool) – Whether, if the number of redirects is exhausted, to raise a MaxRetryError, or to return a response with a response code in the 3xx range. raise_on_status (bool) – Similar meaning to `raise_on_redirect`: whether we should raise an exception, or return a response, if status falls in `status_forcelist` range and retries have been exhausted. history (tuple) – The history of the request encountered during each call to `increment()`. The list is in the order the requests occurred. Each list item is of class `RequestHistory`. respect_retry_after_header (bool) – Whether to respect Retry-After header on status codes defined as `Retry.RETRY_AFTER_STATUS_CODES` or not. remove_headers_on_redirect (iterable) – Sequence of headers to remove from the request when a response indicating a redirect is returned before firing off the redirected request.

  `BACKOFF_MAX` = 120

    Maximum backoff time.

  `DEFAULT` = Retry(total=3, connect=None, read=None, redirect=None, status=None)
  `DEFAULT_METHOD_WHITELIST` = frozenset(['HEAD', 'TRACE', 'GET', 'PUT', 'OPTIONS', 'DELETE'])
  `DEFAULT_REDIRECT_HEADERS_BLACKLIST` = frozenset(['Authorization'])
  `RETRY_AFTER_STATUS_CODES` = frozenset([503, 413, 429])
  classmethod `from_int`(retries, redirect=True, default=None)

    Backwards-compatibility for the old retries format.

  `get_backoff_time`()

    Formula for computing the current backoff

    Return type: | float

  `get_retry_after`(response)

    Get the value of Retry-After in seconds.

  `increment`(method=None, url=None, response=None, error=None, _pool=None, _stacktrace=None)

    Return a new Retry object with incremented retry counters.

    Parameters: | response (`HTTPResponse`) – A response object, or None, if the server did not return a response. error (Exception) – An error encountered during the request, or None if the response was received successfully.
    Returns: | A new `Retry` object.

  `is_exhausted`()

    Are we out of retries?

  `is_retry`(method, status_code, has_retry_after=False)

    Is this method/status code retryable? (Based on whitelists and control variables such as the number of total retries to allow, whether to respect the Retry-After header, whether this header is present, and whether the returned status code is on the list of status codes to be retried upon on the presence of the aforementioned header)

  `new`(**kw)
  `parse_retry_after`(retry_after)
  `sleep`(response=None)

    Sleep between retry attempts.

    This method will respect a server’s `Retry-After` response header and sleep the duration of the time requested. If that is not present, it will use an exponential backoff. By default, the backoff factor is 0 and this method will return immediately.

  `sleep_for_retry`(response=None)

class `urllib3.util.` `Timeout`(total=None, connect=<object object>, read=<object object>)

  Bases: `object`

  Timeout configuration.

  Timeouts can be defined as a default for a pool:

      timeout = Timeout(connect=2.0, read=7.0)
      http = PoolManager(timeout=timeout)
      response = http.request('GET', 'http://example.com/')

  Or per-request (which overrides the default for the pool):

      response = http.request('GET', 'http://example.com/', timeout=Timeout(10))

  Timeouts can be disabled by setting all the parameters to `None`:

      no_timeout = Timeout(connect=None, read=None)
      response = http.request('GET', 'http://example.com/, timeout=no_timeout)

  Parameters: | total (integer, float, or None) – This combines the connect and read timeouts into one; the read timeout will be set to the time leftover from the connect attempt. In the event that both a connect timeout and a total are specified, or a read timeout and a total are specified, the shorter timeout will be applied. Defaults to None. connect (integer, float, or None) – The maximum amount of time (in seconds) to wait for a connection attempt to a server to succeed. Omitting the parameter will default the connect timeout to the system default, probably the global default timeout in socket.py. None will set an infinite timeout for connection attempts. read (integer, float, or None) – The maximum amount of time (in seconds) to wait between consecutive read operations for a response from the server. Omitting the parameter will default the read timeout to the system default, probably the global default timeout in socket.py. None will set an infinite timeout.

  Note

  Many factors can affect the total amount of time for urllib3 to return an HTTP response.

  For example, Python’s DNS resolver does not obey the timeout specified on the socket. Other factors that can affect total request time include high CPU load, high swap, the program running at a low priority level, or other behaviors.

  In addition, the read and total timeouts only measure the time between read operations on the socket connecting the client and the server, not the total amount of time for the request to return a complete response. For most requests, the timeout is raised because the server has not sent the first byte in the specified time. This is not always the case; if a server streams one byte every fifteen seconds, a timeout of 20 seconds will not trigger, even though the request will take several minutes to complete.

  If your goal is to cut off any request after a set amount of wall clock time, consider having a second “watcher” thread to cut off a slow request.

  `DEFAULT_TIMEOUT` = <object object>

    A sentinel object representing the default timeout value

  `clone`()

    Create a copy of the timeout object

    Timeout properties are stored per-pool but each request needs a fresh Timeout object to ensure each one has its own start/stop configured.

    Returns: | a copy of the timeout object
    Return type: | `Timeout`

  `connect_timeout`

    Get the value to use when setting a connection timeout.

    This will be a positive float or integer, the value None (never timeout), or the default system timeout.

    Returns: | Connect timeout.
    Return type: | int, float, `Timeout.DEFAULT_TIMEOUT` or None

  classmethod `from_float`(timeout)

    Create a new Timeout from a legacy timeout value.

    The timeout value used by httplib.py sets the same timeout on the connect(), and recv() socket requests. This creates a `Timeout` object that sets the individual timeouts to the `timeout` value passed to this function.

    Parameters: | timeout (integer, float, sentinel default object, or None) – The legacy timeout value.
    Returns: | Timeout object
    Return type: | `Timeout`

  `get_connect_duration`()

    Gets the time elapsed since the call to `start_connect()`.

    Returns: | Elapsed time in seconds.
    Return type: | float
    Raises: | urllib3.exceptions.TimeoutStateError – if you attempt to get duration for a timer that hasn’t been started.

  `read_timeout`

    Get the value for the read timeout.

    This assumes some time has elapsed in the connection timeout and computes the read timeout appropriately.

    If self.total is set, the read timeout is dependent on the amount of time taken by the connect timeout. If the connection time has not been established, a `TimeoutStateError` will be raised.

    Returns: | Value to use for the read timeout.
    Return type: | int, float, `Timeout.DEFAULT_TIMEOUT` or None
    Raises: | urllib3.exceptions.TimeoutStateError – If `start_connect()` has not yet been called on this object.

  `start_connect`()

    Start the timeout clock, used during a connect() attempt

    Raises: | urllib3.exceptions.TimeoutStateError – if you attempt to start a timer that has been started already.

class `urllib3.util.` `Url`

  Bases: `urllib3.util.url.Url`

  Data structure for representing an HTTP URL. Used as a return value for `parse_url()`. Both the scheme and host are normalized as they are both case-insensitive according to RFC 3986.

  `hostname`

    For backwards-compatibility with urlparse. We’re nice like that.

  `netloc`

    Network location including host and port

  `request_uri`

    Absolute path including the query string.

  `url`

    Convert self into a url

    This function should more or less round-trip with `parse_url()`. The returned url may not be exactly the same as the url inputted to `parse_url()`, but it should be equivalent by the RFC (e.g., urls with a blank port will have : removed).

    Example:

        >>> U = parse_url('http://google.com/mail/')
        >>> U.url
        'http://google.com/mail/'
        >>> Url('http', 'username:password', 'host.com', 80,
        ... '/path', 'query', 'fragment').url
        'http://username:password@host.com:80/path?query#fragment'

`urllib3.util.` `assert_fingerprint`(cert, fingerprint)

  Checks if given fingerprint matches the supplied certificate.

  Parameters: | cert – Certificate as bytes object. fingerprint – Fingerprint as string of hexdigits, can be interspersed by colons.

`urllib3.util.` `current_time`()

  time() -> floating point number

  Return the current time in seconds since the Epoch. Fractions of a second may be present if the system clock provides them.

`urllib3.util.` `is_connection_dropped`(conn)

  Returns True if the connection is dropped and should be closed.

  Parameters: | conn – `httplib.HTTPConnection` object.

  Note: For platforms like AppEngine, this will always return `False` to let the platform handle connection recycling transparently for us.

`urllib3.util.` `is_fp_closed`(obj)

  Checks whether a given file-like object is closed.

  Parameters: | obj – The file-like object to check.

`urllib3.util.` `get_host`(url)

  Deprecated. Use `parse_url()` instead.

`urllib3.util.` `parse_url`(url)

  Given a url, return a parsed `Url` namedtuple. Best-effort is performed to parse incomplete urls. Fields not provided will be None. This parser is RFC 3986 compliant.

  The parser logic and helper functions are based heavily on work done in the `rfc3986` module.

  Parameters: | url (str) – URL to parse into a `Url` namedtuple.

  Partly backwards-compatible with `urlparse`.

  Example:

      >>> parse_url('http://google.com/mail/')
      Url(scheme='http', host='google.com', port=None, path='/mail/', ...)
      >>> parse_url('google.com:80')
      Url(scheme=None, host='google.com', port=80, path=None, ...)
      >>> parse_url('/foo?bar')
      Url(scheme=None, host=None, port=None, path='/foo', query='bar', ...)

`urllib3.util.` `make_headers`(keep_alive=None, accept_encoding=None, user_agent=None, basic_auth=None, proxy_basic_auth=None, disable_cache=None)

  Shortcuts for generating request headers.

  Parameters: | keep_alive – If `True`, adds ‘connection: keep-alive’ header. accept_encoding – Can be a boolean, list, or string. `True` translates to ‘gzip,deflate’. List will get joined by comma. String will be used as provided. user_agent – String representing the user-agent you want, such as “python-urllib3/0.6” basic_auth – Colon-separated username:password string for ‘authorization: basic …’ auth header. proxy_basic_auth – Colon-separated username:password string for ‘proxy-authorization: basic …’ auth header. disable_cache – If `True`, adds ‘cache-control: no-cache’ header.

  Example:

      >>> make_headers(keep_alive=True, user_agent="Batman/1.0")
      {'connection': 'keep-alive', 'user-agent': 'Batman/1.0'}
      >>> make_headers(accept_encoding=True)
      {'accept-encoding': 'gzip,deflate'}

`urllib3.util.` `resolve_cert_reqs`(candidate)

  Resolves the argument to a numeric constant, which can be passed to the wrap_socket function/method from the ssl module. Defaults to `ssl.CERT_NONE`. If given a string it is assumed to be the name of the constant in the `ssl` module or its abbreviation. (So you can specify REQUIRED instead of CERT_REQUIRED. If it’s neither None nor a string we assume it is already the numeric constant which can directly be passed to wrap_socket.

`urllib3.util.` `resolve_ssl_version`(candidate)

  like resolve_cert_reqs

`urllib3.util.` `split_first`(s, delims)

  Deprecated since version 1.25.

  Given a string and an iterable of delimiters, split on the first found delimiter. Return two split parts and the matched delimiter.

  If not found, then the first part is the full input string.

  Example:

      >>> split_first('foo/bar?baz', '?/=')
      ('foo', 'bar?baz', '/')
      >>> split_first('foo/bar?baz', '123')
      ('foo/bar?baz', '', None)

  Scales linearly with number of delims. Not ideal for large number of delims.

`urllib3.util.` `ssl_wrap_socket`(sock, keyfile=None, certfile=None, cert_reqs=None, ca_certs=None, server_hostname=None, ssl_version=None, ciphers=None, ssl_context=None, ca_cert_dir=None, key_password=None)

  All arguments except for server_hostname, ssl_context, and ca_cert_dir have the same meaning as they do when using `ssl.wrap_socket()`.

  Parameters: | server_hostname – When SNI is supported, the expected hostname of the certificate ssl_context – A pre-made `SSLContext` object. If none is provided, one will be created using `create_urllib3_context()`. ciphers – A string of ciphers we wish the client to support. ca_cert_dir – A directory containing CA certificates in multiple separate files, as supported by OpenSSL’s -CApath flag or the capath argument to SSLContext.load_verify_locations(). key_password – Optional password if the keyfile is encrypted.

`urllib3.util.` `wait_for_read`(sock, timeout=None)

  Waits for reading to be available on a given socket. Returns True if the socket is readable, or False if the timeout expired.

`urllib3.util.` `wait_for_write`(sock, timeout=None)

  Waits for writing to be available on a given socket. Returns True if the socket is readable, or False if the timeout expired.