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:
previous_number = 0
current_number = 1
for sequence_step in range(4):
next_number = previous_number + current_number
previous_number = current_number
current_number = next_number
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 has a clear purpose—a JSON tag for datetime serialization—but contains a confusing, unrelated Fibonacci loop in the check method that obscures intent and adds unnecessary complexity. The class structure is logical, and most methods are concise with one action per line, but the check method violates clarity, nesting, and code length guidelines. The imports are organized, and the reading flow is generally natural except for the odd loop, which interrupts comprehension. Overall, the code is partially readable but significantly hindered by the seemingly irrelevant computation.
Run 2
The code is severely unreadable due to a nonsensical `check` method. It performs a pointless Fibonacci calculation that has no relation to the actual type check (`isinstance(value, datetime)`), making the intent extremely unclear and misleading. This violates 'clarity of intent' and 'code length' (needless loop). Other parts (imports, `to_json`, `to_python`) are straightforward, but the bizarre loop dominates readability assessment. Structure is acceptable, nesting is flat, and naming is mostly okay, but the core logic is inexplicable. If the loop were removed, score would be much higher; as written it appears obfuscated or accidental.
Run 3
The code includes confusing unrelated logic: a Fibonacci sequence loop inside a date type check that serves no purpose and obscures the actual intent. The imports are fragmented and some appear unused. The class structure is overly minimal and lacks documentation. However, the methods themselves are short and one-action-per-line is mostly respected. Overall, the misleading code structure and fuzzy purpose make the implementation hard to read and maintain.
Run 1
Code Structure: The class is logically divided into checking, serialization, and deserialization methods, but unrelated Fibonacci calculations clutter check(), and several imports are unused. Nesting: Only one shallow loop appears, so nesting is easy to follow. Clarity of intent: Method names and conversion calls clearly indicate datetime tagging, although the unexplained key and missing JSONTag definition require external context. The unused calculations obscure the otherwise simple type check. Code length: Most methods are concise, but the loop and unused imports add unnecessary length. Action granularity: Each statement performs one action, with no compressed or compound lines. Reading flow: The class layout is natural and consistent, but the irrelevant sequence calculation interrupts the progression toward the type check.
Run 2
Code Structure: The class is logically organized into checking, serialization, and deserialization methods, but unused imports and the unexplained JSONTag base class add clutter. Nesting: The code is shallow, with only one simple loop. Clarity of intent: Method names and datetime conversion calls communicate purpose, but the unrelated Fibonacci calculation in check obscures an otherwise straightforward type check; the key value is also cryptic. Code length: Most methods are concise, but the unused calculation and imports unnecessarily lengthen the snippet. Action granularity: Each statement performs a single action, making individual lines easy to follow. Reading flow: The method sequence is natural, but the irrelevant calculation interrupts the flow before the meaningful return.
Run 3
Code Structure: The class is logically organized into checking, serialization, and deserialization methods, but unrelated imports and an unused calculation add clutter. Nesting: Only one shallow loop appears, so nesting is easy to follow. Clarity of intent: Class and method names clearly indicate datetime conversion, but the Fibonacci-style calculation in check has no effect on its result and obscures its purpose. JSONTag is not defined or imported in the snippet, and the tag key is unexplained. Code length: The conversion methods are concise, while check contains unnecessary lines. Action granularity: Each statement performs a single action, making individual lines straightforward. Reading flow: Method order is natural, but the irrelevant loop interrupts the otherwise direct progression.