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 highly readable due to its clear structure and organization. The class has a single, well-defined responsibility (HTTP Basic Authentication), and methods are short with clear purposes. The use of type hints, overloads, and docstrings enhances clarity of intent, especially for a library-level API. Nesting is minimal, with only one level in the `__eq__` method using `all()` and `getattr()`. Each action is typically one line, and the reading flow is natural — imports, class definition, overloads, constructor, equality checks, and call logic follow a logical sequence. Minor deductions: the overloads add slight verbosity, and `__ne__` could be omitted in Python 3, but these are stylistic, not readability-breaking. Overall, the code is clean, maintainable, and easy to follow.
Run 3
The code is highly readable with clear structure and intent. It follows a logical organization: imports, class definition, type hints, overloads, constructor, comparison methods, and the call method. Nesting is minimal, with only one level inside __eq__ and __call__. The purpose is explicit — attaching HTTP Basic Auth to a request. Each method performs a single action, and lines are concise. Type hints and overloads enhance clarity, though the overload declarations add slight verbosity without affecting readability. The use of 'all([...])' in __eq__ is slightly less natural than a simple 'and' expression but remains clear. Overall, the code is clean, well-typed, and easy to follow.
Run 1
Code Structure: The class logically groups credential storage, equality checks, and request authentication, though many imports are unused in this excerpt. Nesting: Methods are flat, with no complex control flow. Clarity of intent: The docstring, descriptive credential names, and type annotations clearly communicate the purpose; the abbreviated parameter r and externally defined AuthBase, PreparedRequest, and _basic_auth_str slightly reduce standalone clarity. Code length: The implementation is concise, although all([...]) is more verbose than a direct conjunction for two comparisons. Action granularity: Each statement performs a single clear action. Reading flow: Methods follow a natural progression from initialization to comparison to application, but tightly spaced imports and overload declarations slightly impede visual scanning.
Run 2
Code Structure: The class is logically organized into initialization, equality comparisons, and request authentication, although several imports are unused in this excerpt. Nesting: Methods are shallow, with no complex branching or loops. Clarity of intent: The class name, docstring, method signatures, and explicit Authorization assignment clearly communicate its purpose; the short parameter name r is less descriptive. AuthBase, PreparedRequest, and _basic_auth_str are not defined or imported in the excerpt, limiting self-contained understanding. Code length: The implementation is concise overall, though the multiline all([...]) equality check is more verbose than a simple conjunction. Action granularity: Each statement performs a single clear action. Reading flow: Methods follow a natural progression, but crowded imports and tightly spaced overload declarations slightly reduce visual readability.
Run 3
Code Structure: The class logically groups credential storage, equality comparison, and request authentication, although many unused imports clutter the snippet. Nesting: Methods are flat, with only a simple list inside all(). Clarity of intent: The class docstring, descriptive credential names, and type annotations make its purpose clear; the short parameter name r and externally defined symbols require some context. Code length: The implementation is concise, though the equality expression could be simpler and the imports leaner. Action granularity: Statements generally perform one action per line; compact overload declarations remain understandable. Reading flow: Methods follow a natural progression from initialization to comparison to authentication, but tightly spaced imports and overload decorators slightly reduce visual separation.