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 well-structured and readable. It uses clear imports, type hints, and a logical class hierarchy. The methods are concise, each performing a single action. Nesting is minimal, and the reading flow is natural. Minor improvements could include grouping imports consistently and adding a docstring, but overall the intent and structure are very clear.
Run 3
The code is highly readable with a clear, logical structure. Imports are organized, and the class has a single responsibility with focused, well-named methods. Minimal nesting and concise methods make action granularity appropriate. The use of type hints and __slots__ improves clarity. Only minor deduction for assuming imports for JSONTag.
Run 1
Code Structure: A small, cohesive class cleanly separates type checking, serialization, and deserialization, although several imports are unused in this snippet. Nesting: Methods are flat, with no nested control flow. Clarity of intent: Class and method names clearly convey byte conversion, and Base64 operations are straightforward; however, JSONTag is not defined or imported here, and the key " b" is unexplained. Code length: The implementation is concise, though unused imports add clutter. Action granularity: Each statement performs a focused action; the chained encoding and decoding expression remains easy to understand. Reading flow: Imports, class configuration, and methods follow a natural order, but additional blank lines between import groups and the class would improve visual organization.
Run 2
Code Structure: The class is logically organized into type checking, serialization, and deserialization methods. Nesting: There is no unnecessary nesting; every method has a simple return statement. Clarity of intent: The class and method names clearly convey byte handling and JSON conversion, though the opaque key " b" and externally defined JSONTag require context. Code length: The implementation is concise, but several imports are unused in the snippet. Action granularity: Each statement occupies its own line; the chained encode/decode expression is compact and easy to understand. Reading flow: Methods follow a natural check-to-serialization-to-deserialization sequence. Additional spacing between imports and the class would improve visual separation.
Run 3
Code Structure: The class logically groups byte detection, JSON conversion, and Python conversion into separate methods, though several imports are unused in this snippet. Nesting: Methods are flat and easy to scan. Clarity of intent: Descriptive method names and straightforward Base64 operations communicate the serialization purpose; the unexplained key " b" and undefined-in-snippet JSONTag base class require external context. Code length: The implementation is concise without unnecessary logic. Action granularity: Each line performs one clear operation, with a simple encoding-and-decoding chain that remains readable. Reading flow: Methods follow a natural check, serialize, deserialize sequence; additional spacing between imports and the class would improve presentation.