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:
def on_update(self: te.Self) -> None:
self.modified = True
super().__init__(initial, on_update)
Run 1
The code is generally readable but has a few issues. The structure and intent are clear, with good use of type hints and docstrings. However, the import section is cluttered with multiple overlapping imports (collections.abc as c, MutableMapping imported but unused), creating confusion. The unused 'MutableMapping' import and the import of 'te.Self' without an explicit import statement are problematic. The nesting level is minimal (one inline function), but the 'typing as t' alias combined with the undefined 'te' namespace creates a potential runtime error. Action granularity is good in the __init__ method, though the inline 'on_update' function could be extracted for clarity. The reading flow is mostly natural, starting with imports and moving to class definition, but the unused imports and undefined 'te' reference disrupt the flow. The class attributes are well-documented, which aids comprehension.
Run 2
The code demonstrates excellent readability through a clear class definition with descriptive docstring, logical import organization, and proper type hints. The class structure is simple and focused, inheriting from CallbackDict and SessionMixin appropriately. Nesting is minimal — only one level deep in the constructor's inner function. The on_update callback clearly conveys intent with its single responsibility. Code length is concise with no redundancy. Action granularity is well-balanced: each import statement and class attribute on separate lines, the callback function is a single operation. Reading flow is natural: imports, class definition, attribute documentation, then constructor logic. Minor improvements could include adding blank lines between import groups and specifying the 'te' namespace import path for better clarity. The docstring effectively explains the session behavior, including limitations about mutable data tracking and the 'new' attribute being hardcoded.
Run 3
The code is generally readable but has issues with import organization and naming. Multiple import styles are mixed (from __future__, collections.abc as c, typing as t, plus explicit imports). The alias 'c' for collections.abc is non-standard and used for one parameter type annotation, hurting quick readability. The class structure is logical and docstring is helpful, but nesting is introduced through the inner on_update function, creating an unnecessary level. The use of 'te.Self' is incorrect - 'typing' is imported as 't', not 'te', indicating a bug or typo. Action granularity is mostly fine, with the on_update closure being concise. Reading flow is somewhat disrupted by the import block inconsistencies and the unexplained 'SessionMixin' base class (assumed imported elsewhere). Code length is appropriate, and intent is relatively clear for those familiar with Flask session internals, but the mixed import patterns and alias usage reduce overall readability.
Run 1
Code Structure: Imports, the class, its state flag, and initialization are logically organized, though several imports are unused in this excerpt. Nesting: Shallow; the nested update callback is appropriate and easy to follow. Clarity of intent: The class docstring and comments clearly explain signed-cookie sessions and modification tracking, but SessionMixin and te.Self are undefined in the excerpt, and the documented accessed attribute is not shown. Code length: The implementation is concise; documentation is longer than the executable code but provides useful context. Action granularity: Each statement performs one action, with no compressed compound statements. Reading flow: The progression from session behavior to the modified flag and callback setup is natural, although abbreviated aliases and the callback's shadowing of self introduce minor friction.
Run 2
Code Structure: Imports, class documentation, state, and initialization are logically organized, although several imports are unused in this snippet. Nesting: Shallow overall; the nested callback is appropriate and easy to follow. Clarity of intent: Descriptive names, type annotations, and comments clearly explain change tracking, but SessionMixin and te.Self are undefined in the shown code, and the documentation mentions attributes not implemented here. Code length: Concise implementation with useful documentation, though the import list and multiline constructor signature add some overhead. Action granularity: Each statement performs a single clear action. Reading flow: Natural progression from session behavior to initialization and callback registration, with minor interruptions from abbreviated aliases and missing definitions.
Run 3
Code Structure: Imports, class documentation, state, and initialization are logically organized. Nesting: Minimal; the nested callback is appropriate and easy to follow. Clarity of intent: Descriptive names, type annotations, and comments explain modification tracking well, although SessionMixin and te.Self are undefined in the snippet, and documentation references attributes not shown. Code length: The implementation is concise, but documentation is lengthy relative to the small amount of behavior. Action granularity: Each statement performs a single clear action. Reading flow: The progression from class purpose to initial state and callback registration is natural, though abbreviated import aliases and missing definitions slightly interrupt comprehension.