django-orjson 1.0.0__py3-none-any.whl

django_orjson/__init__.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import datetime
+import decimal
+from typing import Any
+
+from django.utils.duration import duration_iso_string
+from django.utils.functional import Promise
+
+
+def default(obj: Any) -> Any:
+    if isinstance(obj, datetime.timedelta):
+        return duration_iso_string(obj)
+    if isinstance(obj, (decimal.Decimal, Promise)):
+        return str(obj)
+    raise TypeError

django_orjson/apps.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from django.apps import AppConfig
+
+
+class DjangoOrjsonConfig(AppConfig):
+    name = "django_orjson"
+    verbose_name = "django-orjson"

django_orjson/html.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+import orjson
+from django.utils.html import format_html
+from django.utils.safestring import SafeString, mark_safe
+
+from django_orjson import default as _default
+
+_json_script_escapes = {
+    ord(">"): "\\u003E",
+    ord("<"): "\\u003C",
+    ord("&"): "\\u0026",
+}
+
+
+def json_script(
+    value: Any,
+    element_id: str | None = None,
+    default: Callable[[Any], Any] = _default,
+    option: int | None = None,
+) -> SafeString:
+    """
+    Escape all the HTML/XML special characters with their unicode escapes, so
+    value is safe to be output anywhere except for inside a tag attribute. Wrap
+    the escaped JSON in a script tag.
+    """
+    json_str = (
+        orjson.dumps(value, default=default, option=option)
+        .decode()
+        .translate(_json_script_escapes)
+    )
+    if element_id:
+        template = '<script id="{}" type="application/json">{}</script>'
+        args: tuple[Any, ...] = (element_id, mark_safe(json_str))
+    else:
+        template = '<script type="application/json">{}</script>'
+        args = (mark_safe(json_str),)
+    return format_html(template, *args)

django_orjson/http.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+import orjson
+from django.http import HttpResponse
+
+from django_orjson import default
+
+
+class JsonResponse(HttpResponse):
+    """
+    An HTTP response class that consumes data to be serialized to JSON.
+
+    :param data: Data to be dumped into json.
+    :param default: A callable that gets called for objects that can’t
+      otherwise be serialized. It should return a JSON encodable version of the
+      object or raise a TypeError.
+    :param option: A bitfield of orjson options.
+    """
+
+    def __init__(
+        self,
+        data: Any,
+        default: Callable[[Any], Any] = default,
+        option: int | None = None,
+        **kwargs: Any,
+    ) -> None:
+        kwargs.setdefault("content_type", "application/json")
+        content = orjson.dumps(data, default=default, option=option)
+        super().__init__(content=content, **kwargs)

django_orjson/rest_framework.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+import orjson
+from django.conf import settings
+from rest_framework.exceptions import ParseError
+from rest_framework.parsers import JSONParser as BaseJSONParser
+from rest_framework.renderers import JSONRenderer as BaseJSONRenderer
+
+from django_orjson import default as django_orjson_default
+
+
+class JSONRenderer(BaseJSONRenderer):  # type: ignore[misc]
+    default: Callable[[Any], Any] = staticmethod(django_orjson_default)
+    option: int = 0
+
+    def render(
+        self,
+        data: Any,
+        accepted_media_type: str | None = None,
+        renderer_context: dict[str, Any] | None = None,
+    ) -> bytes:
+        if data is None:
+            return b""
+
+        renderer_context = renderer_context or {}
+        indent = self.get_indent(accepted_media_type, renderer_context)
+
+        option = self.option
+        if indent is not None:
+            option |= orjson.OPT_INDENT_2
+
+        ret: bytes = orjson.dumps(data, default=self.default, option=option)
+        return ret
+
+
+class JSONParser(BaseJSONParser):  # type: ignore[misc]
+    renderer_class = JSONRenderer
+
+    def parse(
+        self,
+        stream: Any,
+        media_type: str | None = None,
+        parser_context: dict[str, Any] | None = None,
+    ) -> Any:
+        parser_context = parser_context or {}
+        encoding = parser_context.get("encoding", settings.DEFAULT_CHARSET)
+        data = stream.read()
+
+        if isinstance(data, bytes) and encoding.lower().replace("_", "-") not in (
+            "utf-8",
+            "utf8",
+        ):
+            data = data.decode(encoding)
+
+        try:
+            return orjson.loads(data)
+        except ValueError as exc:
+            raise ParseError(f"JSON parse error - {exc}") from exc

django_orjson/serializers/json.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import Any
+
+import orjson
+from django.core.serializers.base import DeserializationError
+from django.core.serializers.json import Deserializer as JSONDeserializer
+from django.core.serializers.json import Serializer as JSONSerializer
+from django.core.serializers.python import Deserializer as PythonDeserializer
+
+from django_orjson import default
+
+
+class Serializer(JSONSerializer):
+    _orjson_option: int | None
+
+    def _init_options(self) -> None:
+        super()._init_options()  # type: ignore [misc]
+        self._orjson_option = (
+            orjson.OPT_INDENT_2 if self.options.get("indent") else None
+        )
+
+    def end_object(self, obj: Any) -> None:
+        if not self.first:
+            self.stream.write(",")
+            if not self._orjson_option:
+                self.stream.write(" ")
+        if self._orjson_option:
+            self.stream.write("\n")
+        self.stream.write(
+            orjson.dumps(
+                self.get_dump_object(obj),
+                default=default,
+                option=self._orjson_option,
+            ).decode()
+        )
+        self._current = None
+
+
+class Deserializer(JSONDeserializer):
+    def __init__(self, stream_or_string: Any, **options: Any) -> None:
+        if not isinstance(stream_or_string, (bytes, str)):
+            stream_or_string = stream_or_string.read()
+        try:
+            objects = orjson.loads(stream_or_string)
+        except Exception as exc:
+            raise DeserializationError(str(exc)) from exc
+        PythonDeserializer.__init__(self, objects, **options)

django_orjson/serializers/jsonl.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from collections.abc import Generator
+from typing import Any
+
+import orjson
+from django.core.serializers.base import DeserializationError
+from django.core.serializers.jsonl import Deserializer as JSONLDeserializer
+from django.core.serializers.jsonl import Serializer as JSONLSerializer
+from django.core.serializers.python import Deserializer as PythonDeserializer
+
+from django_orjson import default
+
+
+class Serializer(JSONLSerializer):
+    def _init_options(self) -> None:
+        self._current = None
+
+    def end_object(self, obj: Any) -> None:
+        self.stream.write(
+            orjson.dumps(self.get_dump_object(obj), default=default).decode()
+        )
+        self.stream.write("\n")
+        self._current = None
+
+
+class Deserializer(JSONLDeserializer):
+    # Copy-paste-modified from upstream: JSONLDeserializer.__init__ hardcodes a
+    # call to its own _get_lines(), so we must skip it and call PythonDeserializer
+    # directly to substitute our orjson-based _get_lines().
+    def __init__(self, stream_or_string: Any, **options: Any) -> None:
+        if isinstance(stream_or_string, bytes):
+            stream_or_string = stream_or_string.decode()
+        if isinstance(stream_or_string, str):
+            stream_or_string = stream_or_string.splitlines()
+        PythonDeserializer.__init__(self, self._get_lines(stream_or_string), **options)
+
+    @staticmethod
+    def _get_lines(
+        stream: Any,
+    ) -> Generator[Any, None, None]:
+        for line in stream:
+            if not line.strip():
+                continue
+            try:
+                yield orjson.loads(line)
+            except Exception as exc:
+                raise DeserializationError(str(exc)) from exc

django_orjson/sessions.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from django_orjson.signing import OrjsonSerializer
+
+__all__ = ["OrjsonSerializer"]

django_orjson/signing.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import Any
+
+import orjson
+
+from django_orjson import default as _default
+
+
+class OrjsonSerializer:
+    def dumps(self, obj: Any) -> bytes:
+        value: bytes = orjson.dumps(obj, default=_default)
+        return value
+
+    def loads(self, data: bytes) -> Any:
+        return orjson.loads(data)

django_orjson/templatetags/django_orjson.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import Any
+
+from django import template
+from django.utils.safestring import SafeString
+
+from django_orjson.html import json_script as _json_script
+
+register = template.Library()
+
+
+@register.filter(is_safe=True)
+def json_script(value: Any, element_id: str | None = None) -> SafeString:
+    """
+    Output value JSON-encoded with orjson, wrapped in a
+    <script type="application/json"> tag (with an optional id).
+    """
+    return _json_script(value, element_id)

django_orjson/test.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from typing import Any
+
+import orjson
+from django.test import SimpleTestCase as DjangoSimpleTestCase
+from django.test.client import JSON_CONTENT_TYPE_RE
+from django.test.client import AsyncClient as DjangoAsyncClient
+from django.test.client import Client as DjangoClient
+
+from django_orjson import default
+
+
+class OrjsonMixin:
+    def _encode_json(self, data: Any, content_type: str) -> Any:
+        should_encode = JSON_CONTENT_TYPE_RE.match(content_type) and isinstance(
+            data, (dict, list, tuple)
+        )
+        return orjson.dumps(data, default=default) if should_encode else data
+
+    def _parse_json(self, response: Any, **extra: Any) -> Any:
+        if extra:
+            raise TypeError("orjson.loads() does not accept keyword arguments")
+        if not hasattr(response, "_json"):
+            content_type = response.get("Content-Type")
+            if not JSON_CONTENT_TYPE_RE.match(content_type):
+                raise ValueError(
+                    f'Content-Type header is "{content_type}", not "application/json"'
+                )
+
+            response._json = orjson.loads(response.content)
+        return response._json
+
+
+class AsyncClient(OrjsonMixin, DjangoAsyncClient):
+    pass
+
+
+class Client(OrjsonMixin, DjangoClient):
+    pass
+
+
+class SimpleTestCase(DjangoSimpleTestCase):
+    client_class = Client
+    async_client_class = AsyncClient
+
+    def assertJSONEqual(
+        self, raw: str | bytes | bytearray, expected_data: Any, msg: str | None = None
+    ) -> None:
+        try:
+            data = orjson.loads(raw)
+        except orjson.JSONDecodeError:
+            self.fail(f"First argument is not valid JSON: {raw!r}")
+        if isinstance(expected_data, (str, bytes, bytearray)):
+            try:
+                expected_data = orjson.loads(expected_data)
+            except orjson.JSONDecodeError:
+                self.fail(f"Second argument is not valid JSON: {expected_data!r}")
+        self.assertEqual(data, expected_data, msg=msg)
+
+    def assertJSONNotEqual(
+        self, raw: str | bytes | bytearray, expected_data: Any, msg: str | None = None
+    ) -> None:
+        try:
+            data = orjson.loads(raw)
+        except orjson.JSONDecodeError:
+            self.fail(f"First argument is not valid JSON: {raw!r}")
+        if isinstance(expected_data, (str, bytes, bytearray)):
+            try:
+                expected_data = orjson.loads(expected_data)
+            except orjson.JSONDecodeError:
+                self.fail(f"Second argument is not valid JSON: {expected_data!r}")
+        self.assertNotEqual(data, expected_data, msg=msg)

django_orjson-1.0.0.dist-info/METADATA

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: django-orjson
+Version: 1.0.0
+Summary: orjson-powered utilities for Django.
+Author-email: Adam Johnson <me@adamj.eu>
+License-Expression: MIT
+Project-URL: Changelog, https://django-orjson.readthedocs.io/en/latest/changelog.html
+Project-URL: Documentation, https://django-orjson.readthedocs.io/
+Project-URL: Funding, https://adamj.eu/books/
+Project-URL: Repository, https://github.com/adamchainz/django-orjson
+Keywords: Django
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Framework :: Django :: 6.1
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: django>=5.2
+Requires-Dist: orjson<4,>=3.10
+Provides-Extra: drf
+Requires-Dist: djangorestframework>=3.16; extra == "drf"
+Dynamic: license-file
+
+=============
+django-orjson
+=============
+
+.. image:: https://img.shields.io/readthedocs/django-orjson?style=for-the-badge
+   :target: https://django-orjson.readthedocs.io/en/latest/
+
+.. image:: https://img.shields.io/github/actions/workflow/status/adamchainz/django-orjson/main.yml.svg?branch=main&style=for-the-badge
+   :target: https://github.com/adamchainz/django-orjson/actions?workflow=CI
+
+.. image:: https://img.shields.io/badge/Coverage-100%25-success?style=for-the-badge
+   :target: https://github.com/adamchainz/django-orjson/actions?workflow=CI
+
+.. image:: https://img.shields.io/pypi/v/django-orjson.svg?style=for-the-badge
+   :target: https://pypi.org/project/django-orjson/
+
+.. image:: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=for-the-badge
+   :target: https://github.com/pre-commit/pre-commit
+   :alt: pre-commit
+
+----
+
+.. figure:: https://raw.githubusercontent.com/adamchainz/django-orjson/main/docs/_static/logo.svg
+   :alt: django-orjson logo
+   :align: center
+
+`orjson <https://github.com/ijl/orjson>`__-powered utilities for Django.
+
+Documentation
+-------------
+
+Please see https://django-orjson.readthedocs.io/.

django_orjson-1.0.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+django_orjson/__init__.py,sha256=R6JVxc23ve-euyAR6m09KxzF4E_5KfTvsLi3xZAAhAE,401
+django_orjson/apps.py,sha256=iRMUmuove5vx_Kp9y0Uj1ey9MQQZs-YWDxkvd0wncZ4,171
+django_orjson/html.py,sha256=Qj6j70F_1sYSXgIC1qUNQw_FT4_oItOugesaPP9oZD4,1190
+django_orjson/http.py,sha256=ufqYygBr0ZZJQwDKGnN6zGUagPohRe3Y-j28HAZ7YtM,948
+django_orjson/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_orjson/rest_framework.py,sha256=WocWiQvSqKAtM2DXKnbAp3nhfgxdd2BtNC_-9trIvt0,1813
+django_orjson/sessions.py,sha256=RlYTnBbyhlny6yhcIuH-YL7Hpxlf4XZ_pT8SCptMoFk,119
+django_orjson/signing.py,sha256=sB_HfYQ2uR1VEyfUNwNot9wL6EefbjltByWKWawNYzo,343
+django_orjson/test.py,sha256=S36PkwwD0Cx_cSp5auESSNHoQcBAVKikz4muGabttyk,2628
+django_orjson/serializers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_orjson/serializers/json.py,sha256=cd6DvsyqHVvcNc6SrIvxbTfv3bGjLTcqi7t3MIi69E0,1600
+django_orjson/serializers/jsonl.py,sha256=IrZiOEEEnQZDmus8ghUnAQ7XZgQ5dlJ6Qc1WUfjqHcU,1734
+django_orjson/templatetags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_orjson/templatetags/django_orjson.py,sha256=yxDBQMfV9VLNgTR5zvqkCqKTx21v_xhdETCtG-xB370,512
+django_orjson-1.0.0.dist-info/licenses/LICENSE,sha256=blVuFA7Qdp2_CcTyGXLxA4CsHsAjAquxVc4O6ODqye4,1069
+django_orjson-1.0.0.dist-info/METADATA,sha256=09dAqQdtWnXD5wM8x9RLhYjdAkUTJMH__JQ0G7qiZNU,2599
+django_orjson-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+django_orjson-1.0.0.dist-info/top_level.txt,sha256=uKNVpyaZsD5ryVJrf453yLl6Gl2JdF9ubLFZQJ65K8c,14
+django_orjson-1.0.0.dist-info/RECORD,,

django_orjson-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

django_orjson-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Adam Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

django_orjson-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+django_orjson