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 generally good readability with clear structure and organization. Imports are logically grouped by source (standard library, third-party, local modules), and the class has a single clear purpose as a base adapter. The send method has a well-documented signature with type hints and descriptive parameter documentation. Nesting is minimal, code length is appropriate for the functionality shown, and each line generally represents one logical action. The reading flow is natural, moving from imports to class definition to methods. However, there are minor readability concerns: the unused socket import with noqa comment is slightly confusing, the wildcard-style grouped imports make some dependencies unclear, and the NotImplementedError pattern in both methods could be improved with an abstract class approach or more explicit documentation of the contract. Overall, the code is quite readable and maintainable.
Run 3
The code is well-structured and readable, with clear separation of imports, class definition, and method signatures. Type hints and docstrings improve clarity of intent. The import block is long but logically grouped. Nesting is minimal and the class is short, avoiding unnecessary complexity. The 'send' method has many parameters but is appropriately documented. One minor issue is the unused `socket` import with a noqa comment, which slightly detracts from cleanliness. Overall, the code follows best practices and is maintainable.
Run 1
Code Structure: Imports are grouped by source, followed by a small, logically organized adapter interface, though many imports are unrelated to the shown class. Nesting: Methods are flat and easy to scan. Clarity of intent: Descriptive method names, type annotations, and detailed docstrings clearly communicate the interface; however, PreparedRequest and _t are not defined or imported in the snippet, making annotation references harder to follow. Code length: The class is concise, but the large import section, trivial constructor, and lengthy parameter documentation add overhead relative to the implementation. Action granularity: Statements generally perform one action per line, and the multiline signature is readable. Reading flow: The progression from imports to initialization, sending, and cleanup is natural, although import clutter and limited separation between import groups slightly weaken it.
Run 2
Code Structure: Imports are grouped and the adapter interface is logically organized, although many imports are unused in this excerpt and annotation names PreparedRequest and _t lack visible definitions. Nesting: There is no unnecessary nesting; methods are flat and easy to inspect. Clarity of intent: Descriptive method names, type annotations, docstrings, and NotImplementedError clearly communicate an abstract transport interface. Code length: The large import block and extensive send documentation outweigh the minimal implementation, and the constructor adds little value. Action granularity: Each statement performs one action, and multiline signatures and imports remain readable. Reading flow: The progression from dependencies to class initialization, sending, and cleanup is natural, but import clutter and unresolved annotation references interrupt comprehension.
Run 3
Code Structure: Imports and a small adapter interface are logically organized, though many imports are unused in this excerpt. Nesting: Methods are flat, with no complex control flow. Clarity of intent: Descriptive method names, type annotations, and parameter documentation clearly communicate the interface; 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 the extensive import block, verbose docstring, and trivial constructor add overhead relative to the functionality shown. Action granularity: Each statement performs a single action, and multiline signatures improve scanning. Reading flow: The progression from imports to class and methods is natural, although the disproportionate import section and limited spacing between top-level sections slightly reduce readability.