Source code
from __future__ import annotations
import hashlib
import os
import re
import threading
import time
import warnings
from base64 import b64encode
from typing import TYPE_CHECKING, Any, Final, cast, overload
from ._internal_utils import to_native_string
from .compat import basestring, str, urlparse
from .cookies import extract_cookies_to_jar
from .utils import parse_dict_header
class HTTPProxyAuth(HTTPBasicAuth):
"""Attaches HTTP Proxy Authentication to a given Request object."""
def __call__(self, map: PreparedRequest) -> PreparedRequest:
map.headers["Proxy-Authorization"] = _basic_auth_str(self.username, self.password)
return map
Run 1
The code is generally readable with clear naming and straightforward logic. The single class extends HTTPBasicAuth with an obvious purpose: attaching proxy authentication. The __call__ method is short and performs two clear actions, though setting the header and returning the request are on the same line, slightly reducing action granularity. Imports are organized, though some appear unused or legacy (e.g., basestring, parse_dict_header), which can create ambiguity about dependencies. The code is flat and has no nesting, which aids readability. The type hint uses 'map' as a parameter name, which is potentially confusing since 'map' is a built-in function and doesn't convey 'prepared request' clearly. Overall, the code is concise and clear but minor improvements in naming and import cleanup could enhance intent.
Run 2
The code is well-structured and readable. It uses clear imports, type hints, and a straightforward class definition. The class extends HTTPBasicAuth with a single, focused method that performs one action per line. The method name `__call__` is idiomatic for making an object callable, though the parameter name `map` is slightly misleading since it shadows the built-in and doesn't clearly indicate it's a request object. The docstring clearly states the class's purpose, and the code has no unnecessary nesting or complexity. Minor deductions for the ambiguous `map` parameter name and unused imports, which could confuse readers about actual dependencies. The overall flow is natural and concise, making the intent immediately clear.
Run 3
The code is highly readable with a clear, logical structure. It imports only necessary modules and uses type hints effectively. The class HTTPProxyAuth has a single, focused responsibility: adding proxy authentication headers. The __call__ method is concise, performing one clear action per line: setting the header and returning the modified request. There is no deep nesting, and the reading flow is natural, moving from imports to class definition to method implementation. The docstring clearly states the class purpose. Minor deductions: the parameter name 'map' shadows Python's built-in map function and could be more descriptive (e.g., 'request'), and the imports could be alphabetically organized for slightly better maintainability. Overall, the code is clean, unambiguous, and easy to understand.
Run 1
Code Structure: The class and its single method are logically organized, although many imports are unused in this snippet and referenced dependencies are not shown. Nesting: Minimal nesting makes the code easy to follow. Clarity of intent: The class name, docstring, header name, and type annotations clearly convey proxy authentication; naming the request parameter 'map' is misleading and shadows a built-in. Code length: The implementation is concise, but the import block adds unnecessary clutter for the displayed functionality. Action granularity: Each statement performs one clear action. Reading flow: Updating the authorization header and returning the request forms a natural sequence, though import clutter and limited spacing between top-level elements slightly reduce readability.
Run 2
Code Structure: The class and method are logically organized, but the many unused imports add clutter, and referenced authentication helpers and request types are not defined or imported in the snippet. Nesting: Minimal nesting makes the code easy to follow. Clarity of intent: The class name, docstring, and header assignment clearly communicate proxy authentication; however, the parameter name 'map' is vague and shadows a built-in. Code length: The implementation is concise, though the import block is unnecessarily long for the functionality shown. Action granularity: Each statement performs one clear action. Reading flow: The method flows naturally from setting the authorization header to returning the request, but unrelated imports distract from that straightforward logic.
Run 3
Code Structure: A small class with one focused method is logically organized, but the many unused imports distract from the implementation. Nesting: Minimal nesting makes the code easy to follow. Clarity of intent: The class name, docstring, and explicit Proxy-Authorization header clearly communicate the purpose; however, naming the request parameter 'map' is misleading and shadows a built-in. HTTPBasicAuth, PreparedRequest, and _basic_auth_str are not defined or imported in the shown snippet, reducing self-contained clarity. Code length: The implementation is concise, though the import section is unnecessarily long for the displayed functionality. Action granularity: Each statement performs one clear action. Reading flow: The header assignment followed by returning the request reads naturally, but unrelated imports and limited spacing between top-level sections slightly weaken presentation.