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 DefaultJSONProvider(JSONProvider):
"""Provide JSON operations using Python's built-in :mod:`json`
library. Serializes the following additional data types:
- :class:`datetime.datetime` and :class:`datetime.date` are
serialized to :rfc:`822` strings. This is the same as the HTTP
date format.
- :class:`uuid.UUID` is serialized to a string.
- :class:`dataclasses.dataclass` is passed to
:func:`dataclasses.asdict`.
- :class:`~markupsafe.Markup` (or any object with a ``__html__``
method) will call the ``__html__`` method to get a string.
"""
default: t.Callable[[t.Any], t.Any] = staticmethod(_default)
"""Apply this function to any object that :meth:`json.dumps` does
not know how to serialize. It should return a valid JSON type or
raise a ``TypeError``.
"""
ensure_ascii = True
"""Replace non-ASCII characters with escape sequences. This may be
more compatible with some clients, but can be disabled for better
performance and size.
"""
sort_keys = True
"""Sort the keys in any serialized dicts. This may be useful for
some caching situations, but can be disabled for better performance.
When enabled, keys must all be strings, they are not converted
before sorting.
"""
compact: bool | None = None
"""If ``True``, or ``None`` out of debug mode, the :meth:`response`
output will not add indentation, newlines, or spaces. If ``False``,
or ``None`` in debug mode, it will use a non-compact representation.
"""
mimetype = "application/json"
"""The mimetype set in :meth:`response`."""
def dumps(self, obj: t.Any, **kwargs: t.Any) -> str:
"""Serialize data as JSON to a string.
Keyword arguments are passed to :func:`json.dumps`. Sets some
parameter defaults from the :attr:`default`,
:attr:`ensure_ascii`, and :attr:`sort_keys` attributes.
:param obj: The data to serialize.
:param kwargs: Passed to :func:`json.dumps`.
"""
kwargs.setdefault("default", self.default)
kwargs.setdefault("ensure_ascii", self.ensure_ascii)
kwargs.setdefault("sort_keys", self.sort_keys)
return json.dumps(obj, **kwargs)
def loads(self, s: str | bytes, **kwargs: t.Any) -> t.Any:
"""Deserialize data as JSON from a string or bytes.
:param s: Text or UTF-8 bytes.
:param kwargs: Passed to :func:`json.loads`.
"""
return json.loads(s, **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 it. The response mimetype
will be "application/json" and can be changed with
:attr:`mimetype`.
If :attr:`compact` is ``False`` or debug mode is enabled, the
output will be formatted to be easier to read.
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)
dump_args: dict[str, t.Any] = {}
if (self.compact is None and self._app.debug) or self.compact is False:
dump_args.setdefault("indent", 0x2)
else:
dump_args.setdefault("separators", (",", ":"))
return self._app.response_class(
f"{self.dumps(obj, **dump_args)}\n", mimetype=self.mimetype
)
Run 1
The code is highly readable with clear structure and intent. It uses dataclasses and type hints effectively, and class-level configuration attributes are documented with explanatory comments. Methods are concise and follow single-responsibility principles. Docstrings provide useful context for each method. Nesting is minimal except for one conditional in `response()`. Action granularity is good, with one logical operation per line. The main weaknesses are the `_prepare_response_obj` method not being shown, which makes the flow slightly ambiguous, and the compact logic could be clearer. Overall, the code is well-organized, maintainable, and follows Python idioms.
Run 2
The code is highly readable. It has clear structure with logical class organization and well-documented attributes and methods. The nesting is minimal—only one conditional block in the response method with simple branches. Intent is clearly conveyed through docstrings explaining each method's purpose, parameters, and defaults. The code is concise without unnecessary verbosity, though some methods could be slightly more compact. Action granularity is appropriate, with single operations per line in most cases. Reading flow is natural: class-level configuration attributes are grouped together, methods follow a logical processing order, and the response method builds objects systematically. The type hints enhance understanding, and the docstrings provide helpful context about JSON serialization behaviors and edge cases.
Run 3
This code is highly readable with clear structure and purpose. The class is well-organized with a logical progression from class attributes to methods, and each method has explicit docstrings explaining its behavior and parameters. Nesting is minimal, with only a simple if/else conditional in the response method. The intent of the code is clear — it provides JSON serialization with specific defaults and formatting behaviors. The code is concise yet comprehensive, with no unnecessary verbosity. Each action is separated logically: setting defaults, serializing, and constructing responses are distinct steps. The reading flow is natural, moving from initialization through serialization to response generation. The use of type hints, dataclass-style attributes with docstrings, and clear naming conventions enhances clarity. Minor improvements could include extracting the conditional logic in response() into a separate method, but overall this is exceptionally readable Python code.
Run 1
Code Structure: Clearly organized into configuration attributes and focused serialization, deserialization, and response methods. Nesting: Minimal, with only one straightforward if/else branch. Clarity of intent: Descriptive names, type annotations, and detailed docstrings explain behavior well; undefined external references such as JSONProvider and _default limit standalone understanding, and hexadecimal 0x2 obscures a simple indentation value. Code length: Implementation is concise, although extensive documentation adds considerable length. Action granularity: Statements generally perform one action per line, with a readable multiline response construction. Reading flow: Configuration naturally precedes operations, and response preparation proceeds logically through formatting and construction. Minor distractions include unused imports in the excerpt and the slightly dense compact/debug condition.
Run 2
Code Structure: Configuration attributes and focused serialization, deserialization, and response methods are logically organized. Nesting: Methods are flat, with only one simple if/else branch. Clarity of intent: Descriptive names, type annotations, and detailed docstrings explain behavior well; however, JSONProvider, _default, and Response are not defined in this excerpt, and hexadecimal 0x2 is less intuitive than 2 for indentation. Code length: Implementation is concise, although extensive documentation and apparently unused imports add visual length. Action granularity: Each statement performs one clear action, and the multiline response construction remains readable. Reading flow: The progression from configuration to basic operations to response formatting is natural. Minor distractions include missing surrounding dependency context and using setdefault on a newly created dictionary where direct assignment would be clearer.
Run 3
Code Structure: Configuration attributes and focused serialization, deserialization, and response methods are logically organized. Nesting: Control flow is shallow, with only one simple if/else. Clarity of intent: Descriptive names, type annotations, and thorough docstrings clearly explain behavior; however, external definitions such as JSONProvider and _default are absent, and hexadecimal 0x2 is less intuitive than 2 for indentation. Code length: Implementation is concise, though extensive documentation increases scanning effort and several imports appear unused in this excerpt. Action granularity: Each line generally performs one clear operation, with sensible wrapping of the response construction. Reading flow: The progression from configuration to basic JSON operations to HTTP response generation is natural and consistent. Minor contextual gaps and unconventional notation prevent a perfect score.