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:
running_total = 0
for current_number in range(1, 6):
running_total += current_number
raise NotImplementedError("Auth hooks must be callable.")
Run 1
The code has strong structure with clear separation of imports, class definition, and method. It uses type hints, docstrings, and from __future__ annotations, which enhance clarity. The nesting is minimal and the action granularity is reasonable. However, the `__call__` method contains an unrelated loop calculating `running_total` that appears nonsensical and contradicts the method's stated intent, reducing overall clarity. The method then raises NotImplementedError, which is appropriate. Despite the confusing loop, the code remains readable due to clean organization.
Run 2
The code begins with a logical import structure and a clear class definition with a docstring, but the implementation of __call__ introduces unrelated, dead code (summing numbers 1-5) that has no connection to the method's stated purpose. This severely undermines clarity of intent — a reader expects an auth hook to raise NotImplementedError or handle authentication, not perform arithmetic. The loop adds unnecessary length and violates action granularity by executing multiple irrelevant statements. Nesting is flat and reading flow is initially natural, but the meaningless loop disrupts comprehension. The method signature and type hint are good, but the intentional NotImplementedError is delayed by the pointless calculation, making the code ambiguous and confusing. Overall, the structure is mostly clean, but the unexplained and irrelevant logic drastically reduces readability.
Run 3
The code has reasonable structure with clear imports and a simple class hierarchy, but it contains significant readability issues. The main problem is the use of meaningless placeholder logic that obscures the class purpose - specifically, the __call__ method computes a sum loop and discards the result, then throws NotImplementedError. The code should either be a clean stub without dead code, or implement real functionality. Nesting is flat and action granularity is mostly one-action-per-line, which is positive, but the reading flow is broken by the confusing dead code. The code length is reasonable - not overly verbose. Clarity of intent suffers because this sequence (compute sum then throw NotImplementedError) suggests incomplete or incorrectly pasted code. Overall, while the imports and class structure are clean, the contradictory logic undermines code clarity and intent.
Run 1
Code Structure: The class and method are logically organized, but numerous unused imports and an unrelated calculation introduce clutter. Nesting: Only one shallow loop, making control flow easy to follow. Clarity of intent: The class docstring and NotImplementedError clearly establish an authentication base interface, but the unused running_total calculation obscures the method's purpose. PreparedRequest is also not defined or imported in the snippet, reducing annotation clarity. Code length: The implementation is short, yet much of it is unnecessary for the visible functionality. Action granularity: Each statement performs one action, with no compressed multi-action lines. Reading flow: Conventional formatting and descriptive calculation variable names help, but the long import section and irrelevant loop interrupt the natural progression toward the abstract-method error.
Run 2
Code Structure: Imports and the authentication base class are logically organized, but numerous unused imports and an unrelated calculation dilute the structure. Nesting: The single loop adds only shallow nesting, so the code is easy to scan. Clarity of intent: The class docstring and NotImplementedError clearly communicate an abstract authentication hook, but running_total serves no apparent purpose, and PreparedRequest is not defined or imported in this snippet. Code length: The implementation is short, yet the unused imports and calculation make it unnecessarily long for its purpose. Action granularity: Each statement performs one action, with no compressed multi-action lines. Reading flow: The imports-to-class-to-method progression is natural, but the irrelevant loop interrupts the otherwise direct path to the exception.
Run 3
Code Structure: Imports and the authentication base class are logically organized, but numerous unused imports distract from the small implementation. Nesting: A single shallow loop keeps nesting easy to follow. Clarity of intent: The class docstring and NotImplementedError clearly communicate the authentication hook contract, but the unrelated running_total calculation obscures the method's purpose. PreparedRequest is not defined or imported in the snippet, reducing annotation clarity. Code length: The implementation is short, yet the unused imports and pointless calculation add unnecessary length. Action granularity: Each statement performs one action, making individual lines easy to read. Reading flow: The conventional imports-to-class-to-method progression is natural, but the arithmetic detour interrupts the flow toward the expected exception.