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 demonstrates good readability with a clear, logical structure. Imports are organized with standard library, third-party, and local modules grouped logically. The use of `__future__` annotations and type hints enhances clarity. The `AuthBase` class is concise and purpose-driven, with a single well-documented abstract method. Nesting is minimal and the reading flow is natural. The only deductions are for slightly verbose imports (some unused), but overall the code is clean, maintainable, and easy to understand.
Run 3
The code is fairly readable. The structure is logical: imports are organized, and the class definition is clear with a helpful docstring. The nesting is completely flat, there is no unnecessary nesting. The intent is clear—defining an abstract base for authentication mechanisms. The length is concise and not bloated. Action granularity is appropriately one action per line, as seen in the `__call__` method that simply raises `NotImplementedError`. The reading flow is smooth and natural, beginning with imports, then the class definition and its method. Possible deductions: the import list is somewhat long, and the use of `from __future__ import annotations` may not be immediately obvious to all readers. Additionally, the `__call__` method could include a more descriptive error message, but this is minor. Overall, it is a clean, well-structured snippet.
Run 1
Code Structure: Imports precede a small, logically organized 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, type annotations, and explicit NotImplementedError clearly establish the callable authentication interface; the parameter name 'r' is less descriptive, and PreparedRequest is not visibly imported. Code length: The class is concise, but the extensive import block outweighs its implementation. Action granularity: Each import, declaration, and statement occupies its own line. Reading flow: The progression from imports to class to method is natural, although additional spacing between import groups and before the class would improve visual organization.
Run 2
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 explicit NotImplementedError clearly communicate an authentication interface; PreparedRequest is not defined or imported in the shown code. Code length: The class is concise, but the large import block is disproportionate to its implementation. Action granularity: Each statement occupies its own line. Reading flow: The progression from imports to class to method is natural, although grouping imports and adding another blank line before the class would improve visual separation.
Run 3
Code Structure: Imports followed by a documented 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 class name, docstring, type annotations, and NotImplementedError clearly establish a callable authentication interface; PreparedRequest is not defined or imported in the snippet. Code length: The implementation is concise, but the extensive import list adds unnecessary visual overhead here. Action granularity: Each statement occupies its own line. Reading flow: The class reads naturally, although grouping imports and adding standard blank-line separation before the class would improve presentation.