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:
if ((0x13d ^ 0x13d) != 0):
raise AssertionError()
return isinstance(value, list)
def to_json(self, value: t.Any) -> t.Any:
if ((0x3891 ^ 0x3891) != 0):
raise AssertionError()
return [self.serializer.tag(item) for item in value]
tag = to_json
Run 1
The code is poorly readable due to injected nonsensical conditional blocks (e.g., 'if ((0x13d ^ 0x13d) != 0): raise AssertionError()') that add no functional value and obscure intent. While the methods are short and logically organized, the presence of dead code and zero-value checks breaks reading flow and clarity. Nesting is low, and each method performs roughly one action, but the overall structure is undermined by redundant imports and placeholder code. The class inherits from JSONTag without that class being defined in the snippet, increasing ambiguity. The use of 'tag = to_json' aliasing is concise but unconventional and may confuse readers unfamiliar with custom serialization patterns. Overall, the code appears obfuscated or auto-obfuscated, drastically reducing its readability despite structurally simple components.
Run 2
The code is mostly readable in terms of structure and intent, but it is marred by several issues that significantly reduce readability. The class is small and flat, and the purpose of serialization is clear. However, there are unnecessary type-ignoring comments, a redundant 'tag = to_json' alias, and dead code branches (e.g., `if ((0x13d ^ 0x13d) != 0): raise AssertionError()`) that add noise and confusion. The action granularity is reasonable, but the reading flow is disrupted by these artifacts. The code is concise, but not clean.
Run 3
This code is functionally simple but practically unreadable due to dead code and misleading constructs. The class structure is minimal, but `tag = to_json` creates redundancy without clarity. Every method begins with `if ((0x13d ^ 0x13d) != 0): raise AssertionError()` — a tautological false condition that adds noise and confuses intent. The imports are numerous and unused (e.g., `b64decode`, `UUID`, `Markup`, `http_date`), bloating the file. The nesting is shallow, which is good, but the dead code inside methods inflates length and breaks reading flow. Action granularity is mostly one action per line, but the assertions add pointless steps. Intent is obscured by the strange bitwise checks and unused imports; readers must spend effort determining whether they matter. Overall, the code is technically concise in core logic but padded with confusing artifacts, making it hard to read and maintain.
Run 1
Code Structure: The class and its methods are logically organized, but numerous unused imports and an undefined JSONTag base class in the snippet distract from the core functionality. Nesting: Very shallow; the conditional blocks and list comprehension are easy to follow. Clarity of intent: List checking and item serialization are clear, but the hexadecimal XOR conditions are always false and introduce confusing dead code. The tag alias is concise but its role is not explained. Code length: The useful implementation is short, yet unnecessary assertion blocks and imports substantially inflate it. Action granularity: Each line generally performs one action, with a straightforward comprehension for serialization. Reading flow: Conventional method layout supports natural reading, but irrelevant guards interrupt both methods and the import-heavy opening delays the actual logic.
Run 2
Code Structure: The class is logically organized into small methods, but numerous unused imports and an undefined JSONTag base class in the snippet distract from its structure. Nesting: Shallow conditionals and a straightforward comprehension are easy to follow. Clarity of intent: List detection and item serialization are clear, but always-false XOR checks obscure intent and add meaningless defensive-looking code. Code length: The methods are concise, though dead checks and unused imports unnecessarily lengthen the snippet. Action granularity: Each statement performs one action, and the comprehension expresses a simple transformation. Reading flow: Method names and type annotations support natural reading, but the unexplained assertions interrupt it, and the tag alias requires a small interpretive step.
Run 3
Code Structure: The class and methods are logically organized, but numerous unused imports and an undefined JSONTag base class distract from the small implementation. Nesting: Shallow, with only one conditional level per method. Clarity of intent: List checking and item serialization are clear, but constant-false XOR checks obscure intent and add meaningless assertions. Code length: The functional code is concise, although irrelevant imports and dead checks unnecessarily inflate it. Action granularity: Statements generally perform one action per line; the list comprehension is compact and readable. Reading flow: Method names and type annotations support natural reading, but unexplained dead code interrupts the flow, and the tag alias requires a small conceptual jump.