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 well-structured and highly readable. It has a clear class definition with a single responsibility (HTTP Basic Auth), no unnecessary nesting, and type hints that improve clarity. Each method is concise and focused on one action. The reading flow is natural, with imports, class definition, overloaded constructors, equality methods, and the main __call__ method in logical order. Minor deductions: the __eq__ method uses an unnecessary list inside all(), and the __ne__ method could be omitted in Python 3. The overloaded constructor with ellipsis bodies may add slight complexity for readers unfamiliar with typing overloads. Overall, this is clean, maintainable code that clearly expresses its intent.
Run 2
The code is well-structured and readable. It uses clear class organization, type hints, and overloads to clarify intent. The class has a single responsibility (HTTP Basic Auth), and methods are concise with minimal nesting. Import statements are organized, though some imports like `hashlib`, `os`, `re`, `threading`, `time`, `warnings`, `b64encode`, and `parse_dict_header` appear unused, which slightly reduces clarity. The `__eq__` method uses `all([...])` which is slightly redundant since a tuple or generator would suffice, but it remains clear. The `__call__` method performs two actions: setting a header and returning the request—arguably acceptable due to their logical relationship, but two lines could improve action granularity. Overall, the code is readable, maintainable, and follows common Python conventions.
Run 3
The code is highly readable with a clear, logical structure. Each method has a single responsibility, and type hints enhance clarity. The class is flat with minimal nesting, and the control flow is straightforward. The overloads and type annotations improve intent, while the use of __eq__ and __ne__ demonstrates good object behavior. The code is concise without being overly terse, and each action is on its own line, improving readability. The only minor drawback is the use of `all` with a list in __eq__, which is slightly less efficient than a generator but not a readability issue. Overall, it follows Python best practices and is immediately understandable.
Run 1
Code Structure: The class logically groups initialization, equality checks, and request authentication, though many 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 undefined external symbols slightly reduce standalone clarity. Code length: The implementation is concise overall, although the equality check could use a direct conjunction rather than all with a list. Action granularity: Each statement performs a single clear action; compact overload declarations are still understandable. Reading flow: Methods follow a natural sequence, but dense imports and limited spacing around overload declarations mildly interrupt scanning.
Run 2
Code Structure: The class is logically organized into annotations, constructor overloads, initialization, comparison methods, and request authentication. However, numerous unused imports add clutter, and referenced definitions are absent from the excerpt. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The descriptive class name, docstring, method names, and type annotations clearly communicate its authentication role. Code length: The implementation is concise overall, though the overload declarations and list-based all() comparison introduce some verbosity. Action granularity: Statements generally perform one action per line, keeping assignments and header modification straightforward. Reading flow: Methods follow a natural sequence, with consistent indentation and spacing within the class; additional separation around imports and overload declarations would improve visual organization.
Run 3
Code Structure: The class is logically organized, with type declarations, constructor overloads, initialization, comparison methods, and request modification. Numerous unused imports add clutter to this snippet. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The class name, docstring, and method bodies clearly communicate basic authentication behavior, though AuthBase, PreparedRequest, and _basic_auth_str are not defined in the excerpt. Code length: Mostly concise, but the all([...]) expression is more verbose than a direct conjunction, and overload declarations add visual weight. Action granularity: Statements generally perform one action per line. Reading flow: Method ordering is natural, but tightly packed imports, overloads, and limited spacing before the class slightly reduce readability.