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,
ini: c.Mapping[str, t.Any] | None = None,
) -> None:
def on_update(self: te.Self) -> None:
self.modified = True
super().__init__(ini, on_update)
Run 1
The code is highly readable with clear structure and intent. It uses modern type hints, descriptive names, and comprehensive docstrings. The class hierarchy is logical, and the one-line update callback is concise. Minor deductions: the import of `te.Self` is missing from the shown imports, and `SessionMixin` appears undefined, suggesting incomplete context rather than poor structure. The `on_update` function could be slightly clearer with an explicit `__setitem__` override instead of a callback, but the current approach is acceptable. Nesting is minimal, action granularity is good, and reading flow is natural.
Run 2
The code shows moderate readability. Structure is generally logical with clear sectioning via class and method definitions, but the `__init__` method contains a nested function that makes the flow less obvious. Nesting is shallow overall, but the inner `on_update` callback adds slight cognitive overhead. Intent is reasonably clear—the class purpose and attribute behavior are documented with docstrings and comments. Code length is appropriately concise and avoids unnecessary verbosity. Action granularity is acceptable, though some lines combine multiple concepts (e.g., the import aliasing and the inner function definition). Reading flow improves from the explanatory comments but is disrupted by the inner callback definition appearing before `super().__init__`, making the initialization order feel slightly counterintuitive. The type hints and `from __future__ import annotations` are helpful for modern Python. Overall, the code is readable but would benefit from moving `on_update` to a module-level function or using a simpler approach like a lambda to reduce nesting and improve immediate clarity of the constructor.
Run 3
The code is generally readable but has several minor issues. The class structure is logical with clear docstrings. However, type hints use abbreviated aliases (c, t) reducing immediate clarity. The __init__ method defines a nested on_update function that references 'te.Self' which is not imported, indicating a bug. The 'modified' class attribute is set outside __init__ in a non-standard way. Import organization is somewhat scattered with mixing of 'from __future__' and standard library imports. The nesting is minimal, but the inner function adds slight complexity. Missing imports (SessionMixin, te) make the code incomplete. Overall, it's readable but could benefit from full import statements and fixing the undefined references.
Run 1
Code Structure: Imports, class documentation, state, and initialization are logically organized, though SessionMixin and te are undefined in the snippet. Nesting: Shallow; the single nested callback is appropriate. Clarity of intent: Documentation clearly explains modification tracking, but the abbreviated parameter ini and unexplained aliases reduce clarity. The docstring also mentions accessed tracking that is not shown. Code length: Implementation is concise, although documentation dominates and the short constructor signature is unnecessarily spread across lines. Action granularity: Each statement performs one clear action. Reading flow: Natural progression from documentation to initialization, with minor friction from missing definitions and the callback parameter shadowing the outer self.
Run 2
Code Structure: Imports, class documentation, state, and initialization are logically organized. Nesting: Shallow; the nested callback is appropriate and easy to follow. Clarity of intent: Documentation clearly explains signed-cookie sessions and modification tracking, although the abbreviated parameter name 'ini' and undefined references to 'SessionMixin' and 'te' reduce self-contained clarity. Code length: The implementation is concise, but documentation is comparatively lengthy and several imports are unused in this snippet. Action granularity: Each statement performs one clear action. Reading flow: Natural progression from session behavior to state initialization and callback registration, though additional blank lines between import groups and the class would improve visual separation.
Run 3
Code Structure: Imports, class documentation, state, and initialization are logically organized, though several imports are unused in this snippet. Nesting: Shallow; the nested callback is small and appropriate. Clarity of intent: The docstrings clearly explain session behavior and modification tracking, but the abbreviated parameter 'ini' and undefined references to 'te' and 'SessionMixin' reduce clarity in isolation. Code length: The implementation is concise, although documentation and imports outweigh the executable code. Action granularity: Each statement performs one action, making changes easy to follow. Reading flow: The progression from class purpose to state tracking and callback registration is natural; alias inconsistencies and missing definitions slightly interrupt it.