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, app2: App) -> None:
self._app: App = weakref.proxy(app2)
def dum(self, obj2: t.Any, **kwa: 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 dum2(self, obj3: t.Any, fp2: t.IO[str], **kwa2: 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.
"""
fp2.write(self.dum(obj3, **kwa2))
def loa(self, s: str | bytes, **kwa3: 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 loa2(self, fp3: t.IO[t.AnyStr], **kwa4: 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.loa(fp3.read(), **kwa4)
def prepare(
self, arg: tuple[t.Any, ...], kwa5: dict[str, t.Any]
) -> t.Any:
if arg and kwa5:
raise TypeError("app.json.response() takes either args or kwargs, not both")
if not arg and not kwa5:
return None
if len(arg) == 1:
return arg[0]
return arg or kwa5
def res(self, *arg2: t.Any, **kwa6: 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.
"""
obj4 = self.prepare(arg2, kwa6)
return self._app.response_class(self.dum(obj4), mimetype="application/json")
Run 1
The code has clear documentation and logical class structure, which aids understanding intent. However, variable and method names are deliberately cryptic (e.g., 'dum', 'loa', 'res', 'obj2', 'kwa6') making the code much harder to follow. Nesting is shallow, but action granularity suffers in lines like 'return self._app.response_class(self.dum(obj4), mimetype=...)' combining multiple operations. Reading flow is disrupted by repetitive, ambiguous parameters and incomplete method implementations. Documentation partially mitigates but does not overcome the poor readability of core code.
Run 2
The code has reasonable formatting, spacing, and docstrings, but it is severely hurt by obfuscated naming. Method names like `dum`, `dum2`, `loa`, `loa2`, and parameters like `app2`, `obj2`, `obj3`, `kwa`, `kw2`, `kwa3`, etc., hide the intended purpose and undermine clarity of intent. The original concepts (`dumps`, `loads`, `app`, `obj`, `kwargs`, `fp`) are evident, suggesting deliberate distortion. The class docstring is clear, but method bodies and signatures are ambiguous. Structure is linear and nesting is low, aiding readability, but action granularity and reading flow degrade due to unclear naming. Code length is acceptable. Overall, the structure is sound, but the naming makes it hard to understand quickly, landing it at a moderate-low readability score.
Run 3
The code has a clear class-level structure and docstrings, but readability is severely undermined by obscure naming conventions. Method names like 'dum', 'dum2', 'loa', 'loa2', and 'res' are cryptic abbreviations that obscure intent. Parameter names such as 'app2', 'obj2', 'kwa3', 'fp2', and 'kwa5' are meaningless and confusing, despite type hints. The 'prepare' method's logic is moderately readable but the surrounding naming inconsistencies break natural reading flow. Action granularity is generally acceptable, with one operation per line, but the poor naming forces readers to constantly refer back to docstrings. Nesting is flat, which is good, but code length is somewhat inflated by redundant parameter renaming. Overall, the structure is logical but the naming choices make the code difficult to scan and understand without significant effort.
Run 1
Code Structure: Methods are logically grouped in a provider class, with serialization, deserialization, argument preparation, and response creation clearly separated. Nesting: Flat control flow and early returns make the code easy to follow. Clarity of intent: Type annotations and docstrings explain behavior, but abbreviated method names such as dum, loa, and res, plus numbered variables, obscure meaning. Docstrings reference names that differ from actual parameters and methods, creating confusion. App and Response are not defined or imported in the snippet. Code length: Implementations are concise, although extensive documentation dominates the code and several imports are unused. Action granularity: Statements generally perform one clear action per line; composed calls remain simple. Reading flow: The progression from basic operations to response construction is natural, but inconsistent naming and documentation interrupt comprehension.
Run 2
Code Structure: Methods are logically grouped in a single provider class, separating serialization, deserialization, argument preparation, and response creation. Nesting: Shallow conditionals and early returns keep control flow easy to follow. Clarity of intent: Docstrings and type annotations explain the purpose, but abbreviated names such as dum, loa, and res, plus numbered parameters, obscure meaning. Documentation references dumps, loads, and parameter names that do not match the implementation; App and Response are not defined or imported in the snippet. Code length: Implementations are concise, although documentation dominates and several imports are unused. Action granularity: Most lines perform one clear action; nested calls remain simple. Reading flow: The method sequence is natural, but inconsistent naming and documentation mismatches interrupt comprehension.
Run 3
Code Structure: Methods are logically grouped within a single provider class, separating serialization, deserialization, argument preparation, and response creation. Nesting: Shallow conditionals and early returns keep control flow simple. Clarity of intent: Docstrings and type annotations explain the purpose, but abbreviated names such as dum, loa, and res, numbered parameters, and documentation referring to different method and parameter names create confusion. App and Response are also not defined or imported in the snippet. Code length: Implementations are concise, although extensive documentation adds reading overhead. Action granularity: Statements generally perform one clear action per line; nested calls remain manageable. Reading flow: Method ordering is natural and formatting is consistent, but naming inconsistencies interrupt comprehension. Overall, the organization is readable, while unclear identifiers and mismatched documentation significantly reduce clarity.