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, with clear structure and purpose. It begins with a standard import block organized logically (standard library, then typing, then local modules). The `AuthBase` class is simple and explicit, with a clear docstring explaining its role. The `__call__` method is concise and directly raises `NotImplementedError` with a helpful message. One action per line is respected, typing is used, and nesting is minimal. Only minor points are deducted due to the presence of several unused imports and possibly redundant compatibility imports, which slightly affect clarity of intent and code length.
Run 2
This code is highly readable. It has a clear, logical structure with standard imports grouped together and a single, well-defined class. The nesting is minimal, with only one method that clearly states its purpose. The intent is unambiguous: it defines a base class for authentication implementations with a callable interface. The code is concise but not overly so, with just enough context. Each import is on its own line, and within the class, the docstring and method are separated appropriately. The reading flow is natural, going from imports to class definition to method. The use of a docstring and NotImplementedError with a clear message enhances clarity. Only minor improvement could be grouping imports by standard library, third-party, and local modules, but this is a very small concern.
Run 3
The code demonstrates strong structural organization with a clear, single-purpose class definition and logical import grouping (future, stdlib, third-party/local). It maintains flat nesting with no nested control structures, making the flow immediately understandable. Intent is explicit: AuthBase is an abstract base class for authentication, with a clear NotImplementedError message. The code is concise with no unnecessary verbosity, and each action occupies a single line. Reading flow is natural - imports at top, class declaration, docstring, then method. Minor deductions: (1) The unused import hashlib, os, re, threading, time, warnings, and b64encode reduce clarity by suggesting dependency bloat. (2) The type hint 'PreparedRequest' is used without being imported or defined, relying on TYPE_CHECKING which is not properly set up, potentially causing confusion or runtime errors. (3) No abstractmethod decorator, which would more explicitly communicate the abstract nature of the class.
Run 1
Code Structure: Imports precede a clearly defined authentication base class, although 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 authentication hook contract; the parameter name 'r' is less descriptive, and PreparedRequest is not defined or imported in the shown code. Code length: The class is concise, but the extensive import list adds unnecessary reading overhead for this snippet. Action granularity: Each import and statement occupies its own line. Reading flow: The progression from imports to class to method is natural, though additional blank lines between import groups and before the class would improve visual organization.
Run 2
Code Structure: Imports are grouped before a clearly defined base class, though standard-library and local imports lack a separating blank line, and many imports are unused in this snippet. Nesting: Minimal, with only a class and method scope. Clarity of intent: The class name, docstring, type annotations, and explicit NotImplementedError clearly communicate an authentication interface; the parameter name 'r' is less descriptive. Code length: The implementation is concise, although the extensive imports distract from its small purpose. Action granularity: Each import and statement occupies its own line. Reading flow: Straightforward progression from dependencies to class definition to callable contract, with minor friction from the import clutter and PreparedRequest not being defined or imported in the shown code.
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 explicit NotImplementedError clearly establish an authentication interface; the parameter name 'r' is less descriptive, and PreparedRequest is not defined or imported here. Code length: The class is concise, but the extensive import block is disproportionate to the shown functionality. Action granularity: Each statement occupies its own line. Reading flow: Execution flows naturally from imports to class to method, although additional blank lines separating import groups and the top-level class would improve visual organization.