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 a flat hierarchy with no nesting, making the control flow obvious. Each class method has a single, well-defined purpose with clear intent expressed through descriptive method names and type hints. The code is concise, avoiding unnecessary boilerplate, and maintains one action per line. The reading flow is natural, grouping related imports together and organizing class methods in a logical sequence (check, to_json, to_python). The use of `__slots__` and type hints demonstrates thoughtful design without sacrificing clarity.
Run 2
The code is highly readable. It has a clear, logical structure: a single class with related methods grouped together. Nesting is minimal (one level for method definitions). The intent is unambiguous—serializing/deserializing datetime objects to/from HTTP date strings. The code is concise, avoiding unnecessary boilerplate. Each action is on its own line, improving clarity. The reading flow is natural: check, to_json, to_python follow the expected serializer pattern. Minor drawbacks include type hints being somewhat generic (t.Any), and the lack of a docstring, but overall it's very clean.
Run 3
The code is well-structured with clear imports, a logical class definition, and concise methods. Each method has a single responsibility and is easy to understand. The use of type hints improves clarity. The class has a clear purpose (serializing/deserializing datetime objects for JSON). Nesting is minimal, and the reading flow is natural. The only minor issue is the lack of docstrings or comments explaining the serialization format, but the code is still highly readable.
Run 1
Code Structure: The class is logically organized into type checking and two conversion methods, although several imports are unused in the snippet and JSONTag is not defined or imported. Nesting: Methods are flat, with no nested control flow. Clarity of intent: Class and method names clearly indicate datetime serialization and deserialization; the cryptic key " d" and broad t.Any annotations provide less guidance. Code length: The implementation is concise, but the unused imports add clutter. Action granularity: Each statement performs one action, and each method has a single responsibility. Reading flow: The progression from checking to encoding to decoding is natural; additional blank lines separating imports and the class would improve visual organization.
Run 2
Code Structure: The class is logically organized into type checking and conversion methods, though several imports are unused in this snippet and JSONTag is not defined or imported. Nesting: Methods are flat, with no nested control flow. Clarity of intent: The class and method names clearly communicate datetime serialization and deserialization, but the cryptic key " d" and broad t.Any annotations provide little context. Code length: The implementation is concise without unnecessary logic. Action granularity: Each statement performs a single action, making individual operations easy to follow. Reading flow: The progression from checking the type to converting in each direction is natural; better import grouping and an extra blank line before the class would improve presentation.
Run 3
Code Structure: A small, logically organized class groups type checking and bidirectional datetime conversion. Nesting: Methods are flat, with no nested control flow. Clarity of intent: The class name and method names clearly communicate datetime serialization, although the tag key " d" is opaque and JSONTag is not defined or imported in the snippet. Code length: The implementation is concise, but several imports are unused in the shown code. Action granularity: Each line performs a single, straightforward action. Reading flow: The progression from checking the value to JSON conversion and Python conversion is natural; additional spacing between imports and the class would improve presentation.