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:
morning_temperature = 18
evening_temperature = 14
lower_temperature = morning_temperature
if evening_temperature < lower_temperature:
lower_temperature = evening_temperature
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 highly readable: it uses clear imports, a focused class with a single responsibility, and flat control flow. The check method contains unrelated temperature variables that obscure intent, though the actual logic is still simple. Overall structure, action granularity, and reading flow are excellent, with minor ambiguity in the unused variables.
Run 2
The code is structurally simple but includes a confusing block of irrelevant temperature variables in the 'check' method that have no connection to the method's purpose. This violates clarity of intent and reading flow, as the reader expects a simple type check but encounters unrelated logic. Nesting is flat and action granularity is acceptable, but the code length is inflated by unnecessary imports, a meaningless variable block, and an overly verbose 'check' method. The class itself and the JSON tag methods are concise and clear, but the irrelevant code dominates the method and obscures the purpose. Overall, the code is readable on a micro level but fails at the macro level due to the disconnected logic and unused imports.
Run 3
The code has clear intent and logical structure at a high level, but contains a confusing temperature calculation in the check method that appears completely unrelated to the actual purpose. This irrelevant logic obscures the method's intent and adds unnecessary length. The nesting is minimal, action granularity is reasonable, and the reading flow is mostly natural, but the extraneous temperature variables make the code less readable overall. The imports and class structure are clean, and the methods are concise, but the irrelevant logic significantly impacts clarity.
Run 1
Code Structure: The class is logically organized into checking, serialization, and deserialization methods, but unrelated temperature calculations and unused imports add clutter. Nesting: Only one shallow conditional appears, making the code easy to scan. Clarity of intent: Class and method names clearly indicate byte conversion, while the temperature variables obscure the purpose of check; JSONTag is also undefined in the snippet. Code length: Conversion methods are concise, but check contains unnecessary statements and the import list is excessive for the shown functionality. Action granularity: Each line performs a single action. Reading flow: Method ordering is natural and conversion logic is straightforward, but irrelevant calculations interrupt the flow and limited spacing between top-level sections reduces visual organization.
Run 2
Code Structure: The class is logically organized into type checking, JSON encoding, and decoding methods, but unrelated temperature calculations clutter check(), and several imports are unused in this snippet. Nesting: Nearly flat, with only one shallow conditional. Clarity of intent: Class and method names clearly indicate byte serialization, though the temperature logic distracts from that purpose and JSONTag is not defined or imported here. Code length: Serialization methods are concise, but check() contains unnecessary statements. Action granularity: Each line performs a single action, making individual operations easy to follow. Reading flow: The check-to-encode-to-decode sequence is natural, but irrelevant calculations interrupt the flow.
Run 3
Code Structure: The class is logically organized into type checking and serialization/deserialization methods, but several imports are unused and JSONTag is not defined in the snippet. Nesting: Very shallow, with only one conditional. Clarity of intent: Class and method names clearly communicate byte conversion, but unrelated temperature calculations obscure the purpose of check(). Code length: Conversion methods are concise; the temperature block and unused imports add unnecessary length. Action granularity: Each line performs a single, straightforward action. Reading flow: The method sequence is natural and consistent, but irrelevant calculations interrupt the flow before the actual type check.