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 SessionMixin(MutableMapping[str, t.Any]):
"""Expands a basic dictionary with session attributes."""
@property
def permanent(self) -> bool:
"""This reflects the ``'_permanent'`` key in the dict."""
return self.get("_permanent", False) # type: ignore[no-any-return]
@permanent.setter
def permanent(self, value: bool) -> None:
self["_permanent"] = bool(value)
#: Some implementations can detect whether a session is newly
#: created, but that is not guaranteed. Use with caution. The mixin
# default is hard-coded ``False``.
new = False
#: Some implementations can detect changes to the session and set
#: this when that happens. The mixin default is hard coded to
#: ``True``.
modified = True
accessed = False
"""Indicates if the session was accessed, even if it was not modified. This
is set when the session object is accessed through the request context,
including the global :data:`.session` proxy. A ``Vary: cookie`` header will
be added if this is ``True``.
.. versionchanged:: 3.1.3
This is tracked by the request context.
"""
Run 1
The code is well-structured with clear class definition and logical grouping of properties and attributes. Nesting is minimal—only one class and no deep indentation. The intent is clear: extending a dictionary with session-specific behavior. Code length is concise; each property is short and focused. Action granularity is appropriate, with one logical action per line. Reading flow is natural, moving from imports to class definition to documented attributes. Type hints and docstrings improve understandability. Minor deductions include a couple of slightly long lines and mixed import styles, but overall readability is strong.
Run 2
The code is highly readable with clear structure and intent. The SessionMixin class logically groups session-related attributes and methods. Nesting is minimal—just one class and property methods, keeping the code flat. Each property has a concise, explicit purpose, with docstrings explaining non-obvious behavior like the '_permanent' key. Code length is appropriate; no unnecessary repetition or verbosity. Action granularity is balanced—each line performs a single clear action, such as returning the default or assigning a cast value. Reading flow is natural: imports are organized, then the mixin class, then properties, then documented attributes. Minor issues include slightly inconsistent import style (mixed `typing as t` with direct `MutableMapping` import), and the `# type: ignore` comment slightly interrupts flow. Overall, the code is maintainable and self-documenting with only trivial improvements possible.
Run 3
The code demonstrates excellent readability with clear structure, minimal nesting, and strong intent clarity. It uses modern Python typing syntax and follows a logical class organization. Each method has a focused purpose and the property decorator pattern is clean. The code is concise, avoiding unnecessary verbosity while maintaining proper documentation through docstrings and comments. Action granularity is appropriate—each line performs a single clear operation. The reading flow is natural, starting with imports, then class definition, followed by well-ordered properties and attributes. Minor points could be noted: the inline type ignore comment slightly interrupts flow, and the multiple class attribute assignments with comments could potentially be grouped differently. However, these are trivial and the overall readability remains very high by Python standards.
Run 1
Code Structure: Imports and the session mixin are logically organized, though import grouping could be clearer. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: Descriptive names, type annotations, and documentation clearly explain session attributes and the permanent property. Code length: The implementation is concise; documentation is somewhat lengthy relative to the executable code but provides useful context. Action granularity: Each statement performs a single action, with no compressed multi-action lines. Reading flow: The property getter and setter are adjacent, followed by related session flags. Flow is slightly interrupted by mixed documentation styles, framework-specific markup, and abbreviated import aliases.
Run 2
Code Structure: Imports and session behavior are logically organized in a focused mixin, although import grouping could be clearer. Nesting: Very shallow, with straightforward property methods and class attributes. Clarity of intent: Descriptive names, type annotations, and documentation make the session flags and permanent setting clear; abbreviated import aliases slightly reduce immediate clarity. Code length: Concise implementation with proportionate documentation, though several imports are unused in the shown snippet. Action granularity: Each executable line performs a single clear action. Reading flow: Natural progression from imports to the class, property accessors, and session flags; inconsistent documentation styles between attributes slightly interrupt the flow.
Run 3
Code Structure: Imports and session behavior are logically organized in a focused mixin, although several imports are unused in this excerpt. Nesting: Minimal nesting makes the property methods easy to follow. Clarity of intent: Descriptive names, type annotations, and documentation clearly explain session attributes; abbreviated import aliases are slightly less explicit. Code length: The implementation is concise, though documentation occupies substantially more space than executable code. Action granularity: Each executable line performs a single clear action. Reading flow: The getter, setter, and default attributes follow a natural sequence. Mixed documentation styles and embedded version metadata slightly interrupt an otherwise smooth reading experience.