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. It has clear structure with logical class organization, minimal nesting, and explicit type hints that clarify intent. The class name and docstring make purpose immediately obvious. The `__eq__` method is concise but slightly unusual in using `all([...])` with a list instead of direct boolean operators; while functional, direct comparison would be more idiomatic. The `__ne__` and `__call__` methods are straightforward. The `@overload` decorators add clarity for type checkers. Import statements are organized and purposeful. Overall the code is concise, each method does one thing, and the reading flow is natural.
Run 3
The code is clean and highly readable. Imports are organized, class structure is logical, and type hints improve clarity. The overloaded constructor and equality method are concise and straightforward. The `__call__` method performs a single clear action per line. Minor deductions: the equality method uses an unnecessary nested list with `all()`, and `__ne__` is redundant in Python 3. Otherwise the structure is flat, intent is explicit, and reading flow is natural.
Run 1
Code Structure: The class is logically organized into initialization, comparison, and request authentication methods, though many imports are unused in this excerpt. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The class name, docstring, method names, and type annotations clearly communicate its purpose; externally defined AuthBase, PreparedRequest, and _basic_auth_str require additional context. Code length: Mostly concise, although overload declarations and the all-based equality check add some verbosity. Action granularity: Each statement performs a focused action, with no crowded multi-action lines. Reading flow: Methods follow a natural progression, but tightly spaced imports and overload definitions slightly reduce visual separation.
Run 2
Code Structure: The class is logically organized, with annotations, constructor overloads, initialization, comparisons, and request authentication grouped naturally. Nesting: Methods are shallow, with only a small nested expression in __eq__. Clarity of intent: The class name, docstring, type hints, and Authorization assignment clearly convey its purpose; the short parameter name r is less descriptive. Code length: The implementation is concise, but numerous imports are unused in this snippet, and all([...]) makes a simple comparison unnecessarily elaborate. Action granularity: Statements generally perform one action per line, making behavior easy to follow. Reading flow: Method order is natural, although compressed spacing around imports and overloads slightly reduces visual separation. AuthBase, PreparedRequest, and _basic_auth_str are not defined or imported in the excerpt, so understanding their roles requires external context.
Run 3
Code Structure: The class is logically organized into type declarations, initialization, comparisons, and request modification, though numerous unrelated imports add clutter. Nesting: Methods are shallow, with no deeply nested control flow. Clarity of intent: The docstring, descriptive attribute names, and type annotations clearly communicate Basic Authentication behavior; however, AuthBase, PreparedRequest, and _basic_auth_str are not defined or imported in the snippet. Code length: The implementation is concise overall, but constructing a list for all() makes the equality check more verbose than a direct conjunction. Action granularity: Statements generally perform one action per line; compact overload declarations remain understandable. Reading flow: Method ordering is natural and consistent, although missing separation between imports and unused imports slightly distract from the class.