Source code
from __future__ import annotations
import typing as t
from base64 import b64decode
from base64 import b64encode
from datetime import datetime
from uuid import UUID
from markupsafe import Markup
from werkzeug.http import http_date
from werkzeug.http import parse_date
from ..json import dumps
from ..json import loads
class PassList(JSONTag):
__slots__ = ()
def check(self, value: t.Any) -> bool:
return isinstance(value, list)
def to_json(self, value: t.Any) -> t.Any:
return [self.serializer.tag(item) for item in value]
tag = to_json
Run 1
The code is generally readable with a clear, logical structure. Imports are organized and type hints improve clarity. The class is focused with a single responsibility. However, some points reduce readability: the `__slots__ = ()` is non-obvious without context, the `tag = to_json` alias is somewhat unusual and could confuse readers about intent, and the import section includes several unused imports (b64decode, b64encode, datetime, UUID, Markup, http_date, parse_date, dumps, loads), adding noise. The method definitions are concise, but the lack of docstrings or comments makes the purpose of `check` and `to_json` dependent on familiarity with the codebase's pattern. Nesting is flat and each line represents one action, which improves readability, but the overall flow could be clearer with a brief class-level comment or docstring explaining the PassList tag's role.
Run 2
The code is generally readable with clear intent and logical organization. It uses modern Python features like __future__ annotations and typing, which improves clarity. The class structure is simple and focused, with a single responsibility. Nesting is minimal and the reading flow is natural. However, a few improvements could be made: the 'tag = to_json' alias at the end is slightly ambiguous without context, and the unused imports (Markup, datetime, UUID, etc.) suggest either incomplete code or leftover dependencies. The check method is straightforward, but the to_json method uses a list comprehension that could benefit from a small explanatory comment. Overall, the code is concise and easy to follow, though the presence of unused imports slightly detracts from its clarity.
Run 3
The code is well-structured and readable, with clear imports and a simple class definition. It follows a logical organization with the 'PassList' class inheriting from 'JSONTag' and implementing 'check' and 'to_json' methods concisely. The use of 'typing' and '__slots__' shows intent for clarity and performance. Nesting is flat, and each method performs a single, clear action. However, the 'tag = to_json' assignment is slightly ambiguous without context, and the lack of docstrings or comments reduces clarity for those unfamiliar with the codebase. Overall, it is concise and follows good practices, but minor improvements in documentation could enhance readability.
Run 1
Code Structure: The class is logically organized, with separate methods for type checking and serialization, though the many unused imports and undefined JSONTag base class distract in this snippet. Nesting: The code is flat, with no deeply nested control flow. Clarity of intent: Method names and the list comprehension clearly convey list detection and item tagging; however, PassList, __slots__, and the tag alias require some framework context. Code length: The implementation is concise, but the import block is disproportionately long for the functionality shown. Action granularity: Each statement performs a distinct action, and the comprehension is compact without being overloaded. Reading flow: The class reads naturally from checking to conversion to aliasing, although missing spacing between imports and the class slightly reduces visual separation.
Run 2
Code Structure: The class is logically organized into a type check, serialization method, and alias, though many imports are unused in this snippet and JSONTag is not defined or imported. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: Method names, type annotations, and the list comprehension clearly convey list detection and item serialization; the class name and tag alias require some surrounding context. Code length: The implementation is concise, but the extensive import block adds clutter relative to the small class. Action granularity: Each statement performs one clear action. Reading flow: The class reads naturally, although import grouping and an additional blank line before the class would improve visual organization.
Run 3
Code Structure: The class is logically organized into type checking and serialization methods, though many unused imports add clutter. Nesting: There is no deep nesting; the list comprehension is straightforward. Clarity of intent: Method names and type hints communicate the purpose, but JSONTag is not defined or imported in the snippet, and the tag alias is unexplained. Code length: The implementation is concise, although the import section is disproportionate to the class. Action granularity: Each statement performs a focused action, with the comprehension expressing a single transformation clearly. Reading flow: The methods follow a natural progression, but the missing blank line between imports and the class and the unexplained trailing alias slightly interrupt readability.