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 demonstrates excellent readability through clear structure, minimal nesting, and clear intent. The class HTTPProxyAuth has a single, well-documented responsibility and inherits logically from HTTPBasicAuth. The __call__ method is flat with no conditional nesting and performs one action per line: setting a header and returning the request. Variable names are descriptive, and type hints enhance clarity. The import block is organized sensibly, with standard library imports first, followed by third-party and local imports. The class docstring concisely explains the purpose. The only minor deductions are that the method modifies the request in-place without explicitly showing the beginning of the modification, and the _basic_auth_str helper function's behavior is not immediately visible—but these are negligible in the overall context. The code is concise, natural to read, and maintains clean action granularity.
Run 3
The code is highly readable with a clear, focused purpose. It uses modern Python syntax and maintains logical organization with strategic imports. The class hierarchy is intuitive (HTTPProxyAuth extends HTTPBasicAuth), and the __call__ method is concise with clear intent - attaching proxy authentication to a request. The code operates at an appropriate action granularity, with one meaningful action per line. Nesting is minimal and the reading flow is natural. The main slight deduction is that some imports appear unused at first glance (hashlib, os, re, threading, time, warnings, b64encode), which could indicate dead code or missing context, slightly reducing clarity of intent. Overall, this is exemplary readable code that follows Python best practices and would be easily understood by developers familiar with the requests library architecture.
Run 1
Code Structure: The small class and its single method are logically organized, although many imports are unused in this snippet and the base class and helper are not shown. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The class name, docstring, method annotation, and explicit Proxy-Authorization assignment clearly communicate the purpose; the parameter name r is less descriptive. Code length: The implementation is concise, but the large import block adds unnecessary visual overhead relative to the functionality shown. Action granularity: Each line performs a single clear action. Reading flow: The method naturally proceeds from setting the authentication header to returning the request, though import clutter and limited spacing slightly weaken overall flow.
Run 2
Code Structure: The class and its method are logically organized, though many imports appear unrelated to the shown functionality. Nesting: Minimal nesting makes the code easy to follow. Clarity of intent: The class name, docstring, method signature, and explicit Proxy-Authorization header 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, but the extensive import block adds unnecessary reading overhead. Action granularity: Each statement performs a single clear action. Reading flow: The method naturally proceeds from setting the authentication header to returning the request, although the imports and limited spacing between top-level sections slightly detract from presentation.
Run 3
Code Structure: The class and its single method are logically organized, but numerous unused imports add clutter, and key dependencies 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 explicit Proxy-Authorization header clearly communicate its purpose. Code length: The implementation is concise, though 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; tighter import organization and standard spacing before the class would improve presentation.