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 imports, a concise class definition, and straightforward methods. However, some issues affect clarity: 'PassList' is an unclear name, the method alias 'tag = to_json' at the class level is unusual and could confuse readers, and the lack of docstrings or type annotations on method parameters and return values reduces intent clarity. The 'check' method is simple, but the relationship between 'PassList' and its parent class 'JSONTag' is not evident. Additionally, while the code is short and flat, the semantic purpose of the class and the reasoning behind the alias are not self-explanatory, slightly lowering overall readability.
Run 3
The code is generally well-structured and readable. Imports are organized, the class uses __slots__ for efficiency, and the methods are concise with clear purposes. The check method clearly validates list types, and to_json efficiently maps the serializer over list items. However, 'PassList' is somewhat ambiguous as a name—it doesn't clearly communicate that this is a JSON serialization tag for lists. Assigning tag = to_json at class level is concise but slightly obscures intent. The code is flat, avoids unnecessary nesting, and follows a natural reading flow.
Run 1
Code Structure: The class is logically organized into type checking and serialization methods, although many imports are unused in this snippet and JSONTag is not defined or imported. 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, the class name PassList and the tag alias require some contextual knowledge. Code length: The implementation is concise, but unrelated imports add clutter. Action granularity: Each statement performs a single clear action. Reading flow: The methods follow a natural progression, though placing tag = to_json after the methods makes its relationship slightly less immediately obvious.
Run 2
Code Structure: The class is logically organized into small methods, although numerous unused imports add clutter and JSONTag is not defined or imported in the snippet. Nesting: The code is flat, with only standard class and method indentation. Clarity of intent: check clearly identifies lists, and to_json clearly tags their elements; however, PassList and the tag alias require some surrounding 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, and the list comprehension is straightforward. Reading flow: The methods follow a natural progression from type checking to conversion, though import clutter and the unexplained alias slightly interrupt comprehension.
Run 3
Code Structure: The class is logically organized into small, focused methods, though the many unused imports distract from the implementation. Nesting: The code is flat, with no deeply nested control flow. Clarity of intent: Type hints, isinstance checking, and the list comprehension clearly convey list handling and item serialization; however, JSONTag is not defined or imported in the snippet, and the purpose of aliasing tag to to_json requires context. Code length: The implementation is concise, but the import section is disproportionately long for the functionality shown. Action granularity: Each line performs one clear action, with a straightforward comprehension. Reading flow: The methods follow a natural progression from checking the value to serializing it, although the unexplained base class and method alias slightly interrupt comprehension.