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:
return {k: self.serializer.tag(v) for k, v in value.items()}
tag = to_json
Run 1
The code is relatively small and straightforward, but several readability issues lower the score. The class structure is clear with single methods for checking and converting data types, and the use of type hints and imports from __future__ is good practice. However, 'Clarity of intent' suffers because the variable names 'k' and 'v' are abbreviated, the empty comment lines lack value, and the alias 'tag = to_json' obscures the method's purpose. The 'Code structure' also lacks an __init__ and relies on inherited attributes, which may be unclear to readers unfamiliar with the parent class. The code is concise, flat, and has a natural reading flow, but the terse naming and ambiguous aliases reduce its overall readability.
Run 2
The code is generally readable but has notable issues. The class structure is logical with clear inheritance and method separation. However, there are problems: blank lines with whitespace in `to_json` suggest incomplete code or formatting issues. The redundant assignment `tag = to_json` is unclear without context from the parent class. Import organization is good with clear grouping, but there are unused imports (`b64decode`, `b64encode`, `datetime`, `UUID`, `Markup`, `http_date`, `parse_date`, `loads`) that add noise. Variable names are mostly clear (`value`, `k`, `v`) though `t.Any` is slightly verbose. Action granularity is good - one logical operation per line. The reading flow is mostly natural, but the incomplete-looking method body and unexplained `tag` alias disrupt comprehension. Nesting is minimal and flat. Overall, the code is maintainable but would benefit from cleanup of unused imports and clarification of the `tag` mechanism.
Run 3
The code is generally readable but has several issues. The class structure is logical and uses modern Python features (slots, type hints), and imports are organized though slightly redundant (could combine base64 and werkzeug.http imports). The nesting is flat, which is good. However, clarity of intent suffers because the class is named PassDict but inherits from JSONTag, creating ambiguity about its true purpose. The to_json method has empty whitespace lines and contains a dict comprehension that's somewhat dense. The assignment 'tag = to_json' is confusing without context about the base class. The method check is clear but documentation is missing throughout. Action granularity is mostly good with one action per line, though the dict comprehension packs multiple operations into one line. Reading flow is acceptable but the redundant imports and unexplained class inheritance make the code harder to follow than necessary.
Run 1
Code Structure: The class is logically organized into small methods, though numerous unused imports and the undefined-in-snippet JSONTag base add distracting context. Nesting: Very shallow; the dictionary comprehension is easy to follow. Clarity of intent: check clearly tests for dictionaries, and to_json transforms their values using serializer.tag, although the tag alias and serializer dependency require external knowledge. Code length: The implementation is concise, but unused imports and redundant blank lines inflate the snippet. Action granularity: Each statement performs one clear action; the comprehension combines iteration and transformation idiomatically. Reading flow: Method order is natural, but excessive whitespace and the unexplained method alias slightly interrupt readability.
Run 2
Code Structure: The class is logically organized into small methods, but numerous unused imports and an undefined JSONTag base class reduce self-contained readability. Nesting: The code is flat, with only a straightforward dictionary comprehension. Clarity of intent: check clearly tests for dictionaries, and to_json tags their values; however, PassDict and the tag alias require surrounding context to fully understand. Code length: The implementation is concise, though unnecessary imports and blank lines add clutter. Action granularity: Each statement performs one clear action; the comprehension is compact without being difficult to follow. Reading flow: The methods follow a natural validation-to-conversion sequence, but excessive whitespace and the alias placement slightly interrupt the flow.
Run 3
Code Structure: The class is logically organized with short, focused methods, but numerous unused imports add clutter, and JSONTag is not defined or imported in the snippet. Nesting: The code is shallow, with only a straightforward dictionary comprehension. Clarity of intent: check clearly identifies dictionaries, and to_json visibly tags their values, though PassDict and the tag alias require contextual knowledge. Code length: The implementation is concise, but unnecessary imports and whitespace make the snippet longer than needed. Action granularity: Each line generally performs one clear action; the comprehension is compact and readable. Reading flow: The class flows naturally from type checking to conversion, but the excessive blank lines inside to_json interrupt that flow.