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 well-structured and readable. Imports are grouped logically, with standard library and third-party imports separated. The class uses __slots__ for memory efficiency and has a clear single responsibility: serializing/deserializing datetime objects. Methods are short, each performing one action, and names (check, to_json, to_python) clearly express intent. Nesting is minimal, and the overall flow is natural. Minor deductions: missing docstrings could slightly improve clarity, and the JSONTag parent class is not shown, which may leave some context implicit.
Run 3
The code is highly readable with clear structure and intent. It has logical organization with imports separated from the class definition, flat nesting, and each method performs a single, well-defined action. Naming conventions are descriptive, and the code uses modern Python features like `__slots__` and type hints to enhance clarity. The only minor deductions are for potential ambiguity around the `key` attribute and missing docstrings, which could further explain the custom JSON tag format and date handling behavior.
Run 1
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: Minimal nesting makes the code easy to scan. Clarity of intent: Descriptive method names and straightforward implementations clearly convey datetime conversion, although the tag key " d" is unexplained and t.Any annotations provide limited specificity. Code length: The class is concise, but unrelated imports add clutter. Action granularity: Each statement performs one action, with simple one-line method bodies. Reading flow: The methods follow a natural progression, and whitespace separates them effectively; additional separation between imports and the class would improve presentation.
Run 2
Code Structure: The class is logically organized, separating type checking, serialization, and deserialization. Nesting: Methods are flat, with no nested control flow. Clarity of intent: TagDateTime and its method names clearly convey datetime conversion, 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 this snippet and add clutter. Action granularity: Each statement performs one action, making individual steps easy to follow. Reading flow: The progression from checking a value to converting it in either direction is natural; additional spacing between imports and the class would improve visual organization.
Run 3
Code Structure: The class is logically organized into type checking, serialization, and deserialization methods, though several imports are unused and JSONTag is not defined or imported in the snippet. Nesting: Methods are flat, with no nested control flow. Clarity of intent: The class and method names clearly communicate datetime tagging and conversion; the abbreviated key " d" is unexplained, and broad t.Any annotations provide limited type guidance. Code length: The implementation is concise, but unused imports add clutter. Action granularity: Each statement performs one action, making individual operations easy to follow. Reading flow: Imports precede the class, and the methods follow a natural check-to-conversion sequence. An additional blank line before the class would improve visual separation.