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 but has some issues. Structure is logical with a clear class definition and docstring. Nesting is minimal, which is good. The intent is clear - providing a session class that fails gracefully when no secret key is set. Code length is appropriate - concise but not too terse. The main readability issue is the last line where multiple methods are assigned in a single line, which reduces clarity and makes the code harder to scan. The imports at the top feel slightly cluttered with unused imports (MutableMapping, datetime, timezone, hashlib, BadSignature, URLSafeTimedSerializer, CallbackDict, TaggedJSONSerializer) which could confuse readers about what's actually needed. The error message is clear and helpful. Type hints are used appropriately where present. The reading flow is mostly natural - docstring explains purpose, then the failure method, then the mass assignment of methods. The mass assignment could be split for better readability.
Run 3
The code is moderately readable. It has clear intent with a docstring explaining the 'NullSession' purpose and a concise '_fail' method that provides a helpful error message. The structure is logical, with the class inheriting from 'SecureCookieSession' and assigning multiple methods to '_fail' in one line, which is concise but slightly reduces action granularity. The nesting is flat, which is good, but the 'del _fail' at the end is somewhat confusing—it removes the helper method after use, which may obscure intent for readers unfamiliar with this pattern. The import block includes several unused or redundant imports (e.g., 'hashlib', 'datetime', 'itsdangerous', 'MutableMapping', 'CallbackDict', 'TaggedJSONSerializer'), which adds noise and reduces clarity. Overall, the code is understandable but could be improved by removing unused imports and clarifying the method reassignment pattern.
Run 1
Code Structure: The class is logically organized around a single failure handler, though numerous unused imports and the undefined-in-snippet base class add clutter and missing context. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The docstring and descriptive error message clearly explain read-only behavior when sessions are unavailable. Code length: The implementation is concise, but the imports are disproportionate to the shown functionality. Action granularity: Most lines perform one action; the chained assignment binds seven mutation methods at once, reducing immediate readability. Reading flow: The progression from documentation to error handling to method bindings is natural, although the dense assignment and deletion of the helper require familiarity with Python class mechanics.
Run 2
Code Structure: The class is logically organized, although numerous unused imports and the missing SecureCookieSession definition distract in this isolated snippet. Nesting: Minimal nesting makes the code easy to follow. Clarity of intent: The docstring and explicit error message clearly explain read-only behavior and why modifications fail. Code length: The implementation is concise, though the imports add unnecessary length here. Action granularity: Most lines express a single action, but chaining seven method assignments into one line makes the overridden operations harder to scan. Reading flow: The progression from class documentation to failure handling to method overrides is natural; deleting _fail and the compact alias assignment require some familiarity with Python class construction.
Run 3
Code Structure: The class is logically organized, with a descriptive docstring and a centralized failure handler, though many imports are unused in this snippet and the base class is not shown. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The docstring and explicit error message clearly explain why session mutations fail. Code length: The implementation is concise without redundant method definitions. Action granularity: Most lines express a single action, but the chained assignment binds seven methods at once, increasing cognitive load. Reading flow: The progression from documentation to handler to method bindings is natural, although the dense assignment and deletion of _fail require familiarity with Python class construction.