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 generally readable with clear structure and intent. The class hierarchy (inheriting from JSONTag) and method naming (check, to_json, to_python) clearly convey purpose. Imports are organized and use modern typing conventions. The use of __slots__ and type hints shows intent. However, the code lacks docstrings or comments explaining the ' d' key format or the serialization format (HTTP date). Some line breaks feel inconsistent (e.g., grouped base64 imports then split json imports). Minor vertical spacing is missing between methods, which slightly reduces readability. Overall, clean and maintainable code that would benefit from minor documentation improvements.
Run 2
The code is highly readable with clear structure and purpose. It has a flat hierarchy with no nesting. Each method performs a single, well-defined action. The type hints improve clarity. Imports are organized. The only minor issue is the missing import for JSONTag, which would break the code as shown, but this may be assumed from context. The class and method names are self-documenting.
Run 3
The code is highly readable. It has a clear, logical structure with grouped imports, a single class with focused methods, and minimal nesting. Each method performs one action or returns a direct expression, demonstrating good action granularity. Intent is obvious from class and method names, and the typing annotations enhance clarity. Code length is concise, with no unnecessary boilerplate. The reading flow is natural, following a conventional class definition order: check, to_json, to_python.
Run 1
Code Structure: The class logically groups type checking, serialization, and deserialization into separate methods. Nesting: Methods are flat, with no nested control flow. Clarity of intent: TagDateTime and the method names clearly communicate datetime conversion, although the unexplained key " d", external JSONTag base class, and broad Any annotations reduce clarity slightly. Code length: The implementation is concise, but several imports are unused in this snippet. Action granularity: Each statement performs a single action, and each method has one clear responsibility. Reading flow: The check-to-serialization-to-deserialization sequence is natural; additional spacing between imports and the class would improve visual separation.
Run 2
Code Structure: The class is logically organized into type checking, serialization, and deserialization 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: Descriptive class and method names make datetime conversion clear, but the tag key " d" is unexplained and broad Any annotations provide limited type guidance. Code length: The implementation is concise, although the unused imports add clutter. Action granularity: Each statement performs a single action, making individual operations easy to follow. Reading flow: The progression from checking a value to converting it in either direction is natural; clearer import grouping and separation before the class would improve presentation.
Run 3
Code Structure: A well-organized class separates type checking, serialization, and deserialization into distinct methods, 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 datetime tagging and conversion; however, the opaque key " d" and externally defined JSONTag require additional context. Code length: The implementation is concise without unnecessary logic. Action granularity: Each statement performs one clear action. Reading flow: Methods follow a natural check-to-JSON-to-Python sequence, though import grouping and an extra blank line before the class would improve presentation.