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, c: Any) -> None:
"""Make a MockResponse for `cookiejar` to read.
:param headers: a httplib.HTTPMessage or analogous carrying the headers
"""
self._headers = c
def a(self) -> Any:
return self._headers
def b(self, d: str) -> Any:
self._headers.getheaders(d)
Run 1
The code has a clear structure with imports and a single class, but it is misleading and unfinished. The docstrings reference 'headers' but the parameter is named 'c', and method names 'a' and 'b' are meaningless, obscuring intent. The 'b' method calls getheaders without returning the result, which is likely a bug or incomplete implementation. There are also unused imports (calendar, time, threading, etc.) that clutter the code. While nesting is low and line length is concise, action granularity fails because the getheaders call lacks a return. The reading flow is natural at the top, but the class body is confusing and incomplete. Overall, the code lacks clarity and appears to be a stub, making it hard to read despite its simple structure.
Run 2
The code exhibits several readability issues. Structure is logical but incomplete - the class is named MockResponse but methods are cryptically named a() and b(), which severely obscures intent. Nesting is acceptable (flat), but this is undermined by unclear purpose. The b() method doesn't return anything despite being called like a getter, which is confusing. Action granularity is mostly fine with one action per line. Reading flow is hindered by the placeholder-like method names and missing return statement. The docstrings partially help but don't compensate for the poor naming. Code length is reasonable - not overly long. Overall, while imports and basic structure follow Python conventions, the ambiguous method names (a, b) and likely bug (missing return in b) make this code difficult to understand and maintain without additional context.
Run 3
The code shows several significant readability issues. The class name and method names (a, b, c) are completely opaque, revealing nothing about their purpose. The docstring mentions 'headers' but the parameter is named 'c', creating confusion. Method 'b' performs an operation but doesn't return the result, making it dead code. Multiple imports (calendar, time, threading, copy) appear unused. The nested import structure mixes standard library and third-party imports without clear organization. While there is minimal nesting and reasonable line length, the lack of meaningful names, unclear intent, and dead code drastically reduce readability. The docstring itself acknowledges confusion ('...what?'), indicating the author was aware of the obscurity. Action granularity is acceptable but cannot compensate for the fundamental lack of clarity in naming and purpose.
Run 1
Code Structure: A small, logically organized wrapper class, but numerous unused imports and the misplaced threading import add clutter. Nesting: Flat methods with no deeply nested control flow are easy to follow. Clarity of intent: Class documentation explains the purpose, but names such as a, b, c, and d obscure method roles and parameter meanings. The constructor docstring describes a parameter named headers rather than c, and b discards the getheaders result, leaving its intended behavior unclear. Code length: The class is concise, though the import block is disproportionately large for the functionality shown. Action granularity: Each statement performs a single action. Reading flow: Simple method bodies support straightforward reading, but cryptic naming, inconsistent documentation, and limited spacing around the class weaken the overall flow.
Run 2
Code Structure: The small class is logically organized, but numerous unused imports clutter the module and threading is separated from other standard-library imports. Nesting: Methods are flat and easy to scan. Clarity of intent: The class docstring explains its cookiejar compatibility role, but names a, b, c, and d obscure method and parameter purposes. The constructor documentation refers to headers rather than its actual parameter c. Method b calls getheaders without returning its result, leaving its intended behavior unclear. Code length: The implementation is concise, though imports outweigh the functional code. Action granularity: Each statement performs one action, with no compressed multi-action lines. Reading flow: The simple class layout helps, but vague naming, inconsistent import grouping, and documentation mismatches interrupt understanding.
Run 3
Code Structure: A small class groups related header-wrapper behavior logically, but numerous unused imports and misplaced threading import clutter the module. Nesting: Methods are flat and easy to scan. Clarity of intent: The class docstring explains the adapter's purpose, but names a, b, c, and d obscure method roles and parameter meanings. The constructor docstring refers to headers rather than its actual parameter c, and b calls getheaders without returning its result, making its intended behavior unclear. Code length: The class is concise, although imports substantially outweigh the implementation. Action granularity: Each executable line performs a single action. Reading flow: Straightforward method sequencing helps, but inconsistent import grouping, cryptic identifiers, and mismatched documentation interrupt comprehension.