Source code
from __future__ import annotations
import calendar
import copy
import time
from collections.abc import Iterator, MutableMapping
from http.cookiejar import Cookie, CookieJar, CookiePolicy
from typing import TYPE_CHECKING, Any, TypeVar, overload
from ._internal_utils import to_native_string
from ._types import is_prepared as _is_prepared
from .compat import Morsel, cookielib, urlparse, urlunparse
import threading
class MockResponse:
"""Wraps a `httplib.HTTPMessage` to mimic a `urllib.addinfourl`.
...what? Basically, expose the parsed HTTP headers from the server response
the way `http.cookiejar` expects to see them.
"""
def __init__(self, hea: Any) -> None:
"""Make a MockResponse for `cookiejar` to read.
:param headers: a httplib.HTTPMessage or analogous carrying the headers
"""
self._headers = hea
def inf(self) -> Any:
return self._headers
def get(self, nam: str) -> Any:
self._headers.getheaders(nam)
Run 1
The code has some positive aspects: clear imports, a concise class definition, and a helpful docstring explaining the purpose. The __init__ method is clear with reasonable parameter naming ('hea' is slightly unclear though). However, there are notable issues: 'inf()' method name is ambiguous and doesn't convey its purpose (should likely be 'info()'), the 'get()' method is missing a return statement, making it appear to return None despite presumably intended to return header values. The parameter names 'hea' and 'nam' are unnecessarily abbreviated, reducing clarity. The overall structure is flat and straightforward, but the action granularity is broken by the missing return in get(). The reading flow is interrupted by the confused method naming and incomplete implementation, suggesting the code may be unfinished or poorly maintained.
Run 2
The code has some strengths like type hints, docstrings, and a clear class structure, but several issues hurt readability. The MockResponse class is short and conceptually simple, yet method names like 'inf' and 'hea' are confusingly abbreviated. The get() method calls getheaders() but doesn't return the result, which makes intent ambiguous and likely indicates a bug. The imports are overly broad, mixing stdlib, third-party, and local modules without clear grouping, and several imports appear unused. The class docstring uses informal language ('...what?'), which is unclear for documentation. These factors make the code harder to understand than necessary, resulting in a moderate readability score.
Run 3
The code has some redeeming qualities: it uses type hints, follows import ordering partially, and includes docstrings. However, readability is severely undermined by several competing factors. The class and method names are structurally unclear—MockResponse has a method inf() that seems to return headers, but the docstring says it mocks httplib.HTTPMessage, and there's no explanation of why inf exists. The get() method lacks a return statement, which would silently return None—likely a bug but certainly ambiguous intent. Some imported modules (calendar, copy, threading) and type names are unused, adding noise. Naming inconsistencies like hea and nam instead of headers and name obscure meaning. Although the code is short and mostly flat, the lack of clear purpose, missing return, and abbreviated identifiers make it difficult to follow at a glance. Correcting these issues would significantly improve readability.
Run 1
Code Structure: The small class logically groups header-wrapper behavior, but numerous unused imports and an out-of-order threading import add clutter. Nesting: Methods are flat and easy to scan. Clarity of intent: The class docstring explains the adapter's purpose, but abbreviated names such as hea, inf, and nam obscure meaning. The constructor documentation refers to headers rather than its actual parameter, and get discards the underlying result, making its intended behavior unclear. Code length: The implementation is concise, although imports dominate this short snippet unnecessarily. Action granularity: Each statement performs a single action, with no compressed multi-action lines. Reading flow: The class and methods follow a natural sequence, but import organization, inconsistent naming, and informal documentation interrupt an otherwise straightforward reading experience.
Run 2
Code Structure: The small class is logically organized, but numerous unused imports and the misplaced threading import add clutter. Nesting: Methods are flat and easy to scan. Clarity of intent: The class docstring explains its adapter role, but abbreviated names such as hea, inf, and nam obscure meaning. The constructor documentation names headers rather than hea, and get does not return the retrieved value, making its intended behavior unclear. Code length: The class is concise, although the import block is disproportionately long for the functionality shown. Action granularity: Each statement performs a single action. Reading flow: Methods follow a natural constructor-then-accessors sequence, but inconsistent import organization, limited spacing, and the conversational docstring interrupt an otherwise straightforward flow.
Run 3
Code Structure: A small, logically organized wrapper class, but numerous unused imports and inconsistent import grouping add clutter. Nesting: Very shallow, with straightforward methods and no nested control flow. Clarity of intent: The class docstring explains its purpose, but abbreviated names such as hea, inf, and nam obscure meaning; the constructor documentation names headers rather than hea. The get method does not return the underlying result, making its intent less clear. Code length: The class is concise, though the import block is disproportionately large for the functionality shown. Action granularity: Each executable line performs one clear action. Reading flow: Methods follow a natural constructor-then-accessors sequence, but informal documentation, cramped top-level spacing, and threading imported after local imports interrupt consistency.