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 a clear, logical structure with a single well-named class, HTTPBasicAuth, representing a single concept. Nesting is minimal, limited to the __eq__ method's 'all' list with a depth of two. The intent is unambiguous, clearly implementing HTTP Basic Authentication. Code length is concise; each method is short and focused. Action granularity is appropriate, with one primary action per line (e.g., setting Authorization header, returning request). The reading flow is natural, following a standard layout: imports, class definition, type hints, overloads, initializer, equality methods, and the main call logic. Minor deductions: the __eq__ method uses a list inside all() unnecessarily when a generator would be cleaner, and the overload definitions add some verbosity. Overall, idiomatic Python with excellent use of type hints and docstrings.
Run 3
The code is well-structured and highly readable. It uses type hints, overloads, and modern Python syntax (e.g., `bytes | str`) effectively. The class has a clear purpose and each method is concise with one action per line. The `__eq__` method is declarative but slightly less readable due to the use of `getattr` and a list inside `all()`. Import organization is standard, though some unused imports may be present (e.g., `hashlib`, `re`), which slightly reduces clarity. Overall, the code is clean, flat, and easy to follow.
Run 1
Code Structure: The class is logically organized, with attributes, constructor overloads, initialization, comparison methods, and request authentication clearly separated. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The descriptive class name, docstring, and type annotations communicate its purpose, although AuthBase, PreparedRequest, and _basic_auth_str are not defined or imported in the excerpt. Code length: The implementation is concise, but numerous unused imports add clutter, and the all([...]) comparison is more verbose than a straightforward conjunction. Action granularity: Statements generally perform one action per line. Reading flow: Methods follow a natural progression, though sparse spacing around imports and overload declarations slightly reduces visual clarity.
Run 2
Code Structure: The class is logically organized into annotations, initialization, comparisons, and request authentication, although numerous unrelated imports distract from the focused implementation. Nesting: Methods are flat, with no deeply nested control flow. Clarity of intent: The docstring, method names, and type annotations clearly communicate HTTP Basic authentication behavior; undefined-in-snippet dependencies and the abbreviated parameter name 'r' slightly reduce clarity. Code length: The implementation is concise, though overload declarations and the list passed to all() add some visual overhead. Action granularity: Each statement performs a single clear action, with no compressed multi-action lines. Reading flow: Methods follow a natural progression, and whitespace separates responsibilities effectively; import clutter and tightly spaced overload declarations slightly interrupt the flow.
Run 3
Code Structure: The class is logically organized, separating initialization, equality checks, and request authentication, although numerous unused imports clutter the snippet. Nesting: Minimal nesting makes the methods easy to follow. Clarity of intent: The descriptive class name, docstring, method names, and type annotations communicate purpose clearly; externally defined AuthBase, PreparedRequest, and _basic_auth_str require additional context. Code length: The implementation is concise overall, though all() around a two-element list makes equality checking more verbose than necessary. Action granularity: Statements generally perform one action per line, with compact overload declarations remaining understandable. Reading flow: Methods follow a natural progression, but limited spacing around imports and overloads slightly reduces visual separation.