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 a(self, *b: t.Any, **c: 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 suffers from severe readability issues. The use of single-character variable names (a, b, c) obscures meaning and intent, while methods like '_fail' are assigned to multiple dunder methods making the class behavior difficult to trace. The class appears incomplete as it inherits from 'SecureCookieSession' which is not imported. The import section mixes aliased and non-aliased imports without clear organization. While the docstring is helpful, the error message is unnecessarily broken across multiple lines. The action granularity at the end attempts to be concise by combining multiple method assignments but at the cost of clarity. The reading flow is disrupted by the non-descriptive names and the unexplained 'del _fail' statement. Even with the forward reference import, there are missing type hints and unclear relationships between components.
Run 2
The code is fairly readable but has some clarity issues. The class structure is logical with a clear docstring explaining its purpose. The nesting is flat, and the action granularity is good with each operation on its own line. However, the method name '_fail' has been renamed to 'a' with parameters '*b' and '**c', which severely hurts clarity of intent - the original name was much more descriptive. The single-line assignment of multiple methods to _fail is concise but slightly dense. The 'del _fail' at the end is a bit unusual and could confuse readers unfamiliar with this pattern. The code length is appropriately minimal for its purpose, and the reading flow is natural despite the obfuscated method naming. Overall, the intent would be much clearer with a descriptive method name rather than 'a', 'b', 'c'.
Run 3
The code is highly unreadable. Variable names like 'a', 'b', and 'c' obscure intent, and the method '_fail' is renamed to 'a' but referenced by its original name in the final line, causing a potential NameError or confusion. The class inherits from 'SecureCookieSession' which is not imported in this snippet, creating a missing dependency. Multiple actions are chained in the last assignment line, violating action granularity. While standard library imports are somewhat organized, the mixing of specific and module-level imports hurts clarity. The overall structure is tangled, and the intent of the class, while documented, is undermined by cryptic parameter naming.
Run 1
Code Structure: Imports and a small class are logically organized, but unused imports clutter the snippet. Nesting: Minimal nesting makes it easy to scan. Clarity of intent: The class docstring and exception message clearly describe read-only fallback behavior, but method and parameter names a, b, and c obscure meaning. More importantly, the mutation aliases reference undefined _fail rather than the defined method a, and SecureCookieSession is not defined or imported in the snippet, disrupting comprehension. Code length: The class is concise, though the import list is disproportionate to its functionality. Action granularity: Most lines perform one action, but the long chained assignment compresses seven method aliases into one line. Reading flow: The progression from documentation to failure behavior is natural, but inconsistent naming and unresolved references force readers to stop and infer the intended implementation.
Run 2
Code Structure: Imports and the class are logically organized, but numerous unused imports add clutter, and SecureCookieSession is not defined or imported in the snippet. Nesting: Very shallow, making the code easy to scan. Clarity of intent: The class docstring and error message clearly explain the intended behavior, but cryptic names a, b, and c obscure meaning. More importantly, the aliases reference _fail rather than the defined method a, breaking the implementation as shown. Code length: The class is concise, although the import list is unnecessarily long for this snippet. Action granularity: Most lines contain one action, but the chained assignment combines seven method aliases into one dense line. Reading flow: The progression from imports to documentation to error handling is natural, but the naming mismatch and subsequent deletion of undefined _fail interrupt comprehension.
Run 3
Code Structure: Imports and the class are logically separated, but numerous unused imports add clutter. Nesting: The code is flat, with only a class and one method. Clarity of intent: The docstring and error message clearly explain the read-only session behavior, but opaque names a, b, and c obscure meaning. The method is named a while the aliases reference undefined _fail, and SecureCookieSession is not defined or imported in the snippet, making the implementation confusing. Code length: The class is concise, though the imports are excessive for the shown functionality. Action granularity: Most lines perform one action, but chaining seven method aliases on one line reduces scanability. Reading flow: The progression from documentation to error handling to mutation-method aliases is natural, but inconsistent naming and unresolved references interrupt comprehension.