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 a(self, d: t.Any) -> bool:
return isinstance(d, bytes)
def b(self, e: t.Any) -> t.Any:
return b64encode(e).decode("ascii")
def c(self, f: t.Any) -> t.Any:
return b64decode(f)
Run 1
This code suffers from severe readability issues. The method names 'a', 'b', and 'c' convey no meaning, violating clarity of intent. The parameter names 'd', 'e', and 'f' are equally opaque. The class name 'TagBytes' suggests purpose, but the implementation obscures it. Missing import for JSONTag creates ambiguity about the class hierarchy. While the structure is technically flat with minimal nesting and reasonable action granularity, the alphabetical method naming destroys the reading flow. The code is concise but at the cost of all semantic meaning - a reader cannot understand what 'a', 'b', or 'c' do without reverse-engineering the logic. The base64 operations appearing only in b/c methods hint at encoding/decoding responsibilities, but nothing explicit communicates this. Even with proper typing imports, the naming choices make this nearly unreadable despite being syntactically valid.
Run 2
This code is extremely difficult to read due to severely obfuscated naming conventions. While the structure is simple and linear, the use of meaningless identifiers like 'a', 'b', 'c', 'd', 'e', and 'f' completely obscures the purpose of each method and parameter. The class name 'TagBytes' hints at functionality, but the single-character method names make it impossible to understand what each method does without deep analysis. The nesting is flat and action granularity is reasonable, but the clarity of intent is severely compromised. The code length is concise, but this conciseness comes at the cost of readability. Even though the imports suggest JSON tag serialization functionality, the obfuscated naming makes this code substantially harder to maintain than necessary.
Run 3
The code is extremely difficult to read due to meaningless names. Method names 'a', 'b', 'c' and parameter names 'd', 'e', 'f' provide zero semantic meaning—the reader cannot tell what each method does without analyzing the implementation. The class itself uses a cryptic key ' b'. Even import aliases are overly compressed: 't' for typing, 'dumps'/'loads' from JSON, and especially 'TagBytes' which has no clear relationship to a base class 'JSONTag' (which isn't even imported, suggesting missing context). The brief method bodies are simple, but the abstraction is poorly communicated. While there is low nesting and one action per line, these positives are overwhelmed by the complete failure to convey intent through naming. The reading flow is unnatural and forces the reader to decode what each symbol means, making the code virtually unreadable without external documentation or renaming all identifiers to meaningful terms.
Run 1
Code Structure: Imports and a small class are logically organized, although several imports are unused and JSONTag is not defined or imported in the snippet. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: TagBytes and the base64 operations suggest byte serialization, but method names a, b, c and parameter names d, e, f obscure their roles; broad Any annotations provide little clarification. Code length: The class is concise, though unrelated imports add clutter. Action granularity: Each statement performs one clear action; the encode-and-decode chain is compact and understandable. Reading flow: The progression from type checking to encoding and decoding is natural, but opaque names and the unexplained key value reduce readability.
Run 2
Code Structure: The class logically groups byte detection, encoding, and decoding, though many imports are unused in this snippet and JSONTag is not defined or imported here. Nesting: Methods are flat and easy to follow. Clarity of intent: TagBytes and the base64 operations suggest byte serialization, but method names a, b, c and parameter names d, e, f obscure their roles. Code length: The implementation is concise, although unrelated imports add clutter. Action granularity: Each method contains one straightforward return expression; the chained encoding and decoding calls remain manageable. Reading flow: Consistent formatting and short methods support smooth reading, but cryptic identifiers and the unexplained key require readers to infer the interface.
Run 3
Code Structure: The class logically groups byte detection, encoding, and decoding, though several imports are unused in this snippet. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: Base64 operations clearly indicate byte serialization, but method names a, b, c and parameter names d, e, f obscure their roles; JSONTag and the tag key lack context. Code length: The implementation is concise, with no unnecessarily long methods. Action granularity: Each line performs a single clear operation. Reading flow: Imports, class metadata, and short methods follow a natural order, but cryptic names and unexplained framework conventions interrupt understanding.