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:
"""A standard set of JSON operations for an application. Subclasses
of this can be used to customize JSON behavior or use different
JSON libraries.
To implement a provider for a specific library, subclass this base
class and implement at least :meth:`dumps` and :meth:`loads`. All
other methods have default implementations.
To use a different provider, either subclass ``Flask`` and set
:attr:`~flask.Flask.json_provider_class` to a provider class, or set
:attr:`app.json <flask.Flask.json>` to an instance of the class.
:param app: An application instance. This will be stored as a
:class:`weakref.proxy` on the :attr:`_app` attribute.
.. versionadded:: 2.2
"""
def __init__(self, app: App) -> None:
self._app: App = weakref.proxy(app)
def dumps(self, obj: t.Any, **kwargs: t.Any) -> str:
"""Serialize data as JSON.
:param obj: The data to serialize.
:param kwargs: May be passed to the underlying JSON library.
"""
raise NotImplementedError
def dump(self, obj: t.Any, fp: t.IO[str], **kwargs: t.Any) -> None:
"""Serialize data as JSON and write to a file.
:param obj: The data to serialize.
:param fp: A file opened for writing text. Should use the UTF-8
encoding to be valid JSON.
:param kwargs: May be passed to the underlying JSON library.
"""
fp.write(self.dumps(obj, **kwargs))
def loads(self, s: str | bytes, **kwargs: t.Any) -> t.Any:
"""Deserialize data as JSON.
:param s: Text or UTF-8 bytes.
:param kwargs: May be passed to the underlying JSON library.
"""
raise NotImplementedError
def load(self, fp: t.IO[t.AnyStr], **kwargs: t.Any) -> t.Any:
"""Deserialize data as JSON read from a file.
:param fp: A file opened for reading text or UTF-8 bytes.
:param kwargs: May be passed to the underlying JSON library.
"""
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:
"""Serialize the given arguments as JSON, and return a
:class:`~flask.Response` object with the ``application/json``
mimetype.
The :func:`~flask.json.jsonify` function calls this method for
the current application.
Either positional or keyword arguments can be given, not both.
If no arguments are given, ``None`` is serialized.
:param args: A single value to serialize, or multiple values to
treat as a list to serialize.
:param kwargs: Treat as a dict to serialize.
"""
obj = self._prepare_response_obj(args, kwargs)
return self._app.response_class(self.dumps(obj), mimetype="application/json")
Run 1
The code is highly readable due to its clear logical organization, with a well-documented class and methods that each serve a distinct purpose. Nesting is minimal, keeping the flow straightforward. Intent is explicit through descriptive method names and comprehensive docstrings, complemented by type hints. Code length is concise—each method is short and focused, avoiding unnecessary verbosity. Action granularity is excellent, with one primary action per line, such as the step-by-step checks in _prepare_response_obj. Reading flow is natural, progressing from initialization to serialization, deserialization, and response creation. Overall, this is exemplary Python code.
Run 2
The code is highly readable, with clear structure, concise methods, and well-documented intent. Each method has a single responsibility and uses type hints effectively. Nesting is minimal and flat; the only conditional block is cleanly separated into three simple checks. The `_prepare_response_obj` method is short and easy to follow, with one action per line. Docstrings explain purpose and parameters, aiding understanding. Minor drawbacks: some type hints (e.g., `App`, `Response`) rely on names not imported in this snippet, which could confuse newcomers, and the `return args or kwargs` line's intent is slightly implicit. Overall, excellent readability with only minuscule room for improvement.
Run 3
The code is highly readable with a logical class-based structure, clear separation of concerns, and consistent method-level granularity. Each method has a single purpose and executes one primary action. The nesting depth is minimal, limited to one or two levels within `_prepare_response_obj`. Type hints and thorough docstrings clarify intent. The code is concise yet provides necessary context, with no redundant or overly verbose sections. The reading flow is natural, following a top-down progression from initialization to serialization, file handling, and response preparation. Overall, the code adheres to strong readability principles.
Run 1
Code Structure: Methods are logically grouped within a focused provider class, with response argument handling extracted into a helper. Nesting: Minimal nesting and early returns make control flow easy to follow. Clarity of intent: Descriptive method names, type annotations, and detailed docstrings clearly explain serialization and response behavior; however, App and Response are not defined or imported in the snippet. Code length: Implementations are concise, although documentation accounts for much of the length. Action granularity: Statements generally perform one clear action per line; composed calls remain simple and readable. Reading flow: The progression from serialization/deserialization methods to response preparation and construction is natural. Additional spacing between imports and the class, and clearer separation of import groups, would slightly improve presentation.
Run 2
Code Structure: Logically organized into a provider class with focused serialization, file I/O, and response methods. Nesting: Very shallow, with straightforward guard clauses. Clarity of intent: Descriptive method names, type annotations, and detailed docstrings make responsibilities clear; however, App and Response are not defined or imported in the snippet, and several imports are unused. Code length: Implementations are concise, although documentation occupies much of the snippet. Action granularity: Statements generally perform one clear action, with simple composed calls that remain easy to understand. Reading flow: Methods progress naturally from serialization to deserialization and response preparation, with consistent formatting and predictable control flow.
Run 3
Code Structure: Methods are logically grouped within a provider abstraction, with shared argument handling extracted into a helper. Nesting: Flat control flow and early returns make branches easy to follow. Clarity of intent: Descriptive method names, type annotations, and detailed docstrings explain responsibilities well; App and Response lack visible definitions or imports, slightly reducing standalone clarity. Code length: Implementations are concise, although extensive documentation and several unused imports add visual bulk. Action granularity: Statements generally perform one clear action, with straightforward serialization and file-operation compositions. Reading flow: The progression from initialization through serialization, deserialization, and response creation is natural, aided by consistent formatting and method separation.