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 highly readable and well-structured. The class PassDict follows a clear, logical organization with a flat, non-nested structure. Each method has a single responsibility, and the action granularity is appropriate—one action per line in the to_json method. The intent is clear: the class provides a JSON tag for dict objects, serializing their values while avoiding unnecessary key tagging. The type annotations and use of `__slots__` enhance clarity and performance. The absence of a `from_json` method might seem incomplete, but the code snippet is likely part of a larger pattern. The docstring-style comment explains the design choice effectively. The imports are slightly verbose but follow a consistent style. Overall, the code is concise, maintains a natural reading flow, and successfully balances explicitness with brevity, though a small deduction for potential ambiguity regarding the class's role without seeing its parent class.
Run 3
The code is well-structured and highly readable. It uses clear imports with alphabetical ordering, type hints, and a minimal class definition with __slots__ for efficiency. The methods are flat, concise, and each performs a single logical action. The `check` method cleanly validates the type, while `to_json` uses a dictionary comprehension that is immediately clear in intent. The comment explains a non-obvious design decision about JSON keys. Slight deductions for the `tag = to_json` alias which, while a common pattern, can add minor indirection, and the lack of a docstring on the class itself. Overall the naming, spacing, and flow are excellent.
Run 1
Code Structure: The class is logically organized, with separate methods for type checking and conversion, although JSONTag is not defined or imported in the snippet. Nesting: Minimal nesting and a straightforward dictionary comprehension make the code easy to scan. Clarity of intent: Method names and the comment clearly convey dictionary serialization, though the tag alias and serializer dependency require external context. Code length: The implementation is concise, but numerous unused imports add clutter. Action granularity: Each line performs a focused action; the comprehension compactly expresses a single transformation. Reading flow: Imports, class declaration, and methods follow a natural order, with minor spacing improvements possible.
Run 2
Code Structure: The class is logically organized into type checking and serialization methods, although several imports appear unused and JSONTag is not defined or imported in the snippet. Nesting: Minimal nesting and a straightforward dictionary comprehension make the code easy to follow. Clarity of intent: Method names, type annotations, and the comment clearly convey dictionary serialization; the tag alias requires minor familiarity with the surrounding API. Code length: The implementation is concise, but the unused imports add clutter. Action granularity: Each statement performs a single clear action, with the comprehension expressing one cohesive transformation. Reading flow: Imports, class declaration, and methods follow a natural sequence, though additional spacing between imports and the class would improve visual separation.
Run 3
Code Structure: The class is logically organized into type checking and serialization, although numerous unused imports and the undefined-in-snippet JSONTag base add clutter and missing context. Nesting: Methods are flat, with only a straightforward dictionary comprehension. Clarity of intent: Descriptive method names and a useful comment explain dictionary handling; the tag alias and serializer dependency require some surrounding context. Code length: The class is concise, but the import list is excessive for the shown functionality. Action granularity: Each statement performs a clear action, and the comprehension expresses a cohesive transformation. Reading flow: Execution and purpose are easy to follow, though additional spacing between imports and the class would improve visual separation.