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: imports are logically grouped (standard library, typing, internal modules), class and method names clearly express intent, and the class docstring succinctly explains its purpose. The method body is flat, concise, and performs one action per line—setting a header and returning the prepared request. Type hints, final/overload imports, and future annotations indicate careful structure. Minor deductions for unused imports (hashlib, os, re, threading, time, warnings, b64encode, cast, overload, etc.) which reduce clarity slightly, but overall the organization and flow are excellent.
Run 3
The code demonstrates moderate readability but suffers from unnecessary complexity. The class structure is logical and the __call__ method has clear intent with single-action granularity. However, the excessive imports—many of which appear unused for this specific class definition—clutter the beginning and obscure the actual purpose. The presence of TYPE_CHECKING, Final, overload, and various utility imports without context creates ambiguity about dependencies. Deep inheritance (HTTPProxyAuth extends HTTPBasicAuth) is straightforward, but the nesting is acceptable. The main readability issue is the disproportionate import block relative to the tiny class body, making the file feel longer than necessary. While the actual method is concise and clear, the overall structure lacks cohesion because unrelated imports distract from the core logic. Better import organization or placement of this class within a larger module would improve clarity, as would removing speculative imports. The code itself is clean, but its isolated presentation with excessive dependencies reduces its readability score.
Run 1
Code Structure: The class and method are logically organized, but numerous unrelated imports clutter the snippet, and required symbols such as HTTPBasicAuth and _basic_auth_str are not defined or imported here. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The class name, docstring, method signature, and explicit Proxy-Authorization header clearly convey its purpose. Code length: The implementation is concise, although the unused imports add unnecessary length. Action granularity: Each statement performs one clear action. Reading flow: The method naturally proceeds from setting the authentication header to returning the request; however, the excessive import block and missing dependencies interrupt understanding of the snippet as a standalone unit.
Run 2
Code Structure: The class and its single method are logically organized, but numerous unused imports add clutter. Nesting: Minimal nesting makes the code easy to follow. Clarity of intent: The class name, docstring, and explicit Proxy-Authorization assignment clearly communicate its purpose; however, HTTPBasicAuth, PreparedRequest, and _basic_auth_str are not defined or imported in the snippet. Code length: The implementation is concise, although the import section is disproportionately long. Action granularity: Each statement performs one clear action. Reading flow: The method flows naturally from setting the authentication header to returning the request, but unrelated imports and limited spacing between top-level sections slightly disrupt readability.
Run 3
Code Structure: A small, logically organized class with a focused method, though numerous unused imports clutter the snippet. Nesting: Minimal nesting makes the implementation easy to scan. Clarity of intent: The class name, docstring, method signature, and explicit header assignment clearly convey proxy authentication; however, HTTPBasicAuth, PreparedRequest, and _basic_auth_str are not defined or imported in the shown code. Code length: The implementation is concise, but the import section is disproportionately long. Action granularity: Each line performs a single clear action. Reading flow: Header assignment followed by returning the request is natural and straightforward; additional spacing between import groups and the class would improve presentation.