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 readable with clear intent, flat nesting, and concise structure. Logical imports are organized. Class and method naming is clear. However, several unused imports (b64decode, b64encode, datetime, UUID, Markup, http_date, parse_date, loads) reduce clarity, suggesting copied boilerplate or unfinished refactoring. The alias `tag = to_json` is slightly ambiguous—perhaps intentional for API compatibility, but it requires context to understand. Minimal documentation or type annotations on methods beyond `value` and return types are adequate but not exhaustive. Overall, the class is simple and well-formed, but import hygiene could be improved to increase readability.
Run 3
The code is well-structured and readable. Imports are organized and explicit, with clear separation between standard library, third-party, and local modules. The class uses __slots__ for efficiency and has focused, single-purpose methods. The check method cleanly validates list types, while to_json uses a concise list comprehension. The tag alias is unusual but clearly intentional. The only minor deductions are for the redundant tag = to_json assignment (which could confuse readers about why two identical methods exist) and the heavy use of typing imports without aliases visible in context. Overall, the code demonstrates flat nesting, clear intent, appropriate length, good action granularity, and natural reading flow, making it highly maintainable.
Run 1
Code Structure: The class is logically organized into a type check and serialization method, though the many unused imports add clutter and JSONTag is not defined or imported in the snippet. Nesting: Methods are flat, with only a straightforward list comprehension. Clarity of intent: Method names and the isinstance check clearly convey list recognition and serialization; the tag alias and __slots__ declaration require some familiarity with Python conventions. Code length: The implementation is concise, but the import block is disproportionate to the shown functionality. Action granularity: Each statement performs one clear action. Reading flow: The class reads naturally, although irrelevant imports and missing base-class context slightly interrupt comprehension.
Run 2
Code Structure: The class is logically organized into small, focused methods, though the many unused imports add clutter and JSONTag is not defined or imported in the snippet. Nesting: The code is shallow, with a straightforward list comprehension. Clarity of intent: check clearly identifies lists, and to_json clearly tags their elements; the tag alias is concise but its purpose depends on surrounding context. Code length: The implementation is compact, but the import block is disproportionately long for the shown functionality. Action granularity: Each statement performs one clear action. Reading flow: The methods follow a natural validation-to-conversion sequence, although import clutter and missing context slightly interrupt comprehension.
Run 3
Code Structure: The class is logically organized into a type check, serialization method, and alias, though many imports are unused in the snippet 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 communicate list serialization, but PassList, the tag alias, and the inherited serializer rely on external context. Code length: The class is concise, while the import block adds unnecessary length for the displayed functionality. Action granularity: Each statement performs a single clear action. Reading flow: The methods follow a natural progression, although import grouping and a blank line before the class would improve presentation.