django-fastdrf 0.1.0__py3-none-any.whl

django_fastdrf-0.1.0.dist-info/METADATA

@@ -0,0 +1,214 @@
+Metadata-Version: 2.5
+Name: django-fastdrf
+Version: 0.1.0
+Summary: Opt-in serializer and query optimizations for synchronous Django REST framework.
+Project-URL: Homepage, https://github.com/ctolon/django-fastdrf
+Project-URL: Documentation, https://github.com/ctolon/django-fastdrf/tree/main/docs
+Project-URL: Changelog, https://github.com/ctolon/django-fastdrf/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/ctolon/django-fastdrf/issues
+Project-URL: Source, https://github.com/ctolon/django-fastdrf
+Author: Cevat Batuhan Tolon
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+License-File: NOTICE
+Keywords: django,django-rest-framework,msgspec,performance,serializers
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Framework :: Django :: 6.1
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: django>=5.2
+Requires-Dist: djangorestframework>=3.16
+Provides-Extra: msgspec
+Requires-Dist: msgspec>=0.19; extra == 'msgspec'
+Provides-Extra: pydantic
+Requires-Dist: pydantic>=2.9; extra == 'pydantic'
+Description-Content-Type: text/markdown
+
+# django-fastdrf
+
+Opt-in serializer, query and response optimizations for synchronous
+[Django REST framework](https://www.django-rest-framework.org/) projects.
+
+django-fastdrf is for DRF projects that stay synchronous (WSGI, or ASGI with
+synchronous views) and want less time per request without leaving DRF. It
+adds subclasses, mixins and settings next to DRF's own classes. Each
+optimization is enabled explicitly, per project, per view or per serializer,
+and falls back to DRF's code wherever it cannot produce DRF's result.
+
+It does not replace or patch any Django or DRF class, add async support, or
+change DRF's validation errors.
+
+## Installation
+
+```console
+pip install django-fastdrf
+```
+
+The distribution is `django-fastdrf`; the import name is `fastdrf`. Two
+extras install the optional backends:
+
+```console
+pip install "django-fastdrf[msgspec]"    # msgspec backend, renderer, parser, codec
+pip install "django-fastdrf[pydantic]"   # pydantic backend, schema serializers, codec
+```
+
+Adding `"fastdrf"` to `INSTALLED_APPS` is optional. It registers system checks
+and two management commands; everything else works without it.
+
+## Quick start
+
+Use fastdrf's serializer bases and choose a backend for their output:
+
+```python
+# settings.py
+FASTDRF = {
+    "SERIALIZER_BACKEND": "msgspec",  # or "pydantic", or "python" (no dependency)
+    "CACHE_SERIALIZER_FIELDS": True,
+    "FIELD_COPY_MODE": "compiled",
+}
+```
+
+```python
+# serializers.py
+from fastdrf import serializers
+
+
+class ArticleSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Article
+        fields = ["id", "title", "author", "published_at"]
+        auto_prefetch = True
+```
+
+```python
+# views.py
+from rest_framework import viewsets
+
+from fastdrf.views import DispatchOptimizationMixin, QueryOptimizationMixin
+
+
+class ArticleViewSet(
+    DispatchOptimizationMixin, QueryOptimizationMixin, viewsets.ModelViewSet
+):
+    queryset = Article.objects.all()
+    serializer_class = ArticleSerializer
+```
+
+`.data`, `.is_valid()`, `.save()`, `many=True`, routers, pagination,
+permissions and error responses are DRF's. With `"fastdrf"` in
+`INSTALLED_APPS`, this command lists which serializers the backend compiles,
+and why the others stay on DRF:
+
+```console
+python manage.py fastdrf_inspect_serializers
+```
+
+## Features
+
+Serialization:
+
+- Compiled serializer output with the msgspec, pydantic or dependency-free
+  `python` backend, equal to DRF's `.data` in the default strict parity mode
+  ([serializers](https://github.com/ctolon/django-fastdrf/blob/main/docs/serializers.md#output-backends)).
+- Input recognition: JSON input that DRF would accept unchanged is validated
+  by a compiled class; everything else, including every error, is DRF's
+  ([input recognition](https://github.com/ctolon/django-fastdrf/blob/main/docs/serializers.md#input-recognition)).
+- Cached field templates, copied per request with `deepcopy`, a scalar clone
+  or a compiled copy plan
+  ([field caching](https://github.com/ctolon/django-fastdrf/blob/main/docs/serializers.md#field-caching-and-copying)).
+- List serializers whose child refers to the list weakly
+  ([list serializers](https://github.com/ctolon/django-fastdrf/blob/main/docs/serializers.md#list-serializers)).
+- Schema serializers: a msgspec `Struct` or a pydantic model as a DRF
+  serializer, and `SchemaViewMixin` for views
+  ([schema serializers](https://github.com/ctolon/django-fastdrf/blob/main/docs/schema-serializers.md)).
+
+Queries:
+
+- `select_related` and `prefetch_related` derived from the serializer by
+  `QueryOptimizationMixin`, explicit `Meta.prefetch` hints, Django 6.1's
+  `FETCH_MODE`, one query for many-valued primary-key input, and
+  `PrefetchListSerializer` for per-list enrichment
+  ([queries](https://github.com/ctolon/django-fastdrf/blob/main/docs/queries.md)).
+
+Views and responses:
+
+- Dispatch mixins that keep content negotiation and request construction
+  between requests, compiled create and update responses, a `Response` that
+  releases its request objects when closed, and `DataResponse`, rendered
+  without DRF's template response
+  ([views and responses](https://github.com/ctolon/django-fastdrf/blob/main/docs/views.md)).
+- A `JSONRenderer` that keeps its encoder, msgspec's JSON renderer and
+  parser, and msgspec and pydantic codecs for Django's Redis cache
+  ([rendering and codecs](https://github.com/ctolon/django-fastdrf/blob/main/docs/rendering.md)).
+
+Tooling:
+
+- System checks for the `FASTDRF` setting and two management commands:
+  `fastdrf_inspect_serializers` and `fastdrf_convert`, which writes a schema
+  for a serializer or a serializer for a schema
+  ([commands](https://github.com/ctolon/django-fastdrf/blob/main/docs/commands.md)).
+
+## Guarantees and limits
+
+- No Django or DRF class is replaced, patched or monkeypatched. fastdrf's
+  classes are subclasses and mixins that a project selects.
+- Everything is opt-in. With the default settings, fastdrf's serializer bases
+  behave as DRF's.
+- In strict parity, compiled output equals DRF's output; a field, value or
+  hook the compiler cannot prove equal keeps the serializer, or that one
+  source, on DRF. Input recognition never produces an error of its own.
+- Synchronous only: no ORM call becomes asynchronous, and transactions,
+  authentication, permissions, throttling and pagination are DRF's and
+  Django's.
+- Schema serializers, `fast` parity and the msgspec renderer have their own
+  documented output and validation rules; they are not DRF-identical by
+  design.
+- A serializer instance belongs to one request; do not share it between
+  threads.
+
+See [architecture](https://github.com/ctolon/django-fastdrf/blob/main/docs/architecture.md)
+for how the caches are bounded and invalidated, and for the deliberate
+differences.
+
+## Compatibility
+
+| Django | DRF | Python |
+| --- | --- | --- |
+| 5.2 | 3.16, 3.17, 3.18 | 3.12, 3.13, 3.14 |
+| 6.0 | 3.17, 3.18 | 3.12, 3.13, 3.14 |
+| 6.1 | 3.18 | 3.12, 3.13, 3.14 |
+
+The test suite also runs on free-threaded Python 3.14t (Django 6.1,
+DRF 3.18) and at the declared minimum versions (Django 5.2, DRF 3.16,
+msgspec 0.19, pydantic 2.9). `FETCH_MODE` needs Django 6.1.
+
+## Documentation
+
+- [Documentation index](https://github.com/ctolon/django-fastdrf/blob/main/docs/README.md)
+- [Configuration reference](https://github.com/ctolon/django-fastdrf/blob/main/docs/configuration.md)
+- [Example project](https://github.com/ctolon/django-fastdrf/blob/main/examples/blog/README.md):
+  the same API with plain DRF and with fastdrf, with parity tests and a
+  measurement script
+- [Changelog](https://github.com/ctolon/django-fastdrf/blob/main/CHANGELOG.md)
+- [Contributing](https://github.com/ctolon/django-fastdrf/blob/main/CONTRIBUTING.md)
+- [Security policy](https://github.com/ctolon/django-fastdrf/blob/main/SECURITY.md)
+
+## License
+
+BSD 3-Clause. See
+[LICENSE](https://github.com/ctolon/django-fastdrf/blob/main/LICENSE) and
+[NOTICE](https://github.com/ctolon/django-fastdrf/blob/main/NOTICE): the optimizations derive from the aiodrf project, and the list-construction protocol from Django REST framework.

django_fastdrf-0.1.0.dist-info/RECORD

@@ -0,0 +1,44 @@
+fastdrf/__init__.py,sha256=5I3edBDLCmaTShByretrBMm6FtyNFqPlAywvfmXj3fU,99
+fastdrf/_classify.py,sha256=K4mvUSJ8RlwvAwZpNxCdaJcxwchYI-k2YlmMY9cYWcQ,8067
+fastdrf/_compiled.py,sha256=IGePq5r-TXOWacY90MN_KYWH84s2KSONDNRd6gOs0gU,4631
+fastdrf/_field_cache.py,sha256=zOWIef98mMlrcGT_4i47K5abpcBCjj-nfcan8X9Moik,5525
+fastdrf/_field_copy.py,sha256=HTUiH2maQMae_sOexSsMnxCEt6zJAWHnvB63byBLEY4,8938
+fastdrf/_field_options.py,sha256=zBg0PXBlY5SILY4sL8DxK8IiFOXRimsfE-uxAdxzqeY,2772
+fastdrf/_inspection.py,sha256=ll0m5IJUl0aE18TfoCi9RS0rShGG1erAzPvyJ3WvqVA,659
+fastdrf/_relations.py,sha256=qMkgKQVOKl3bFgLLB6NAPZsfAFs2l0x81NZEFEvvZOM,7851
+fastdrf/apps.py,sha256=MrWUij4rMWQeRi7HcqV9x_3TDvUP9mq3C0nk7Z0mWlg,718
+fastdrf/checks.py,sha256=P311eRZecAP0AP8m70GxwTKohWvkzHHB0A6ueXNkkQ8,4184
+fastdrf/codecs.py,sha256=6cprANo93rmc7vx3uZcqeNTEIDrCZtbwWmMlC19oBmg,3613
+fastdrf/compat.py,sha256=WjVmr7qawlkIDYHqAU1rTIJRmFvdrUuYRXWzYIvFdFk,309
+fastdrf/compiler.py,sha256=CDnljlEY3ylKO7tRZgbPaRwUXurAnjW2tf0XVuq1Ch4,66465
+fastdrf/convert.py,sha256=3Fny7qZu8rVX1NDxfDm26BfyuOh0ZaySEe8f9-mk25g,48396
+fastdrf/inputs.py,sha256=NPA3CinEez8n53GXJIAudcNeytrJrnFUl9G7OKcIASI,32656
+fastdrf/list_serializers.py,sha256=Xx8lXG4xaBUaM7iboE4yx6nwEpp60NadRAdK_t8eX6Q,4315
+fastdrf/mixins.py,sha256=zMxSm1HgkMmVWo4gNlvvO-KJwJ7KszR4dfNdewHDsPI,4477
+fastdrf/output.py,sha256=182k315wkYn-of8T8QEvGnVV6ZTz97stBNAw2WS2lXw,5700
+fastdrf/prefetch.py,sha256=FQwnjdDISsfKNcaMqO6M4H4ggsezz--x-P6rv236HZM,11645
+fastdrf/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastdrf/renderers.py,sha256=SF_PwbZ25Ppp9-DfnxqoWI0_ffMuYQBGCqQXADxUI3M,3348
+fastdrf/response.py,sha256=rdQxxT_5H8ctbDatZCzSF3-7tPITB7ZaGnVOFW3zrpk,9584
+fastdrf/serializers.py,sha256=uQhtnYGRNndgjPkHY8nNGja6cjbWP7Rf3JkevlUiTQ8,6842
+fastdrf/settings.py,sha256=S8jfn5dx8y5U4aCvXnFadhW3vD1olDhr4wx2T3TdOuk,4375
+fastdrf/typed.py,sha256=LLljN-olgYWPeYW5IfueKbnKMZGjt6TE2JBBflLKXgA,28120
+fastdrf/utils.py,sha256=yJ0p93NzyFj5KuW8GUTeKdoODBiWwDYEkTMYK_54gco,6200
+fastdrf/views.py,sha256=e3RxOSler5VRxsA6eL3MAg-iHeJ-J3cc50Wencyw6Zk,16156
+fastdrf/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastdrf/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastdrf/management/commands/fastdrf_convert.py,sha256=gF8YJ4NPL_DX3ToUte27ggNU5oh6yvaLD31ffHXdchs,3967
+fastdrf/management/commands/fastdrf_inspect_serializers.py,sha256=SuGsOMxRUoBQh00fB_wChJzim9ccE2i2ETXQCj-KSEc,11069
+fastdrf/msgspec/__init__.py,sha256=P1_WRWIhV3RQBbtzdMeWK2W05qjcfdibFeduxKygX4w,985
+fastdrf/msgspec/compiler.py,sha256=9YbUvhy3ZOjDAcc1-2jduJTu6NdfDr586BgSv7A0vEg,8225
+fastdrf/msgspec/parsers.py,sha256=Bw29XHdkv1onYuMTehfY6GajjiYdWgnbCoB_0g5wsxM,1067
+fastdrf/msgspec/renderers.py,sha256=euFS4ybf4NMlAxkurvL9pxeeYlMDe29TIbtriED27gc,3795
+fastdrf/msgspec/serializers.py,sha256=DocG9PCtpR49Nlos2VGVk9PZbvRh5p9_csV1hTS3HWQ,12897
+fastdrf/pydantic/__init__.py,sha256=Wkl4T1sUef_tvTEetoTkqV1dDd1iKwm7shlJwtRCqe4,639
+fastdrf/pydantic/compiler.py,sha256=3r64qZHcE6HBshX1bRAZWwYn-V7GyGAwhkTaH5IopCc,2836
+fastdrf/pydantic/serializers.py,sha256=jwy2On3dFYEgVyUzQDQqX3NTMkJ1obKU0sJEmASkAko,12268
+django_fastdrf-0.1.0.dist-info/METADATA,sha256=yF-gNJ7S-NesjRLtd7adUDTwaVliDqy53MBX_1a843I,8860
+django_fastdrf-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+django_fastdrf-0.1.0.dist-info/licenses/LICENSE,sha256=rLcfHn1I1iqXETdM-Wi-o3r5l3WbYvqSE_bX-QV74IY,1493
+django_fastdrf-0.1.0.dist-info/licenses/NOTICE,sha256=bpZ9XXWwEQOxItXGwBQXzW_OEPzav_1yHKZSHMc8oWY,494
+django_fastdrf-0.1.0.dist-info/RECORD,,

django_fastdrf-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

django_fastdrf-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, ctolon
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

django_fastdrf-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,8 @@
+django-fastdrf includes code derived from aiodrf, Copyright (c) ctolon,
+distributed under the BSD 3-Clause license included in LICENSE.
+
+The many_init list-construction protocol derives from Django REST framework:
+Copyright (c) 2011-present, Encode OSS Ltd. All rights reserved.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted under the BSD 3-Clause license in LICENSE. The original DRF
+project is https://github.com/encode/django-rest-framework.

fastdrf/__init__.py

@@ -0,0 +1,3 @@
+"""Synchronous, explicitly selected extensions to Django REST framework."""
+
+__version__ = "0.1.0"

fastdrf/_classify.py

@@ -0,0 +1,210 @@
+"""Which serializers are a function of their class; coroutine hooks refused."""
+
+import inspect
+import weakref
+from inspect import iscoroutinefunction
+
+from django.db import models
+from django.utils.choices import CallableChoiceIterator
+from rest_framework import fields, relations, serializers
+
+from fastdrf._inspection import _FIELD_HOOKS, _PLAIN_KWARGS
+from fastdrf.utils import (
+    class_cache,
+    depends_on_classification,
+    is_framework_class,
+    user_defines,
+)
+
+# Exact DRF field classes, defined in DRF's modules: a class of the
+# project's, or one a module only imported, may bind or represent otherwise.
+_BUILTIN_FIELDS = frozenset(
+    value
+    for module in (fields, relations)
+    for value in vars(module).values()
+    if inspect.isclass(value) and value.__module__ == module.__name__
+)
+
+
+@depends_on_classification
+@class_cache
+def _model_fields_call_code(model):
+    """
+    Return True if building a serializer field from a field of ``model`` may
+    call the project's code: callable ``choices`` or ``limit_choices_to``
+    (commonly a query), a ``limit_choices_to`` applied through the related
+    model's default manager of the project's (its ``get_queryset()``), a
+    model field class of the project's, whose attributes DRF reads, or a
+    FilePathField, which lists its directory.
+    """
+    for field in model._meta.get_fields():
+        if isinstance(field, models.FilePathField) or not is_framework_class(
+            type(field)
+        ):
+            return True
+        if isinstance(getattr(field, "choices", None), CallableChoiceIterator):
+            return True
+        limit = getattr(getattr(field, "remote_field", None), "limit_choices_to", None)
+        if callable(limit) or (
+            limit and user_defines(field.related_model._default_manager, "get_queryset")
+        ):
+            return True
+    return False
+
+
+# What DRF sets on a serializer instance over a class attribute of the same
+# name. Any other instance attribute that shadows one of the class may change
+# what DRF does: a method assigned to the instance, fields materialized (and
+# perhaps edited), a ``Meta`` or ``url_field_name`` of its own.
+_DRF_SHADOWS = frozenset({"_creation_counter", "initial", "default_empty_html"})
+
+# Declared serializers are deep-copied into every instance, which builds them
+# again from their arguments; these hooks could make the copy differ.
+_BUILD_HOOKS = (*_FIELD_HOOKS, "bind", "__deepcopy__", "__new__")
+
+# class -> the names an instance must not shadow, or None when it is not static
+_static_classes: weakref.WeakKeyDictionary[type, frozenset[str] | None] = (
+    weakref.WeakKeyDictionary()
+)
+depends_on_classification(_static_classes)
+
+
+def is_static(serializer):
+    """
+    Return True if the fields of ``serializer`` (the child of a list
+    serializer), and those of the serializers nested in it, are a function
+    of its class.
+
+    That holds for an instance built with the usual arguments only that
+    shadows nothing of its class (no fields materialized, no method assigned),
+    of a class that builds its fields with DRF's code alone from declarations
+    and a model, whose declared fields are DRF's, children included, and
+    whose declared serializers are static too. The compiler, the input
+    recognizer and the classification below keep per-class answers for these
+    alone.
+    """
+    if isinstance(serializer, serializers.ListSerializer):
+        serializer = serializer.child
+    names = _instance_shadow_names(type(serializer))
+    return (
+        names is not None
+        and _PLAIN_KWARGS.issuperset(serializer._kwargs)
+        and names.isdisjoint(vars(serializer))
+    )
+
+
+def _instance_shadow_names(cls):
+    """
+    The names an instance of ``cls`` must not set for its fields to be those
+    of its class (:func:`is_static`), or None when they never are.
+    """
+    try:
+        return _static_classes[cls]
+    except KeyError:
+        pass
+    meta = getattr(cls, "Meta", None)
+    model = getattr(meta, "model", None)
+    static = (
+        issubclass(cls, serializers.Serializer)
+        # A child may build fields from its parent's context, or change them
+        # when bound.
+        and not getattr(meta, "depth", 0)
+        and not user_defines(cls, *_BUILD_HOOKS)
+        # The project's code, run whenever a ModelSerializer builds its fields.
+        and not (
+            issubclass(cls, serializers.ModelSerializer)
+            and model is not None
+            and _model_fields_call_code(model)
+        )
+        and all(_static_declaration(field) for field in cls._declared_fields.values())
+    )
+    names = frozenset(dir(cls)) - _DRF_SHADOWS if static else None
+    # Racing threads store the same value.
+    return _static_classes.setdefault(cls, names)
+
+
+def _static_declaration(field):
+    if isinstance(field, serializers.ListSerializer):
+        return not user_defines(field, *_BUILD_HOOKS) and _static_declaration(
+            field.child
+        )
+    if isinstance(field, serializers.BaseSerializer):
+        return _instance_shadow_names(type(field)) is not None
+    # DRF's own fields; a custom one may bind differently per parent. DRF's
+    # collections and to-many relations bind the child they were declared with.
+    return type(field) in _BUILTIN_FIELDS and all(
+        _static_declaration(child)
+        for child in (
+            getattr(field, "child", None),
+            getattr(field, "child_relation", None),
+        )
+        if child is not None
+    )
+
+
+# What DRF materializes on an instance the first time it is read. Once any of
+# these exists, the instance's fields may have been changed; the class says
+# nothing about such an instance.
+_MATERIALIZED = frozenset(
+    {"fields", "_validators", "_readable_fields", "_writable_fields"}
+)
+
+# Static serializer class -> whether its representation has a coroutine hook.
+_class_representation: weakref.WeakKeyDictionary[type, bool] = (
+    weakref.WeakKeyDictionary()
+)
+depends_on_classification(_class_representation)
+
+
+def _classified_by_class(serializer):
+    """
+    Whether :func:`has_async_representation` of ``serializer`` is a property
+    of its class: its fields are (:func:`is_static`), none exists yet, and
+    nothing callable was set on the instance.
+    """
+    state = vars(serializer)
+    return (
+        isinstance(serializer, serializers.Serializer)
+        and is_static(serializer)
+        and _MATERIALIZED.isdisjoint(state)
+        # ``default`` is ``fields.empty``, a class, on every instance.
+        and not any(
+            callable(value) and not isinstance(value, type) for value in state.values()
+        )
+    )
+
+
+def has_async_representation(serializer):
+    """
+    Whether representing ``serializer`` reaches a coroutine function: an
+    ``async def to_representation`` of a serializer or field, or an
+    ``ato_representation`` / ``adata`` of the project's. Such a serializer is
+    not represented by a synchronous plan. A static serializer is answered
+    once per class, without building its fields again.
+    """
+    if not _classified_by_class(serializer):
+        return _async_representation(serializer)
+    cls = type(serializer)
+    try:
+        return _class_representation[cls]
+    except KeyError:
+        pass
+    # Racing threads store the same value.
+    return _class_representation.setdefault(cls, _async_representation(serializer))
+
+
+def _async_representation(serializer):
+    if isinstance(serializer, serializers.ListSerializer):
+        return has_async_representation(serializer.child)
+    if not isinstance(serializer, serializers.Serializer):
+        return iscoroutinefunction(type(serializer).to_representation)
+    if iscoroutinefunction(
+        getattr(type(serializer), "to_representation", None)
+    ) or user_defines(serializer, "ato_representation", "adata"):
+        return True
+    return any(
+        has_async_representation(field)
+        if isinstance(field, serializers.BaseSerializer)
+        else iscoroutinefunction(type(field).to_representation)
+        for field in serializer.fields.values()
+    )

fastdrf/_compiled.py

@@ -0,0 +1,131 @@
+"""``serializer.data`` from a compiled class, for fastdrf's serializer bases."""
+
+from django.db import models
+from rest_framework import serializers
+
+from fastdrf._classify import (
+    _instance_shadow_names,
+    has_async_representation,
+    is_static,
+)
+from fastdrf._inspection import _PLAIN_KWARGS
+from fastdrf.settings import fastdrf_settings
+from fastdrf.utils import user_defines
+
+#: Set by :mod:`fastdrf.mixins` on a serializer that a generic view built,
+#: validated and saved with framework code alone (:func:`fields_from_class`).
+FIELDS_FROM_CLASS = "_fastdrf_fields_from_class"
+
+
+def fields_from_class(serializer):
+    """
+    :func:`~fastdrf._classify.is_static` for a serializer whose fields exist
+    on the instance because framework code built and used them: a generic
+    view's serializer after validation and the save, when no
+    ``get_serializer*`` or ``perform_*`` of the project's and no method of
+    the serializer's class could have edited them. Only the write mixins of
+    :mod:`fastdrf.mixins` mark such an instance (:data:`FIELDS_FROM_CLASS`).
+    """
+    if not vars(serializer).get(FIELDS_FROM_CLASS, False):
+        return False
+    if isinstance(serializer, serializers.ListSerializer):
+        serializer = serializer.child
+    return _instance_shadow_names(type(serializer)) is not None and (
+        _PLAIN_KWARGS.issuperset(serializer._kwargs)
+    )
+
+
+def compiled_data(serializer):
+    """
+    ``serializer.data`` produced by a compiled class, when
+    ``SERIALIZER_BACKEND`` (or ``Meta.serializer_backend``) asks for one and
+    the serializer compiles (see :mod:`fastdrf.compiler`), None for
+    DRF's code.
+    """
+    source = serializer.instance
+    if (
+        (
+            fastdrf_settings.SERIALIZER_BACKEND == "drf"
+            and not _declares_backend(serializer)
+        )
+        or user_defines(serializer, "data")
+        or source is None
+        or getattr(serializer, "_errors", None)
+        or hasattr(serializer, "_data")
+    ):
+        return None
+    from fastdrf.compiler import compiled_for, declines_source
+
+    # A static serializer is looked up by its class before it is classified:
+    # classifying one with nested serializers builds all their fields, which
+    # is what the compiled class saves.
+    if not is_static(serializer) and has_async_representation(serializer):
+        return None
+    encoder = compiled_for(serializer)
+    if encoder is None:
+        return None
+    if not isinstance(serializer, serializers.ListSerializer) and declines_source(
+        serializer, source
+    ):
+        return None
+    return _producer(serializer, encoder, source)
+
+
+def _producer(serializer, encoder, source):
+    if isinstance(serializer, serializers.ListSerializer):
+
+        def produce(serializer):
+            from fastdrf.compiler import declines_source
+
+            items = (
+                source.all()
+                if isinstance(source, models.manager.BaseManager)
+                else source
+            )
+            items = list(items)
+            if declines_source(serializer, items):
+                # DRF's ListSerializer.to_representation, on the items read.
+                serializer._data = serializer.to_representation(items)
+                return serializer.data
+            try:
+                serializer._data = encoder.dump_many(items, serializer.context)
+            except encoder.error as exc:
+                serializer._data = _unreadable(serializer, exc, items)
+            return serializer.data
+
+    else:
+
+        def produce(serializer):
+            try:
+                serializer._data = encoder.dump(source, serializer.context)
+            except encoder.error as exc:
+                serializer._data = _unreadable(serializer, exc, source)
+            return serializer.data
+
+    return produce
+
+
+def _unreadable(serializer, error, source):
+    """
+    DRF's representation of a source the compiled class failed to read, or
+    the backend's ``error`` when that is the result
+    (:func:`fastdrf.compiler.unreadable_source`). The backends take any
+    exception raised while reading an attribute for a missing attribute;
+    DRF's own read raises it as itself.
+    """
+    from fastdrf.compiler import unreadable_source
+
+    if not unreadable_source(serializer, error):
+        raise error
+    return serializer.to_representation(source)
+
+
+def _declares_backend(serializer):
+    target = (
+        serializer.child
+        if isinstance(serializer, serializers.ListSerializer)
+        else serializer
+    )
+    return (
+        getattr(getattr(target, "Meta", None), "serializer_backend", None) is not None
+    )