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:
def __init__(self, headers: Any) -> None:
self._headers = headers
def info(self) -> Any:
return self._headers
def getheaders(self, name: str) -> Any:
self._headers.getheaders(name)
Run 1
The code is minimal and generally readable, but it suffers from a few clarity and completeness issues. The structure is straightforward: imports, a class, and a constructor with two methods. Nesting is flat, and each action is on its own line, which is good. However, the `getheaders` method has a clear bug: it calls `self._headers.getheaders(name)` but does not return the result, making its intent ambiguous and likely incorrect. The `_headers` attribute is only type-hinted as `Any`, which reduces clarity. The method `info()` returning `self._headers` is simple but lacks explanation of the expected header format. The code is concise but overly sparse—some methods are empty, and the class-level docstring is absent. The reading flow is natural, but the missing return statement and lack of documentation hurt overall readability. With clearer type hints, a docstring, and fixing the return bug, this would be much more readable.
Run 2
The code is poorly structured and contains multiple critical flaws. It begins with many unused imports, suggesting a copy-paste or unmaintained file. The MockResponse class is incomplete and incorrectly indented, with blank lines inside class and method bodies. The getheaders method calls self._headers.getheaders(name) but does not return the result, making it functionally broken. The code lacks docstrings, proper formatting, and consistent spacing. The reading flow is disrupted by disorganized blank lines and unclear intent. Action granularity is acceptable, but nesting is absent. Overall, the file appears to be an unfinished sketch, lacking clarity of purpose and proper structure.
Run 3
The code has some positive structural elements like clear imports, type hints, and a logical class definition with an initializer. However, it fails significantly on readability criteria. The most critical issue is in the getheaders method, which is missing a return statement, rendering it functionally broken and creating ambiguous intent — this alone substantially lowers its readability score. Additionally, there are excessive blank lines within the class that disrupt the natural reading flow. Several imports appear unused (calendar, copy, time, CookieJar, CookiePolicy, Iterator, MutableMapping, TYPE_CHECKING, TypeVar, overload, etc.), adding noise and making the code's actual dependencies unclear. The action granularity is adequate, but the overall code length is unnecessarily long due to unused imports and formatting issues. The nesting is flat, which is good, but the clarity of intent is severely compromised by the broken method and unexplained imports. Though the code structure is basically logical and flat, the missing return statement and clutter create ambiguity about the code's true purpose.
Run 1
Code Structure: The class is logically organized, but numerous unused imports and the separately placed threading import add clutter. Nesting: Methods are flat and easy to follow. Clarity of intent: MockResponse and its method names suggest a response-header adapter, although Any annotations provide little detail. The missing return in getheaders makes its intended behavior unclear. Code length: The implementation is concise, but excessive imports and empty lines unnecessarily expand the snippet. Action granularity: Each statement performs a single action, with no compressed expressions. Reading flow: Constructor followed by access methods reads naturally, but inconsistent spacing and import organization interrupt the flow.
Run 2
Code Structure: The class and methods are logically organized, but numerous unused imports and inconsistent import grouping add clutter. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: MockResponse and its methods suggest a response-header adapter, although Any annotations provide little detail and getheaders lacks a return statement, making its intended behavior unclear. Code length: The implementation is concise, but excessive blank lines and unused imports unnecessarily lengthen the snippet. Action granularity: Each statement performs one action, with no compressed multi-action lines. Reading flow: Method order is natural, but whitespace gaps and the misplaced threading import interrupt the flow.
Run 3
Code Structure: The class and its methods are logically organized, but numerous unused imports and inconsistent import grouping add clutter. Nesting: The code is flat, with no complex nesting. Clarity of intent: MockResponse and its methods suggest a response-header wrapper, though broad Any annotations provide little guidance, and getheaders discards its result, making its intended behavior unclear. Code length: The implementation is concise, but excessive blank lines and unused imports unnecessarily expand it. Action granularity: Each statement performs a single action. Reading flow: Methods follow a natural order, but irregular spacing and threading appearing after local imports disrupt the flow.