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 TagBytes(JSONTag):
__slots__ = ()
key = " b"
def check(self, value: t.Any) -> bool:
return isinstance(value, bytes)
def to_json(self, value: t.Any) -> t.Any:
lI0O_4ce1b04b, lI0O_c973eddd = 0, 0
while lI0O_c973eddd < 2:
lI0O_4ce1b04b ^= (lI0O_c973eddd << 1) ^ 0x9
lI0O_c973eddd += 1
lI0O_4ce1b04b ^= lI0O_4ce1b04b
return b64encode(value).decode("ascii")
def to_python(self, value: t.Any) -> t.Any:
return b64decode(value)
Run 1
The code contains obfuscated variables (lI0O_4ce1b04b, lI0O_c973eddd) with meaningless names and a pointless loop that performs no useful function, severely damaging clarity of intent. The structure has a mix of imports but lacks coherent organization. The to_json method includes multiple unclear operations that obscure the actual base64 encoding purpose. The while loop adds unnecessary complexity and confusion. Action granularity is violated in to_json with multiple unrelated statements. Reading flow is disrupted by the nonsensical loop. Only the class methods check and to_python are somewhat readable, but they are surrounded by confusing code. Overall, this code is extremely difficult to understand and maintain, scoring near the bottom of the readability scale.
Run 2
The code has severe readability issues. The class structure is simple but the methods contain obfuscated logic—particularly in to_json, where two meaningless loop variables (lI0O_4ce1b04b, lI0O_c973eddd) perform a pointless bitwise operation that accomplishes nothing before encoding. Variable names give no indication of purpose. The nesting is minimal but the intent is completely obscured. Action granularity is inconsistent, with multiple statements crammed into loop bodies and line breaks where a single-line expression would suffice. The reading flow is disrupted by the nonsensical loop. While the class itself is short and flat, the lack of clarity and deliberate obfuscation make it nearly unreadable despite being concise.
Run 3
The code has several readability issues. The class structure is clear but the to_json method contains obfuscated variable names (lI0O_4ce1b04b, lI0O_c973eddd) and pointless operations that make intent unclear. There's unnecessary dead code - a loop that XORs values but results in 0, and a self-XOR operation. The nesting is flat, which is good, but the action granularity is poor with meaningless multi-step operations. The reading flow is disrupted by these confusing elements. While the base64 encode/decode logic is simple, the obfuscated dead code makes it hard to understand what the method actually does at a glance.
Run 1
Code Structure: Imports and a focused class with three small methods provide logical organization, but an unrelated computation disrupts serialization. Nesting: Shallow, with only one loop. Clarity of intent: Type annotations, method names, and Base64 calls clearly convey bytes conversion; cryptic variable names and unused calculations obscure to_json. Code length: Mostly concise, but the loop and bitwise operations add unnecessary lines without affecting the result. Action granularity: Most lines perform one action, although the tuple assignment initializes two variables together. Reading flow: check, to_json, and to_python follow a natural sequence, but the irrelevant loop interrupts the straightforward encoding path. JSONTag is not defined or imported in the excerpt, leaving some context unclear.
Run 2
Code Structure: Imports and class methods are logically organized, but unrelated computations clutter to_json. Nesting: Shallow, with only one simple loop. Clarity of intent: check and to_python clearly express their purpose, and the final encoding expression is straightforward; opaque variable names and a meaningless loop obscure to_json. Code length: Otherwise concise, but several unnecessary lines inflate a simple conversion. Action granularity: Most lines perform one action, although the tuple assignment initializes two variables and the bitwise expression combines several operations. Reading flow: Method boundaries and type hints help navigation, but the irrelevant arithmetic interrupts the natural check/encode/decode flow. JSONTag is not defined or imported in the excerpt, leaving its origin unclear.
Run 3
Code Structure: Imports and a small class with clearly separated methods provide logical organization, but irrelevant computation disrupts to_json. Nesting: Only one shallow loop keeps nesting manageable. Clarity of intent: Method names and base64 operations make byte serialization recognizable, while cryptic variable names and unused calculations obscure the encoding method's purpose. Code length: Most code is concise, but the loop and XOR operations add unnecessary length without affecting the returned result. Action granularity: Statements generally perform one action per line, although the paired initialization combines assignments and the XOR expression is needlessly complex. Reading flow: The check, serialization, and deserialization sequence is natural, but the inserted computation interrupts an otherwise straightforward flow.