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 highly readable with a clear, logical structure. The class PassList inherits from JSONTag and implements its interface cleanly, with each method performing a distinct action. Nesting is minimal, and the code is concise, avoiding unnecessary length. Intent is evident: the class handles serialization of list types by tagging each item. Action granularity is appropriate, with one clear operation per line, and the reading flow follows a natural sequence from type checking to serialization. Minor deductions are for the redundant tag = to_json assignment, which is slightly ambiguous without context, but overall the code is well-organized and easy to follow.
Run 2
The code is generally well-structured and readable. It uses clear imports, type hints, and a simple class definition with `__slots__` for efficiency. The `PassList` class has a clear purpose: serializing lists for a JSON tagging system. The `check` method is a straightforward type guard, and `to_json` uses a concise list comprehension. The alias `tag = to_json` is slightly ambiguous but likely intentional for API compatibility. Overall, the code is flat, concise, and easy to follow, though a brief comment explaining the purpose of the class or the `tag` alias would improve clarity.
Run 3
The code is generally readable with clear structure and organization. Imports are properly grouped and formatted, the class has a clear single responsibility, and method names are descriptive. Action granularity is good with one operation per line. Nesting is minimal. The main readability issues are: (1) unused imports (b64decode, b64encode, datetime, UUID, Markup, http_date, parse_date, dumps, loads) which add noise and ambiguity about intent, (2) the 'tag = to_json' alias at the bottom lacks explanation of why both methods exist, and (3) while concise, the class would benefit from a docstring explaining the PassList purpose and how it differs from the parent JSONTag class.
Run 1
Code Structure: The class is logically organized into type checking, conversion, and an alias, although many imports are unused in this excerpt and JSONTag is not defined or imported. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: Method names and the list comprehension clearly convey checking for lists and tagging their contents, but PassList and the tag alias require some framework context. Code length: The implementation is concise, with unnecessary imports adding visual clutter. Action granularity: Each statement performs one clear action; the comprehension expresses a straightforward transformation. Reading flow: Imports followed by a small class provide a natural progression, though additional spacing between imports and the class would improve readability.
Run 2
Code Structure: The class is logically organized into type checking and JSON conversion, but numerous unused imports add clutter, and JSONTag is not defined or imported in the snippet. Nesting: There is no deep nesting; the list comprehension is straightforward. Clarity of intent: Method names and the isinstance check make the purpose clear, though the tag alias and inherited serializer require external context. Code length: The implementation is concise, but the import block is disproportionately long for the functionality shown. Action granularity: Each statement performs a focused action; the comprehension naturally combines iteration and conversion. Reading flow: The methods are easy to follow, although a blank line between imports and the class would improve separation.
Run 3
Code Structure: The class is logically organized into small, focused methods, but numerous unused imports add clutter, and JSONTag is not defined or imported in the snippet. Nesting: Minimal nesting; the list comprehension is straightforward. Clarity of intent: check clearly identifies lists, and to_json tags each item, though PassList and the tag alias require framework context. Code length: The implementation is concise, but the import block is disproportionately long for the functionality shown. Action granularity: Each line performs one clear action, with a simple comprehension expressing the transformation compactly. Reading flow: The methods follow a natural check-then-convert sequence, although import clutter and limited spacing between top-level sections slightly disrupt scanning.