Source code
from __future__ import annotations
import os.path
import socket # noqa: F401
import typing
import warnings
from typing import Any
from urllib3.exceptions import (
ClosedPoolError,
ConnectTimeoutError,
LocationValueError,
MaxRetryError,
NewConnectionError,
ProtocolError,
ReadTimeoutError,
ResponseError,
)
from urllib3.exceptions import HTTPError as _HTTPError
from urllib3.exceptions import InvalidHeader as _InvalidHeader
from urllib3.exceptions import ProxyError as _ProxyError
from urllib3.exceptions import SSLError as _SSLError
from urllib3.poolmanager import PoolManager, proxy_from_url
from urllib3.util import Timeout as TimeoutSauce
from urllib3.util import parse_url
from urllib3.util.retry import Retry
from .auth import _basic_auth_str
from .compat import basestring, urlparse
from .cookies import extract_cookies_to_jar
from .exceptions import (
ConnectionError,
ConnectTimeout,
InvalidHeader,
InvalidProxyURL,
InvalidSchema,
InvalidURL,
ProxyError,
ReadTimeout,
RetryError,
SSLError,
)
from .models import Response
from .structures import CaseInsensitiveDict
from .utils import (
DEFAULT_CA_BUNDLE_PATH,
get_auth_from_url,
get_encoding_from_headers,
prepend_scheme_if_needed,
select_proxy,
urldefragauth,
)
from ._types import is_prepared as _is_prepared
class BaseAdapter:
"""The Base Transport Adapter"""
def __init__(self) -> None:
super().__init__()
def send(
self,
request: PreparedRequest,
stream: bool = False,
timeout: _t.TimeoutType = None,
verify: _t.VerifyType = True,
cert: _t.CertType = None,
proxies: dict[str, str] | None = None,
) -> Response:
"""Sends PreparedRequest object. Returns Response object.
:param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
:param stream: (optional) Whether to stream the request content.
:param timeout: (optional) How long to wait for the server to send
data before giving up, as a float, or a :ref:`(connect timeout,
read timeout) <timeouts>` tuple.
:type timeout: float or tuple
:param verify: (optional) Either a boolean, in which case it controls whether we verify
the server's TLS certificate, or a string, in which case it must be a path
to a CA bundle to use
:param cert: (optional) Any user-provided SSL certificate to be trusted.
:param proxies: (optional) The proxies dictionary to apply to the request.
"""
raise NotImplementedError
def close(self) -> None:
"""Cleans up adapter specific items."""
raise NotImplementedError
Run 1
The code demonstrates good organization with logical import grouping (stdlib, third-party, local) and clear separation of concerns. The BaseAdapter class has a single responsibility with well-documented abstract methods. Nesting is minimal and the code flows naturally. Type hints improve readability and intent. The docstrings are comprehensive, explaining parameters clearly. Import section is lengthy but necessary for the adapter's functionality. Minor deductions: some unused imports (socket with noqa, typing) create slight noise, and the imports could potentially be condensed. The class structure is clean with no unnecessary complexity or deep nesting. Action granularity is appropriate - each method has a single clear purpose. The code achieves good balance between being concise and explicit. Overall, this is highly maintainable code that would be easily understood by other developers.
Run 2
The code demonstrates strong readability with clear logical organization - imports are systematically grouped by source (standard library, third-party, local modules) and functionality. The nesting depth is minimal, with only class-level and method-level indentation. Intent is explicit through name selection and the comprehensive docstring that clearly documents parameters and return values. Code length is appropriate for a base adapter class - it defines an interface without unnecessary implementation details. Action granularity follows the principle of one action per line, with each method raising NotImplementedError to signal abstract methods. Reading flow is natural: imports lead to class definition, then the two core methods. Minor deductions: the explicit `super().__init__()` call is redundant for a base class, and some type annotations could be slightly simplified. Overall, this code is well-structured, maintains flat hierarchies, and effectively communicates its purpose as an abstract base class for HTTP adapters.
Run 3
The code is highly readable. Imports are well-organized and grouped logically (standard library, third-party, local modules), with clear aliasing where needed. The BaseAdapter class has a clear purpose, with concise docstrings explaining method behavior and parameters. The send() method uses descriptive parameter names and type hints, enhancing clarity. Action granularity is appropriate—each method performs a single, clear action (raising NotImplementedError). Nesting is minimal, and the code follows a natural top-down reading flow. The only minor drawback is the large number of imports, but this is justified by the module's role as an adapter layer. Overall, the structure is clean, intent is explicit, and length is appropriate for the functionality provided.
Run 1
Code Structure: Imports are grouped and the adapter interface is logically organized, although many imports are unused in this snippet. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: Descriptive method names, type annotations, and detailed docstrings clearly communicate the transport interface; however, PreparedRequest and _t are not defined or imported here, making the annotations harder to interpret. Code length: The implementation is concise, but the extensive imports and trivial constructor add unnecessary bulk relative to the functionality shown. Action granularity: Each statement performs one clear action, with readable multiline signatures and imports. Reading flow: The progression from imports to class initialization, sending, and cleanup is natural, though the lengthy import section delays reaching the actual interface.
Run 2
Code Structure: Imports are grouped and the adapter interface is logically organized, although many imports are unused in this snippet. Nesting: Methods are flat, with no complicated control flow. Clarity of intent: Descriptive method names, type annotations, and detailed documentation clearly communicate the interface; however, PreparedRequest and _t are not defined or imported in the provided code, making annotations harder to trace. Code length: The implementation is concise, but the extensive imports and parameter documentation outweigh the small interface, and the constructor adds little value. Action granularity: Each executable statement performs one action, and multiline signatures remain easy to scan. Reading flow: The progression from imports to class initialization, sending, and cleanup is natural, though the lengthy import section delays reaching the core functionality.
Run 3
Code Structure: Imports precede a clearly defined adapter interface, although many imports are unused in this snippet and PreparedRequest and _t lack visible definitions. Nesting: Flat class methods with no nested control flow are easy to scan. Clarity of intent: Descriptive method names, annotations, docstrings, and NotImplementedError clearly communicate the interface contract. Code length: The extensive import section and parameter documentation outweigh the minimal implementation; the constructor adds little value. Action granularity: Each statement performs a single action, and multiline imports and signatures are readable. Reading flow: The progression from initialization to sending and cleanup is natural, but import clutter and unresolved annotation references interrupt comprehension.