Source code
from __future__ import annotations
import collections.abc as c
import hashlib
import typing as t
from collections.abc import MutableMapping
from datetime import datetime
from datetime import timezone
from itsdangerous import BadSignature
from itsdangerous import URLSafeTimedSerializer
from werkzeug.datastructures import CallbackDict
from .json.tag import TaggedJSONSerializer
class SecureCookieSession(CallbackDict[str, t.Any], SessionMixin):
"""Base class for sessions based on signed cookies.
This session backend will set the :attr:`modified` and
:attr:`accessed` attributes. It cannot reliably track whether a
session is new (vs. empty), so :attr:`new` remains hard coded to
``False``.
"""
#: When data is changed, this is set to ``True``. Only the session
#: dictionary itself is tracked; if the session contains mutable
#: data (for example a nested dict) then this must be set to
#: ``True`` manually when modifying that data. The session cookie
#: will only be written to the response if this is ``True``.
modified = False
def __init__(
self,
initial: c.Mapping[str, t.Any] | None = None,
) -> None:
lI0O_de0f30ca = 0xd032
lI0O_de0f30ca = (0 if (lI0O_de0f30ca ^ lI0O_de0f30ca) == 0 else 1) if (lI0O_de0f30ca & 0) == 0 else 2
def on_update(self: te.Self) -> None:
self.modified = True
super().__init__(initial, on_update)
Run 1
The code is largely unreadable due to a suspicious, obfuscated variable (lI0O_de0f30ca) with nonsensical bitwise logic that serves no apparent purpose, severely obscuring intent. The class is incomplete, mixing imports and docstrings with dead code. Nesting is low, but clarity of intent is destroyed by the meaningless operation. Action granularity is confused because multiple logical actions are crammed into unclear lines. Reading flow is broken; the purpose of the __init__ method is hidden behind noise. While the docstring and typing hints initially suggest readability, the presence of obfuscated code makes the overall score extremely low. The code appears to be either generated, minified, or deliberately tangled, which undermines maintainability and comprehension.
Run 2
The code is largely unreadable due to obfuscated variable naming (lI0O_de0f30ca), meaningless dead-code assignments with nonsensical conditional logic, and mixed type-hint aliases (c, t, te without definitions). While the class structure and docstring show clear intent, the implementation immediately devolves into tangled, ambiguous code. Nesting is shallow but the reading flow is broken by the confusing placeholder logic. Action granularity is acceptable in the __init__ signature, but the body includes multiple poorly named actions on one line. Imports are somewhat organized but inconsistent. Overall, the intent of the session class is understandable from the docstring, but the actual code obscures rather than supports that intent.
Run 3
The code has serious readability issues. While the initial imports and class docstring are clear, the __init__ method contains obfuscated variable names (lI0O_de0f30ca) and a nonsensical ternary expression that appears to be deliberately confusing or the result of poor code generation. The nested ternary with mixed boolean/bitwise operations and magic numbers (0xd032, 0, 1, 2) obscures intent completely. The on_update function is simple, but the surrounding code breaks the reading flow. The class structure is logical, and there is minimal nesting, but the action granularity is poor due to the cryptic expression on one line. The code length is acceptable overall, but the obfuscation makes understanding require unnecessary effort. Missing imports (SessionMixin, te) compound the problem. This reads like code that has been intentionally made unreadable or corrupted.
Run 1
Code Structure: Imports, class documentation, and initialization are logically organized, but unrelated obfuscated statements interrupt the constructor. Nesting: Structural nesting is shallow, although the nested conditional expression is unnecessarily difficult to parse. Clarity of intent: The session class, modified flag, and update callback have clear purposes; the cryptic variable and redundant bitwise operations do not. The unexplained SessionMixin reference and undefined te alias further impede understanding. Code length: The functional implementation is concise, but the dead computations add needless length and complexity. Action granularity: Most lines perform one action, while the long assignment combines several operations and conditions. Reading flow: Documentation provides useful context and the callback-to-super sequence is natural, but inconsistent spacing and the obfuscated constructor lines disrupt that flow.
Run 2
Code Structure: The class, initializer, and update callback are logically organized, but unrelated obfuscation disrupts the structure. Nesting: Mostly shallow, although the nested conditional expression adds unnecessary complexity. Clarity of intent: The docstring and modified flag explain session tracking well; the meaningless variable name and redundant bitwise operations obscure intent. The unexplained SessionMixin and undefined te alias also hinder comprehension. Code length: The functional implementation is concise, but two apparently useless assignments and a long expression add avoidable bulk. Action granularity: Most lines perform one clear action, except the conditional assignment, which packs several operations and branches into one line. Reading flow: Documentation leads naturally into initialization, but the obfuscated statements interrupt the transition to the callback, and missing spacing before the nested function reduces visual separation.
Run 3
Code Structure: Imports, the class, and its initializer are logically organized, but unrelated obfuscation disrupts the initializer. Nesting: Mostly shallow, though the nested conditional expression is unnecessarily difficult to parse. Clarity of intent: The docstring, modified flag, and update callback clearly convey session-change tracking; the opaque variable and redundant bitwise operations obscure intent. SessionMixin and te.Self are also undefined in the shown code, creating uncertainty. Code length: The functional implementation is concise, but the two irrelevant assignments and lengthy conditional add needless complexity. Action granularity: Most lines perform one action, although the conditional assignment combines several operations. Reading flow: Documentation and descriptive names support natural reading, but the unexplained obfuscated statements interrupt the transition from initialization to callback setup.