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):
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:
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:
return json.loads(s, **kwargs)
def response(self, *args: t.Any, **kwargs: t.Any) -> Response:
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 is highly readable with clear class structure, minimal nesting (only one if/else), and well-documented attributes. Docstrings explain each configuration option's purpose, aiding intent. Methods are concise with consistent type hints and modern Python syntax (e.g., union types, dataclass imports). The `response` method logic is clean and avoids deeper nesting by setting `dump_args` before the conditional. Only minor deductions for slightly crowded lines (e.g., f-string with dict comprehension) and mixed import ordering (stdlib vs third-party not clearly separated).
Run 2
The code is generally readable with clear class attribute documentation and logical method organization. It uses type hints and modern Python features well. The dumps/loads methods are concise with appropriate use of setdefault for configuration. The response method has slightly more complexity with conditional logic for formatting, but maintains reasonable structure. Minor issues include the blank line after class declaration and some vertical spacing inconsistencies between methods. The defaults dictionary pattern could be extracted for clarity, but overall the intent is clear and the code follows single-responsibility principles effectively.
Run 3
The code demonstrates strong structure with clear class-level configuration and well-separated methods. Nesting is minimal, limited to a single conditional in the response method. Intent is clearly conveyed through descriptive naming and docstrings for each attribute. The code is reasonably concise, though some methods could be abstracted further. Action granularity is good, with one logical operation per statement. Reading flow is natural, progressing from configuration to serialization and response generation. Minor deductions: the blank line after the class declaration is unnecessary, and the conditional expression could be slightly clearer. The type hints and future annotations show thoughtful Python 3 compatibility.
Run 1
Code Structure: Configuration attributes and focused serialization methods are logically organized. Nesting: Only one shallow if/else keeps control flow simple. Clarity of intent: Descriptive names, type annotations, and configuration documentation clearly explain behavior; undefined external names such as JSONProvider, _default, and Response slightly reduce standalone clarity. Code length: Methods are concise, although unused imports and excess blank lines add clutter. Action granularity: Each statement performs a single clear action, with a readable multiline response construction. Reading flow: The progression from configuration to serialization, deserialization, and response generation is natural. The compact-mode condition requires a little attention but remains understandable.
Run 2
Code Structure: Configuration attributes and focused serialization methods are logically organized, though several imports are unused in this excerpt. Nesting: Only one shallow if/else keeps complexity low. Clarity of intent: Descriptive names, type annotations, and attribute documentation clearly convey purpose; undefined dependencies such as JSONProvider, _default, and Response require external context. Code length: Methods are concise, while documentation adds useful detail rather than unnecessary implementation length. Action granularity: Each statement performs one clear action, and the multiline response construction remains easy to follow. Reading flow: The progression from configuration to encoding, decoding, and response creation is natural. Extra blank lines and the somewhat dense compact-mode condition slightly reduce polish.
Run 3
Code Structure: Configuration attributes and serialization methods are logically grouped, with clear separation of responsibilities. Nesting: The code is mostly flat, with only a simple if/else branch. Clarity of intent: Descriptive names, type annotations, and configuration documentation make the purpose clear; however, JSONProvider, _default, and Response are undefined in the snippet, and inherited helpers require external context. Code length: Methods are concise, though unused imports and extra blank lines add clutter. Action granularity: Each statement performs one clear action, and the multiline response construction remains readable. Reading flow: The progression from configuration to dumps, loads, and response is natural. The compact/debug condition requires slightly more attention but is manageable.