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 NullSession(SecureCookieSession):
"""Class used to generate nicer error messages if sessions are not
available. Will still allow read-only access to the empty session
but fail on setting.
"""
def _fail(self, *args: t.Any, **kwargs: t.Any) -> t.NoReturn:
raise RuntimeError(
"The session is unavailable because no secret "
"key was set. Set the secret_key on the "
"application to something unique and secret."
)
__setitem__ = __delitem__ = clear = pop = popitem = update = setdefault = _fail
del _fail
Run 1
The code is highly readable, with clear imports, a single purpose, and a clean class definition. The NullSession class is logically structured, and the _fail method clearly communicates intent with a descriptive error message. Nesting is minimal, and each assignment of methods to _fail is concise. Action granularity is well handled, as the method aliasing is compact but still understandable. The only minor drawback is the slight ambiguity in the import of collections.abc as c, which is unused, but this does not significantly impact readability.
Run 2
The code is generally readable with clear intent and logical structure. The class purpose is documented, and the error message is descriptive. However, the final line assigning multiple methods to _fail in one statement reduces action granularity and harms readability; it is dense and easy to miss. Nesting is minimal, length is concise, and reading flow is natural. Overall, it is understandable but could improve clarity by separating method assignments or using a loop.
Run 3
The code is relatively clear in its intent and readable for a small utility class. The docstring explains the class purpose well, and the error message is descriptive. However, there are a few issues that reduce readability. The imports are somewhat messy—mixing `collections.abc` with an alias `c`, then separately importing `MutableMapping`—which adds visual noise and ambiguity. The `NullSession` class inherits from `SecureCookieSession` without explanation or local definition, forcing the reader to understand an external context. The assignment of multiple dunder methods (`__setitem__`, `__delitem__`, `clear`, `pop`, etc.) to `_fail` on one line is compact but reduces action granularity and reading flow, making it less obvious what each method does. The line is also long and can be easily overlooked. Overall, the code is not deeply nested and has a logical structure, but the mixed import style and compressed method assignment lower its readability.
Run 1
Code Structure: The class is logically organized around a single failure handler, although numerous unused imports distract from its purpose and the base class is not defined or imported in the snippet. Nesting: Minimal nesting makes the code easy to follow. Clarity of intent: The docstring and descriptive error message clearly explain read-only session behavior and why modifications fail. Code length: The implementation is concise, but the imports add unnecessary length within this excerpt. Action granularity: Most lines perform one action; the chained assignment binds seven methods at once, sacrificing some readability for compactness. Reading flow: The progression from documentation to error handler to method bindings is natural, though the dense assignment and deletion of the helper require familiarity with Python class construction.
Run 2
Code Structure: The class is logically organized, although several imports are unused in this snippet and the SecureCookieSession base class is not shown. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The docstring and descriptive error message clearly explain the read-only fallback behavior; assigning mutation methods to _fail is less immediately obvious. Code length: The implementation is concise, with little unnecessary code beyond the unused imports. Action granularity: Most lines perform one action, but the chained assignment binds seven methods at once, increasing cognitive load. Reading flow: The progression from documentation to error handling to method binding is natural, though the dense assignment and deletion of _fail require familiarity with Python class construction.
Run 3
Code Structure: The class is logically organized into a descriptive docstring, an error-raising helper, and mutation-method overrides, although several imports are unused in this snippet. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The docstring and explicit error message clearly explain the read-only session behavior; however, SecureCookieSession is not defined or imported here, leaving some context missing. Code length: The implementation is concise without repetitive method definitions. Action granularity: Most lines perform one action, but the chained assignment binds seven methods at once and requires closer reading. Reading flow: The progression from explanation to implementation is natural, though the dense assignment and subsequent deletion of _fail introduce a slightly non-obvious idiom.