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 demonstrates excellent readability. It has a clear, logical structure with a single class definition and proper type hints. Nesting is minimal, with only one level of indentation in methods. The intent is immediately clear: it's a JSON tag for datetime serialization that converts between Python datetime objects and HTTP date strings. Each method is concise, focused on a single responsibility, and performs one action per line. The reading flow is natural, progressing from imports to class definition to methods ordered logically (check, to_json, to_python). The use of `__slots__` and the custom key `" d"` shows intentional design. Minor improvements could include a brief docstring explaining the custom key format, but the code remains highly maintainable and self-documenting.
Run 3
The code is well-structured and readable with clear intent. It uses a logical class organization, flat nesting, and concise methods. Imports are explicit and grouped sensibly (stdlib, third-party, local). Each method performs one action and the return types are clear from context. Method names like 'check', 'to_json', and 'to_python' clearly indicate their purpose. However, minor deductions: the class references 'JSONTag' without definition or import in this snippet, which could confuse readers. Additionally, type hints use 't.Any' consistently but could be more specific. Overall, it follows good practices and is easy to follow.
Run 1
Code Structure: The class is logically organized into type checking, serialization, and deserialization methods, although several imports are unused in this snippet and JSONTag is not shown. Nesting: There is no nested control flow; each method is straightforward. Clarity of intent: The class and method names clearly convey datetime conversion, but the tag key " d" is unexplained and broad t.Any annotations provide little type detail. Code length: The implementation is concise, though the import section adds unnecessary length for the code shown. Action granularity: Each statement performs one action, making individual lines easy to understand. Reading flow: The methods follow a natural check-to-encode-to-decode sequence; 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. Nesting: There is no nested control flow, making the code easy to scan. Clarity of intent: The class name and method names clearly communicate datetime conversion, though the unexplained key " d" and externally defined JSONTag base class require context. Code length: The implementation is concise, but several imports are unused in the provided snippet. Action granularity: Each statement performs a single action, with straightforward one-line method bodies. Reading flow: Imports followed by a small class provide a natural progression; an additional blank line before the class and tighter import grouping would improve presentation.
Run 3
Code Structure: The class is logically organized into type checking and two conversion 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 class and method names clearly communicate datetime serialization, but the opaque key " d" and broad Any annotations provide little explanatory context. Code length: The implementation is concise without unnecessary logic. Action granularity: Each statement performs a single action. Reading flow: The progression from checking a value to converting it to JSON and back is natural; clearer import grouping and spacing before the class would improve presentation.