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. It uses type hints and imports are organized, though the import of 'c' as an alias for collections.abc is unused and confusing. The NullSession class has a clear purpose and the _fail method is concise with a helpful error message. The assignment of multiple methods to _fail in one line is slightly dense but acceptable for boilerplate session methods. The del _fail statement is unusual and could be surprising to readers. Nesting is minimal and the flow is natural. The main drawbacks are the unused import and the slightly cryptic method assignment line, which could benefit from a comment explaining why these methods are assigned to _fail.
Run 3
The code is highly readable and follows good practices. The structure is logical, with a clear class definition and a purpose-explaining docstring. Nesting is minimal, with only one level of indentation in the _fail method. Intent is explicit: the class exists to produce a helpful error when sessions are unavailable. Code length is concise and appropriate for the single responsibility. Action granularity is strong—one clear assignment line consolidates mutating method replacements, which is idiomatic for this pattern. Reading flow is natural: imports, class definition, docstring, method, then method reassignment. Minor deductions: the chained assignment line, while concise, may require a moment to parse; variable names like 'c' and 't' as import aliases are slightly terse; and the 'del _fail' line, though clean, could surprise readers unfamiliar with the pattern.
Run 1
Code Structure: The class is logically organized, with a descriptive docstring and a centralized failure handler, though several imports are unused in this excerpt and the base class is not defined here. 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, although the surrounding imports add clutter. Action granularity: Most lines perform one action, but the chained assignment binds seven methods at once, reducing immediate readability. Reading flow: The progression from documentation to failure behavior to method bindings is natural; deleting the helper afterward and the compact chained assignment require some familiarity with Python class construction.
Run 2
Code Structure: The class is logically organized, although numerous unused imports and an undefined-in-snippet base class distract from its implementation. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The descriptive class name, docstring, and actionable error message clearly explain the read-only session behavior. Code length: The implementation is concise, but the imports add unnecessary length in isolation. Action granularity: Most lines express a single action; the chained assignment overriding seven methods compresses several actions into one line and requires extra attention. Reading flow: The progression from documentation to failure handler to method overrides is natural, though deleting the helper after assigning its aliases is a less obvious idiom.
Run 3
Code Structure: The class is logically organized, with a descriptive docstring and a centralized error handler, although several imports are unused in this snippet and SecureCookieSession is not defined or imported. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The docstring and explicit error message clearly explain the session's behavior. Code length: The implementation is concise without redundant methods. Action granularity: Most statements perform one action, but the chained assignment binds seven mutation methods at once, reducing readability. Reading flow: The progression from documentation to error handling to method bindings is natural; however, the dense assignment and deletion of _fail require familiarity with Python class construction.