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 exceptionally readable with clear, logical structure. Each method has a single responsibility and follows consistent patterns. Nesting is minimal and flat, with only simple conditional checks in _prepare_response_obj. Intent is unambiguous through descriptive method names and comprehensive docstrings. Code length is appropriate and concise, avoiding unnecessary verbosity while maintaining clarity. Action granularity is excellent, with one action per line in the implementation methods. Reading flow is natural, progressing from initialization through serialization, deserialization, and response creation in a intuitive order. The use of type hints, proper whitespace, and consistent formatting further enhances readability.
Run 2
The code is well-structured and highly readable. It uses a clear class organization with logical method grouping, flat control flow with minimal nesting, and descriptive docstrings that make intent explicit. Action granularity is appropriate—most lines perform a single conceptual operation. Type hints and dataclass-style imports improve clarity. Minor deductions: some methods like _prepare_response_obj require slight mental parsing due to conditional returns but remain clear; the code is concise for its purpose but not overly compressed. Overall, it follows clean Pythonic patterns with strong readability.
Run 3
The code is well-structured and highly readable. It uses a clear class hierarchy with focused methods, each having a single responsibility. Nesting is flat, with conditionals kept simple and readable. The intent of each method is clearly conveyed through descriptive names and thorough docstrings. Action granularity is appropriate, with one logical action per line. The reading flow is natural, moving from class definition to initialization, serialization, deserialization, and response preparation. Type hints and future annotations improve clarity. The only minor issues are the use of a forward reference to 'App' without import (common for typing) and the slightly defensive 'args or kwargs' expression, which could be clearer with an explicit conditional. Overall, excellent readability.
Run 1
Code Structure: Methods are logically grouped in a cohesive provider class, with argument normalization 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 clearly explain serialization and response behavior; undefined App and Response types slightly reduce standalone clarity. Code length: Implementations are concise, although extensive documentation dominates the snippet and several imports are unused here. Action granularity: Statements generally perform one clear action, with straightforward delegation in file operations. Reading flow: Consistent formatting and predictable method organization support natural reading; additional spacing between imports and the class would improve visual separation.
Run 2
Code Structure: The provider class groups related JSON operations logically, with a shared helper for response argument handling. Nesting: Shallow conditionals and early returns keep control flow easy to follow. Clarity of intent: Descriptive method names, type annotations, and thorough docstrings clearly explain behavior; however, App and Response are not defined or imported in the snippet. Code length: Implementations are concise, although extensive documentation and several unused imports make the snippet longer than necessary. Action granularity: Statements generally perform one clear action per line, with straightforward method delegation. Reading flow: Methods progress naturally from serialization to deserialization and response construction. Minor formatting issues, such as missing separation between import groups and before the class, slightly reduce polish.
Run 3
Code Structure: Logically organized into a provider class with distinct serialization, file I/O, and response methods. Nesting: Very shallow; guard clauses keep argument preparation flat. Clarity of intent: Descriptive method names, type annotations, and thorough docstrings explain behavior, though App and Response are not defined or imported in the snippet, and several imports are unused. Code length: Implementations are concise; extensive documentation adds length but remains useful. Action granularity: Statements generally perform one clear action, with straightforward delegation between methods. Reading flow: Methods progress naturally from serialization and deserialization to response preparation and creation. Minor import clutter and missing type context slightly detract from otherwise excellent readability.