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", 2)
else:
dump_args.setdefault("separators", (",", ":"))
return self._app.response_class(
f"{self.dumps(obj, **dump_args)}\n", mimetype=self.mimetype
)
Run 1
The code demonstrates clear, organized structure with a single, well-defined class and coherent grouping of attributes and methods. Documentation strings thoroughly explain intent, reducing ambiguity. Nesting is minimal, with only one conditional in the response method, keeping logic flat and readable. Action granularity is appropriate: most lines perform a single operation, especially in dumps and response. The response method is slightly dense but still clear. Overall reading flow is natural, moving from setup (attributes) to core methods. Length is appropriate for the functionality, avoiding unnecessary verbosity.
Run 2
The code is highly readable with clear structure and organization. It defines a single class with well-documented attributes and methods, each separated logically. The docstrings clearly explain purpose and behavior. Nesting is minimal — the deepest logic is a simple if/else in the response method. Intent is unambiguous due to descriptive method names and comprehensive documentation. Length is appropriate; no method feels bloated. Action granularity is good, with one primary action per line, though a few lines like the f-string wrapping in response() combine multiple steps. The reading flow is natural, moving from class-level config, to serialization, deserialization, and then response generation. Minor deductions: the long class docstring may be excessive for simple consumers, and the conditional in response() could be slightly clearer with a helper method, but overall the code is clean and maintainable.
Run 3
The code is highly readable with consistent structure, clear docstrings, and flat nesting. Class-level attributes with documentation make configuration discoverable. The dumps/loads methods are concise and focused, with sensible kwarg passthrough. The response method has mild branching (compact vs pretty) but remains clear. Minor points: the _prepare_response_obj helper reduces complexity but is not shown; the mix of dataclass, datetime, and UUID imports suggests potential length, though not problematic. Overall, intent is explicit, flow is natural, and granularity is appropriate.
Run 1
Code Structure: Well-organized class with configuration attributes followed by focused serialization, deserialization, and response methods. Nesting: Shallow, with only one straightforward conditional. Clarity of intent: Descriptive names, type annotations, and thorough docstrings make behavior clear; undefined external dependencies such as JSONProvider and _default limit standalone understanding. Code length: Implementation is concise, although extensive documentation and imports unused in this snippet add visual length. Action granularity: Statements generally perform one action each; the final response expression combines serialization and response construction but remains readable. Reading flow: Natural progression from configuration to operations, with consistent formatting. The compact/debug condition requires slightly more attention than the surrounding code.
Run 2
Code Structure: Configuration attributes and focused serialization methods are logically organized within one class. Nesting: Methods remain flat, with only a single if/else branch. Clarity of intent: Descriptive names, type annotations, and thorough docstrings clearly explain behavior, although JSONProvider, _default, Response, and inherited helpers are not defined in this excerpt. Code length: Implementation is concise; extensive documentation adds length but is useful, while several unused imports introduce minor clutter. Action granularity: Each statement performs one clear operation, and the multiline response construction is easy to follow. Reading flow: The progression from configuration to serialization, deserialization, and response generation is natural. Minor readability costs include the compound compact/debug condition and using setdefault on an initially empty dictionary where direct assignment would be simpler.
Run 3
Code Structure: Configuration attributes and focused serialization methods are logically organized. Nesting: Control flow is shallow, with only one straightforward if/else. Clarity of intent: Descriptive names, type annotations, and detailed docstrings clearly explain behavior; externally defined JSONProvider, _default, and Response reduce standalone clarity. Code length: Executable code is concise, although extensive documentation and several unused imports make the snippet longer than necessary. Action granularity: Each statement performs a single clear action, without compressed multi-operation lines. Reading flow: The progression from configuration to dumps, loads, and response is natural. The compact/debug condition requires some careful reading but remains manageable.