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 follows a clear logical organization with grouped imports, a single class definition, and simple methods. The nesting is flat, and each method has a clear, single responsibility. Intent is explicit through method names and the use of type hints, which enhance clarity. The code is concise without unnecessary verbosity, and each action is on its own line, contributing to a clean reading flow. Minor deductions include the lack of a docstring for the class and methods, which would improve understanding of the tag's purpose, and the slightly cryptic key assignment. Some imports are split across multiple lines, which is stylistic but consistent. Overall, it is a clean, maintainable piece of code that is easy to follow.
Run 3
The code is well-structured and highly readable. It logically groups imports, follows a single class purpose, and uses flat, minimal nesting. Each method has a clear, singular responsibility. The use of type hints and concise conditional expressions enhances clarity. The class and method names are descriptive. The code is compact without being terse, maintaining a natural reading flow from definition to implementation.
Run 1
Code Structure: The class is logically organized into type checking, serialization, and deserialization methods. Nesting: There is no unnecessary nesting; each method is a straightforward return. Clarity of intent: Method names and base64 operations clearly indicate byte conversion, though the unexplained key " b" and undefined JSONTag base class reduce standalone clarity. Code length: The implementation is concise, but several imports are unused in the provided snippet. Action granularity: Each line performs one focused action; the encode/decode chain is short and readable. Reading flow: Imports, class attributes, and methods follow a natural sequence, although a blank line between imports and the class would improve visual separation.
Run 2
Code Structure: Imports and a compact class are logically organized, with separate methods for type checking, serialization, and deserialization. Nesting: There is no nested control flow, making the code easy to scan. Clarity of intent: TagBytes, check, to_json, and to_python communicate their roles clearly; Base64 conversion is straightforward. However, JSONTag is not defined or imported in the snippet, and the key " b" lacks explanation. Code length: The class is concise, though several imports are unused in the displayed code and add clutter. Action granularity: Each statement occupies its own line; the encode-and-decode chain remains simple and readable. Reading flow: The methods follow a natural check-to-serialization-to-deserialization sequence. Limited spacing between import groups and the class slightly reduces visual organization.
Run 3
Code Structure: A small, cohesive class cleanly separates type checking, serialization, and deserialization, though several imports are unused and JSONTag is not defined in the snippet. Nesting: Methods are flat with no nested control flow. Clarity of intent: TagBytes and the method names clearly convey byte serialization using Base64; the opaque key " b" and unexplained __slots__ slightly reduce clarity. Code length: The implementation is concise, but unused imports add clutter. Action granularity: Each method contains a single return statement; the encode-and-decode chain is compact and easy to follow. Reading flow: Imports followed by class metadata and three straightforward methods provide a natural progression, although more spacing between imports and the class would improve presentation.