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 a(self, c: t.Any) -> bool:
return isinstance(c, list)
def b(self, d: t.Any) -> t.Any:
return [self.serializer.tag(e) for e in d]
tag = to_json
Run 1
The code is extremely difficult to read due to poor naming conventions (methods named 'a' and 'b', parameter 'c' and 'd'), unclear class inheritance (JSONTag is undefined), and unrelated imports that suggest incomplete or obfuscated code. The structure lacks logical organization and clarity of intent, making it impossible to determine the class's purpose. Nesting is minimal but this is overshadowed by ambiguous naming and missing context. Code length is concise but misleading, as brevity comes at the cost of readability. Action granularity and reading flow are acceptable line-by-line, but the overall effect is disorienting. The assignment 'tag = to_json' references an undefined attribute, further confusing readers. The code appears intentionally obfuscated or severely incomplete, which drastically reduces readability despite its short length.
Run 2
The code has minimal nesting and is concise, which are positives. However, it suffers from poor clarity of intent due to cryptic method names ('a', 'b'), unclear variable names ('c', 'd', 'e'), and an unexplained reference to 'JSONTag', 'serializer', and 'to_json'. The class structure is fragmented, and the reading flow is broken by the lack of context—imports are unused or unrelated to the visible logic, and the assignment 'tag = to_json' appears detached from the class's purpose. Action granularity is acceptable, but the overall structure feels tangled because the class's role and inheritance are not self-evident. The code is short, but that brevity comes at the cost of readability, as the developer must infer meaning from cryptic names and missing surrounding context.
Run 3
The code is extremely difficult to read due to several critical issues. The class PassList inherits from JSONTag which is never imported or defined, making the code non-functional as presented. Method names 'a' and 'b' are meaningless and provide zero clarity of intent. Parameter names 'c', 'd', and 'e' further obscure purpose. The code is flat (good nesting), but suffers from poor action granularity and reading flow - imports are scattered and unused (datetime, UUID, Markup, http_date, parse_date, b64decode, b64encode, loads). The list comprehension in method 'b' is concise but unclear due to naming. Code structure appears disorganized with unused imports and missing definitions. While the code is short, it fails on clarity of intent, meaningful naming, and logical organization. A reader cannot determine what PassList does or how it relates to serialization without guessing.
Run 1
Code Structure: Imports and a small class are logically organized, but numerous unused imports and unresolved names obscure context. Nesting: Very shallow; the list comprehension is easy to follow. Clarity of intent: The list type check and element tagging are understandable, but method names a and b and parameter names c, d, and e convey little meaning. JSONTag and to_json are not defined or imported in the snippet, making the class contract and tag assignment unclear. Code length: The implementation is concise, although imports dominate the snippet unnecessarily. Action granularity: Each statement performs one clear action. Reading flow: The methods are straightforward individually, but cryptic naming and the unexplained final alias interrupt understanding of how the class works.
Run 2
Code Structure: Imports and a small class provide a recognizable organization, but many unused imports add clutter. Nesting: Methods are flat, with a straightforward list comprehension and no deeply nested logic. Clarity of intent: The list check and element tagging are understandable, but names such as a, b, c, d, and e obscure their roles. JSONTag and to_json are not defined or imported in the snippet, making the class relationship and tag assignment unclear. Code length: Method bodies are concise, although the import block is disproportionately long. Action granularity: Statements generally perform one action per line; the comprehension expresses a cohesive transformation. Reading flow: The progression from checking a list to tagging its elements is natural, but the unexplained final alias and weak naming interrupt comprehension.
Run 3
Code Structure: The imports and small class are logically organized, but numerous unused imports distract from the implementation. Nesting: Minimal nesting and a simple comprehension make the code easy to scan. Clarity of intent: The list check and element tagging are understandable, but names such as a, b, c, d, and e obscure their roles. JSONTag and to_json are not defined or imported in the snippet, making the inheritance and tag alias unclear. Code length: The class is concise, although the import block is disproportionately long. Action granularity: Each line generally performs one clear action. Reading flow: The methods follow a straightforward sequence, but cryptic naming and the unexplained final alias interrupt comprehension.