diff options
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | python-drf-orjson-renderer.spec | 345 | ||||
| -rw-r--r-- | sources | 1 |
3 files changed, 347 insertions, 0 deletions
@@ -0,0 +1 @@ +/drf_orjson_renderer-1.7.1.tar.gz diff --git a/python-drf-orjson-renderer.spec b/python-drf-orjson-renderer.spec new file mode 100644 index 0000000..557a47f --- /dev/null +++ b/python-drf-orjson-renderer.spec @@ -0,0 +1,345 @@ +%global _empty_manifest_terminate_build 0 +Name: python-drf-orjson-renderer +Version: 1.7.1 +Release: 1 +Summary: Django RestFramework JSON Renderer Backed by orjson +License: MIT +URL: https://github.com/brianjbuck/drf_orjson_renderer +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/d5/c2/20717ad18ad22a2538dc7376743a1e9add5a90b49a153696a35468effba7/drf_orjson_renderer-1.7.1.tar.gz +BuildArch: noarch + +Requires: python3-django +Requires: python3-djangorestframework +Requires: python3-orjson + +%description +[](https://github.com/brianjbuck/drf_orjson_renderer/actions/workflows/main.yml) +`drf_orjson_renderer` is JSON renderer and parser for Django Rest Framework +using the [orjson](https://github.com/ijl/orjson) library. Backed by +[Rust](https://www.rust-lang.org/), orjson is safe, correct and _fast_. ⚡️ +In addition, unlike some performance optimized DRF renderers, It also renders +pretty printed JSON when requests are made via RestFramework's BrowsableAPI. +You get: +- The safety of Rust +- The speed of orjson when requests are made with `Accept: appliation/json` HTTP + header or when requests are made with an unspecified `Accept` header. +- The convenience of formatted output when requested with `Accept: text/html`. +- The ability to pass your own `default` function definition. +## Installation +`pip install drf_orjson_renderer` +You can then set the `ORJSONRenderer` class as your default renderer in your `settings.py` +```Python +REST_FRAMEWORK = { + "DEFAULT_RENDERER_CLASSES": ( + "drf_orjson_renderer.renderers.ORJSONRenderer", + "rest_framework.renderers.BrowsableAPIRenderer", + ), +} +``` +To modify how data is serialized, specify options in your `settings.py` +```Python +REST_FRAMEWORK = { + "ORJSON_RENDERER_OPTIONS": ( + orjson.OPT_NON_STR_KEYS, + orjson.OPT_SERIALIZE_DATACLASS, + orjson.OPT_SERIALIZE_NUMPY, + ), +} +``` +Also you can set the `ORJSONParser` class as your default parser in your `settings.py` +```Python +REST_FRAMEWORK = { + "DEFAULT_PARSER_CLASSES": ( + "drf_orjson_renderer.parsers.ORJSONParser", + ), +} +``` +## Passing Your Own `default` Function +By default, the `ORJSONRenderer` will pass a `default` function as a helper for +serializing objects that orjson doesn't recognize. That should cover the most +common cases found in a Django web application. If you find you have an object +it doesn't recognize you can pass your own default function by overriding the +`get_renderer_context()` method of your view: +```Python +from rest_framework.views import APIView +from rest_framework.response import Response +class MyView(APIView): + def default(self, obj): + if isinstance(obj, MyComplexData): + return dict(obj) + def get_renderer_context(self): + renderer_context = super().get_renderer_context() + renderer_context["default_function"] = self.default + return renderer_context + def get(self, request, *args, **kwargs): + my_complex_data = MyComplexData() + return Response(data=my_complex_data) +``` +If you know your data is already in a format orjson natively +[recognizes](https://github.com/ijl/orjson/#types) you can get a small +performance boost by passing `None` to the `renderer_context`: +```Python +def get_renderer_context(self): + renderer_context = super().get_renderer_context() + renderer_context["default_function"] = None + return renderer_context +``` +As of ORJSON version 3, 2-space indenting is supported in serialization. In +order to take advantage of the RestFramework Browsable API, when the +requested media type is not `application/json`, the ORJSON renderer will add +`orjson.OPT_INDENT_2` to the options mask to pretty print your output. +## Numpy +When this package was originally written ORJSON did not natively support +serializing numpy types. This package provided an encoder class that +overrides the DjangoJSONEncoder with support for numpy types. This encoder +is no longer necessary but included for backwards compatibility. +```Python +from drf_orjson_renderer.encoders import DjangoNumpyJSONEncoder +from rest_framework.views import APIView +class MyView(APIView): + def get_renderer_context(self): + renderer_context = super().get_renderer_context() + renderer_context["django_encoder_class"] = DjangoNumpyJSONEncoder + return renderer_context +``` +## Benchmarks +See the [orjson Benchmarks](https://github.com/ijl/orjson#performance) for more information + +%package -n python3-drf-orjson-renderer +Summary: Django RestFramework JSON Renderer Backed by orjson +Provides: python-drf-orjson-renderer +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-drf-orjson-renderer +[](https://github.com/brianjbuck/drf_orjson_renderer/actions/workflows/main.yml) +`drf_orjson_renderer` is JSON renderer and parser for Django Rest Framework +using the [orjson](https://github.com/ijl/orjson) library. Backed by +[Rust](https://www.rust-lang.org/), orjson is safe, correct and _fast_. ⚡️ +In addition, unlike some performance optimized DRF renderers, It also renders +pretty printed JSON when requests are made via RestFramework's BrowsableAPI. +You get: +- The safety of Rust +- The speed of orjson when requests are made with `Accept: appliation/json` HTTP + header or when requests are made with an unspecified `Accept` header. +- The convenience of formatted output when requested with `Accept: text/html`. +- The ability to pass your own `default` function definition. +## Installation +`pip install drf_orjson_renderer` +You can then set the `ORJSONRenderer` class as your default renderer in your `settings.py` +```Python +REST_FRAMEWORK = { + "DEFAULT_RENDERER_CLASSES": ( + "drf_orjson_renderer.renderers.ORJSONRenderer", + "rest_framework.renderers.BrowsableAPIRenderer", + ), +} +``` +To modify how data is serialized, specify options in your `settings.py` +```Python +REST_FRAMEWORK = { + "ORJSON_RENDERER_OPTIONS": ( + orjson.OPT_NON_STR_KEYS, + orjson.OPT_SERIALIZE_DATACLASS, + orjson.OPT_SERIALIZE_NUMPY, + ), +} +``` +Also you can set the `ORJSONParser` class as your default parser in your `settings.py` +```Python +REST_FRAMEWORK = { + "DEFAULT_PARSER_CLASSES": ( + "drf_orjson_renderer.parsers.ORJSONParser", + ), +} +``` +## Passing Your Own `default` Function +By default, the `ORJSONRenderer` will pass a `default` function as a helper for +serializing objects that orjson doesn't recognize. That should cover the most +common cases found in a Django web application. If you find you have an object +it doesn't recognize you can pass your own default function by overriding the +`get_renderer_context()` method of your view: +```Python +from rest_framework.views import APIView +from rest_framework.response import Response +class MyView(APIView): + def default(self, obj): + if isinstance(obj, MyComplexData): + return dict(obj) + def get_renderer_context(self): + renderer_context = super().get_renderer_context() + renderer_context["default_function"] = self.default + return renderer_context + def get(self, request, *args, **kwargs): + my_complex_data = MyComplexData() + return Response(data=my_complex_data) +``` +If you know your data is already in a format orjson natively +[recognizes](https://github.com/ijl/orjson/#types) you can get a small +performance boost by passing `None` to the `renderer_context`: +```Python +def get_renderer_context(self): + renderer_context = super().get_renderer_context() + renderer_context["default_function"] = None + return renderer_context +``` +As of ORJSON version 3, 2-space indenting is supported in serialization. In +order to take advantage of the RestFramework Browsable API, when the +requested media type is not `application/json`, the ORJSON renderer will add +`orjson.OPT_INDENT_2` to the options mask to pretty print your output. +## Numpy +When this package was originally written ORJSON did not natively support +serializing numpy types. This package provided an encoder class that +overrides the DjangoJSONEncoder with support for numpy types. This encoder +is no longer necessary but included for backwards compatibility. +```Python +from drf_orjson_renderer.encoders import DjangoNumpyJSONEncoder +from rest_framework.views import APIView +class MyView(APIView): + def get_renderer_context(self): + renderer_context = super().get_renderer_context() + renderer_context["django_encoder_class"] = DjangoNumpyJSONEncoder + return renderer_context +``` +## Benchmarks +See the [orjson Benchmarks](https://github.com/ijl/orjson#performance) for more information + +%package help +Summary: Development documents and examples for drf-orjson-renderer +Provides: python3-drf-orjson-renderer-doc +%description help +[](https://github.com/brianjbuck/drf_orjson_renderer/actions/workflows/main.yml) +`drf_orjson_renderer` is JSON renderer and parser for Django Rest Framework +using the [orjson](https://github.com/ijl/orjson) library. Backed by +[Rust](https://www.rust-lang.org/), orjson is safe, correct and _fast_. ⚡️ +In addition, unlike some performance optimized DRF renderers, It also renders +pretty printed JSON when requests are made via RestFramework's BrowsableAPI. +You get: +- The safety of Rust +- The speed of orjson when requests are made with `Accept: appliation/json` HTTP + header or when requests are made with an unspecified `Accept` header. +- The convenience of formatted output when requested with `Accept: text/html`. +- The ability to pass your own `default` function definition. +## Installation +`pip install drf_orjson_renderer` +You can then set the `ORJSONRenderer` class as your default renderer in your `settings.py` +```Python +REST_FRAMEWORK = { + "DEFAULT_RENDERER_CLASSES": ( + "drf_orjson_renderer.renderers.ORJSONRenderer", + "rest_framework.renderers.BrowsableAPIRenderer", + ), +} +``` +To modify how data is serialized, specify options in your `settings.py` +```Python +REST_FRAMEWORK = { + "ORJSON_RENDERER_OPTIONS": ( + orjson.OPT_NON_STR_KEYS, + orjson.OPT_SERIALIZE_DATACLASS, + orjson.OPT_SERIALIZE_NUMPY, + ), +} +``` +Also you can set the `ORJSONParser` class as your default parser in your `settings.py` +```Python +REST_FRAMEWORK = { + "DEFAULT_PARSER_CLASSES": ( + "drf_orjson_renderer.parsers.ORJSONParser", + ), +} +``` +## Passing Your Own `default` Function +By default, the `ORJSONRenderer` will pass a `default` function as a helper for +serializing objects that orjson doesn't recognize. That should cover the most +common cases found in a Django web application. If you find you have an object +it doesn't recognize you can pass your own default function by overriding the +`get_renderer_context()` method of your view: +```Python +from rest_framework.views import APIView +from rest_framework.response import Response +class MyView(APIView): + def default(self, obj): + if isinstance(obj, MyComplexData): + return dict(obj) + def get_renderer_context(self): + renderer_context = super().get_renderer_context() + renderer_context["default_function"] = self.default + return renderer_context + def get(self, request, *args, **kwargs): + my_complex_data = MyComplexData() + return Response(data=my_complex_data) +``` +If you know your data is already in a format orjson natively +[recognizes](https://github.com/ijl/orjson/#types) you can get a small +performance boost by passing `None` to the `renderer_context`: +```Python +def get_renderer_context(self): + renderer_context = super().get_renderer_context() + renderer_context["default_function"] = None + return renderer_context +``` +As of ORJSON version 3, 2-space indenting is supported in serialization. In +order to take advantage of the RestFramework Browsable API, when the +requested media type is not `application/json`, the ORJSON renderer will add +`orjson.OPT_INDENT_2` to the options mask to pretty print your output. +## Numpy +When this package was originally written ORJSON did not natively support +serializing numpy types. This package provided an encoder class that +overrides the DjangoJSONEncoder with support for numpy types. This encoder +is no longer necessary but included for backwards compatibility. +```Python +from drf_orjson_renderer.encoders import DjangoNumpyJSONEncoder +from rest_framework.views import APIView +class MyView(APIView): + def get_renderer_context(self): + renderer_context = super().get_renderer_context() + renderer_context["django_encoder_class"] = DjangoNumpyJSONEncoder + return renderer_context +``` +## Benchmarks +See the [orjson Benchmarks](https://github.com/ijl/orjson#performance) for more information + +%prep +%autosetup -n drf-orjson-renderer-1.7.1 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-drf-orjson-renderer -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Tue Apr 11 2023 Python_Bot <Python_Bot@openeuler.org> - 1.7.1-1 +- Package Spec generated @@ -0,0 +1 @@ +b13230b04603bac7d187b34ae562fa0e drf_orjson_renderer-1.7.1.tar.gz |