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 HTTPBasicAuth(AuthBase):
"""Attaches HTTP Basic Authentication to the given Request object."""
username: bytes | str
password: bytes | str
@overload
def __init__(self, username: str, password: str) -> None: ...
@overload
def __init__(self, username: bytes, password: bytes) -> None: ...
def __init__(self, username: bytes | str, password: bytes | str) -> None:
self.username = username
self.password = password
def __eq__(self, other: object) -> bool:
return all(
[
self.username == getattr(other, "username", None),
self.password == getattr(other, "password", None),
]
)
def __ne__(self, other: Any) -> bool:
return not self == other
def __call__(self, r: PreparedRequest) -> PreparedRequest:
r.headers["Authorization"] = _basic_auth_str(self.username, self.password)
return r
Run 1
The code is highly readable with clear structure, logical organization, and flat nesting. Each method has a single responsibility, and action granularity is well-maintained with one action per line. The class hierarchy and type hints make intent explicit. The overload decorators properly document the type flexibility. Minor deductions: the __eq__ method uses a list inside all() when a generator would be marginally cleaner, and the __ne__ method could use `is not` for slightly better clarity. Overall, the code follows Python best practices, uses appropriate spacing, imports, and docstrings, making it easy to understand and maintain.
Run 2
The code is highly readable with clear structure and intent. The class is logically organized with a simple method sequence, minimal nesting, and one action per line. Type hints and overloads improve clarity, though they add some length. The __eq__ method uses a list with getattr, which is slightly less concise than a tuple comparison, but still clear. Overall, the code is concise, well-structured, and easy to follow, with only minor verbosity from typing overhead.
Run 3
The code is well-structured and highly readable. It has a clear class definition with a focused purpose, minimal nesting, and a natural reading flow. The use of type hints, overloads for type safety, and docstrings clarifies intent. Each action is separated logically, and the methods are concise. The `__eq__` method uses `all()` with a list for readability, though a generator could be slightly more efficient. The `__ne__` method is straightforward. Overall, the code adheres to best practices, with good separation of concerns and clean formatting. Minor deductions for slightly verbose list construction in `__eq__` and reliance on `getattr` without a default type check.
Run 1
Code Structure: The class logically groups initialization, equality checks, and request authentication, though numerous unused imports clutter the excerpt. Nesting: Methods remain flat, with no deeply nested control flow. Clarity of intent: The descriptive class name, docstring, and type annotations clearly communicate HTTP Basic Authentication; however, AuthBase, PreparedRequest, and _basic_auth_str are not defined or imported in the snippet, reducing standalone clarity. Code length: The implementation is concise, although using all() with a list for two comparisons is more verbose than a direct conjunction. Action granularity: Each statement generally performs one clear action. Reading flow: Methods follow a natural progression, but the dense import block and limited spacing around overload declarations slightly weaken visual readability.
Run 2
Code Structure: The class is logically organized into type declarations, initialization, comparison, and request modification, although many imports are unused in this snippet. Nesting: Methods are flat, with no deeply nested control flow. Clarity of intent: The class name, docstring, type annotations, and Authorization assignment clearly communicate its purpose; the abbreviated parameter r and externally defined AuthBase, PreparedRequest, and _basic_auth_str require some context. Code length: The implementation is concise overall, but the overloads and all([...]) equality expression add verbosity for simple operations. Action granularity: Each statement generally performs one action, making changes easy to follow. Reading flow: Method ordering is natural and consistent, though tighter spacing around imports and overload declarations slightly reduces visual separation.
Run 3
Code Structure: The class logically groups initialization, equality checks, and request authentication, though numerous unused imports clutter the snippet. Nesting: Methods remain flat, with no deeply nested control flow. Clarity of intent: The class name, docstring, type annotations, and Authorization assignment clearly convey its purpose; the abbreviated parameter r and externally defined dependencies slightly reduce self-contained clarity. Code length: The implementation is concise, although the all() call with a two-element list is more verbose than a direct conjunction. Action granularity: Each statement performs one clear action; compact overload declarations are conventional and understandable. Reading flow: Methods follow a natural progression from construction to comparison to application, with consistent indentation and spacing within the class.