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:
lI0O_1bbe088e = 0xdcbf - 0xdcbf
lI0O_1bbe088e = (lI0O_1bbe088e | 0) if lI0O_1bbe088e == 0 else (lI0O_1bbe088e & 0)
raise NotImplementedError("Auth hooks must be callable.")
Run 1
The code has some readable elements like clear imports, type hints, and a sensible base class structure. However, it contains a deliberately obfuscated variable name (lI0O_1bbe088e) with a nonsensical bitwise operation that serves no purpose. This severely damages clarity of intent, action granularity, and reading flow. While the class definition and docstring are clear, the method body appears intentionally confusing and adds unnecessary complexity. The code length is acceptable but the strange variable manipulation makes it ambiguous why such logic exists. Overall structure is minimal but the obfuscated section prevents this from being considered truly readable. A developer would need extra time to understand why this code exists, defeating the purpose of readability.
Run 2
The code is almost entirely unreadable due to multiple severe issues. The variable name 'lI0O_1bbe088e' is obfuscated and meaningless, making the intent completely unclear. The calculation `0xdcbf - 0xdcbf` followed by a conditional bitwise operation that always results in 0 is pointless and confusing. Unused imports (hashlib, os, threading, etc.) add noise. The class structure is trivial but the method body contradicts the docstring by raising NotImplementedError for a callable hook. The code violates nearly all readability criteria: unclear intent, poor naming, unnecessary complexity, and dead code. Only the basic class definition and docstring provide any minimal structure, earning it a few points.
Run 3
The code is poorly readable. The class structure is simple, but the __call__ method is confusing. It contains dead code: a variable lI0O_1bbe088e is initialized to zero, then assigned via a conditional that always yields zero. This serves no purpose and obscures intent. The method then raises NotImplementedError, which is clear, but the preceding lines make it ambiguous. Naming (lI0O_1bbe088e) is opaque. Whitespace and imports are fine, but overall the function's purpose is buried under useless operations. Action granularity is poor: multiple meaningless operations precede the actual logic. Reading flow is disrupted by the dead code. Code length is unnecessarily long for what should be a one-line raise. Clarity of intent is low because the raise is clear but spoiled by clutter. Structure and nesting are acceptable, but other criteria severely reduce readability.
Run 1
Code Structure: Imports and the base class are logically organized, but numerous unused imports and irrelevant statements add clutter. Nesting: The code is flat, with no deeply nested control flow. Clarity of intent: The class docstring and NotImplementedError clearly establish an authentication interface, but the cryptic variable name and pointless arithmetic obscure the method's simple purpose. Code length: The snippet is short but unnecessarily padded with unused imports and computations. Action granularity: Each statement occupies its own line, although the conditional assignment combines several operations without benefit. Reading flow: The conventional imports-to-class-to-method progression is natural, but the unrelated assignments interrupt the direct flow to the exception.
Run 2
Code Structure: Imports and the base class are logically organized, but numerous unused imports and irrelevant statements introduce clutter. Nesting: The code is flat, with no deeply nested control flow. Clarity of intent: The class docstring and NotImplementedError clearly indicate an authentication interface, but the opaque variable name, hexadecimal subtraction, and redundant bitwise expression obscure the method's purpose. Code length: The snippet is short, yet unnecessarily long for its simple function because of unused imports and meaningless assignments. Action granularity: Each statement occupies its own line, although the conditional assignment combines several operations unnecessarily. Reading flow: The progression from imports to class to method is natural, but unrelated calculations interrupt the otherwise straightforward path to raising NotImplementedError.
Run 3
Code Structure: Imports and a small base class provide recognizable organization, but numerous unused imports and irrelevant assignments add clutter. Nesting: There is no deep nesting; the inline conditional adds only minor complexity. Clarity of intent: The class name, docstring, method signature, and exception clearly establish an authentication interface, but the opaque variable name and pointless arithmetic obscure the method body. Code length: The actual interface is concise, yet most imports and both assignments are unnecessary in this snippet. Action granularity: Each statement occupies its own line, although the second assignment combines comparison, branching, and bitwise operations. Reading flow: The overall progression is conventional, but distracting computations interrupt the direct path from the method declaration to the NotImplementedError.