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, r: PreparedRequest) -> PreparedRequest:
r.headers["Proxy-Authorization"] = _basic_auth_str(self.username, self.password)
return r
Run 1
The code is well-structured with clear imports, type hints, and a single, focused class. It uses modern Python features like `from __future__ import annotations` and explicit typing, which improves clarity. The class inherits from a presumably well-defined `HTTPBasicAuth` and overrides `__call__` concisely. Nesting is minimal, with only one method and one conditional-free line inside it. The purpose is unambiguous: attach proxy authentication headers. However, some imported modules (`hashlib`, `os`, `re`, `threading`, etc.) are not used in the visible snippet, which slightly reduces perceived cleanliness. The action granularity is appropriate—each line performs one logical step. Reading flow is natural, aided by the docstring and consistent naming. Overall, very readable despite minor unused imports.
Run 2
The code is highly readable due to its simple, logical structure and clear intent. The class has one concise method that performs a single action: setting a header. Nesting is flat, with no conditional or loop complexity. Naming is descriptive ('HTTPProxyAuth'), and the docstring clearly explains the class purpose. Imports are organized and separated. The only minor deduction is the use of a private helper function '_basic_auth_str' which is not defined in the snippet, slightly reducing immediate clarity for a reader unfamiliar with the module. Overall, the code is concise, follows standard Python conventions, and reads naturally from top to bottom.
Run 3
The code is highly readable with a clear, focused purpose. The structure is logical: imports are organized and the class definition is straightforward with a single, well-documented method. There is minimal nesting, and the inheritance from HTTPBasicAuth explicitly communicates intent. The action granularity is good—one meaningful operation per line—and the flow is natural. The only minor drawbacks are the large number of unused imports and type-related imports that add noise, and the reliance on an implicit base class definition rather than showing its implementation. These factors slightly reduce conciseness and immediate clarity, but overall the code is easy to understand.
Run 1
Code Structure: The class and method are logically organized, though numerous unused imports add clutter. Nesting: Minimal nesting makes the implementation easy to follow. Clarity of intent: The class name, docstring, and explicit Proxy-Authorization header clearly communicate its purpose; however, HTTPBasicAuth, PreparedRequest, and _basic_auth_str are not defined or imported in the snippet, limiting standalone understanding. Code length: The implementation is concise, but the import section is disproportionate to the functionality shown. Action granularity: Each statement performs a single clear action. Reading flow: The method naturally progresses from setting the authentication header to returning the request, although the unrelated imports distract from that flow.
Run 2
Code Structure: A focused class and single method provide logical organization, though numerous unrelated imports add clutter. Nesting: Minimal nesting makes the code easy to follow. Clarity of intent: The class name, docstring, method signature, and header assignment clearly communicate proxy authentication behavior; however, HTTPBasicAuth, PreparedRequest, and _basic_auth_str are not defined or imported in the snippet, limiting standalone understanding. Code length: The implementation is concise, but unused imports unnecessarily lengthen the excerpt. Action granularity: Each statement performs one clear action. Reading flow: The method naturally progresses from setting the authorization header to returning the request, although the import block and limited spacing before the class slightly weaken presentation.
Run 3
Code Structure: The class and its single method are logically organized, but numerous unused imports clutter the snippet, and referenced dependencies are not defined or imported here. Nesting: Minimal nesting makes the code easy to follow. Clarity of intent: The class name, docstring, and explicit Proxy-Authorization header clearly communicate its purpose, although the parameter name 'r' is less descriptive than 'request'. Code length: The implementation is concise, but the import block is disproportionately long for the shown functionality. Action granularity: Each statement performs one clear action. Reading flow: The method flows naturally from setting the authentication header to returning the request; clearer import grouping and an additional blank line before the class would improve presentation.