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 highly readable. It has a clear, flat structure with no nesting. Imports are organized logically, and the single class with a concise docstring and one method is straightforward. The use of type hints and the NotImplementedError with a clear message demonstrates clarity of intent. Each action is on its own line, and the reading flow is natural.
Run 3
The code is highly readable with a clear, logical structure. It begins with standard library imports, followed by typing imports, then internal/local imports — a conventional and organized pattern. Nesting is minimal; there are no deeply nested control structures. The intent is explicit: defining an abstract base class for authentication with a clear docstring and a straightforward `__call__` method that raises `NotImplementedError`. The code is concise, avoiding unnecessary verbosity. Action granularity is appropriate — each import and class/method definition occupies its own line, enhancing clarity. Reading flow is natural, moving from dependencies to class definition to method body. Minor deductions: the import block is slightly long and some type-related imports (e.g., `Final`, `cast`, `overload`) are unused in the visible code, which could confuse readers about their purpose.
Run 1
Code Structure: Imports followed by a clearly defined authentication 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 explicit NotImplementedError clearly communicate the callable authentication interface; the parameter name 'r' is less descriptive, and PreparedRequest is not defined or imported in the snippet. Code length: The implementation is concise, but the extensive import list adds unnecessary bulk here. Action granularity: Each statement occupies its own line. Reading flow: The progression from imports to class to method is natural, though additional spacing between import groups and before the class would improve readability.
Run 2
Code Structure: Imports precede a clearly defined base class, providing logical organization, though numerous unused imports clutter this standalone snippet. Nesting: Minimal, with only a class and its method. Clarity of intent: The class name, docstring, and NotImplementedError clearly establish an authentication interface; however, the parameter name 'r' is vague, and PreparedRequest is not defined or imported in the shown code. Code length: The implementation is concise, but the import block is disproportionate to its functionality. Action granularity: Each statement occupies its own line. Reading flow: Natural top-to-bottom progression, slightly weakened by limited spacing between import groups and the class.
Run 3
Code Structure: Imports followed by a small base class provide logical organization, although many imports are unused in this snippet. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The class name, docstring, typed call signature, and explicit NotImplementedError clearly communicate the authentication-hook interface; PreparedRequest is not defined or imported in the shown code. Code length: The implementation is concise, but the extensive import list adds visual overhead. Action granularity: Each line performs a single clear action. Reading flow: The progression from dependencies to interface is natural, though blank lines separating import groups and preceding the class would improve readability.