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 relatively concise and readable but has notable clarity issues. The structure is logical, with clear imports and a straightforward class definition using __slots__. Nesting is minimal. However, the intent is somewhat ambiguous: the class is named PassList, yet it subclasses JSONTag, and its purpose isn't immediately clear. The `tag = to_json` alias adds confusion without explanation. The redundant __slots__ = () is slightly misleading since it suggests no instance attributes, but the class has methods that rely on inherited state. Code length is appropriate, and action granularity is reasonable, but reading flow is hampered by the unexplained alias and unclear relationship between PassList and JSONTag. Overall, the code would benefit from a docstring or clearer naming to express intent.
Run 2
The code is concise and readable. It has clear intent, with a simple class hierarchy and straightforward type checks. Imports are organized and specific, avoiding wildcard imports. Action granularity is one per line, improving readability. Nesting is minimal, with only one list comprehension. Minor issues: some imported names (JSONTag, serializer, Any) are not defined in the snippet, suggesting reliance on external context, and 'tag = to_json' could use a comment explaining its purpose as an alias for compatibility. Overall, the structure is logical and the flow natural.
Run 3
The code is well-structured and highly readable. It uses clear imports with `from __future__ import annotations` for modern type hints, and organizes stdlib, third-party, and local imports logically. The class `PassList` inherits from `JSONTag` with a clear single responsibility: serializing lists. Nesting is minimal—only a single list comprehension, which is flat and easy to follow. Each method has a clear purpose: `check` validates type, and `to_json` transforms the list by tagging each item. The code is concise without unnecessary verbosity, and each line performs one logical action, maintaining good action granularity. Reading flow is natural: class definition, type check, then serialization. Minor deductions: the `tag = to_json` alias might be briefly confusing without context, and a docstring or comment explaining why the alias is needed would improve clarity. Overall, the code is clean, idiomatic Python.
Run 1
Code Structure: The class is logically organized into type checking and serialization methods, though many imports are unused in the snippet and JSONTag is not defined or imported. Nesting: Methods are flat, with only a straightforward list comprehension. Clarity of intent: Method names and isinstance clearly convey list handling and item tagging; however, __slots__ and the tag = to_json alias require some contextual knowledge. Code length: The class is concise, but the unused imports add clutter. Action granularity: Each statement performs a single clear action. Reading flow: The progression from checking to conversion is natural, although the import block and unexplained alias slightly interrupt readability.
Run 2
Code Structure: The class is logically organized into small, focused methods, but numerous unused imports distract from its purpose, and JSONTag is not defined or imported in the snippet. Nesting: Very shallow, with a straightforward list comprehension. Clarity of intent: check clearly identifies lists, and to_json tags each item; however, PassList, the inherited serializer, and the tag alias require contextual knowledge. Code length: The implementation is concise, though the import block is disproportionate to the functionality shown. Action granularity: Each statement performs one clear action. Reading flow: Methods follow a natural progression from type checking to conversion, but limited spacing around the class and the trailing alias slightly reduce scanability.
Run 3
Code Structure: The class is logically organized into small, focused methods, though numerous unused imports and the undefined JSONTag base class distract from the snippet. Nesting: There is no deep nesting; the list comprehension is straightforward. Clarity of intent: check clearly tests for lists, and to_json tags each item, but PassList and the tag alias require some surrounding context to fully understand. Code length: The implementation is concise, while the import block is disproportionately long for the shown functionality. Action granularity: Each statement performs a single clear action. Reading flow: The methods follow a natural progression from type checking to conversion, although import clutter and limited spacing between top-level sections slightly weaken readability.