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:
return b64encode(value).decode("ascii")
def to_python(self, value: t.Any) -> t.Any:
return b64decode(value)
Run 1
The code is clean and readable. It follows a logical structure with clear imports and a focused class definition. Nesting is minimal and intent is unambiguous for each method. The use of type hints, __slots__, and a class-level key attribute demonstrates good design and reduces ambiguity. Each method performs a single action, and the flow is natural (check → serialize → deserialize). Although it omits the parent class definition, the code is concise and easy to follow.
Run 2
The code is highly readable. It has a clear, logical structure with grouped imports and a concise class definition. Nesting is minimal, with only straightforward method-level code. Intent is clear: this is a JSON tag serializer for bytes using base64. The code is concise and avoids unnecessary length, keeping each method focused on a single action. Action granularity is good, with one operation per line. Reading flow is natural, starting from imports through class definition to method implementations. Minor deductions: the empty `__slots__ = ()` could be slightly confusing to readers unfamiliar with this optimization, and type hints could be more specific (`bytes` instead of `t.Any` where possible).
Run 3
The code is highly readable with a clear, logical structure. It uses explicit imports, type hints, and a flat class hierarchy with no deep nesting. Each method has a single, focused responsibility, and the action granularity is appropriate—one logical operation per line. The reading flow is natural: imports, class definition, then methods in a conventional order. Naming is descriptive and consistent with the surrounding framework. The code is concise without sacrificing clarity. Minor deductions only for the incomplete context (JSONTag base class not shown) and the absence of docstrings or comments explaining the serialization format, which slightly affects standalone clarity.
Run 1
1. Code Structure: A small, cohesive class cleanly separates type checking, serialization, and deserialization, though several imports are unused in this snippet and JSONTag is not defined or imported. 2. Nesting: Methods are flat, with no nested control flow. 3. Clarity of intent: Class and method names clearly indicate byte conversion for JSON; the cryptic key " b" and broad t.Any annotations provide little additional guidance. 4. Code length: Concise implementation with no unnecessary method logic, although unused imports add clutter. 5. Action granularity: Each method contains a single return statement; the encode-and-decode chain is compact and understandable. 6. Reading flow: The progression from checking bytes to encoding and decoding is natural, with consistent formatting.
Run 2
Code Structure: Imports and a focused class are logically organized, although several imports are unused in this snippet. Nesting: The code is flat, with no nested control flow. Clarity of intent: Class and method names clearly express byte detection and conversion between bytes and a JSON-compatible Base64 string. However, the opaque key " b" and undefined-in-snippet JSONTag base class require external context. Code length: The implementation is concise without unnecessary logic. Action granularity: Each statement occupies its own line; the encoding-and-decoding chain is short and easy to understand. Reading flow: Methods follow a natural sequence from type checking to serialization and deserialization. Additional spacing between imports and the class would improve visual separation.
Run 3
Code Structure: Imports and a focused class with three small methods provide logical organization, although several imports are unused in this snippet. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: TagBytes and its method names clearly communicate byte detection and Base64 conversion, but the opaque key " b" and undefined-in-snippet JSONTag require external context. Code length: The implementation is concise, with no unnecessary method logic. Action granularity: Each statement performs a single clear action; the chained encode/decode expression remains straightforward. Reading flow: Methods naturally progress from type checking to JSON conversion and restoration. Additional spacing between import groups and the class would improve visual readability.