endoreg-db 0.8.8.9__py3-none-any.whl → 0.8.9.10__py3-none-any.whl

endoreg_db/views/patient_finding/patient_finding_optimized.py

@@ -1,5 +1,15 @@
-from endoreg_db.models import Examination, Finding, FindingClassification, PatientFinding
-from endoreg_db.serializers.patient_finding import PatientFindingClassificationSerializer, PatientFindingDetailSerializer, PatientFindingListSerializer, PatientFindingWriteSerializer
+from endoreg_db.models import (
+    Examination,
+    Finding,
+    FindingClassification,
+    PatientFinding,
+)
+from endoreg_db.serializers.patient_finding import (
+    PatientFindingClassificationSerializer,
+    PatientFindingDetailSerializer,
+    PatientFindingListSerializer,
+    PatientFindingWriteSerializer,
+)
 
 
 from django.db import transaction
@@ -20,30 +30,39 @@ class OptimizedPatientFindingViewSet(viewsets.ModelViewSet):
     Hochoptimiertes ViewSet für PatientFinding mit Query-Optimierung,
     Bulk-Endpoints und intelligenter Serializer-Auswahl
     """
+
     permission_classes = [IsAuthenticated]
     filter_backends = [DjangoFilterBackend, OrderingFilter, SearchFilter]
-    filterset_fields = ['patient_examination__patient', 'finding', 'patient_examination__examination']
-    ordering_fields = ['id', 'patient_examination__date_start']
-    search_fields = ['finding__name', 'patient_examination__patient__first_name', 'patient_examination__patient__last_name']
+    filterset_fields = [
+        "patient_examination__patient",
+        "finding",
+        "patient_examination__examination",
+    ]
+    ordering_fields = ["id", "patient_examination__date_start"]
+    search_fields = [
+        "finding__name",
+        "patient_examination__patient__first_name",
+        "patient_examination__patient__last_name",
+    ]
 
     def get_queryset(self):
         """Optimierte QuerySet mit Prefetching basierend auf Action"""
         base_queryset = PatientFinding.objects.select_related(
-            'patient_examination__patient',
-            'patient_examination__examination',
-            'finding'
+            "patient_examination__patient",
+            "patient_examination__examination",
+            "finding",
         )
 
         # Detail-Views: fetch nested relations
-        if self.action in ['retrieve', 'update', 'partial_update']:
+        if self.action in ["retrieve", "update", "partial_update"]:
             return base_queryset.prefetch_related(
                 "classifications__classification",
                 "classifications__choice",
                 # 'locations__location_classification',
                 # 'locations__location_choice',
-                # 'morphologies__morphology_classification', 
+                # 'morphologies__morphology_classification',
                 # 'morphologies__morphology_choice',
-                'interventions__intervention'
+                "interventions__intervention",
             )
 
         # For List-Views: fetch only necessary relations
@@ -51,90 +70,90 @@ class OptimizedPatientFindingViewSet(viewsets.ModelViewSet):
 
     def get_serializer_class(self):
         """Intelligente Serializer-Auswahl basierend auf Action"""
-        if self.action == 'list':
+        if self.action == "list":
             return PatientFindingListSerializer
-        elif self.action in ['create', 'update', 'partial_update']:
+        elif self.action in ["create", "update", "partial_update"]:
             return PatientFindingWriteSerializer
         else:
             return PatientFindingDetailSerializer
 
     @method_decorator(cache_page(60 * 15))  # 15 Minuten Cache
-    @method_decorator(vary_on_headers('Accept-Language'))
-    @action(detail=False, methods=['get'])
+    @method_decorator(vary_on_headers("Accept-Language"))
+    @action(detail=False, methods=["get"])
     def examination_manifest(self, request):
         """
         Bulk-Endpoint: Liefert alle Setup-Daten für eine Examination in einem Call
         """
-        examination_id = request.query_params.get('examination_id')
+        examination_id = request.query_params.get("examination_id")
         if not examination_id:
             return Response(
-                {'error': 'examination_id parameter erforderlich'},
-                status=status.HTTP_400_BAD_REQUEST
+                {"error": "examination_id parameter erforderlich"},
+                status=status.HTTP_400_BAD_REQUEST,
             )
 
         try:
             examination = Examination.objects.get(id=examination_id)
         except Examination.DoesNotExist:
             return Response(
-                {'error': 'Examination nicht gefunden'},
-                status=status.HTTP_404_NOT_FOUND
+                {"error": "Examination nicht gefunden"},
+                status=status.HTTP_404_NOT_FOUND,
             )
 
         # Alle Daten in optimierten Queries laden
         findings = examination.get_available_findings().prefetch_related(
-            'location_classifications__choices',
-            'morphology_classifications__choices'
+            "location_classifications__choices", "morphology_classifications__choices"
         )
 
         manifest_data = {
-            'examination': {
-                'id': examination.id,
-                'name': examination.name,
+            "examination": {
+                "id": examination.id,
+                "name": examination.name,
                 # 'name_de': examination.name_de,
                 # 'name_en': examination.name_en,
             },
-            'findings': []
+            "findings": [],
         }
 
         for finding in findings:
             assert isinstance(finding, Finding), "Expected Finding instance"
             finding_data = {
-                'id': finding.id,
-                'name': finding.name,
+                "id": finding.id,
+                "name": finding.name,
                 # 'name_de': finding.name_de,
                 # 'name_en': finding.name_en,
                 "classifications": [],
-                'location_classifications': [],
-                'morphology_classifications': []
+                "location_classifications": [],
+                "morphology_classifications": [],
             }
 
             for classification_obj in finding.get_classifications():
-                assert isinstance(classification_obj, FindingClassification), "Expected FindingClassification instance"
+                assert isinstance(classification_obj, FindingClassification), (
+                    "Expected FindingClassification instance"
+                )
                 classification_data = {
-                    'id': classification_obj.id,
-                    'name': classification_obj.name,
+                    "id": classification_obj.id,
+                    "name": classification_obj.name,
                     "choices": [
                         {
-                            'id': choice.id,
-                            'name': choice.name,
+                            "id": choice.id,
+                            "name": choice.name,
                         }
                         for choice in classification_obj.choices.all()
-                    ]
+                    ],
                 }
 
-                finding_data['classifications'].append(classification_data)
+                finding_data["classifications"].append(classification_data)
 
-    @action(detail=False, methods=['post'])
+    @action(detail=False, methods=["post"])
     def bulk_create(self, request):
         """
         Bulk-Endpoint für gleichzeitige Erstellung mehrerer PatientFindings
         Optimiert für Mobile Apps mit schlechter Verbindung
         """
-        findings_data = request.data.get('findings', [])
+        findings_data = request.data.get("findings", [])
         if not findings_data:
             return Response(
-                {'error': 'findings array required'},
-                status=status.HTTP_400_BAD_REQUEST
+                {"error": "findings array required"}, status=status.HTTP_400_BAD_REQUEST
             )
 
         created_findings = []
@@ -146,33 +165,34 @@ class OptimizedPatientFindingViewSet(viewsets.ModelViewSet):
                 if serializer.is_valid():
                     try:
                         finding = serializer.save()
-                        created_findings.append({
-                            'index': i,
-                            'id': finding.id,
-                            'status': 'created'
-                        })
+                        created_findings.append(
+                            {"index": i, "id": finding.id, "status": "created"}
+                        )
                     except Exception as e:
-                        errors.append({
-                            'index': i,
-                            'error': str(e),
-                            'status': 'error'
-                        })
+                        errors.append({"index": i, "error": str(e), "status": "error"})
                 else:
-                    errors.append({
-                        'index': i,
-                        'errors': serializer.errors,
-                        'status': 'validation_error'
-                    })
-
-        return Response({
-            'created': created_findings,
-            'errors': errors,
-            'total_processed': len(findings_data),
-            'success_count': len(created_findings),
-            'error_count': len(errors)
-        }, status=status.HTTP_201_CREATED if created_findings else status.HTTP_400_BAD_REQUEST)
-
-    @action(detail=True, methods=['post'])
+                    errors.append(
+                        {
+                            "index": i,
+                            "errors": serializer.errors,
+                            "status": "validation_error",
+                        }
+                    )
+
+        return Response(
+            {
+                "created": created_findings,
+                "errors": errors,
+                "total_processed": len(findings_data),
+                "success_count": len(created_findings),
+                "error_count": len(errors),
+            },
+            status=status.HTTP_201_CREATED
+            if created_findings
+            else status.HTTP_400_BAD_REQUEST,
+        )
+
+    @action(detail=True, methods=["post"])
     def add_classification(self, request, pk=None):
         """
         Create and link a PatientFindingClassification to the PatientFinding
@@ -185,32 +205,38 @@ class OptimizedPatientFindingViewSet(viewsets.ModelViewSet):
 
         """
         patient_finding = self.get_object()
-        assert isinstance(patient_finding, PatientFinding), "Expected PatientFinding instance"
+        assert isinstance(patient_finding, PatientFinding), (
+            "Expected PatientFinding instance"
+        )
         classification_data = request.data
 
         # Validierung
-        classification_id = classification_data.get('classification_id')
-        choice_id = classification_data.get('choice_id')
+        classification_id = classification_data.get("classification_id")
+        choice_id = classification_data.get("choice_id")
 
         if not classification_id or not choice_id:
             return Response(
-                {'error': 'classification und choice erforderlich'},
-                status=status.HTTP_400_BAD_REQUEST
+                {"error": "classification und choice erforderlich"},
+                status=status.HTTP_400_BAD_REQUEST,
             )
 
         patient_finding.add_classification(classification_id, choice_id)
         try:
-            patient_finding_classification = patient_finding.add_classification(classification_id, choice_id)
-            serializer = PatientFindingClassificationSerializer(patient_finding_classification)
+            patient_finding_classification = patient_finding.add_classification(
+                classification_id, choice_id
+            )
+            serializer = PatientFindingClassificationSerializer(
+                patient_finding_classification
+            )
             return Response(serializer.data, status=status.HTTP_201_CREATED)
 
         except FindingClassification.DoesNotExist:
             return Response(
-                {'error': 'location_classification nicht gefunden'},
-                status=status.HTTP_404_NOT_FOUND
+                {"error": "location_classification nicht gefunden"},
+                status=status.HTTP_404_NOT_FOUND,
             )
 
-    @action(detail=False, methods=['get'])
+    @action(detail=False, methods=["get"])
     def export_for_analysis(self, request):
         """
         Export-Endpoint für Datenanalyse mit flacher Struktur
@@ -219,41 +245,47 @@ class OptimizedPatientFindingViewSet(viewsets.ModelViewSet):
         queryset = self.filter_queryset(self.get_queryset())
 
         # Format-Parameter
-        export_format = request.query_params.get('format', 'json')
+        export_format = request.query_params.get("format", "json")
 
         # Flache Datenstruktur für Analyse
         export_data = []
         for finding in queryset:
-            assert isinstance(finding, PatientFinding), "Expected PatientFinding instance"
+            assert isinstance(finding, PatientFinding), (
+                "Expected PatientFinding instance"
+            )
             base_data = {
-                'finding_id': finding.id,
-                'patient_id': finding.patient_examination.patient.id,
-                'patient_name': finding.patient_examination.patient.get_full_name(),
-                'examination_type': finding.patient_examination.examination.name,
-                'examination_date': finding.patient_examination.date_start,
-                'finding_name': finding.finding.name,
+                "finding_id": finding.id,
+                "patient_id": finding.patient_examination.patient.id,
+                "patient_name": finding.patient_examination.patient.get_full_name(),
+                "examination_type": finding.patient_examination.examination.name,
+                "examination_date": finding.patient_examination.date_start,
+                "finding_name": finding.finding.name,
             }
 
             # Locations denormalisieren
             for classification in finding.classifications.all():
                 classification_data = base_data.copy()
-                classification_data.update({
-                    'location_classification': classification.location_classification.name,
-                    'location_choice': classification.location_choice.name,
-                    'location_subcategories': classification.subcategories,
-                })
+                classification_data.update(
+                    {
+                        "location_classification": classification.location_classification.name,
+                        "location_choice": classification.location_choice.name,
+                        "location_subcategories": classification.subcategories,
+                    }
+                )
                 export_data.append(classification_data)
 
             # Wenn keine Locations, trotzdem Base-Data hinzufügen
             if not finding.locations.exists():
                 export_data.append(base_data)
 
-        if export_format == 'csv':
+        if export_format == "csv":
             # CSV-Export implementierung würde hier hin
             pass
 
-        return Response({
-            'data': export_data,
-            'count': len(export_data),
-            'exported_at': timezone.now()
-        })
+        return Response(
+            {
+                "data": export_data,
+                "count": len(export_data),
+                "exported_at": timezone.now(),
+            }
+        )

endoreg_db/views/patient_finding_classification/__init__.py

@@ -2,4 +2,4 @@ from .pfc_create import create_patient_finding_classification
 
 __all__ = [
     "create_patient_finding_classification",
-]
+]

endoreg_db/views/patient_finding_classification/pfc_create.py

@@ -4,10 +4,11 @@ from rest_framework import status
 from endoreg_db.models import (
     PatientFinding,
     FindingClassificationChoice,
-    FindingClassification
+    FindingClassification,
 )
 
-@api_view(['POST'])
+
+@api_view(["POST"])
 def create_patient_finding_classification(request):
     """
     Create a patient finding classification relationship.
@@ -18,50 +19,57 @@ def create_patient_finding_classification(request):
     }
     """
     try:
-        patient_finding_id = request.data.get('patient_finding_id')
-        choice_id = request.data.get('classification_choice_id')
-        classification_id = request.data.get('classification_id')
-        
+        patient_finding_id = request.data.get("patient_finding_id")
+        choice_id = request.data.get("classification_choice_id")
+        classification_id = request.data.get("classification_id")
+
         if not patient_finding_id or not choice_id:
             return Response(
-                {'detail': 'patient_finding_id and classification_choice_id are required'}, 
-                status=status.HTTP_400_BAD_REQUEST
+                {
+                    "detail": "patient_finding_id and classification_choice_id are required"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
             )
-        
+
         # Get the objects
         try:
             patient_finding = PatientFinding.objects.get(id=patient_finding_id)
         except PatientFinding.DoesNotExist:
             return Response(
-                {'detail': f'PatientFinding with id {patient_finding_id} not found'}, 
-                status=status.HTTP_404_NOT_FOUND
+                {"detail": f"PatientFinding with id {patient_finding_id} not found"},
+                status=status.HTTP_404_NOT_FOUND,
             )
-        
+
         try:
             choice = FindingClassificationChoice.objects.get(id=choice_id)
         except FindingClassificationChoice.DoesNotExist:
             return Response(
-                {'detail': f'ClassificationChoice with id {choice_id} not found'}, 
-                status=status.HTTP_404_NOT_FOUND
+                {"detail": f"ClassificationChoice with id {choice_id} not found"},
+                status=status.HTTP_404_NOT_FOUND,
             )
 
         try:
             FindingClassification.objects.get(id=classification_id)
         except FindingClassification.DoesNotExist:
             return Response(
-                {'detail': f'Classification with id {classification_id} not found'}, 
-                status=status.HTTP_404_NOT_FOUND
+                {"detail": f"Classification with id {classification_id} not found"},
+                status=status.HTTP_404_NOT_FOUND,
             )
-        patient_finding_classification = patient_finding.add_classification(classification_id = classification_id, choice_id = choice_id)
-        
-        return Response({
-            'id': patient_finding_classification.id,
-            'patient_finding_id': patient_finding.id,
-            'classification_choice_id': choice.id
-        }, status=status.HTTP_201_CREATED)
-        
+        patient_finding_classification = patient_finding.add_classification(
+            classification_id=classification_id, choice_id=choice_id
+        )
+
+        return Response(
+            {
+                "id": patient_finding_classification.id,
+                "patient_finding_id": patient_finding.id,
+                "classification_choice_id": choice.id,
+            },
+            status=status.HTTP_201_CREATED,
+        )
+
     except Exception as e:
         return Response(
-            {'detail': f'Error creating patient finding classification: {str(e)}'}, 
-            status=status.HTTP_500_INTERNAL_SERVER_ERROR
-        )
+            {"detail": f"Error creating patient finding classification: {str(e)}"},
+            status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        )

endoreg_db/views/report/reimport.py

@@ -11,7 +11,7 @@ from endoreg_db.services.report_import import ReportImportService
 logger = logging.getLogger(__name__)
 
 
-class  ReportReimportView(APIView):
+class ReportReimportView(APIView):
     """
     API endpoint to re-import a pdf file and regenerate metadata.
     This is useful when OCR failed or metadata is incomplete.

endoreg_db/views/report/report_stream.py

@@ -5,7 +5,6 @@ import re
 from django.http import FileResponse, Http404, StreamingHttpResponse
 from django.views.decorators.clickjacking import (
     xframe_options_exempt,
-    xframe_options_sameorigin,
 )
 from rest_framework.views import APIView
 
@@ -172,13 +171,11 @@ class ReportStreamView(APIView):
             logger.debug(f"Serving full {file_type} report {pk} ({file_size} bytes)")
 
             try:
-                with open(file_path, "rb") as file_handle:
-                    response = FileResponse(file_handle, content_type="application/pdf")
-                    response["Content-Length"] = str(file_size)
-                    response["Accept-Ranges"] = "bytes"
-                    response["Content-Disposition"] = (
-                        f'inline; filename="{safe_filename}"'
-                    )
+                file_handle = open(file_path, "rb")
+                response = FileResponse(file_handle, content_type="application/pdf")
+                response["Content-Length"] = str(file_size)
+                response["Accept-Ranges"] = "bytes"
+                response["Content-Disposition"] = f'inline; filename="{safe_filename}"'
 
                 # FileResponse will take ownership of file_handle and close it after response
                 return response

endoreg_db/views/requirement/__init__.py

@@ -4,7 +4,8 @@ from .evaluate import (
 from .lookup import (
     LookupViewSet,
 )
+
 __all__ = [
     "evaluate_requirements",
     "LookupViewSet",
-]
+]

endoreg_db/views/requirement/evaluate.py

@@ -2,8 +2,7 @@ from endoreg_db.models.requirement.requirement import Requirement
 from endoreg_db.views.requirement.requirement_utils import safe_evaluate_requirement
 from endoreg_db.models.requirement.requirement_set import RequirementSet
 from endoreg_db.models.requirement.requirement_evaluation.evaluate_with_dependencies import (
-    evaluate_requirement_sets_with_dependencies,
-    RequirementStatus,   # if you export it there, otherwise re-declare in view
+    evaluate_requirement_sets_with_dependencies,  # if you export it there, otherwise re-declare in view
 )
 from endoreg_db.models.medical.patient.patient_examination import PatientExamination
 from rest_framework import status
@@ -51,10 +50,7 @@ def evaluate_requirements(request):
 
     # ---- fetch PatientExamination
     try:
-        pe = (
-            PatientExamination.objects.select_related("patient")
-            .get(id=pe_id)
-        )
+        pe = PatientExamination.objects.select_related("patient").get(id=pe_id)
     except PatientExamination.DoesNotExist:
         msg = f"PatientExamination with id {pe_id} does not exist"
         errors.append(msg)
@@ -153,9 +149,11 @@ def evaluate_requirements(request):
 
         for set_id, req_dict in set_results.items():
             req_set = sets_by_id.get(set_id)
-            set_name = getattr(
-                req_set, "name", str(set_id)
-            ) if req_set is not None else str(set_id)
+            set_name = (
+                getattr(req_set, "name", str(set_id))
+                if req_set is not None
+                else str(set_id)
+            )
 
             for req_id, (status_value, details) in req_dict.items():
                 try:

endoreg_db/views/requirement/lookup.py

@@ -54,7 +54,7 @@ class LookupViewSet(viewsets.ViewSet):
         "selectedRequirementSetIds",
         "selectedChoices",
     }
-    
+
     user_tags = Tag
 
     @action(detail=False, methods=["post"])
@@ -134,7 +134,7 @@ class LookupViewSet(viewsets.ViewSet):
 
                 except Exception:
                     pass
-        
+
         user_tags = request.data.get("user_tags", None)
         if user_tags and not isinstance(user_tags, list):
             user_tags = [user_tags]
@@ -269,7 +269,6 @@ class LookupViewSet(viewsets.ViewSet):
                     cache.set(f"{ORIGIN_MAP_PREFIX}{pk}", pe_id, DEFAULT_TTL_SECONDS)
                     return Response(store.get_all(), status=status.HTTP_200_OK)
 
-
                 except Exception:
                     pass
 

endoreg_db/views/requirement/lookup_store.py

@@ -8,7 +8,6 @@ from typing import Any, Dict, Iterable, Optional
 from django.conf import settings
 from django.core.cache import cache
 
-from endoreg_db.models.medical import PatientExamination
 
 # Align TTL with Django cache TIMEOUT for consistency in tests and runtime
 

endoreg_db/views/requirement/requirement_utils.py

@@ -31,7 +31,7 @@ def safe_evaluate_requirement(
         if hasattr(requirement, "evaluate_with_details"):
             met, details = requirement.evaluate_with_details(*args, mode=mode, **kwargs)
         else:
-            met = requirement.evaluate(*args, mode=mode, **kwargs)
+            met = requirement.evaluate(*args, **kwargs)
             details = "Voraussetzung erfüllt" if met else "Voraussetzung nicht erfüllt"
         error = None
 
@@ -70,9 +70,7 @@ def safe_evaluate_requirement(
         display_name = getattr(requirement, "description", None) or getattr(
             requirement, "name", "unbekannte Voraussetzung"
         )
-        details = (
-            f"Bei der Auswertung der Voraussetzung „{display_name}“ ist ein interner Fehler aufgetreten."
-        )
+        details = f"Bei der Auswertung der Voraussetzung „{display_name}“ ist ein interner Fehler aufgetreten."
         error = f"{e.__class__.__name__}: {e}"
         logger.exception(
             "Requirement '%s' unexpected error",

endoreg_db/views/stats/__init__.py

@@ -6,8 +6,8 @@ from .stats_views import (
 )
 
 __all__ = [
-    'ExaminationStatsView',
-    'VideoSegmentStatsView', 
-    'SensitiveMetaStatsView',
-    'GeneralStatsView',
+    "ExaminationStatsView",
+    "VideoSegmentStatsView",
+    "SensitiveMetaStatsView",
+    "GeneralStatsView",
 ]