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 organization with clean imports (stdlib, third-party, local) and clear class/method structure. The docstrings accurately describe purpose and parameters. The abstract BaseAdapter is concise, with NotImplementedError appropriately signaling interface methods. Type hints enhance clarity without clutter. Nesting is minimal since this is an interface definition. Action granularity is appropriate - each line serves a single purpose. Reading flow follows conventional Python patterns. Some minor deductions: the unused `socket` import with noqa comment and the wildcard-ish import approach (though specific names are used) create slight noise. The `# noqa: F401` on socket suggests dead code that could be removed. The parameter list is lengthy but unavoidable for this adapter pattern, though grouping related parameters could improve readability. Overall, this is well-structured, maintainable code that clearly communicates intent.
Run 3
The code is well-structured with clear separation of imports, class definition, and method signatures. It uses type hints and docstrings to clarify intent. The imports are grouped logically, though some exceptions are split across two blocks, which slightly disrupts flow. Nesting is flat, and each method has a single, explicit action (raising NotImplementedError). The send method's signature is long but appropriately documented. Minor readability issues include redundant typing imports and the use of aliases like '_t' without visible definition, which could confuse readers. Overall, it is professional and easy to understand.
Run 1
Code Structure: Imports are grouped and the adapter interface is logically organized, though many imports are irrelevant to this excerpt. Nesting: Methods are flat, with no complex control flow. Clarity of intent: Descriptive method names and detailed docstrings clearly explain the interface, but PreparedRequest and _t are not defined or imported in the shown code, making annotations harder to interpret. Code length: The implementation is concise, although the extensive import list and trivial constructor add overhead relative to its functionality. Action granularity: Each statement performs one action, and the multiline signature is easy to scan. Reading flow: The progression from imports to initialization, sending, and cleanup is natural; missing annotation definitions and inconsistent spacing between import groups slightly interrupt readability.
Run 2
Code Structure: Imports are grouped and the adapter interface is logically organized, although many imports are unused in this excerpt. Nesting: Methods are flat, with no complex control flow. Clarity of intent: Class and method names, annotations, and docstrings clearly communicate the transport interface; however, PreparedRequest and _t are not defined or imported in the shown code, making type references harder to follow. Code length: The implementation is concise, but the extensive imports and verbose send docstring outweigh the small amount of executable code. Action granularity: Each statement performs a single action, and the multiline signature is easy to scan. Reading flow: The progression from imports to initialization, sending, and cleanup is natural, though the long import section delays reaching the interface.
Run 3
Code Structure: Imports and a small adapter class are logically organized, though many imports are unused in this excerpt. Nesting: Methods are flat, with no nested control flow. Clarity of intent: Descriptive method names, type annotations, and docstrings clearly communicate the transport adapter interface; however, PreparedRequest and _t are not defined or imported in the shown code, making annotations harder to follow. Code length: Method implementations are concise, but the large import block and lengthy parameter documentation outweigh the minimal functionality. Action granularity: Statements generally perform one action per line, and multiline signatures remain easy to scan. Reading flow: The progression from imports to initialization, sending, and cleanup is natural, although import clutter and inconsistent spacing between top-level sections slightly interrupt it.