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 is generally well-structured and readable. Imports are logically grouped and alphabetized. Classes and methods have clear names and docstrings that explain intent. Nesting is minimal; the code is flat. Each line typically performs one action. The main weaknesses are the long import list, which increases visual noise, and the unused 'socket' import marked with noqa, which suggests legacy clutter. Type hints improve clarity but add length. Overall, the code is concise, organized, and easy to follow, with only minor readability drawbacks.
Run 3
The code is generally well-structured with clear imports, logical grouping of exceptions, and sensible class organization. It avoids deep nesting and maintains a flat structure. The intent is clear: it defines an abstract BaseAdapter with NotImplementedError methods. However, the code is somewhat verbose due to extensive imports and docstring parameters that repeat type information, which reduces readability. The action granularity is good—one action per line—and reading flow is natural with consistent formatting. Some unused imports (socket, typing) and redundant type hints in docstrings could be trimmed to improve conciseness and clarity.
Run 1
Code Structure: Imports and a small adapter interface are logically organized, although the extensive import block overwhelms the implementation. Nesting: Flat methods with no nested control flow make scanning easy. Clarity of intent: Descriptive method names, type hints, and detailed docstrings clearly communicate the adapter contract; however, PreparedRequest and _t are not defined or imported in the shown code, making annotations harder to interpret. Code length: The implementation is concise, but many imports are unused in this excerpt, and the trivial constructor adds little value. Action granularity: Each statement performs one action, with multiline signatures and imports formatted clearly. Reading flow: The class progresses naturally from initialization to sending and cleanup, though inconsistent import grouping and the lengthy preamble slightly disrupt the flow.
Run 2
Code Structure: Imports are grouped and the adapter interface is logically organized, though many imports are unused in this snippet. Nesting: Flat methods and no nested control flow make scanning easy. Clarity of intent: Descriptive method names, type annotations, and docstrings clearly communicate the transport adapter contract; however, PreparedRequest and _t are not defined or imported in the shown code. Code length: The implementation is concise, but the extensive imports and parameter documentation outweigh the minimal behavior, and the constructor adds little value. Action granularity: Each statement performs one action, with signatures and imports cleanly split across lines. Reading flow: The progression from dependencies to class initialization, sending, and cleanup is natural, although the lengthy import section delays reaching the interface.
Run 3
Code Structure: Imports are grouped and the adapter interface is logically organized, but many imports are unused in this excerpt, and PreparedRequest and _t lack visible definitions. Nesting: Very shallow, making methods easy to scan. Clarity of intent: Descriptive method names, annotations, and docstrings clearly communicate the transport adapter contract, although unresolved annotation names reduce self-containment. Code length: The implementation is concise, but the extensive import list and detailed send docstring dominate a small interface; the constructor adds little value. Action granularity: Each statement performs one action, and parameters and imports are formatted cleanly on separate lines. Reading flow: The progression from imports to class initialization, sending, and cleanup is natural, though import clutter and limited spacing between major sections slightly hinder scanning.