endoreg-db 0.8.5.4__py3-none-any.whl → 0.8.5.5__py3-none-any.whl

endoreg_db/views/video/video_examination_viewset.py

@@ -1,329 +1,242 @@
-# endoreg_db/views/examination_views.py
-from rest_framework.viewsets import ModelViewSet
-from rest_framework import status
-from rest_framework.decorators import api_view
-from rest_framework.response import Response
+# endoreg_db/views/video/video_examination_viewset.py
+"""
+Video Examination ViewSet
+
+Provides REST API endpoints for managing video-based patient examinations.
+Handles CRUD operations for PatientExamination records linked to VideoFile instances.
+
+**API Endpoints:**
+- GET /api/video-examinations/ - List all video examinations
+- GET /api/video-examinations/{id}/ - Get examination details
+- POST /api/video-examinations/ - Create new examination
+- PATCH /api/video-examinations/{id}/ - Update examination
+- DELETE /api/video-examinations/{id}/ - Delete examination
+- GET /api/video/{video_id}/examinations/ - List examinations for specific video
+
+**Frontend Integration:**
+Used by VideoExaminationAnnotation.vue for annotation workflow.
+"""
+
+import logging
+
+from django.db import transaction
 from django.shortcuts import get_object_or_404
-from rest_framework import viewsets
-
-from endoreg_db.models import (
-    Examination, 
-    VideoFile,
-    FindingClassification,
-    FindingClassificationChoice,
-    FindingIntervention,
-    Finding
-)
-from ...serializers.examination import (
-    ExaminationSerializer as ExaminationSerializer,
-    # FindingSerializer as FindingSerializer,
-)
+from rest_framework import status, viewsets
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from endoreg_db.models import PatientExamination, VideoFile
 
+from ...serializers.video_examination import (
+    VideoExaminationCreateSerializer,
+    VideoExaminationSerializer,
+    VideoExaminationUpdateSerializer,
+)
 
-class ExaminationViewSet(ModelViewSet):
-    queryset = Examination.objects.all()
-    serializer_class = ExaminationSerializer
+logger = logging.getLogger(__name__)
 
 
-# NEW: Video Examination CRUD ViewSet
 class VideoExaminationViewSet(viewsets.ModelViewSet):
     """
-    ViewSet for Video Examination CRUD operations
-    Handles POST and PATCH for video examinations at timestamps
+    ViewSet for Video Examination CRUD operations.
+
+    Provides comprehensive API for managing patient examinations within
+    the video annotation workflow. Supports filtering by video, patient,
+    and examination type.
+
+    **Usage Example:**
+    ```python
+    # Frontend (JavaScript)
+    // Get examinations for video 123
+    const response = await api.get('/api/video/123/examinations/');
+
+    // Create new examination
+    await api.post('/api/video-examinations/', {
+        video_id: 123,
+        examination_id: 5,
+        date_start: '2024-01-15'
+    });
+    ```
     """
-    
+
+    queryset = PatientExamination.objects.select_related(
+        "patient", "examination", "video"
+    ).prefetch_related("patient_findings")
+    serializer_class = VideoExaminationSerializer
+
+    def get_serializer_class(self):
+        """
+        Return appropriate serializer based on action.
+
+        - create: VideoExaminationCreateSerializer (handles complex creation logic)
+        - update/partial_update: VideoExaminationUpdateSerializer
+        - list/retrieve: VideoExaminationSerializer (read-only with nested data)
+        """
+        if self.action == "create":
+            return VideoExaminationCreateSerializer
+        elif self.action in ["update", "partial_update"]:
+            return VideoExaminationUpdateSerializer
+        return VideoExaminationSerializer
+
     def get_queryset(self):
-        # Return empty queryset as we handle retrieval manually
-        return []
-    
+        """
+        Filter examinations based on query parameters.
+
+        **Supported filters:**
+        - ?video_id=123 - Get examinations for specific video
+        - ?patient_id=456 - Get examinations for specific patient
+        - ?examination_id=789 - Get examinations of specific type
+        """
+        queryset = super().get_queryset()
+
+        # Filter by video if provided
+        video_id = self.request.query_params.get("video_id")
+        if video_id:
+            queryset = queryset.filter(video_id=video_id)
+
+        # Filter by patient if provided
+        patient_id = self.request.query_params.get("patient_id")
+        if patient_id:
+            queryset = queryset.filter(patient_id=patient_id)
+
+        # Filter by examination type if provided
+        examination_id = self.request.query_params.get("examination_id")
+        if examination_id:
+            queryset = queryset.filter(examination_id=examination_id)
+
+        return queryset
+
+    @action(detail=False, methods=["get"], url_path="video/(?P<video_id>[^/.]+)")
+    def by_video(self, request, video_id=None):
+        """
+        Get all examinations for a specific video.
+
+        **Endpoint:** GET /api/video-examinations/video/{video_id}/
+        **Alternative:** GET /api/video/{video_id}/examinations/
+
+        Args:
+            video_id: ID of the video
+
+        Returns:
+            200: List of examinations for the video
+            404: Video not found
+        """
+        # Validate video exists
+        video = get_object_or_404(VideoFile, id=video_id)
+
+        # Get examinations for this video
+        examinations = self.queryset.filter(video=video)
+
+        serializer = self.get_serializer(examinations, many=True)
+        return Response(serializer.data)
+
     def create(self, request, *args, **kwargs):
         """
-        Create a new video examination
-        POST /api/examinations/
-        
-        Expected payload:
+        Create a new video examination.
+
+        **Endpoint:** POST /api/video-examinations/
+
+        **Payload:**
+        ```json
         {
-            "videoId": 123,
-            "timestamp": 45.5,
-            "examinationTypeId": 1,
-            "findingId": 2,
-            "locationClassificationId": 3,
-            "locationChoiceId": 4,
-            "morphologyClassificationId": 5,
-            "morphologyChoiceId": 6,
-            "interventionIds": [7, 8],
-            "notes": "Sample notes"
+            "video_id": 123,
+            "examination_id": 5,
+            "date_start": "2024-01-15",
+            "date_end": "2024-01-15"
         }
+        ```
+
+        Returns:
+            201: Examination created successfully
+            400: Invalid data (missing required fields, validation errors)
+            404: Video or examination type not found
         """
-        from django.db import transaction
-        import logging
-        
-        logger = logging.getLogger(__name__)
-        
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+
         try:
-            data = request.data
-            
-            # Validate required fields
-            required_fields = ['videoId', 'timestamp', 'examinationTypeId', 'findingId']
-            for field in required_fields:
-                if field not in data or data[field] is None:
-                    return Response(
-                        {'error': f'Missing or null required field: {field}'}, 
-                        status=status.HTTP_400_BAD_REQUEST
-                    )
-            
-            # Validate data types
-            try:
-                video_id = int(data['videoId'])
-                timestamp = float(data['timestamp'])
-                examination_type_id = int(data['examinationTypeId'])
-                finding_id = int(data['findingId'])
-            except (ValueError, TypeError) as e:
-                return Response(
-                    {'error': f'Invalid data type in request: {str(e)}'}, 
-                    status=status.HTTP_400_BAD_REQUEST
+            with transaction.atomic():
+                patient_exam = serializer.save()
+
+                # Return created examination with full serialization
+                response_serializer = VideoExaminationSerializer(patient_exam)
+                logger.info(
+                    f"Created video examination: video={request.data.get('video_id')}, "
+                    f"exam={request.data.get('examination_id')}"
                 )
-            
-            # Validate timestamp is not negative
-            if timestamp < 0:
                 return Response(
-                    {'error': 'Timestamp cannot be negative'}, 
-                    status=status.HTTP_400_BAD_REQUEST
+                    response_serializer.data, status=status.HTTP_201_CREATED
                 )
-            
-            with transaction.atomic():
-                # Get video
-                try:
-                    video = VideoFile.objects.get(id=video_id)
-                except VideoFile.DoesNotExist:
-                    return Response(
-                        {'error': 'Video not found'}, 
-                        status=status.HTTP_404_NOT_FOUND
-                    )
-                
-                # Get examination type
-                try:
-                    examination = Examination.objects.get(id=examination_type_id)
-                except Examination.DoesNotExist:
-                    return Response(
-                        {'error': 'Examination type not found'}, 
-                        status=status.HTTP_404_NOT_FOUND
-                    )
-                
-                # Get finding
-                try:
-                    finding = Finding.objects.get(id=finding_id)
-                except Finding.DoesNotExist:
-                    return Response(
-                        {'error': 'Finding not found'}, 
-                        status=status.HTTP_404_NOT_FOUND
-                    )
-                
-                # Validate optional foreign keys if provided
-                if data.get('locationClassificationId'):
-                    try:
-                        FindingClassification.objects.get(id=data['locationClassificationId'], classification_types__name__iexact="location")
-                    except FindingClassification.DoesNotExist:
-                        return Response(
-                            {'error': 'Location classification not found'}, 
-                            status=status.HTTP_404_NOT_FOUND
-                        )
-                
-                if data.get('morphologyClassificationId'):
-                    try:
-                        FindingClassification.objects.get(
-                            id=data['morphologyClassificationId'],
-                            classification_types__name__iexact="morphology"
-                        )
-                    except FindingClassification.DoesNotExist:
-                        return Response(
-                            {'error': 'Morphology classification not found'}, 
-                            status=status.HTTP_404_NOT_FOUND
-                        )
-                
-                # Create examination record
-                examination_data = {
-                    'id': f"exam_{video.id}_{timestamp}_{examination.id}",
-                    'video_id': video_id,
-                    'timestamp': timestamp,
-                    'examination_type': examination.name,
-                    'finding': finding.name,
-                    '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', ''),
-                    'created_at': '2024-01-01T00:00:00Z'  # Placeholder timestamp
-                }
-                
-                logger.info(f"Created video examination for video {video_id} at timestamp {timestamp}")
-                return Response(examination_data, status=status.HTTP_201_CREATED)
-            
         except Exception as e:
-            logger.error(f"Unexpected error creating examination: {str(e)}")
+            logger.error(f"Error creating video examination: {str(e)}")
             return Response(
-                {'error': 'Internal server error while creating examination'}, 
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                {"error": "Internal server error while creating examination"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
             )
-    
+
     def update(self, request, *args, **kwargs):
         """
-        Update an existing video examination
-        PATCH /api/examinations/{id}/
+        Update an existing video examination.
+
+        **Endpoint:** PATCH /api/video-examinations/{id}/
+
+        **Payload:**
+        ```json
+        {
+            "examination_id": 6,
+            "date_start": "2024-01-16"
+        }
+        ```
+
+        Returns:
+            200: Examination updated successfully
+            400: Invalid data
+            404: Examination not found
         """
-        from django.db import transaction
-        import logging
-        
-        logger = logging.getLogger(__name__)
-        
+        partial = kwargs.pop("partial", False)
+        instance = self.get_object()
+        serializer = self.get_serializer(instance, data=request.data, partial=partial)
+        serializer.is_valid(raise_exception=True)
+
         try:
-            examination_id = kwargs.get('pk')
-            if not examination_id:
-                return Response(
-                    {'error': 'Examination ID is required'}, 
-                    status=status.HTTP_400_BAD_REQUEST
-                )
-            
-            data = request.data
-            
-            # Validate data types for provided fields
-            if 'videoId' in data:
-                try:
-                    data['videoId'] = int(data['videoId'])
-                except (ValueError, TypeError):
-                    return Response(
-                        {'error': 'Invalid videoId format'}, 
-                        status=status.HTTP_400_BAD_REQUEST
-                    )
-            
-            if 'timestamp' in data:
-                try:
-                    timestamp = float(data['timestamp'])
-                    if timestamp < 0:
-                        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
-                    )
-            
             with transaction.atomic():
-                # Validate foreign keys if provided
-                if 'videoId' in data:
-                    try:
-                        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:
-                    try:
-                        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
-                        )
-                    except Examination.DoesNotExist:
-                        return Response(
-                            {'error': 'Examination type not found'}, 
-                            status=status.HTTP_404_NOT_FOUND
-                        )
-                
-                if 'findingId' in data:
-                    try:
-                        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
-                        )
-                    except Finding.DoesNotExist:
-                        return Response(
-                            {'error': 'Finding not found'}, 
-                            status=status.HTTP_404_NOT_FOUND
-                        )
-                
-                # Return updated examination data
-                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': '2024-01-01T00:00:00Z'  # Placeholder timestamp
-                }
-                
-                logger.info(f"Updated video examination {examination_id}")
-                return Response(examination_data, status=status.HTTP_200_OK)
-            
+                patient_exam = serializer.save()
+
+                # Return updated examination
+                response_serializer = VideoExaminationSerializer(patient_exam)
+                logger.info(f"Updated video examination {instance.id}")
+                return Response(response_serializer.data)
         except Exception as e:
-            logger.error(f"Unexpected error updating examination {examination_id}: {str(e)}")
+            logger.error(f"Error updating video examination {instance.id}: {str(e)}")
             return Response(
-                {'error': 'Internal server error while updating examination'}, 
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                {"error": "Internal server error while updating examination"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
             )
-    
+
     def destroy(self, request, *args, **kwargs):
         """
-        Delete a video examination
-        DELETE /api/examinations/{id}/
+        Delete a video examination.
+
+        **Endpoint:** DELETE /api/video-examinations/{id}/
+
+        Returns:
+            204: Examination deleted successfully
+            404: Examination not found
         """
-        from django.db import transaction
-        import logging
-        
-        logger = logging.getLogger(__name__)
-        
+        instance = self.get_object()
+        examination_id = instance.id
+
         try:
-            examination_id = kwargs.get('pk')
-            if not examination_id:
-                return Response(
-                    {'error': 'Examination ID is required'}, 
-                    status=status.HTTP_400_BAD_REQUEST
-                )
-            
-            # Validate examination_id format
-            try:
-                # For now, we're using string IDs, so just validate it's not empty
-                if not str(examination_id).strip():
-                    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
-                )
-            
             with transaction.atomic():
-                # For now, we simulate successful deletion
-                # TODO: Implement actual examination record deletion when persistence is added
-                
+                instance.delete()
                 logger.info(f"Deleted video examination {examination_id}")
                 return Response(
-                    {'message': f'Examination {examination_id} deleted successfully'}, 
-                    status=status.HTTP_204_NO_CONTENT
+                    {"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)}")
+            logger.error(f"Error deleting examination {examination_id}: {str(e)}")
             return Response(
-                {'error': 'Internal server error while deleting examination'}, 
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                {"error": "Internal server error while deleting examination"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
             )

{endoreg_db-0.8.5.4.dist-info → endoreg_db-0.8.5.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: endoreg-db
-Version: 0.8.5.4
+Version: 0.8.5.5
 Summary: EndoReg Db Django App
 Project-URL: Homepage, https://info.coloreg.de
 Project-URL: Repository, https://github.com/wg-lux/endoreg-db

{endoreg_db-0.8.5.4.dist-info → endoreg_db-0.8.5.5.dist-info}/RECORD

@@ -380,7 +380,7 @@ endoreg_db/models/media/__init__.py,sha256=WuomOKk-3kNGDLKoLO_ltnXbo028JDVlCCScd
 endoreg_db/models/media/frame/__init__.py,sha256=25WriZHocR82rbHr_IMIgBt5z-mkV2O0LVWUpJRnQ5E,45
 endoreg_db/models/media/frame/frame.py,sha256=6BvNKTAGsC_Q0S27nrvZ2cySDy3LSu5HCxrNcZwIEsA,4408
 endoreg_db/models/media/pdf/__init__.py,sha256=1fimtZK5LUuP_yqETN6pMj0hxKXuQqeLb1DP5wPmtT4,343
-endoreg_db/models/media/pdf/raw_pdf.py,sha256=sBm5C1Pr4N4n8oQw_nNMLN5cnl3efQ-WKWby2_xBauk,26185
+endoreg_db/models/media/pdf/raw_pdf.py,sha256=aUOGyqFAMcOdfPE_BDGM1_e9vk_YQvZgNcXoSxOR2sg,29963
 endoreg_db/models/media/pdf/report_file.py,sha256=6Vt_TJSB3qaF26qXbyjRSn-s_zN5y4e-PPrN8ZbYS9s,4296
 endoreg_db/models/media/pdf/report_reader/__init__.py,sha256=LiMooVstXRay5qcB-uZW0wxbcdUvPrfAs_xBwWiuuWc,166
 endoreg_db/models/media/pdf/report_reader/report_reader_config.py,sha256=wYVDmPSmNIuCTpaaWqoLVgVZFYW-dqGpnAyVBqRLqXE,3445
@@ -390,7 +390,7 @@ endoreg_db/models/media/video/create_from_file.py,sha256=3n4bbzFteEOFDUuEikP0x-S
 endoreg_db/models/media/video/pipe_1.py,sha256=ljO3vO2mqqTXLZsKjzMTC6-sW4JRWMVRfJcK0n5CjKg,9740
 endoreg_db/models/media/video/pipe_2.py,sha256=DnMxW0uOqSsf7-0n9Rlvn7u89U4Jpkv7n6hFpQfUjkQ,4964
 endoreg_db/models/media/video/refactor_plan.md,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-endoreg_db/models/media/video/video_file.py,sha256=AyRmG_HSAgYTF-UWivk3EF7G9RHCpJbWE1PEeqlZJiU,29424
+endoreg_db/models/media/video/video_file.py,sha256=TULxjYp2vY-uQkSIAACkDY_cXIyApqFM9iQeojKQXuQ,30179
 endoreg_db/models/media/video/video_file_ai.py,sha256=3ABea52FOF1qlrlxHdYhz_M3Kmqfzqtgq7M0prl-FAo,18819
 endoreg_db/models/media/video/video_file_anonymize.py,sha256=pet1UfSsbSHJJZxq6gDPifAfBWpGyEpD1jEQuSQi0Gg,16027
 endoreg_db/models/media/video/video_file_frames.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -517,10 +517,11 @@ endoreg_db/queries/sanity/__init_.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 endoreg_db/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 endoreg_db/schemas/examination_evaluation.py,sha256=G6uBSQf9ZclwnGvMI-xVPd4IzD6GORUHYYRRCr5Qp6k,844
 endoreg_db/serializers/Frames_NICE_and_PARIS_classifications.py,sha256=q06UKC0Nt4sOJphwN9lEaY28ZAvtcMAlOwT5Zq_sblI,31384
-endoreg_db/serializers/__init__.py,sha256=DFcJPYKdCKHgfB8emktMyAWa9nArjzEqRsy0IXLagS8,3386
+endoreg_db/serializers/__init__.py,sha256=LryzaMvorz_qacOnaT8Uu10L8KHHQRtLVaWU-nlQ43g,3589
 endoreg_db/serializers/anonymization.py,sha256=R5hlk6KiHpQ2JshKlFq5gY6Ed4TrarA74hlvll9w-4s,2576
 endoreg_db/serializers/examination_serializer.py,sha256=JPI9diMup9e-nSCH6UwU9KulnSKreg6pOwjKCLHWJfs,281
 endoreg_db/serializers/sensitive_meta_serializer.py,sha256=zF_0HOrdhi9714DExVD1DTsQqDbRIJevkjLU4vZEgYE,10748
+endoreg_db/serializers/video_examination.py,sha256=jotR5PNTA_xEMpqsqdP3PFaie8TO7SGv2Vp18sj8TlY,6937
 endoreg_db/serializers/_old/raw_pdf_meta_validation.py,sha256=hZaPTY4AA4wO7uAA0-DKLueHwtqnNsJqFR8Apdv6wTk,7608
 endoreg_db/serializers/_old/raw_video_meta_validation.py,sha256=Owku2MmHjEZR_FpgKUdaG9In9IRwur53NmhJdser9Bs,7542
 endoreg_db/serializers/_old/video.py,sha256=O7PIt7uJNP5Xy9R9tbWuptCcsrm1dV0382_ymyVgl5w,2634
@@ -610,7 +611,7 @@ endoreg_db/tasks/video_processing_tasks.py,sha256=rZ7Kr49bAR4Q-vALO2SURebrhcJ5hS
 endoreg_db/templates/timeline.html,sha256=H9VXKOecCzqcWWkpNIZXFI29ztg-oxV5uvxMglgoClk,6167
 endoreg_db/templates/admin/patient_finding_intervention.html,sha256=F3JUKm3HhWIf_xoZZ-SET5d5ZDlm2jMM8g909w1dnYc,10164
 endoreg_db/templates/admin/start_examination.html,sha256=3K4wirul9KNyB5mN9cpfCSCAyAD6ro19GwxFOY5sZ3A,267
-endoreg_db/urls/__init__.py,sha256=xR1QnSBY0mdUUJ8Wkf71063in59ZEKIFgoaw3Ak76Ow,2973
+endoreg_db/urls/__init__.py,sha256=YpT06IceApAkWfQvNmqMku8F_vozWD4UDl6j3BamS_I,3303
 endoreg_db/urls/anonymization.py,sha256=zLoOOpu4XSha002nOi0fiJUAT8Dff7u7RQFtdU4A6aw,1853
 endoreg_db/urls/auth.py,sha256=t95D8n3fiOhkUiINVGygrW0jiQiJc_XNmfk2S8pcDxk,440
 endoreg_db/urls/classification.py,sha256=2JdHsCSpLs5bZWiTsDpWvyLE_OJkf7LrCCOob7H8M-k,1802
@@ -759,7 +760,7 @@ endoreg_db/views/patient_finding_morphology/pfm_create.py,sha256=-OYTH7iHPuSrYxb
 endoreg_db/views/pdf/__init__.py,sha256=N3fR1qX7xpt4LMFU0BmJxnHRGoG-nKezj9ifStWVt7M,188
 endoreg_db/views/pdf/pdf_media.py,sha256=Ox981PIOVPqhRwZUZ_nkuLZ3L91owZpOzYZRS06C94k,11055
 endoreg_db/views/pdf/pdf_stream_views.py,sha256=oLfV60lNAqn2eZgbkRxuoVftDphTYHiSoZaqfX2pcl4,5495
-endoreg_db/views/pdf/reimport.py,sha256=GNUUFJS56qaegbhCdD4t3ytdp-EGPb5mRvq6BSe5QQ4,6902
+endoreg_db/views/pdf/reimport.py,sha256=9tMIsxZ5R83rC-GBcJt78QBLqmYaEBypFd6ToEeTsfk,6939
 endoreg_db/views/report/__init__.py,sha256=mw1WncSWijE73mSzkZPWsQ66ii9icZMLmEEEx9iV4BA,241
 endoreg_db/views/report/report_list.py,sha256=Ziav43FKYux2dsETaX7zUYs-g7__4laHwXEMZSq1Ahs,3940
 endoreg_db/views/report/report_with_secure_url.py,sha256=vMGgngPGvNkPYxhNjSJG6rZKN0yuSoJNl1vZPiAoh6I,1042
@@ -782,13 +783,13 @@ endoreg_db/views/video/video_analyze.py,sha256=vxQHnXRFH5Y6IaWEmEnE4Svkz6Vjw1O9N
 endoreg_db/views/video/video_apply_mask.py,sha256=spGK4oXMAKhVotJuwZGndbKKws6klveKe35mbX7Rv6k,1630
 endoreg_db/views/video/video_correction.py,sha256=9mFICVvRSxp0WhGv7ib4d4M1hJs1iIhYmTl2OUIXQAg,767
 endoreg_db/views/video/video_download_processed.py,sha256=tp5llYJKyQD0WSr4Fvqi-YrgBw2EPPe23E8F8SZbR4w,2000
-endoreg_db/views/video/video_examination_viewset.py,sha256=77ujdUh8fzTC5Oe2fo4ESLBkwJ10rGhJLlQBpP1eMbQ,13663
+endoreg_db/views/video/video_examination_viewset.py,sha256=ej6CUK1JGFN7JmZOj25g1heaIIAwh6cf1HaYFmcR9EE,8331
 endoreg_db/views/video/video_media.py,sha256=fvMQmSM1a-3rxpx_wK0wee9sRXV3EZz2bF8jLRAeaIQ,7022
 endoreg_db/views/video/video_meta.py,sha256=C1wBMTtQb_yzEUrhFGAy2UHEWMk_CbU75WXX_5z00sE,1021
 endoreg_db/views/video/video_processing_history.py,sha256=mhFuS8RG5GV8E-lTtuD0qrq-bIpnUFp8vy9aERfC-J8,770
 endoreg_db/views/video/video_remove_frames.py,sha256=2FmvNrSPM0fUXiBxINN6vBUUDCqDlBkNcGR3WsLDgKo,1696
 endoreg_db/views/video/video_stream.py,sha256=kLyuf0ORTmsLeYUQkTQ6iRYqlIQozWhMMR3Lhfe_trk,12148
-endoreg_db-0.8.5.4.dist-info/METADATA,sha256=F2Ma_FJzdqwLhv8CoQlTc3U2lXg-axA8T9EJd2KumPo,14719
-endoreg_db-0.8.5.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-endoreg_db-0.8.5.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-endoreg_db-0.8.5.4.dist-info/RECORD,,
+endoreg_db-0.8.5.5.dist-info/METADATA,sha256=8JT-qB-gQdbZy2OD0K8bzTa3ngHy6nlgxj7XQC28DOU,14719
+endoreg_db-0.8.5.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+endoreg_db-0.8.5.5.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+endoreg_db-0.8.5.5.dist-info/RECORD,,