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 a(
self,
c: PreparedRequest,
d: bool = False,
e: _t.TimeoutType = None,
f: _t.VerifyType = True,
g: _t.CertType = None,
h: 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 b(self) -> None:
"""Cleans up adapter specific items."""
raise NotImplementedError
Run 1
The code has good structural elements such as organized imports and clear docstrings, but readability is undermined by vague naming and unnecessary abstraction. The method names 'a' and 'b' and parameter names 'c', 'd', etc. obscure intent, despite the docstrings explaining them. The imports are grouped logically, and the class structure is simple and flat, which helps. However, the misleading or generic naming requires constant cross-referencing with documentation, breaking natural reading flow. The method signature is still reasonably flat, and action granularity is fine, but the overall clarity of intent suffers significantly. Eliminating unused or redundant imports (e.g., socket, typing) would also reduce noise.
Run 2
The imports are organized but excessively long, with multiple unused items (socket, basestring, CaseInsensitiveDict, many exceptions) cluttering the module. The class and method names (BaseAdapter.a, .b) are meaningless and obscure intent, while parameter names (c, d, e, f, g, h) fail to communicate purpose, contradicting the detailed docstring. The docstring references parameter names (request, stream, timeout) that do not match actual parameters, creating confusion. Type hints use undefined names (_t.TimeoutType), further reducing clarity. Nesting is flat and code length is moderate, but the cryptic naming, unused imports, and misleading documentation severely undermine readability. Action granularity and reading flow are adequate within method bodies, but the overall structure lacks logical cohesion. A reader must cross-reference the docstring and infer parameter meanings from context, making the code difficult to maintain. More meaningful names, removal of unused imports, and alignment between documentation and code would significantly improve clarity.
Run 3
The code imports are well-organized, but the class method 'a' uses meaningless single-letter parameter names (c, d, e, f, g, h) that directly contradict the documented parameters (request, stream, timeout, verify, cert, proxies), making the code highly ambiguous. The method name 'a' and 'b' are equally uninformative, obscuring their purpose despite the docstrings. The nested list of imports is somewhat verbose but standard. While the code has flat nesting and one action per line, clarity of intent is severely compromised by the obfuscated naming, which appears intentionally degraded. This makes the code nearly unreadable despite proper structure and formatting, because readers cannot map parameters to their documented meanings without constant cross-referencing.
Run 1
Code Structure: Imports and the adapter class are logically separated, but many imports are unused in this excerpt and distract from the small interface. Nesting: Very flat, with no nested control flow. Clarity of intent: The class and docstrings explain the transport interface, but method names a and b and parameters c through h obscure meaning. Docstring parameter names do not match the signature, and PreparedRequest and _t are not defined or imported in the excerpt, making annotations harder to interpret. Code length: The implementation is concise, but the lengthy import block and documentation dominate the minimal functionality. Action granularity: Statements generally perform one action per line; the multiline signature is easy to scan. Reading flow: Conventional imports followed by a class provide a natural progression, but cryptic identifiers and mismatched documentation interrupt comprehension.
Run 2
Code Structure: Imports and the adapter class are logically organized, but extensive unused imports obscure the small interface. Nesting: Very flat, with no nested control flow. Clarity of intent: The class name, return types, and docstrings establish a transport-adapter purpose, but single-letter method and parameter names are ambiguous. Docstring parameter names do not match the signatures, and PreparedRequest and _t are not defined or imported in the snippet, making annotations harder to interpret. Code length: The actual interface is concise, but the import block and lengthy documentation are disproportionate to the implementation shown. Action granularity: Each statement performs one action, and multiline signatures are easy to scan. Reading flow: Conventional imports followed by a class and methods provide a natural sequence, but irrelevant imports and mismatched documentation interrupt comprehension.
Run 3
Code Structure: Imports are grouped and the adapter class has clearly separated methods, but many imports are irrelevant to the shown implementation. Nesting: Very flat, with no nested control flow. Clarity of intent: Class and docstrings explain the transport interface, but method names a/b and parameter names c–h obscure meaning. Docstring parameter names do not match the signatures, and PreparedRequest and _t are not defined or imported in the snippet, making annotations harder to interpret. Code length: The implementation is concise, but extensive imports and documentation disproportionately outweigh the minimal behavior. Action granularity: Each statement performs one action, and multiline signatures improve scanning. Reading flow: Conventional imports-to-class organization helps, but the large import preamble and mismatch between descriptive documentation and opaque identifiers interrupt comprehension.