Thread-safe connection pool for one host. :param host: Host used for this HTTP Connection (e.g. "localhost"), passed into :c

HTTP Response container. Backwards-compatible with :class:`http.client.HTTPResponse` but the response ``body`` is loaded and decoded on-

Same as :class:`.HTTPConnectionPool`, but HTTPS. :class:`.HTTPSConnection` uses one of ``assert_fingerprint``, ``assert_hostname`` and `

Allows for arbitrary requests while transparently keeping track of necessary connection pools for you. :param num_pools: Number

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

:param headers: An iterable of field-value pairs. Must not contain multiple field names when compared case-insensitively. :p

Timeout configuration. Timeouts can be defined as a default for a pool: .. code-block:: python import urllib3 timeout = ur

The SSLTransport wraps an existing socket and establishes an SSL connection. Contrary to Python's implementation of SSLSocket, it allows you

Memory-efficient bytes buffer To return decoded data in read() and still follow the BufferedIOBase API, we need a buffer to always return the

Behaves just like :class:`PoolManager`, but sends all requests through the defined proxy, using the CONNECT method for HTTPS URLs. :para

Raised when a socket timeout occurs while receiving data from a server

Raised when a socket timeout occurs while connecting to a server

Data structure for representing an HTTP URL. Used as a return value for :func:`parse_url`. Both the scheme and host are normalized as they ar

Raised when SSL certificate fails in an HTTPS connection.

Based on :class:`http.client.HTTPConnection` but provides an extra constructor backwards-compatibility layer between older and newer Pythons.

Many of the parameters to this constructor are passed to the underlying SSL socket by means of :py:func:`urllib3.util.ssl_wrap_socket`.

A data container for request body parameters. :param name: The name of this request field. Must be unicode. :param data:

Raised when get_host or similar fails to parse the URL input.

Raised when a pool runs out of connections and no more are allowed.

The header provided was somehow invalid.

Raised when we fail to establish a new connection. Usually ECONNREFUSED.

Raised when something unexpected happens mid-request/response.

Raised when automatic decoding based on Content-Type fails.

Raised by assert_header_parsing, but we convert it to a log.warning statement.

Block Imports To be placed on ``sys.meta_path``. This ensures that the modules specified cannot be imported, even if they are a builtin.

Raised when there is something wrong with a given URL input.

Raised when the maximum number of retries is exceeded. :param pool: The connection pool :type pool: :class:`~urllib3.connectionpool.HTTPConne

Stashes away previously imported modules If we reimport a module the data from coverage is lost, so we reuse the old modules

Fetching HTTPS resources through HTTPS proxies is unsupported

:param socket_handler: Callable which receives a socket argument for one request. :param ready_event: Event which gets set when the s

Raised when a socket timeout error occurs. Catching this error will catch both :exc:`ReadTimeoutErrors <ReadTimeoutError>` and :exc:`ConnectT

Raised when passing an invalid state to a timeout

Body should be :class:`http.client.HTTPResponse` like (have an fp attribute which returns raw chunks) for read_chunked().

Raised when a request enters a pool after the pool has been closed.

Base class for all connection pools, such as :class:`.HTTPConnectionPool` and :class:`.HTTPSConnectionPool`. .. note:: Connection

Raised when we try to add a connection to a full pool in blocking mode.

Base exception used by this module.

HTTPHeaderDict is unusual for a Mapping[str, str] in that it has two modes of address. If we directly try to get an item with a particul

Raised when an existing pool gets a request for a foreign host.

Response length doesn't match expected Content-Length Subclass of :class:`http.client.IncompleteRead` to allow int value for ``partial``

Invalid chunk length in a chunked response.

A BytesIO-like reader returning ``payload`` in ``NUMBER_OF_READS`` calls to ``read``.

From RFC7231: If one or more encodings have been applied to a representation, the sender that applied the encodings MUST generate

Raised when host name resolution fails.

Raised when the connection to a proxy fails.

ProxyManager does not support the supplied scheme

Provides a thread-safe dict-like container which maintains up to ``maxsize`` keys while throwing away the least-recently-used keys beyond

Used as a container for an error reason supplied in a MaxRetryError.

Response needs to be chunked in order to read it as chunks.

Simulates a proxy that performs a simple I/O loop on client/server socket.

Raised when a URL input has an unsupported scheme.

urllib3 encountered an error when trying to rewind a body

API-compatibility wrapper for Python OpenSSL's Connection-class.

A wrapper class that hides a specific object behind a lock. The goal here is to provide a simple way to protect access to an object that

Wrapped socket and whether the connection is verified after the TLS handshake