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 MockRequest:
"""Wraps a `requests.PreparedRequest` to mimic a `urllib2.Request`.
The code in `http.cookiejar.CookieJar` expects this interface in order to correctly
manage cookie policies, i.e., determine whether a cookie can be set, given the
domains of the request and the cookie.
The original request object is read-only. The client is responsible for collecting
the new headers via `get_new_headers()` and interpreting them appropriately. You
probably want `get_cookie_header`, defined below.
"""
type: str
def __init__(self, request: PreparedRequest) -> None:
assert _is_prepared(request)
self._r = request
self._new_headers: dict[str, str] = {}
self.type = urlparse(self._r.url).scheme
def get_type(self) -> str:
return self.type
def get_host(self) -> str:
return urlparse(self._r.url).netloc
def get_origin_req_host(self) -> str:
return self.get_host()
def get_full_url(self) -> str:
# Only return the response's URL if the user hadn't set the Host
# header
if not self._r.headers.get("Host"):
return self._r.url
# If they did set it, retrieve it and reconstruct the expected domain
parsed = urlparse(self._r.url)
# Reconstruct the URL as we expect it
return urlunparse(
[
parsed.scheme,
(to_native_string(self._r.headers["Host"], encoding="utf-8")),
parsed.path,
parsed.params,
parsed.query,
parsed.fragment,
]
)
def is_unverifiable(self) -> bool:
return True
def has_header(self, name: str) -> bool:
return name in self._r.headers or name in self._new_headers
def get_header(self, name: str, default: str | None = None) -> str | None:
return self._r.headers.get(name, self._new_headers.get(name, default)) # type: ignore[return-value]
def add_header(self, key: str, val: str) -> None:
"""cookiejar has no legitimate use for this method; add it back if you find one."""
raise NotImplementedError(
"Cookie headers should be added with add_unredirected_header()"
)
def add_unredirected_header(self, name: str, value: str) -> None:
self._new_headers[name] = value
def get_new_headers(self) -> dict[str, str]:
return self._new_headers
@property
def unverifiable(self) -> bool:
return self.is_unverifiable()
@property
def origin_req_host(self) -> str:
return self.get_origin_req_host()
@property
def host(self) -> str:
return self.get_host()
Run 1
The code is highly readable with clear structure and consistent style. The class has a single, well-documented purpose. Methods are short and focused, each performing one action. Nesting is minimal (only one if-block in get_full_url). Type hints are used throughout, enhancing clarity. The docstring explains the class's role and its relationship to cookiejar's expected interface. Method names are descriptive and follow Python conventions. The only minor issues are the # type: ignore comment in get_header and the absence of a docstring on that method, but these are negligible. The code flows naturally from constructor to properties, making it easy to follow.
Run 2
The code is well-structured and readable. It has a clear class purpose, follows consistent naming conventions, and uses docstrings effectively. Each method has a single responsibility, and action granularity is appropriate, with one main operation per line. Nesting is minimal, and the overall flow is logical—request wrapping methods are grouped and easy to follow. The only slight deduction comes from a few verbose type annotations and minor redundancy in property/method pairs, but these do not significantly hinder readability.
Run 3
The code is generally clear and well-structured, with a single class wrapping a PreparedRequest for cookie handling. Methods are short, focused, and mostly flat, with minimal nesting. Naming and comments clarify intent. Minor issues: the get_full_url method contains a multi-line list with a long cast expression, slightly reducing readability. The type annotation MockRequest.type is declared without initialization, relying on __init__, which is acceptable but not ideal. Some methods (e.g., get_new_headers) are trivial but add length. Overall, the logical organization and clear purpose make it quite readable, though not perfect.
Run 1
Code Structure: The class logically groups request-adapter methods, although import ordering is inconsistent and several imports are unused in this snippet. Nesting: Minimal nesting and an early return make control flow easy to follow. Clarity of intent: The class docstring, descriptive method names, and type annotations clearly explain its purpose; the abbreviated _r attribute and externally defined PreparedRequest slightly reduce local clarity. Code length: Mostly concise, though some wrapper methods and comments are repetitive. Action granularity: Statements generally perform one action per line; the nested dictionary lookups in get_header are slightly denser. Reading flow: Methods progress naturally from initialization through request information and header handling to properties, with consistent formatting overall. Minor distractions include redundant parentheses, a long type-ignore line, and a comment referring to a response when the class wraps a request.
Run 2
Code Structure: The class logically groups request-adapter methods and properties, though numerous unused imports and inconsistent import ordering add clutter. Nesting: Methods are flat, with only one simple conditional and an early return. Clarity of intent: The detailed class docstring, descriptive method names, and type annotations explain the adapter's purpose well; the abbreviated attribute `_r` and externally defined `PreparedRequest` annotation require additional context. Code length: Most methods are concise, but some comments repeat obvious operations and the imports unnecessarily lengthen the excerpt. Action granularity: Statements generally perform one action per line; the nested dictionary lookup in `get_header` is slightly denser. Reading flow: Initialization, interface methods, and property aliases follow a natural sequence, with minor distractions from redundant comments, a stray blank line, and the long return line.
Run 3
Code Structure: A cohesive adapter class groups related request-interface methods logically, although numerous unused imports and inconsistent import ordering add clutter. Nesting: Very shallow, with a simple conditional and early return. Clarity of intent: The class docstring, descriptive method names, and type annotations explain its purpose well; the abbreviated attribute `_r` and unexplained `PreparedRequest` reference slightly reduce clarity. Code length: Methods are concise, though some comments repeat obvious operations and imports are excessive for this snippet. Action granularity: Statements generally perform one action per line; the nested header lookup is compact but requires a little extra attention. Reading flow: Initialization followed by interface methods and properties creates a natural progression, with minor formatting inconsistencies and a long return line interrupting readability.