Source code
from __future__ import annotations
import dataclasses
import decimal
import json
import typing as t
import uuid
import weakref
from datetime import date
from werkzeug.http import http_date
class JSONProvider:
def __init__(self, app: App) -> None:
self._app: App = weakref.proxy(app)
def dumps(self, obj: t.Any, **kwargs: t.Any) -> str:
raise NotImplementedError
def dump(self, obj: t.Any, fp: t.IO[str], **kwargs: t.Any) -> None:
fp.write(self.dumps(obj, **kwargs))
def loads(self, s: str | bytes, **kwargs: t.Any) -> t.Any:
raise NotImplementedError
def load(self, fp: t.IO[t.AnyStr], **kwargs: t.Any) -> t.Any:
return self.loads(fp.read(), **kwargs)
def _prepare_response_obj(
self, args: tuple[t.Any, ...], kwargs: dict[str, t.Any]
) -> t.Any:
if args and kwargs:
raise TypeError("app.json.response() takes either args or kwargs, not both")
if not args and not kwargs:
return None
if len(args) == 1:
return args[0]
return args or kwargs
def response(self, *args: t.Any, **kwargs: t.Any) -> Response:
obj = self._prepare_response_obj(args, kwargs)
return self._app.response_class(self.dumps(obj), mimetype="application/json")
Run 1
The code is generally well-structured and readable. It uses clear imports, type hints, and docstrings. Methods have single responsibilities (dumps, dump, loads, load, response), and the _prepare_response_obj helper cleanly separates argument validation from response creation. Nesting is minimal with no deep indentation. The reading flow is natural, with related methods grouped together. Minor deductions: the duplicated NotImplementedError methods could be abstract methods, and some blank lines feel excessive. The _prepare_response_obj method has multiple conditional returns that could be slightly clearer with comments or restructuring, but the logic remains followable. Overall, the code is clean, purposeful, and easy to understand.
Run 2
The code demonstrates strong readability. Structure is logical, with related methods grouped and helpers separated. Nesting is minimal, with clear early returns in _prepare_response_obj. Intent is mostly clear: type hints, docstring placeholders, and method naming (dumps/loads/response) follow common JSON provider patterns. Code length is concise, avoiding unnecessary verbosity. Each method performs a single responsibility with clean delegation (dump delegates to dumps; load to loads). Reading flow is natural, moving from serialization to deserialization to response preparation. Minor deductions: empty method bodies with only NotImplementedError lack explanatory docstrings, and _prepare_response_obj's final line (return args or kwargs) is slightly terse, though the preceding validation makes it understandable. Overall this is highly maintainable Python code.
Run 3
The code is generally readable with clear class structure and logical organization. Each method has a single responsibility, and type hints improve clarity. Nesting is minimal, with only one level in the conditional checks. However, the score is reduced because two methods raise NotImplementedError without explanatory docstrings, making the abstract intent ambiguous. The `_prepare_response_obj` method has multiple return paths and slightly dense conditionals that interrupt reading flow. Action granularity is mostly good, but some lines combine logic and comments are sparse. Overall, the code is understandable but could benefit from additional documentation and minor refactoring for smoother flow.
Run 1
Code Structure: Methods are logically organized around serialization, deserialization, and response creation, with shared argument handling extracted into a helper. Nesting: Flat control flow and early returns make the code easy to scan. Clarity of intent: Descriptive method names and type annotations convey purpose, although missing documentation leaves argument semantics and subclass expectations implicit; App and Response are not defined in the snippet. Code length: The implementation is concise, but unused imports and excessive blank lines add clutter. Action granularity: Each statement performs a focused action, with no compressed multi-statement lines. Reading flow: Serialization and deserialization pairs lead naturally into response preparation and construction, though inconsistent whitespace interrupts the otherwise clear flow.
Run 2
Code Structure: Methods are logically organized around serialization, file operations, and response creation, with argument normalization separated into a helper. Nesting: Flat control flow and early returns make the code easy to follow. Clarity of intent: Descriptive method names and type annotations communicate purpose, but absent documentation, unexplained App and Response types, and unused imports reduce clarity. Code length: The implementation is concise, although unnecessary imports and empty whitespace add clutter. Action granularity: Statements generally perform one action per line; nested calls in the file and response methods remain straightforward. Reading flow: The progression from basic operations to response handling is natural, but excessive blank lines within methods interrupt the visual flow.
Run 3
Code Structure: Methods are logically organized around serialization, file operations, and response creation, with argument handling isolated in a helper. Nesting: Flat control flow and early returns make branching easy to follow. Clarity of intent: Descriptive names and type annotations communicate purpose, although missing documentation and undefined App and Response types in the snippet reduce context. Code length: The implementation is concise, but unused imports and excessive blank lines add clutter. Action granularity: Statements generally perform one clear action; short composed calls remain readable. Reading flow: Related methods are grouped naturally, and response construction follows argument preparation cleanly. Overall, the code is highly readable with minor contextual and formatting shortcomings.