Convert report API to ADRF views (prep for async embedding trigger)

radis-client/tests/test_client.py

@@ -15,7 +15,7 @@ def test_report_data_valid():
     assert report.is_valid()
 
 
-@pytest.mark.django_db
+@pytest.mark.django_db(transaction=True)
 def test_report_data_post(live_server: LiveServer, mocker: MockerFixture):
     # Make sure it won't try to save created reports to any full text search database
     # as those are not available during test

radis/reports/api/operations.py

@@ -0,0 +1,94 @@
+"""Async domain operations for the report API.
+
+Each function is a pure async write operation using native async ORM
+methods (`aget_or_create`, `acreate`, `aset`, `asave`, `adelete`, ...).
+None of these functions open their own transactions — atomicity is the
+caller's responsibility. The caller is a sync helper decorated with
+`@sync_to_async(thread_sensitive=True)` + `@transaction.atomic` that
+invokes these operations via `async_to_sync(...)`.
+
+The `thread_sensitive=True` chain ensures the outer sync helper and any
+nested `sync_to_async` adapters (which Django's `a*` ORM methods use
+internally) all run on the same Django thread, so the transaction
+context held by the outer helper applies to every write performed by
+these operations.
+"""
+import logging
+from typing import Any
+
+from ..models import Language, Metadata, Modality, Report
+
+logger = logging.getLogger(__name__)
+
+
+async def create_report_from_validated(
+    validated_data: dict[str, Any],
+) -> Report:
+    """Create a Report and its nested associations from validated payload.
+
+    Pops `language`, `groups`, `metadata`, `modalities` out of
+    `validated_data` and uses the remaining keys as direct Report fields.
+    """
+    language = validated_data.pop("language")
+    groups = validated_data.pop("groups")
+    metadata = validated_data.pop("metadata")
+    modalities = validated_data.pop("modalities")
+
+    language_instance, _ = await Language.objects.aget_or_create(**language)
+    report = await Report.objects.acreate(
+        **validated_data, language=language_instance
+    )
+
+    await report.groups.aset(groups)
+
+    for item in metadata:
+        await Metadata.objects.acreate(report=report, **item)
+
+    modality_instances: list[Modality] = []
+    for modality in modalities:
+        instance, _ = await Modality.objects.aget_or_create(**modality)
+        modality_instances.append(instance)
+    await report.modalities.aset(modality_instances)
+
+    return report
+
+
+async def update_report_from_validated(
+    report: Report, validated_data: dict[str, Any]
+) -> Report:
+    """Replace all mutable fields and nested associations on an existing Report.
+
+    Matches the legacy `ReportSerializer.update` semantics: metadata is
+    fully replaced (delete + recreate), modalities and groups are reset
+    to the provided sets.
+    """
+    language = validated_data.pop("language")
+    groups = validated_data.pop("groups")
+    metadata = validated_data.pop("metadata")
+    modalities = validated_data.pop("modalities")
+
+    language_instance = await Language.objects.aget(**language)
+    report.language = language_instance
+    for attr, value in validated_data.items():
+        setattr(report, attr, value)
+    await report.asave()
+
+    await report.groups.aset(groups)
+
+    await report.metadata.all().adelete()
+    for item in metadata:
+        await Metadata.objects.acreate(report=report, **item)
+
+    await report.modalities.aclear()
+    modality_instances: list[Modality] = []
+    for modality in modalities:
+        instance, _ = await Modality.objects.aget_or_create(**modality)
+        modality_instances.append(instance)
+    await report.modalities.aset(modality_instances)
+
+    return report
+
+
+async def delete_report(report: Report) -> None:
+    """Delete a single Report row."""
+    await report.adelete()

radis/reports/api/serializers.py

@@ -1,11 +1,14 @@
 from typing import Any
 
+from adrf.serializers import ModelSerializer as AsyncModelSerializer
+from asgiref.sync import async_to_sync, sync_to_async
 from django.db import transaction
 from rest_framework import serializers, validators
 from rest_framework.exceptions import ValidationError
 from rest_framework.relations import PrimaryKeyRelatedField
 
 from ..models import Language, Metadata, Modality, Report
+from . import operations
 
 
 class MetadataSerializer(serializers.ModelSerializer):
@@ -42,7 +45,16 @@ def run_validation(self, data: dict[str, Any]) -> Any:
         return super().run_validation(data)
 
 
-class ReportSerializer(serializers.ModelSerializer):
+class ReportSerializer(AsyncModelSerializer):
+    """Async serializer for Report.
+
+    Subclasses `adrf.serializers.ModelSerializer` so callers can do
+    `await serializer.asave()` directly. `acreate` and `aupdate` below
+    delegate to the async write operations in `operations.py`. None of
+    these methods own a transaction — the caller (the view's
+    `@sync_to_async @transaction.atomic` helper) does.
+    """
+
     language = LanguageSerializer()
     metadata = MetadataSerializer(many=True)
     modalities = ModalitySerializer(many=True)
@@ -75,60 +87,25 @@ def _strip_unique_validator(self, field_name: str) -> None:
             if not isinstance(validator, validators.UniqueValidator)
         ]
 
-    def create(self, validated_data: Any) -> Any:
-        language = validated_data.pop("language")
-        groups = validated_data.pop("groups")
-        metadata = validated_data.pop("metadata")
-        modalities = validated_data.pop("modalities")
-
-        with transaction.atomic():
-            language_instance, _ = Language.objects.get_or_create(**language)
-
-            report = Report.objects.create(**validated_data, language=language_instance)
-
-            report.groups.set(groups)
-
-            for metadata in metadata:
-                Metadata.objects.create(report=report, **metadata)
-
-            modality_instances: list[Modality] = []
-            for modality in modalities:
-                modality_instance, _ = Modality.objects.get_or_create(**modality)
-                modality_instances.append(modality_instance)
-
-            report.modalities.set(modality_instances)
-
-        return report
-
-    def update(self, report: Report, validated_data: Any) -> Any:
-        language = validated_data.pop("language")
-        groups = validated_data.pop("groups")
-        metadata = validated_data.pop("metadata")
-        modalities = validated_data.pop("modalities")
-
-        with transaction.atomic():
-            language_instance = Language.objects.get(**language)
-            report.language = language_instance
-
-            for attr, value in validated_data.items():
-                setattr(report, attr, value)
-
-            report.save()
-
-            report.groups.set(groups)
-
-            report.metadata.all().delete()
-            for metadata in metadata:
-                Metadata.objects.create(report=report, **metadata)
-
-            report.modalities.clear()
-            modality_instances: list[Modality] = []
-            for modality in modalities:
-                modality_instance, _ = Modality.objects.get_or_create(**modality)
-                modality_instances.append(modality_instance)
-            report.modalities.set(modality_instances)
-
-        return report
+    async def acreate(self, validated_data: Any) -> Report:
+        @sync_to_async(thread_sensitive=True)
+        @transaction.atomic
+        def _atomic() -> Report:
+            return async_to_sync(operations.create_report_from_validated)(
+                validated_data
+            )
+
+        return await _atomic()
+
+    async def aupdate(self, report: Report, validated_data: Any) -> Report:
+        @sync_to_async(thread_sensitive=True)
+        @transaction.atomic
+        def _atomic() -> Report:
+            return async_to_sync(operations.update_report_from_validated)(
+                report, validated_data
+            )
+
+        return await _atomic()
 
     def to_internal_value(self, data: Any) -> Any:
         if "language" in data:

radis/reports/api/urls.py

@@ -1,10 +1,10 @@
+from adrf.routers import DefaultRouter
 from django.urls import include, path
-from rest_framework.routers import DefaultRouter
 
 from .viewsets import ReportViewSet
 
 router = DefaultRouter()
-router.register(r"", ReportViewSet)
+router.register("", ReportViewSet, basename="report")
 
 urlpatterns = [
     path("", include(router.urls)),