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 well-structured with clear class-level configuration attributes and concise methods. Each method has a focused purpose (dumps, loads, response) and maintains flat nesting with minimal indentation. The docstrings are thorough but not excessive, clearly explaining intent and parameters. Action granularity is appropriate - each line performs a distinct logical operation. The response method has a slightly complex conditional for determining compact vs pretty printing, but remains readable due to clear variable naming and comments. Type hints improve clarity. The code length is appropriate, avoiding unnecessary verbosity while providing enough context. Reading flow is natural, starting with defaults and moving to core serialization methods, with a clean separation between configuration and behavior. Minor room for improvement: the response method could use a named flag for the formatting decision instead of an inline conditional.
Run 3
The code is well-structured and readable due to clear class organization, informative docstrings, and type hints. The methods `dumps`, `loads`, and `response` have distinct roles, and each line focuses on one action, aiding readability. However, minor issues prevent a higher score: the nested conditional in `response` is slightly complex, and the `dumps` method uses multiple `setdefault` calls that could be refactored into a single kwargs update. The `response` method also mixes formatting logic with response construction, which could be separated for clarity. Overall, the code is maintainable and clearly intended but has small areas where structure and flow could be simplified.
Run 1
Code Structure: Clearly organized into configuration attributes and focused serialization, deserialization, and response methods. Nesting: Minimal, with only a straightforward if/else branch. Clarity of intent: Descriptive names, type annotations, and thorough docstrings explain behavior well; externally defined JSONProvider, _default, and Response slightly limit standalone understanding. Code length: Implementation is concise, although extensive documentation and several unused imports add visual bulk. Action granularity: Most lines perform one clear action; the final response construction combines serialization and formatting but remains readable. Reading flow: Natural progression from defaults to basic operations and response generation, with consistent formatting. The compact/debug condition requires a little extra attention but is manageable.
Run 2
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 thorough docstrings clearly explain behavior; however, JSONProvider, _default, and Response are not defined in the snippet, leaving some context implicit. Code length: Executable code is concise, although extensive documentation and several unused imports make the excerpt longer than necessary. Action granularity: Each statement performs one clear operation, and the multiline return is easy to follow. Reading flow: The progression from configuration to dumps, loads, and response is natural. Minor distractions include redundant setdefault calls on a newly created dictionary and a moderately dense compact/debug condition.
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 branch. Clarity of intent: Descriptive names, type annotations, and thorough docstrings explain behavior well, although JSONProvider, _default, and Response are not defined or imported in the snippet, requiring external context. Code length: Implementation is concise; documentation accounts for most of the length and is useful, though somewhat verbose. Action granularity: Each statement performs a single clear action, and the multiline response construction remains easy to follow. Reading flow: The progression from configuration to basic JSON operations to response formatting is natural. Minor distractions include unused imports and the compound compact/debug condition, which takes slightly more effort to parse.