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 highly readable. It begins with a clear import section organized logically: standard library imports, third-party/type-related imports, and internal module imports. The use of `from __future__ import annotations` and type hints like `Final`, `cast`, and `overload` indicates modern, well-maintained code. The `AuthBase` class is minimal but clear in intent—it defines a base class for authentication implementations and explicitly raises `NotImplementedError` with a helpful message. Nesting is non-existent, and the code is concise without sacrificing clarity. Action granularity is appropriate: each import, class definition, and method occupies its own logical line. Reading flow is natural, moving from imports to class definition to method signature. Minor deductions: some imported names (`TYPE_CHECKING`, `Any`, `to_native_string`) are unused in the visible snippet, which could slightly reduce perceived clarity. Overall, the code is clean, purposeful, and easy to follow.
Run 3
The code is highly readable. It begins with a clean import section, with clear separation of standard library, third-party, and local modules. Type hints, `Final`, `cast`, and `overload` imports suggest attention to clarity and correctness. The `AuthBase` class is minimal and logical, with a clear docstring and a single purpose. The `__call__` method is short, explicit, and fulfills the class contract. Nesting is absent. Action granularity is one action per line. Naming follows Python conventions. Minor deductions: unused imports (e.g., `os`, `re`, `threading`, `warnings`) would add noise but do not affect readability for this snippet, and the use of a `PreparedRequest` type implies readability depends on context outside the snippet, but within the given code, the intent is unambiguous.
Run 1
Code Structure: Imports are grouped before a small, logically organized base class, although standard-library and local imports lack a separating blank line. Nesting: Minimal, with only a class and its method. Clarity of intent: The class name, docstring, type annotations, and explicit NotImplementedError clearly establish an authentication interface; the parameter name 'r' is less descriptive. Code length: The implementation is concise, but many imports are unused in the shown snippet, adding visual noise. Action granularity: Each import and the exception statement occupy separate lines. Reading flow: Natural top-to-bottom progression from dependencies to interface definition, with minor spacing improvements possible.
Run 2
Code Structure: Imports followed by a small base class provide logical organization, though many imports are unused in this snippet. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The descriptive class name, docstring, type annotations, and explicit NotImplementedError clearly establish an authentication interface. PreparedRequest is not defined or imported in the shown code, leaving some context unclear. Code length: The class is concise, but the extensive import list adds unnecessary length for the functionality shown. Action granularity: Each statement occupies its own line. Reading flow: The progression from imports to class documentation to the callable method is natural; additional spacing between import groups and before the class would improve readability.
Run 3
Code Structure: Imports followed by a small base class provide clear organization, though many imports are unused in this snippet. Nesting: Minimal, with only a class and its method. Clarity of intent: The class name, docstring, type annotations, and explicit NotImplementedError clearly communicate the authentication hook contract; the parameter name 'r' is less descriptive. Code length: The implementation is concise, but the extensive imports add visual overhead relative to its size. Action granularity: Each statement occupies its own line. Reading flow: Straightforward from dependencies to interface definition, though separating import groups and adding standard blank lines before the class would improve scanning.