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 has logical organization and a clear class purpose, but it is marred by poor readability choices. The class name references 'SecureCookieSession' even though the defined class is 'NullSession', which creates ambiguity. The error message is clear, but the string contains multiple consecutive spaces in two places, creating formatting noise. The final line assigns six methods to '_fail' on one line, undermining action granularity and disrupting reading flow. This dense assignment makes it harder to immediately understand which methods are overwritten. Import organization is conventional, with clear separation between standard library, third-party, and local modules. However, the unused imports and inconsistent alias usage (like 'collections.abc as c') add clutter. Nesting is flat and simple, and code length is concise, but the technical issues with formatting and assignment compactness reduce overall readability.
Run 2
The code is generally readable but has some issues. The class structure is logical and the docstring clearly explains the purpose. However, there are several problems: the imports are disorganized (mixed standard library and third-party imports, unused imports like hashlib and datetime), the multiline string in the RuntimeError has awkward spacing, and the final line reassigning multiple methods to _fail is confusing without context—it's a clever pattern but hurts readability. The code is relatively flat with minimal nesting, which is good, but the action granularity is mixed—the final assignment line packs multiple operations into one dense line. The reading flow is disrupted by the inconsistent indentation in the raise statement and unclear import organization. Overall, while the intent is discernible, the implementation could benefit from cleaner imports, better formatting, and more explicit handling of the method reassignment pattern.
Run 3
The code structure is logical but the overall readability is impacted by several issues. The nesting is minimal, but the class definition is missing its base class import (SecureCookieSession is not imported in the provided snippet), making the code incomplete. The clarity of intent is adequate for the error message but the assignment of many dunder methods to _fail in a single line reduces action granularity. The code length is concise, but the lack of spacing around the multi-line assignment and the odd indentation of the closing parenthesis in the raise statement hurt the reading flow. Additionally, the use of abbreviated imports like 'collections.abc as c' and 'typing as t' is not utilized in the visible code, which adds unnecessary ambiguity. Overall, the code works but feels cramped and disorganized in places, which reduces its readability despite a straightforward purpose.
Run 1
Code Structure: The class groups related behavior logically, but numerous unused imports and little spacing between imports and the class add clutter. Nesting: Very shallow, with only a class and one method. Clarity of intent: The docstring and descriptive error clearly explain read-only session behavior, although SecureCookieSession is not defined or imported in the snippet. Code length: The implementation is concise, but imports are excessive for the shown functionality. Action granularity: Most lines express one action; the chained assignment of seven methods is compact but requires extra attention. Reading flow: The sequence from documentation to failure handler to method overrides is natural, though the awkward closing-parenthesis placement and deletion of _fail slightly disrupt readability.
Run 2
Code Structure: The class logically groups unavailable-session behavior, but numerous unused imports and an undefined SecureCookieSession base in the snippet weaken its standalone organization. Nesting: Very shallow, making control flow easy to follow. Clarity of intent: The docstring and explicit RuntimeError clearly explain the purpose; assigning all mutating methods to _fail is compact but requires familiarity with Python idioms. Code length: The implementation is concise, though the import block adds unnecessary length for the shown functionality. Action granularity: Most lines perform one action, but the long chained assignment binds seven methods at once, reducing scanability. Reading flow: The progression from documentation to failure behavior to method bindings is natural, but missing spacing before the class, awkward closing-parenthesis formatting, and deleting _fail introduce minor reading friction.
Run 3
Code Structure: The class is logically organized, but unused imports and an undefined SecureCookieSession base class in the snippet weaken self-contained readability. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: The docstring and explicit RuntimeError clearly explain why writes are forbidden, though chained method aliases require familiarity with Python. Code length: The implementation is concise, but the import list is disproportionate to the functionality shown. Action granularity: Most lines express one action; assigning seven methods in one statement is compact but less immediately readable. Reading flow: The progression from documentation to failure handler to method aliases is natural, but missing separation after imports and awkward closing-parenthesis placement interrupt the flow.