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 TagDateTime(JSONTag):
__slots__ = ()
key = " d"
def check(self, value: t.Any) -> bool:
return isinstance(value, datetime)
def to_json(self, value: t.Any) -> t.Any:
return http_date(value)
def to_python(self, value: t.Any) -> t.Any:
return parse_date(value)
Run 1
The code is highly readable with a clear, logical structure. It uses flat nesting, explicit type hints, and concise imports. Each method performs a single action, maintaining good action granularity. The class purpose is evident from its name and method names (check, to_json, to_python). The reading flow is natural, moving from imports to class definition to methods. Minor deductions: the class inherits from JSONTag without showing its definition, and the methods are somewhat terse, but this is common in tag serializers. Overall, the code follows clean, maintainable patterns.
Run 2
The code is highly readable due to its clean structure and clear intent. The class TagDateTime is logically organized with a flat structure, minimal nesting, and a single purpose: serializing/deserializing datetime objects. Each method performs one clear action, and the use of type hints (t.Any) and __slots__ improves clarity. Imports are grouped and explicit, and method names (check, to_json, to_python) clearly describe their roles. The code is concise, with no redundant logic or long blocks. Reading flow is natural: check, then convert to JSON, then convert back to Python. Potential minor improvements could include a docstring for the class, but overall the code is very readable and maintainable.
Run 3
The code is well-structured with clear separation of concerns between imports and class definition. Nesting is minimal, with all methods at a single level. Each method has a clear, single responsibility: type checking, serialization, and deserialization of datetime objects. The code is concise, with short methods that avoid unnecessary verbosity. Action granularity is good—each method performs one focused action. Reading flow is natural: the class name and key attribute establish context, then methods follow a logical check → to_json → to_python order. Type hints and modern Python features (__slots__, from __future__ import annotations) enhance clarity. Minor deductions: the JSONTag base class is not imported in the shown snippet, which could cause ambiguity, and some contextual understanding of the serialization framework is assumed.
Run 1
Code Structure: The class is logically organized into type checking, serialization, and deserialization methods, although several imports are unused in this snippet. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: Class and method names clearly convey datetime conversion, but the unexplained key " d", absent JSONTag definition or import, and broad Any annotations reduce clarity. Code length: The implementation is concise, with no unnecessary method logic; unused imports add clutter. Action granularity: Each statement performs a single action. Reading flow: Methods follow a natural check-to-serialize-to-deserialize sequence, though additional spacing between imports and the class would improve visual separation.
Run 2
Code Structure: The class is logically organized, with separate methods for type checking and conversion. Nesting: There is no nested control flow, making each method easy to follow. Clarity of intent: The class and method names clearly indicate datetime serialization and deserialization, though the cryptic key " d" and undefined-in-snippet JSONTag base class require external context. Code length: The implementation is concise, but numerous imports are unused in the provided snippet. Action granularity: Each statement performs one action, and the methods have single responsibilities. Reading flow: The progression from checking the value to converting it in either direction is natural; additional spacing between imports and the class would improve visual separation.
Run 3
Code Structure: The class is logically organized into type checking and serialization/deserialization methods. Nesting: Methods are flat, with no nested control flow. Clarity of intent: Descriptive class and method names make the datetime conversion purpose clear, though the opaque key " d" and undefined-in-snippet JSONTag base class require external context. Code length: The implementation is concise, but several imports are unused in the shown snippet. Action granularity: Each statement performs a single action. Reading flow: The consistent method layout is easy to follow, although import grouping and an additional blank line before the class would improve presentation.