drf-react-by-schema 0.29.0__tar.gz → 0.29.2__tar.gz

{drf_react_by_schema-0.29.0 → drf_react_by_schema-0.29.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: drf_react_by_schema
-Version: 0.29.0
+Version: 0.29.2
 Summary: A Django app to easily integrate with React from models.
 Home-page: https://gitlab.com/eita/drf-react-by-schema/drf-react-by-schema-django
 Author: Cooperativa EITA

drf_react_by_schema-0.29.2/drf_react_by_schema/autocomplete_viewsets.py

@@ -0,0 +1,135 @@
+import importlib
+
+from django.apps import apps
+from django.core.exceptions import FieldDoesNotExist
+from rest_framework import serializers as drf_serializers
+
+from . import settings, autocomplete_serializers, viewsets
+from .utils import camel_to_snake, to_pascal_case
+
+# ``settings`` is ``django.conf.settings.__dict__`` (see the package ``__init__``):
+# ``override_settings`` clears that dict when it swaps ``_wrapped``, so the apps
+# list is snapshotted here (as the generation loop below already implicitly is).
+_APPS = tuple(settings["APPS"])
+
+
+for app in _APPS:
+    for name, model in apps.all_models[app].items():
+        model_name = model.__name__
+        if isinstance(model, type):
+            viewset_name = f"{model_name}ViewSet"
+            if viewset_name not in globals():
+                generated_class = type(
+                    viewset_name,
+                    (viewsets.GenericAutocompleteViewSet,),
+                    {
+                        "model_name": model_name,
+                        "app": app,
+                        "serializer_class": getattr(
+                            autocomplete_serializers, f"{model_name}Serializer"
+                        ),
+                    },
+                )
+                globals()[viewset_name] = generated_class
+
+
+def _is_nested_field(field):
+    """Whether a declared serializer field exposes a related model (a relation).
+
+    Nested model serializers (FK/M2M/O2O and declared reverse relations) are
+    ``BaseSerializer`` instances; ``NestedSerializerMethodField`` wraps a
+    serializer class in ``serializer_class``. Plain scalars and ``source``-based
+    ``CharField``s are not relations and carry no autocomplete route.
+    """
+    return isinstance(field, drf_serializers.BaseSerializer) or hasattr(
+        field, "serializer_class"
+    )
+
+
+def _related_model(serializer_model, field_name):
+    """The related model of ``field_name`` on ``serializer_model``, if any."""
+    try:
+        model_field = serializer_model._meta.get_field(field_name)
+    except FieldDoesNotExist:
+        return None
+    return getattr(model_field, "related_model", None)
+
+
+def _iter_serializer_classes():
+    """Serializer classes whose model belongs to the configured apps.
+
+    Covers the package-generated serializers (whose forward relations are
+    auto-populated) and the app's own ``serializers`` module (which declares the
+    reverse relations rendered as nested/inline serializers).
+    """
+    from . import serializers as generated_serializers
+
+    modules = [generated_serializers]
+    for app in _APPS:
+        try:
+            modules.append(importlib.import_module(f"{app}.serializers"))
+        except ImportError:
+            pass
+
+    seen = set()
+    for module in modules:
+        for obj in vars(module).values():
+            if not isinstance(obj, type) or obj in seen:
+                continue
+            seen.add(obj)
+            yield obj
+
+
+def generate_field_name_viewsets(serializer_classes):
+    """Autocomplete viewsets named after the relation field they serve.
+
+    The React client asks ``/autocomplete/<field>/`` using the serializer field
+    name, but the package only registers ``/autocomplete/<model>/``. A relation
+    field whose name differs from its related model — a reverse FK/M2M/O2O with a
+    custom ``related_name`` (``projetos`` for ``Projeto``), or a forward FK named
+    differently (``responsavel`` for ``Pessoa``) — therefore has no route and had
+    to be declared by hand in the consuming app.
+
+    This derives that route from the related model's autocomplete viewset, so its
+    ``serializer_class`` and configuration are inherited. An app-defined viewset
+    of the same name still wins: the app's ``autocomplete_viewsets`` module is
+    registered first and the router skips an already-registered basename.
+    """
+    for serializer_class in serializer_classes:
+        meta = getattr(serializer_class, "Meta", None)
+        serializer_model = getattr(meta, "model", None)
+        if (
+            serializer_model is None
+            or serializer_model._meta.app_label not in _APPS
+        ):
+            continue
+
+        for field_name, field in getattr(
+            serializer_class, "_declared_fields", {}
+        ).items():
+            if not _is_nested_field(field):
+                continue
+            related_model = _related_model(serializer_model, field_name)
+            if (
+                related_model is None
+                or related_model._meta.app_label not in _APPS
+            ):
+                continue
+            # The related model's own route already serves this name.
+            if camel_to_snake(related_model.__name__) == field_name:
+                continue
+
+            base_viewset = globals().get(f"{related_model.__name__}ViewSet")
+            if base_viewset is None:
+                continue
+            viewset_name = f"{to_pascal_case(field_name)}ViewSet"
+            if viewset_name in globals():
+                continue
+            globals()[viewset_name] = type(
+                viewset_name,
+                (base_viewset,),
+                {"__module__": __name__},
+            )
+
+
+generate_field_name_viewsets(_iter_serializer_classes())

{drf_react_by_schema-0.29.0 → drf_react_by_schema-0.29.2}/drf_react_by_schema/metadata.py

@@ -64,66 +64,19 @@ class Metadata(SimpleMetadata):
             return None
         return getter()
 
-    def determine_metadata(self, request, view):
-        serializer_class = self.get_schema_serializer_class(view)
-        if serializer_class is None:
-            metadata = super().determine_metadata(request, view)
-        else:
-            with _PinnedSerializerClass(view, serializer_class):
-                metadata = super().determine_metadata(request, view)
-
-        if not metadata.get("actions", {}).get("POST") or not hasattr(
-            view, "get_serializer"
-        ):
-            return metadata
-
-        try:
-            serializer = (
-                serializer_class() if serializer_class else view.get_serializer()
-            )
-        except (AttributeError, TypeError, ValueError):
-            return metadata
-
-        model = getattr(getattr(serializer, "Meta", None), "model", None)
-        if not model:
-            return metadata
-
-        metadata.update(
-            {
-                "verbose_name": getattr(model._meta, "verbose_name", None),
-                "verbose_name_plural": getattr(
-                    model._meta, "verbose_name_plural", None
-                ),
-            }
-        )
-
-        try:
-            serializer_fields = serializer.get_fields()
-        except (AttributeError, TypeError, ValueError):
-            return metadata
-
-        # Type derived method fields and expand nested serializers; the client
-        # reads ``derived`` to tell them apart from editable relations.
-        self._apply_serializer_field_info(metadata["actions"]["POST"], serializer)
-
-        for serializer_field_name, serializer_field in serializer_fields.items():
-            if serializer_field_name not in metadata["actions"]["POST"]:
-                continue
-
-            if (
-                isinstance(serializer_field, serializers.CharField)
-                and serializer_field.style
-            ):
-                metadata["actions"]["POST"][serializer_field_name][
-                    "style"
-                ] = serializer_field.style
+    def _apply_model_field_info(self, field_infos, serializer, model):
+        """Enrich a schema's field infos with the model field metadata.
 
+        Applied to the top-level POST schema and, recursively, to every nested
+        serializer's children, so an inline formset's fields carry the same keys
+        (``conditional_visible``, ``ui_required``, ``model_required``, ...) as the
+        standalone model schema.
+        """
+        serializer_fields = serializer.get_fields()
         for field in model._meta.get_fields():
             field_name = getattr(field, "name", None)
 
-            if not field_name or field_name not in metadata.get("actions", {}).get(
-                "POST", {}
-            ):
+            if not field_name or field_name not in field_infos:
                 continue
 
             serializer_field = serializer_fields.get(field_name)
@@ -153,7 +106,7 @@ class Metadata(SimpleMetadata):
             )
 
             if is_now_default:
-                metadata["actions"]["POST"][field_name]["model_default"] = (
+                field_infos[field_name]["model_default"] = (
                     "{dateTimeNow}" if is_datetime else "{dateNow}"
                 )
             elif default_value:
@@ -162,25 +115,25 @@ class Metadata(SimpleMetadata):
                         model_instance = field.related_model.objects.get(
                             pk=default_value
                         )
-                        metadata["actions"]["POST"][field_name]["model_default"] = (
+                        field_infos[field_name]["model_default"] = (
                             serializer_field.to_representation(model_instance)
                         )
                     except field.related_model.DoesNotExist:
-                        metadata["actions"]["POST"][field_name][
+                        field_infos[field_name][
                             "model_default_error"
                         ] = "Related object not found"
                         pass
                 else:
-                    metadata["actions"]["POST"][field_name][
+                    field_infos[field_name][
                         "model_default"
                     ] = default_value
             elif serializer_field and serializer_field.default:
                 if isinstance(serializer_field.default, (int, str)):
-                    metadata["actions"]["POST"][field_name][
+                    field_infos[field_name][
                         "model_default"
                     ] = serializer_field.default
                 elif isinstance(serializer_field.default, CurrentUserDefault):
-                    metadata["actions"]["POST"][field_name][
+                    field_infos[field_name][
                         "model_default"
                     ] = "{currentUser}"
 
@@ -197,7 +150,7 @@ class Metadata(SimpleMetadata):
                         }
                     )
             if len(validators_regex) > 0:
-                metadata["actions"]["POST"][field_name][
+                field_infos[field_name][
                     "validators_regex"
                 ] = validators_regex
 
@@ -206,11 +159,11 @@ class Metadata(SimpleMetadata):
                 serializer_fields[field_name],
                 serializers.ManyRelatedField,
             ):
-                metadata["actions"]["POST"][field_name]["required"] = False
+                field_infos[field_name]["required"] = False
 
             # Add ui_required to OPTIONS:
             is_ui_required = getattr(field, "ui_required", False)
-            metadata["actions"]["POST"][field_name]["ui_required"] = is_ui_required
+            field_infos[field_name]["ui_required"] = is_ui_required
 
             # Add model_required to OPTIONS:
             # Reverse relations (a declared reverse-FK/M2M/O2O nested list) never
@@ -231,19 +184,19 @@ class Metadata(SimpleMetadata):
                     )
                 )
             )
-            metadata["actions"]["POST"][field_name]["model_required"] = is_required
+            field_infos[field_name]["model_required"] = is_required
 
             # Add pattern_format to OPTIONS:
             pattern_format = get_pattern_format(getattr(field, "pattern_format", None))
             if pattern_format:
-                metadata["actions"]["POST"][field_name][
+                field_infos[field_name][
                     "pattern_format"
                 ] = pattern_format
 
             # Add help_text to OPTIONS:
             help_text = getattr(field, "help_text", None)
             if help_text:
-                metadata["actions"]["POST"][field_name]["help_text"] = help_text
+                field_infos[field_name]["help_text"] = help_text
 
             # Add related model is editable to OPTIONS:
             # Non-editable (editable=False) model fields are never written by the
@@ -252,57 +205,57 @@ class Metadata(SimpleMetadata):
             if related_editable is not None:
                 if not getattr(field, "editable", True):
                     related_editable = False
-                metadata["actions"]["POST"][field_name][
+                field_infos[field_name][
                     "related_editable"
                 ] = related_editable
 
             # Add DecimalField decimal_places in OPTIONS:
             decimal_places = getattr(field, "decimal_places", None)
             if decimal_places is not None:
-                metadata["actions"]["POST"][field_name][
+                field_infos[field_name][
                     "decimal_places"
                 ] = decimal_places
 
             # Add DecimalField max_digits in OPTIONS:
             max_digits = getattr(field, "max_digits", None)
             if max_digits is not None:
-                metadata["actions"]["POST"][field_name]["max_digits"] = max_digits
+                field_infos[field_name]["max_digits"] = max_digits
 
             # Add DecimalField is_currency in OPTIONS:
             is_currency = getattr(field, "is_currency", None)
             if is_currency is not None:
-                metadata["actions"]["POST"][field_name]["is_currency"] = is_currency
+                field_infos[field_name]["is_currency"] = is_currency
 
             # Add DecimalField prefix in OPTIONS:
             prefix = getattr(field, "prefix", None)
             if prefix is not None:
-                metadata["actions"]["POST"][field_name]["prefix"] = prefix
+                field_infos[field_name]["prefix"] = prefix
 
             # Add DecimalField suffix in OPTIONS:
             suffix = getattr(field, "suffix", None)
             if suffix is not None:
-                metadata["actions"]["POST"][field_name]["suffix"] = suffix
+                field_infos[field_name]["suffix"] = suffix
 
             # Add DateField views in OPTIONS:
             views = getattr(field, "views", None)
             if views is not None:
-                metadata["actions"]["POST"][field_name]["date_views"] = views
+                field_infos[field_name]["date_views"] = views
 
             if field_name in serializer_fields and (
                 isinstance(
                     serializer_fields[field_name],
                     (serializers.ManyRelatedField, serializers.ListSerializer),
                 )
-                or metadata["actions"]["POST"][field_name]["type"] == "list"
+                or field_infos[field_name]["type"] == "list"
             ):
-                metadata["actions"]["POST"][field_name]["many"] = True
+                field_infos[field_name]["many"] = True
 
             # Mirror the parent's required onto the child of list/array fields.
             # DRF's SimpleMetadata always reports the child serializer field as
             # required (e.g. a CharField child of a ListField), which is wrong
             # when the parent ArrayField itself is optional (blank=True/null=True).
             # The child "required" should follow the parent's "required".
-            field_info = metadata["actions"]["POST"][field_name]
+            field_info = field_infos[field_name]
             if field_info.get("type") == "list" and isinstance(
                 field_info.get("child"), dict
             ):
@@ -313,18 +266,18 @@ class Metadata(SimpleMetadata):
                 serializer_fields[field_name],
                 serializers.ManyRelatedField,
             ):
-                metadata["actions"]["POST"][field_name]["required"] = False
+                field_infos[field_name]["required"] = False
 
             # Print multiline in OPTIONS:
             if isinstance(field, models.TextField):
-                metadata["actions"]["POST"][field_name]["model_multiline"] = True
+                field_infos[field_name]["model_multiline"] = True
                 # Rich-text fields store HTML and get a WYSIWYG widget.
                 if getattr(field, "rich_text", False):
-                    metadata["actions"]["POST"][field_name]["model_html"] = True
+                    field_infos[field_name]["model_html"] = True
 
             # Force slug to be read_only:
             if field_name == SLUG_FIELD_NAME:
-                metadata["actions"]["POST"][field_name].update(
+                field_infos[field_name].update(
                     {
                         "required": False,
                         "read_only": True,
@@ -334,22 +287,79 @@ class Metadata(SimpleMetadata):
             # Add max_file_size for ImageField and FileField in OPTIONS:
             max_file_size = getattr(field, "max_file_size", None)
             if max_file_size is not None:
-                metadata["actions"]["POST"][field_name]["max_file_size"] = max_file_size
+                field_infos[field_name]["max_file_size"] = max_file_size
 
             # Add allowed_mime_types for ImageField and FileField in OPTIONS:
             allowed_mime_types = getattr(field, "allowed_mime_types", None)
             if allowed_mime_types is not None:
-                metadata["actions"]["POST"][field_name][
+                field_infos[field_name][
                     "allowed_mime_types"
                 ] = allowed_mime_types
 
             # Add help_text to OPTIONS:
             conditional_visible = getattr(field, "conditional_visible", None)
             if conditional_visible:
-                metadata["actions"]["POST"][field_name][
+                field_infos[field_name][
                     "conditional_visible"
                 ] = conditional_visible
 
+
+    def determine_metadata(self, request, view):
+        serializer_class = self.get_schema_serializer_class(view)
+        if serializer_class is None:
+            metadata = super().determine_metadata(request, view)
+        else:
+            with _PinnedSerializerClass(view, serializer_class):
+                metadata = super().determine_metadata(request, view)
+
+        if not metadata.get("actions", {}).get("POST") or not hasattr(
+            view, "get_serializer"
+        ):
+            return metadata
+
+        try:
+            serializer = (
+                serializer_class() if serializer_class else view.get_serializer()
+            )
+        except (AttributeError, TypeError, ValueError):
+            return metadata
+
+        model = getattr(getattr(serializer, "Meta", None), "model", None)
+        if not model:
+            return metadata
+
+        metadata.update(
+            {
+                "verbose_name": getattr(model._meta, "verbose_name", None),
+                "verbose_name_plural": getattr(
+                    model._meta, "verbose_name_plural", None
+                ),
+            }
+        )
+
+        try:
+            serializer_fields = serializer.get_fields()
+        except (AttributeError, TypeError, ValueError):
+            return metadata
+
+        # Type derived method fields and expand nested serializers; the client
+        # reads ``derived`` to tell them apart from editable relations.
+        self._apply_serializer_field_info(metadata["actions"]["POST"], serializer)
+
+        for serializer_field_name, serializer_field in serializer_fields.items():
+            if serializer_field_name not in metadata["actions"]["POST"]:
+                continue
+
+            if (
+                isinstance(serializer_field, serializers.CharField)
+                and serializer_field.style
+            ):
+                metadata["actions"]["POST"][serializer_field_name][
+                    "style"
+                ] = serializer_field.style
+
+        self._apply_model_field_info(metadata["actions"]["POST"], serializer, model)
+
         # PostGIS geometry fields have no DRF type that SimpleMetadata can emit,
         # so set the drf-react-by-schema geometry types directly. Only applied
         # when the database engine is PostGIS.
@@ -412,9 +422,18 @@ class Metadata(SimpleMetadata):
                 self._apply_inline_object_info(info, field, info["children"])
 
     def _nested_serializer_info(self, serializer, parent_model=None):
-        """Schema info for a nested serializer, with its derived fields typed."""
+        """Schema info for a nested serializer, with its derived fields typed.
+
+        The model-field enrichment (``conditional_visible``, ``ui_required``,
+        ``model_required``, ...) is applied here too, so an inline formset's child
+        fields carry the same keys as the standalone model schema — the widget
+        reads ``conditional_visible`` from these nested children.
+        """
         info = self.get_serializer_info(serializer)
         self._apply_serializer_field_info(info, serializer)
+        nested_model = getattr(getattr(serializer, "Meta", None), "model", None)
+        if nested_model is not None:
+            self._apply_model_field_info(info, serializer, nested_model)
         if parent_model is not None:
             self._mark_auto_managed(info, serializer, parent_model)
         return info

{drf_react_by_schema-0.29.0 → drf_react_by_schema-0.29.2}/drf_react_by_schema/serializers.py

@@ -600,15 +600,26 @@ class GenericSerializer(
         Binding the row's existing instance for the duration of the validation
         lets DRF's validators exclude it — the write itself still applies the
         implicit diff (see ``utils.update_nested_relations``).
+
+        A row that targets an existing object is also a *partial* write: the
+        client sends only the fields it changed (an upload-first file is omitted
+        when it is unchanged), so a field absent from the payload keeps its stored
+        value and must be skipped, not required. DRF reads ``partial`` from the
+        root serializer (``Field.validate_empty_values``), so it is toggled there
+        for the duration of this row's validation.
         """
         nested_instance = self._nested_row_instance(data)
-        if nested_instance is not None:
-            self.instance = nested_instance
+        if nested_instance is None:
+            return super().run_validation(data)
+        self.instance = nested_instance
+        root = self.root
+        was_partial = root.partial
+        root.partial = True
         try:
             return super().run_validation(data)
         finally:
-            if nested_instance is not None:
-                self.instance = None
+            root.partial = was_partial
+            self.instance = None
 
     def _nested_write_context(self):
         """``(parent_serializer, back_fk)`` when validating a nested-write row.

{drf_react_by_schema-0.29.0 → drf_react_by_schema-0.29.2}/drf_react_by_schema.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: drf-react-by-schema
-Version: 0.29.0
+Version: 0.29.2
 Summary: A Django app to easily integrate with React from models.
 Home-page: https://gitlab.com/eita/drf-react-by-schema/drf-react-by-schema-django
 Author: Cooperativa EITA

{drf_react_by_schema-0.29.0 → drf_react_by_schema-0.29.2}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = drf_react_by_schema
-version = 0.29.0
+version = 0.29.2
 description = A Django app to easily integrate with React from models.
 long_description = file: README.rst
 long_description_content_type = text/x-rst

drf_react_by_schema-0.29.0/drf_react_by_schema/autocomplete_viewsets.py

@@ -1,22 +0,0 @@
-from django.apps import apps
-
-from . import settings, autocomplete_serializers, viewsets
-
-for app in settings["APPS"]:
-    for name, model in apps.all_models[app].items():
-        model_name = model.__name__
-        if isinstance(model, type):
-            viewset_name = f"{model_name}ViewSet"
-            if viewset_name not in globals():
-                generated_class = type(
-                    viewset_name,
-                    (viewsets.GenericAutocompleteViewSet,),
-                    {
-                        "model_name": model_name,
-                        "app": app,
-                        "serializer_class": getattr(
-                            autocomplete_serializers, f"{model_name}Serializer"
-                        ),
-                    },
-                )
-                globals()[viewset_name] = generated_class