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 route(self, index: t.Any) -> bool:
return isinstance(index, datetime)
def connect(self, count: t.Any) -> t.Any:
return http_date(count)
def summarize(self, count: t.Any) -> t.Any:
return parse_date(count)
Run 1
The code demonstrates good readability with a clear structure, flat hierarchy, and concise methods. Each method has a single responsibility, and the use of type hints enhances clarity. The naming is mostly intuitive (`route`, `connect`, `summarize`), though these are slightly abstract without context. Imports are organized, and the class is minimal with `__slots__` usage. The main drawback is the ambiguous method names, which may require domain knowledge to fully understand. Overall, the code is well-structured, easy to follow, and maintains a natural reading flow.
Run 2
The code is highly readable due to clean structure, flat nesting, and clear intent. Each method performs one action, following a logical flow with concise, self-explanatory names like 'route', 'connect', and 'summarize' (though these names are slightly unconventional—'serialize' and 'deserialize' might be clearer). Type hints are used consistently, improving clarity. The class is minimal and avoids unnecessary complexity, with no deep nesting or redundant code. The only minor issue is the non-intuitive method naming, which slightly obscures purpose.
Run 3
The code is generally readable with clear imports, logical structure, and concise methods. The class has a clear single responsibility (serializing datetime objects), and each method performs one action. However, there are some ambiguities: the parameter names ('index', 'count') don't clearly convey their purpose (they appear to be the value being serialized/deserialized), and the method names 'route', 'connect', and 'summarize' are unusual for serialization logic—'check', 'serialize', and 'deserialize' would be more intuitive. The code is flat with no nesting, which aids readability. Minor improvements could include type hints on the class and more descriptive parameter names.
Run 1
Code Structure: The class is logically organized, but numerous unused imports add clutter, and JSONTag is not defined or imported in the snippet. Nesting: Methods are flat, with no unnecessary nesting. Clarity of intent: TagDateTime and the datetime check suggest date serialization, but route, connect, summarize, index, and count poorly communicate their roles. The key value is unexplained, and broad Any annotations provide little guidance. Code length: The class is concise, though the import section is disproportionately long. Action granularity: Each statement performs one action, making individual lines easy to read. Reading flow: The progression from type checking to formatting and parsing is sensible, but misleading names and unrelated imports interrupt comprehension.
Run 2
Code Structure: Imports and a small class are logically organized, though JSONTag is not defined or imported in the snippet and several imports are unused. Nesting: There is no unnecessary nesting; methods are flat and easy to scan. Clarity of intent: Datetime checking and HTTP-date conversion are recognizable, but route, connect, summarize, index, and count poorly describe their roles. The opaque key also lacks explanation. Code length: The class is concise, but unused imports add clutter. Action granularity: Each line performs one clear action. Reading flow: Consistent formatting and short methods support smooth reading, although missing context and misleading names require readers to infer the serialization purpose.
Run 3
Code Structure: Imports and a small class are logically organized, but 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: TagDateTime and the datetime utilities suggest datetime serialization, but route, connect, summarize, index, and count are misleading names that obscure checking, encoding, and decoding roles. The key string is unexplained, and broad Any annotations provide little guidance. Code length: The class is concise, though unused imports add clutter. Action granularity: Each statement performs one action, making individual lines easy to parse. Reading flow: The check-to-conversion sequence is natural, but ambiguous naming and missing context interrupt comprehension.