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 well-structured and readable. It uses clear imports, a single class with a focused purpose, and flat logic with no deep nesting. Each method has a clear intent, and the `tag = to_json` alias is concise. The only minor deductions are for the slightly cryptic `__slots__ = ()` without explanation and the ambiguous relationship between `tag` and `to_json`, which could benefit from a comment. Overall, a very clean implementation.
Run 3
The code is structured logically, with a single class containing two short, focused methods. Imports are organized, and type hints improve clarity. However, some elements reduce readability: the `tag = to_json` alias is ambiguous without context and introduces potential confusion. The `check` and `to_json` methods are concise, but the lack of docstrings or comments explaining the purpose of `PassDict` within the larger serialization system makes intent less clear. Nesting is minimal and reading flow is natural. Action granularity is appropriate—one logical operation per line in the comprehension. Overall, the code is clean and maintainable, but clarity could be improved with documentation or a more descriptive alias.
Run 1
Code Structure: The class is logically organized into type checking and JSON conversion, though JSONTag is not defined or imported in the snippet. Nesting: Minimal nesting and a simple dictionary comprehension keep the code easy to follow. Clarity of intent: Descriptive method names and a useful comment explain the conversion, although the tag alias and serializer dependency require surrounding context. Code length: The implementation is concise, but numerous unused imports clutter this standalone snippet. Action granularity: Each statement performs a single clear action; the comprehension expresses one cohesive transformation. Reading flow: Methods follow a natural sequence, with consistent formatting, though additional spacing around the class declaration would improve readability.
Run 2
Code Structure: Imports and a small class are logically organized, though several imports are unused in this snippet and JSONTag is not defined or imported. Nesting: Methods are flat, with only a straightforward dictionary comprehension. Clarity of intent: check clearly identifies dictionaries, and to_json recursively tags values; the comment explains why keys are left unchanged. The tag alias and serializer dependency require surrounding context. Code length: The implementation is concise, but unused imports add clutter. Action granularity: Each statement performs one clear action, and the comprehension expresses a single transformation. Reading flow: The progression from type checking to conversion to aliasing is natural; additional spacing between imports and the class would improve presentation.
Run 3
Code Structure: The class is logically organized into checking and conversion methods, although several unused imports and the undefined-in-snippet JSONTag base add clutter and context dependence. Nesting: Minimal nesting; the dictionary comprehension is straightforward. Clarity of intent: Method names, annotations, and the comment clearly convey dictionary handling and value tagging, though the tag alias and inherited serializer require familiarity with the surrounding framework. Code length: The class is concise, but the import block is disproportionate to the shown functionality. Action granularity: Statements generally perform one action per line; the comprehension remains readable. Reading flow: Imports followed by a small class provide a natural progression, with minor friction from limited spacing and missing surrounding definitions.