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 a(self, d: t.Any) -> bool:
return isinstance(d, datetime)
def b(self, e: t.Any) -> t.Any:
return http_date(e)
def c(self, f: t.Any) -> t.Any:
return parse_date(f)
Run 1
The code exhibits several readability issues. The class and method names (a, b, c) are single letters, making intent unclear. The import section is verbose with multiple separate imports from the same modules rather than combining them. The use of single-letter variable names (d, e, f) obscures what data types are being handled. The method bodies are concise, and nesting is minimal, which are positives, but the overall structure lacks clarity. The JSONTag base class is undefined in this snippet, leaving context ambiguous. The code appears to be a datetime serialization tag but the naming prevents understanding without additional documentation or reverse engineering. Type hints are present, which helps somewhat, but the fundamental naming choices undermine readability for anyone unfamiliar with the codebase.
Run 2
The code suffers from severe readability issues. The class name 'TagDateTime' and key ' d' are acceptable, but the method names 'a', 'b', 'c' are meaningless and fail to convey intent, violating clarity. The single-letter parameter names ('d', 'e', 'f') further obscure purpose. The structure is technically organized but the serialization/deserialization logic is unclear due to ambiguous naming. Nesting is flat, which is positive, but action granularity is adequate. The reading flow is disorienting because nothing explains what 'a', 'b', 'c' do — one must infer from return types. The code is concise but unnecessarily terse. Overall, it reads like obfuscated code despite simple operations, making it hard to maintain or review without external documentation or guessing based on the imported functions.
Run 3
The code suffers from poor readability due to obfuscated naming (methods named 'a', 'b', 'c'), ambiguous class purpose, inconsistent type variable names ('d', 'e', 'f'), and missing docstrings. The method names give no indication of their functionality, forcing readers to infer behavior from return types or implementation. The class inherits from an undefined JSONTag, and the method 'a' appears to be a type check while 'b' and 'c' handle serialization/deserialization—but this is not explicit. The structure is flat, which is good, and line length is reasonable, but clarity of intent and action granularity suffer significantly. The mix of imports (some grouped, some individual) adds minor inconsistency. Overall, the code is functional but requires significant mental effort to decipher due to cryptic naming and lack of context.
Run 1
Code Structure: Imports and a compact class are logically organized, though several imports are unused and JSONTag is not defined or imported in the snippet. Nesting: Very shallow, with simple methods and no nested control flow. Clarity of intent: TagDateTime and the datetime-related calls suggest serialization and deserialization, but method names a, b, c and parameter names d, e, f obscure their roles. The key value is unexplained, and broad Any annotations provide little guidance. Code length: Methods are concise, but unused imports add clutter. Action granularity: Each statement performs a single action. Reading flow: The class is easy to scan, but cryptic naming and missing context prevent readers from immediately understanding its interface.
Run 2
Code Structure: The imports and compact class are logically organized, 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: TagDateTime and the datetime-related calls suggest datetime serialization, but method names a, b, c and parameter names d, e, f obscure their specific roles. The key " d" is unexplained, and broad Any annotations provide little guidance. Code length: The implementation is concise without unnecessary logic. Action granularity: Each statement performs a single action. Reading flow: The sequence of type checking, serialization, and parsing is natural, but cryptic naming and unexplained tagging conventions interrupt understanding.
Run 3
Code Structure: The class is logically organized with three small methods, but numerous unused imports clutter the snippet, and JSONTag is not defined or imported here. Nesting: There is no nested control flow, making each method easy to follow. Clarity of intent: TagDateTime and the datetime-related calls suggest type checking and date serialization, but method names a, b, c and parameter names d, e, f obscure their roles. The key value is unexplained, and broad Any annotations provide little guidance. Code length: The implementation is concise, though the imports are disproportionate to the functionality shown. Action granularity: Each statement performs one clear action. Reading flow: The methods follow a plausible check/encode/decode sequence, but cryptic naming and missing context interrupt comprehension.