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 AuthBase:
"""Base class that all auth implementations derive from"""
def __call__(self, r: PreparedRequest) -> PreparedRequest:
raise NotImplementedError("Auth hooks must be callable.")
Run 1
The code is highly readable. It begins with clear future import and standard imports, organized logically (standard library, then local modules). Constants like `Final` are properly imported. The `AuthBase` class has a clear docstring and a single, focused method with a descriptive parameter type hint and return type. Nesting is non-existent, action granularity is one action per line, and overall structure is flat. The only minor deduction is that some imported names (e.g., `overload`, `cast`, `Any`) are not used in the shown code, which slightly reduces clarity of intent for a reviewer seeing only this fragment.
Run 2
The code is well-structured and readable. It begins with necessary `__future__` import followed by standard library and local imports in a logical order. The `AuthBase` class is simple, with a clear docstring and a single method that explicitly raises `NotImplementedError`, making intent obvious. The code is flat, has no unnecessary nesting, and each line performs a distinct action. Type hints like `PreparedRequest` improve clarity, and the use of `__all__`-style imports (e.g., `Final`, `cast`) shows intent without clutter. The only minor drawback is the presence of several unused imports (e.g., `hashlib`, `threading`, `warnings`, `b64encode`), which slightly reduces cleanliness. Overall, the code is concise, intention-revealing, and maintains a natural reading flow.
Run 3
The code is highly readable. Structure is logical with clear separation of imports, module-level constants, and a single well-defined class. Nesting is minimal. Intent is clear: AuthBase defines a simple interface for authentication hooks with a precise __call__ contract and an explicit NotImplementedError. Code length is concise and appropriate—each import group and class method is kept minimal. Action granularity is one action per line, with no cramming of logic. Reading flow is natural: imports grouped by standard library, third-party, and local modules, then module constants, then the class definition. Type hints and docstrings enhance clarity. The only minor deduction is the unused or type-checking imports (TYPE_CHECKING, Any, Final, cast, overload) which could be opaque to beginners, but they are correctly marked and not detrimental.
Run 1
Code Structure: Imports precede a clearly defined base class, providing logical organization, although numerous unused imports distract in this snippet. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The class name, docstring, and explicit NotImplementedError clearly communicate the authentication hook contract; PreparedRequest is not imported or defined in the shown code, slightly reducing self-contained clarity. Code length: The class is concise, but the import section is disproportionately long for the functionality shown. Action granularity: Each import and the exception statement occupy separate lines. Reading flow: The progression from imports to class to method is natural, though additional spacing between import groups and the class would improve visual separation.
Run 2
Code Structure: Imports precede a clearly defined authentication base class, though many imports are unused in this snippet. Nesting: Minimal, with only a class and its method. Clarity of intent: The class docstring and explicit NotImplementedError clearly communicate the callable interface expected of subclasses; the parameter name 'r' is less descriptive, and PreparedRequest is not defined or imported here. Code length: The implementation is concise, but the extensive import list adds unnecessary clutter for the shown functionality. Action granularity: Each import and statement occupies its own line. Reading flow: Conventional top-to-bottom organization makes the code easy to follow, although clearer spacing between import groups and before the class would improve presentation.
Run 3
Code Structure: Imports precede a clearly defined base class, providing logical organization, though many imports are unused in this snippet. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The class name, docstring, type annotations, and exception clearly establish a callable authentication interface; the parameter name 'r' is less descriptive, and PreparedRequest is not defined or imported here. Code length: The implementation is concise, but the import block is disproportionately large for the functionality shown. Action granularity: Each statement occupies its own line. Reading flow: The code proceeds naturally from dependencies to the interface definition, although grouping imports and adding spacing before the class would improve presentation.