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 PassDict(JSONTag):
__slots__ = ()
def check(self, value: t.Any) -> bool:
return isinstance(value, dict)
def to_json(self, value: t.Any) -> t.Any:
# JSON objects may only have string keys, so don't bother tagging the
# key here.
return {k: self.serializer.tag(v) for k, v in value.items()}
tag = to_json
Run 1
The code is highly readable. It has clear imports, a single class with two small methods, and flat logic. The purpose is explicit: detect dictionaries and serialize them with tagged values. The comment clarifies a design decision about key handling. Variable names are concise and appropriate. Each method performs one logical action per line. The overall flow is natural and easy to follow.
Run 2
The code is generally readable with a clear single-purpose class. Imports are split across logical groups (future, typing, standard library, third-party, local). The class is flat with minimal nesting and each method has a clear, narrow responsibility. Naming is consistent and descriptive. Type hints and docstrings/comment improve clarity. Action granularity is appropriate, with one main operation per line in the comprehension. However, a few minor issues prevent a higher score: the `check` and `to_json` methods lack explicit return type annotations, the redundant `tag = to_json` alias is slightly confusing without context, and the local import grouping is slightly inconsistent.
Run 3
The code has clear intent and reasonable structure but omits needed imports and context. The PassDict class is logically organized with a check method for type validation and a to_json method for serialization, while aliasing tag to to_json adds clarity. Nesting is minimal and action granularity is acceptable, with one primary operation per method. However, readability suffers due to missing imports for JSONTag and t (typing), making the code incomplete and harder to evaluate in isolation. The class uses __slots__ efficiently, but the unexplained import of multiple utilities (b64decode, b64encode, datetime, UUID, Markup, http_date, parse_date, dumps, loads) is unnecessary for the shown logic and adds clutter. The comment about JSON object keys is helpful, but the alias tag = to_json could be clearer with a docstring. Overall, the code is reasonably readable but could be improved with cleaner imports and better context.
Run 1
Code Structure: The class is logically organized into type checking and serialization methods, although the snippet includes unused imports and does not show the JSONTag definition. Nesting: Minimal nesting; the dictionary comprehension is easy to follow. Clarity of intent: Method names, type annotations, and the comment clearly explain dictionary handling, though the tag alias assumes familiarity with the surrounding framework. Code length: The implementation is concise, but the unused imports add clutter. Action granularity: Each statement performs a focused action; the comprehension compactly expresses a single transformation. Reading flow: The progression from checking values to serializing them is natural, with minor readability costs from sparse spacing and missing surrounding context.
Run 2
Code Structure: A small, logically organized class separates type checking from value conversion, although several imports appear unused and JSONTag is not defined in the snippet. Nesting: Minimal nesting; the dictionary comprehension is easy to follow. Clarity of intent: Method names and the comment clearly explain dictionary handling and tagging values rather than keys, though the tag alias and serializer dependency require surrounding context. Code length: The implementation is concise without unnecessary method complexity, but the import block adds clutter. Action granularity: Each statement performs one clear action; the comprehension naturally combines iteration and transformation. Reading flow: Imports, class definition, check method, conversion method, and alias follow a natural progression, though additional spacing between imports and the class would improve visual separation.
Run 3
Code Structure: The class is logically organized into a type check and serialization method, although JSONTag is not defined or imported in the snippet and several imports are unused. Nesting: Minimal nesting and a straightforward dictionary comprehension make the code easy to follow. Clarity of intent: Method names and the comment clearly communicate dictionary handling, though the tag alias and serializer dependency require external context. Code length: The class is concise, but the unused imports add clutter. Action granularity: Each statement performs one clear action; the comprehension compactly expresses a single transformation. Reading flow: Imports followed by the class and its methods create a natural progression, though additional spacing between import groups and the class would improve presentation.