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

endoreg_db/views/patient_examination/patient_examination_list.py

@@ -6,6 +6,7 @@ from rest_framework.response import Response
 from endoreg_db.utils.permissions import DEBUG_PERMISSIONS
 
 import logging
+
 logger = logging.getLogger(__name__)
 
 
@@ -20,20 +21,21 @@ class PatientExaminationListView(generics.ListAPIView):
     - limit: Number of results (default 20)
     - offset: Pagination offset (default 0)
     """
+
     serializer_class = PatientExaminationSerializer
     permission_classes = DEBUG_PERMISSIONS
 
     def get_queryset(self):
         queryset = PatientExamination.objects.select_related(
-            'patient', 'examination'
-        ).order_by('-date_start', '-id')
+            "patient", "examination"
+        ).order_by("-date_start", "-id")
 
         # Apply filters
-        patient_id = self.request.query_params.get('patient_id')
+        patient_id = self.request.query_params.get("patient_id")
         if patient_id:
             queryset = queryset.filter(patient_id=patient_id)
 
-        examination_name = self.request.query_params.get('examination_name')
+        examination_name = self.request.query_params.get("examination_name")
         if examination_name:
             queryset = queryset.filter(examination__name__icontains=examination_name)
 
@@ -44,25 +46,27 @@ class PatientExaminationListView(generics.ListAPIView):
             queryset = self.get_queryset()
 
             # Pagination
-            limit = int(request.query_params.get('limit', 20))
-            offset = int(request.query_params.get('offset', 0))
+            limit = int(request.query_params.get("limit", 20))
+            offset = int(request.query_params.get("offset", 0))
 
             total_count = queryset.count()
-            paginated_queryset = queryset[offset:offset + limit]
+            paginated_queryset = queryset[offset : offset + limit]
 
             serializer = self.get_serializer(paginated_queryset, many=True)
 
-            return Response({
-                'results': serializer.data,
-                'total_count': total_count,
-                'limit': limit,
-                'offset': offset,
-                'has_more': (offset + limit) < total_count
-            })
+            return Response(
+                {
+                    "results": serializer.data,
+                    "total_count": total_count,
+                    "limit": limit,
+                    "offset": offset,
+                    "has_more": (offset + limit) < total_count,
+                }
+            )
 
         except Exception as e:
             logger.error(f"Error listing examinations: {str(e)}")
             return Response(
-                {'error': 'Failed to list examinations'},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )
+                {"error": "Failed to list examinations"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )

endoreg_db/views/patient_examination/video.py

@@ -5,30 +5,29 @@ from endoreg_db.models import (
     Examination,
     VideoFile,
     Finding,
-    FindingClassification,
-    PatientExamination, PatientFinding, PatientFindingClassification,
-    PatientFindingIntervention,
+    PatientExamination,
 )
 from django.db import DatabaseError, transaction
 from django.utils import timezone
 import logging
 from rest_framework.decorators import api_view
 
+
 @api_view(["GET"])
 def get_examinations_for_video(request, video_id):
     _video = get_object_or_404(VideoFile, id=video_id)
-    #TODO no functionality implemented yet
+    # TODO no functionality implemented yet
     return Response([])
 
+
 class VideoPatientExaminationViewSet(viewsets.ModelViewSet):
     """
     ViewSet for PatientExamination CRUD operations in the context of video files
     Handles POST and PATCH for video examinations at timestamps
     """
 
-
     def get_queryset(self):
-        video_id = self.request.query_params.get('videoId')
+        video_id = self.request.query_params.get("videoId")
         if video_id:
             return PatientExamination.objects.filter(video_id=video_id)
         return PatientExamination.objects.all()
@@ -42,50 +41,44 @@ class VideoPatientExaminationViewSet(viewsets.ModelViewSet):
         errors = {}
 
         # patient_id validation
-        if 'patient_id' not in data:
-            errors['patient_id'] = 'This field is required.'
+        if "patient_id" not in data:
+            errors["patient_id"] = "This field is required."
         else:
             try:
-                data['patient_id'] = int(data['patient_id'])
+                data["patient_id"] = int(data["patient_id"])
             except (TypeError, ValueError):
-                errors['patient_id'] = 'Must be an integer.'
+                errors["patient_id"] = "Must be an integer."
 
         # exam_date validation
-        if 'exam_date' not in data:
-            errors['exam_date'] = 'This field is required.'
+        if "exam_date" not in data:
+            errors["exam_date"] = "This field is required."
         else:
             from django.utils.dateparse import parse_date
-            parsed = parse_date(data['exam_date'])
+
+            parsed = parse_date(data["exam_date"])
             if not parsed:
-                errors['exam_date'] = 'Invalid date format.'
+                errors["exam_date"] = "Invalid date format."
             else:
-                data['exam_date'] = parsed
+                data["exam_date"] = parsed
 
         # video_file presence
-        if 'video_file' not in data:
-            errors['video_file'] = 'This field is required.'
+        if "video_file" not in data:
+            errors["video_file"] = "This field is required."
 
         return data, errors
 
-
     def _create_examination_data(self, validated_data):
         """
         Create examination and video record, then return payload.
         """
         # assume Examination, Video imported above
         exam = Examination.objects.create(
-            patient_id=validated_data['patient_id'],
-            date=validated_data['exam_date']
+            patient_id=validated_data["patient_id"], date=validated_data["exam_date"]
         )
         vid = VideoFile.objects.create(
-            examination=exam,
-            file=validated_data['video_file']
+            examination=exam, file=validated_data["video_file"]
         )
-        return {
-            'examination_id': exam.id,
-            'video_id': vid.id
-        }
-
+        return {"examination_id": exam.id, "video_id": vid.id}
 
     def create(self, request, *args, **kwargs):
         """
@@ -94,101 +87,142 @@ class VideoPatientExaminationViewSet(viewsets.ModelViewSet):
         logger = logging.getLogger(__name__)
         clean_data, errors = self._validate_create_data(request)
         if errors:
-            return Response({'errors': errors}, status=400)
+            return Response({"errors": errors}, status=400)
 
         try:
             payload = self._create_examination_data(clean_data)
             return Response(payload, status=201)
         except DatabaseError as db_err:
-            return Response(
-                {'error': f'Database error: {db_err}'},
-                status=500
-            )
+            return Response({"error": f"Database error: {db_err}"}, status=500)
         except Exception:
             logger.exception("Unexpected error in create()")
-            return Response(
-                {'error': 'Internal server error'},
-                status=500
-            )
+            return Response({"error": "Internal server error"}, status=500)
 
     def update(self, request, *args, **kwargs):
         logger = logging.getLogger(__name__)
         try:
-            examination_id = kwargs.get('pk')
+            examination_id = kwargs.get("pk")
             if not examination_id:
-                return Response({'error': 'Examination ID is required'}, status=status.HTTP_400_BAD_REQUEST)
+                return Response(
+                    {"error": "Examination ID is required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
             data = request.data
-            if 'videoId' in data:
+            if "videoId" in data:
                 try:
-                    data['videoId'] = int(data['videoId'])
+                    data["videoId"] = int(data["videoId"])
                 except (ValueError, TypeError):
-                    return Response({'error': 'Invalid videoId format'}, status=status.HTTP_400_BAD_REQUEST)
-            if 'timestamp' in data:
+                    return Response(
+                        {"error": "Invalid videoId format"},
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
+            if "timestamp" in data:
                 try:
-                    timestamp = float(data['timestamp'])
+                    timestamp = float(data["timestamp"])
                     if timestamp < 0:
-                        return Response({'error': 'Timestamp cannot be negative'}, status=status.HTTP_400_BAD_REQUEST)
-                    data['timestamp'] = timestamp
+                        return Response(
+                            {"error": "Timestamp cannot be negative"},
+                            status=status.HTTP_400_BAD_REQUEST,
+                        )
+                    data["timestamp"] = timestamp
                 except (ValueError, TypeError):
-                    return Response({'error': 'Invalid timestamp format'}, status=status.HTTP_400_BAD_REQUEST)
+                    return Response(
+                        {"error": "Invalid timestamp format"},
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
             with transaction.atomic():
-                if 'videoId' in data:
+                if "videoId" in data:
                     try:
-                        VideoFile.objects.get(id=data['videoId'])
+                        VideoFile.objects.get(id=data["videoId"])
                     except VideoFile.DoesNotExist:
-                        return Response({'error': 'Video not found'}, status=status.HTTP_404_NOT_FOUND)
-                if 'examinationTypeId' in data:
+                        return Response(
+                            {"error": "Video not found"},
+                            status=status.HTTP_404_NOT_FOUND,
+                        )
+                if "examinationTypeId" in data:
                     try:
-                        examination_type_id = int(data['examinationTypeId'])
+                        examination_type_id = int(data["examinationTypeId"])
                         Examination.objects.get(id=examination_type_id)
                     except (ValueError, TypeError):
-                        return Response({'error': 'Invalid examination type ID format'}, status=status.HTTP_400_BAD_REQUEST)
+                        return Response(
+                            {"error": "Invalid examination type ID format"},
+                            status=status.HTTP_400_BAD_REQUEST,
+                        )
                     except Examination.DoesNotExist:
-                        return Response({'error': 'Examination type not found'}, status=status.HTTP_404_NOT_FOUND)
-                if 'findingId' in data:
+                        return Response(
+                            {"error": "Examination type not found"},
+                            status=status.HTTP_404_NOT_FOUND,
+                        )
+                if "findingId" in data:
                     try:
-                        finding_id = int(data['findingId'])
+                        finding_id = int(data["findingId"])
                         Finding.objects.get(id=finding_id)
                     except (ValueError, TypeError):
-                        return Response({'error': 'Invalid finding ID format'}, status=status.HTTP_400_BAD_REQUEST)
+                        return Response(
+                            {"error": "Invalid finding ID format"},
+                            status=status.HTTP_400_BAD_REQUEST,
+                        )
                     except Finding.DoesNotExist:
-                        return Response({'error': 'Finding not found'}, status=status.HTTP_404_NOT_FOUND)
+                        return Response(
+                            {"error": "Finding not found"},
+                            status=status.HTTP_404_NOT_FOUND,
+                        )
                 examination_data = {
-                    'id': examination_id,
-                    'video_id': data.get('videoId'),
-                    'timestamp': data.get('timestamp'),
-                    'examination_type': data.get('examinationTypeId'),
-                    'finding': data.get('findingId'),
-                    'location_classification': data.get('locationClassificationId'),
-                    'location_choice': data.get('locationChoiceId'),
-                    'morphology_classification': data.get('morphologyClassificationId'),
-                    'morphology_choice': data.get('morphologyChoiceId'),
-                    'interventions': data.get('interventionIds', []),
-                    'notes': data.get('notes', ''),
-                    'updated_at': timezone.now().isoformat()
+                    "id": examination_id,
+                    "video_id": data.get("videoId"),
+                    "timestamp": data.get("timestamp"),
+                    "examination_type": data.get("examinationTypeId"),
+                    "finding": data.get("findingId"),
+                    "location_classification": data.get("locationClassificationId"),
+                    "location_choice": data.get("locationChoiceId"),
+                    "morphology_classification": data.get("morphologyClassificationId"),
+                    "morphology_choice": data.get("morphologyChoiceId"),
+                    "interventions": data.get("interventionIds", []),
+                    "notes": data.get("notes", ""),
+                    "updated_at": timezone.now().isoformat(),
                 }
                 logger.info(f"Updated video examination {examination_id}")
                 return Response(examination_data, status=status.HTTP_200_OK)
         except Exception as e:
-            logger.error(f"Unexpected error updating examination {examination_id}: {str(e)}")
-            return Response({'error': 'Internal server error while updating examination'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+            logger.error(
+                f"Unexpected error updating examination {examination_id}: {str(e)}"
+            )
+            return Response(
+                {"error": "Internal server error while updating examination"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
 
     def destroy(self, request, *args, **kwargs):
         logger = logging.getLogger(__name__)
         try:
-            examination_id = kwargs.get('pk')
+            examination_id = kwargs.get("pk")
             if not examination_id:
-                return Response({'error': 'Examination ID is required'}, status=status.HTTP_400_BAD_REQUEST)
+                return Response(
+                    {"error": "Examination ID is required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
             try:
                 if not str(examination_id).strip():
-                    return Response({'error': 'Invalid examination ID format'}, status=status.HTTP_400_BAD_REQUEST)
+                    return Response(
+                        {"error": "Invalid examination ID format"},
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
             except (ValueError, TypeError):
-                return Response({'error': 'Invalid examination ID format'}, status=status.HTTP_400_BAD_REQUEST)
+                return Response(
+                    {"error": "Invalid examination ID format"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
             with transaction.atomic():
                 logger.info(f"Deleted video examination {examination_id}")
-                return Response({'message': f'Examination {examination_id} deleted successfully'}, status=status.HTTP_204_NO_CONTENT)
+                return Response(
+                    {"message": f"Examination {examination_id} deleted successfully"},
+                    status=status.HTTP_204_NO_CONTENT,
+                )
         except Exception as e:
-            logger.error(f"Unexpected error deleting examination {examination_id}: {str(e)}")
-            return Response({'error': 'Internal server error while deleting examination'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-
+            logger.error(
+                f"Unexpected error deleting examination {examination_id}: {str(e)}"
+            )
+            return Response(
+                {"error": "Internal server error while deleting examination"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )

endoreg_db/views/patient_finding/__init__.py

@@ -4,4 +4,4 @@ from .patient_finding_optimized import OptimizedPatientFindingViewSet
 __all__ = [
     "PatientFindingViewSet",
     "OptimizedPatientFindingViewSet",
-]
+]

endoreg_db/views/patient_finding/patient_finding.py

@@ -10,9 +10,13 @@ class PatientFindingViewSet(ModelViewSet):
     queryset = PatientFinding.objects.all()
     serializer_class = PatientFindingSerializer
     filter_backends = [DjangoFilterBackend]
-    filterset_fields = ['patient_examination']
-    
-    @action(detail=False, methods=['get'], url_path='by-examination/(?P<patient_examination_id>[^/.]+)')
+    filterset_fields = ["patient_examination"]
+
+    @action(
+        detail=False,
+        methods=["get"],
+        url_path="by-examination/(?P<patient_examination_id>[^/.]+)",
+    )
     def get_patient_findings_by_examination(self, request, patient_examination_id=None):
         """Explicitly get patient findings by patient examination id_
 
@@ -23,12 +27,15 @@ class PatientFindingViewSet(ModelViewSet):
         Returns:
             _type_: _description_
         """
-        patient_finding_objs = PatientFinding.objects.filter(patient_examination=patient_examination_id)
+        patient_finding_objs = PatientFinding.objects.filter(
+            patient_examination=patient_examination_id
+        )
         serializer = self.get_serializer(patient_finding_objs, many=True)
         return Response(serializer.data)
-    
 
-    @action(detail=False, methods=['get'], url_path='by-id/(?P<patient_finding_id>[^/.]+)')
+    @action(
+        detail=False, methods=["get"], url_path="by-id/(?P<patient_finding_id>[^/.]+)"
+    )
     def get_patient_finding_by_id(self, request, patient_finding_id=None):
         """_summary_
 
@@ -42,18 +49,18 @@ class PatientFindingViewSet(ModelViewSet):
         patient_finding_obj = PatientFinding.objects.filter(id=patient_finding_id)
         serializer = self.get_serializer(patient_finding_obj, many=True)
         return Response(serializer.data)
-    
+
     def add_patient_finding(self, request):
         """
         Endpoint to add a new finding to a PatientExamination
         POST /api/patient_findings/add/
         """
-        
+
         serializer = self.get_serializer(data=request.data)
         serializer.is_valid(raise_exception=True)
         serializer.save()
         return Response(serializer.data, status=201)
-    
+
     def get_all_patient_findings(self, request):
         """
         Endpoint to retrieve all PatientFindings
@@ -61,4 +68,4 @@ class PatientFindingViewSet(ModelViewSet):
         """
         findings = PatientFinding.objects.all()
         serializer = self.get_serializer(findings, many=True)
-        return Response(serializer.data)
+        return Response(serializer.data)