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:
lI0O_6fc921c4, lI0O_271670d1 = 0x4384, ~0x4384
lI0O_6fc921c4 = (lI0O_6fc921c4 & lI0O_271670d1) | (lI0O_6fc921c4 ^ lI0O_6fc921c4)
lI0O_271670d1 ^= lI0O_271670d1
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 significantly unreadable due to several major issues. The class PassList contains obfuscated variable names (lI0O_6fc921c4, lI0O_271670d1) with meaningless bitwise operations that serve no purpose in the check method, making the intent completely unclear. The action granularity is poor as multiple operations are crammed onto single lines with semicolons. The nesting is shallow but the reading flow is severely disrupted by the cryptic variable names and dead code. While the imports are organized and the class structure is minimal, the clarity of intent is nearly zero for the check method. The to_json method is slightly clearer but still ambiguous due to the lack of context about the serializer attribute. Overall, the code appears intentionally obfuscated or poorly maintained, making it very difficult to understand without extensive investigation.
Run 2
The code has a clear top-level structure with conventional imports and a class definition, but readability is severely compromised by obfuscated variable names (`lI0O_6fc921c4`, `lI0O_271670d1`) and meaningless bitwise operations that appear to do nothing useful. The `check` method contains multiple actions on single lines and convoluted reassignments that obscure intent. Nesting is flat and action granularity is mostly reasonable in `to_json`, but the obfuscated logic in `check` destroys reading flow and clarity of intent. The `tag = to_json` alias is concise but slightly ambiguous without context. Overall, the code is technically functional but reads as deliberately obscured, making it difficult to understand or maintain.
Run 3
This code is highly unreadable. The class structure and method names are somewhat recognizable, but the presence of nonsensical obfuscated variable names (e.g., lI0O_6fc921c4, lI0O_271670d1) and dead bitwise operations destroys clarity of intent. The check method includes arithmetic that serves no purpose and obscures the trivial isinstance check. Action granularity is poor because multiple meaningless operations are packed into each line. The reading flow is broken by this dead code, and while nesting is low, the overall structure is undermined by the lack of meaningful logic. Code length is inflated with useless statements, making a trivial method unnecessarily long and confusing.
Run 1
Code Structure: The class and methods are logically organized, but unrelated imports and meaningless calculations clutter the implementation. Nesting: Very shallow, with a straightforward list comprehension and no nested control flow. Clarity of intent: List detection and item serialization are clear, but cryptic variable names and redundant bitwise operations obscure the check method. JSONTag and serializer also depend on context not shown. Code length: The functional implementation is concise, but several unused imports and three unnecessary calculation lines inflate the snippet. Action granularity: Most lines perform one action, although the initial tuple assignment combines two assignments and the bitwise expression is unnecessarily complex. Reading flow: Method ordering is natural, but the distracting calculations interrupt the path to the simple type check; the tag alias requires a small contextual inference.
Run 2
Code Structure: The class is logically organized into checking and serialization methods, but numerous unused imports and irrelevant operations clutter it. Nesting: The code is flat, with only a straightforward list comprehension. Clarity of intent: Method names and the final return statements convey the purpose, while cryptic variable names and pointless bitwise operations obscure the check method. Code length: The actual functionality is concise, but unnecessary imports and calculations substantially inflate the snippet. Action granularity: Most lines contain a single action, although the tuple assignment and compound bitwise expression add avoidable complexity. Reading flow: The class layout is natural, but unrelated calculations interrupt the otherwise direct flow from type checking to list serialization.
Run 3
Code Structure: The class is logically organized into checking and serialization methods, but numerous unrelated imports and dead computations add clutter. Nesting: Flat methods and a simple list comprehension are easy to follow. Clarity of intent: The isinstance check and serialization comprehension express their purposes clearly, while cryptic variable names and meaningless bitwise operations obscure the check method. Code length: The functional logic is concise, but unnecessary statements and imports inflate the snippet. Action granularity: Most lines perform one action, although the tuple assignment combines two initializations and the bitwise expression is needlessly complex. Reading flow: Method ordering and the tag alias are coherent, but readers must work past distracting obfuscation before reaching the actual type check.