endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/views/video/video_apply_mask.py

@@ -0,0 +1,49 @@
+from endoreg_db.models import VideoFile
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+
+
+from django.shortcuts import get_object_or_404
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+
+class VideoApplyMaskView(APIView):
+    """
+    POST /api/video-apply-mask/{id}/ - Apply mask to video using streaming processing
+    """
+
+    permission_classes = [EnvironmentAwarePermission]
+
+    def post(self, request, pk):
+        video = get_object_or_404(VideoFile, pk=pk)
+
+        mask_type = request.data.get("mask_type", "device_default")
+        device_name = request.data.get("device_name", "olympus_cv_1500")
+        use_streaming = request.data.get("use_streaming", True)
+        custom_mask = request.data.get("custom_mask")
+
+        try:
+            # Start async task for video masking
+            from endoreg_db.tasks.video_processing_tasks import apply_video_mask_task
+
+            task_data = {
+                "video_id": pk,
+                "mask_type": mask_type,
+                "device_name": device_name,
+                "use_streaming": use_streaming,
+                "custom_mask": custom_mask,
+            }
+
+            task = apply_video_mask_task.delay(**task_data)
+
+            return Response(
+                {"task_id": task.id, "status": "started"},
+                status=status.HTTP_202_ACCEPTED,
+            )
+
+        except Exception as e:
+            return Response(
+                {"error": f"Failed to start masking task: {str(e)}"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )

endoreg_db/views/video/video_correction.py

@@ -0,0 +1,22 @@
+from endoreg_db.models import VideoFile
+from endoreg_db.serializers.video.video_file_detail import VideoDetailSerializer
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+
+
+from django.shortcuts import get_object_or_404
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+
+class VideoCorrectionView(APIView):
+    """
+    GET /api/video/media/video-correction/{id}/ - Get video details for correction
+    """
+
+    permission_classes = [EnvironmentAwarePermission]
+
+    def get(self, request, pk):
+        video = get_object_or_404(VideoFile, pk=pk)
+        ser = VideoDetailSerializer(video, context={"request": request})
+        return Response(ser.data, status=status.HTTP_200_OK)

endoreg_db/views/video/video_download_processed.py

@@ -0,0 +1,58 @@
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+
+
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+
+import os
+
+
+class VideoDownloadProcessedView(APIView):
+    """
+    GET /api/video-download-processed/{id}/ - Download processed video result
+    """
+
+    permission_classes = [EnvironmentAwarePermission]
+
+    def get(self, request, pk):
+        # Remove unused 'video' variable
+        output_path = request.query_params.get("path")
+
+        # Define the allowed base directory for processed videos
+        processed_base_dir = os.path.abspath(
+            os.getenv("PROCESSED_VIDEO_DIR", "/srv/processed_videos")
+        )
+        if not output_path:
+            return Response(
+                {"error": "Processed file not found"}, status=status.HTTP_404_NOT_FOUND
+            )
+
+        # Resolve the absolute path and check if it's within the allowed directory
+        abs_output_path = os.path.abspath(output_path)
+        if not abs_output_path.startswith(processed_base_dir + os.sep):
+            return Response(
+                {"error": "Invalid file path"}, status=status.HTTP_400_BAD_REQUEST
+            )
+
+        if not os.path.exists(abs_output_path):
+            return Response(
+                {"error": "Processed file not found"}, status=status.HTTP_404_NOT_FOUND
+            )
+
+        try:
+            from django.http import FileResponse
+
+            with open(abs_output_path, "rb") as f:
+                response = FileResponse(f, content_type="video/mp4")
+                response["Content-Disposition"] = (
+                    f'attachment; filename="{os.path.basename(abs_output_path)}"'
+                )
+                return response
+
+        except Exception as e:
+            return Response(
+                {"error": f"Failed to serve file: {str(e)}"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )

endoreg_db/views/video/video_examination_viewset.py

@@ -0,0 +1,242 @@
+# 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 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,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class VideoExaminationViewSet(viewsets.ModelViewSet):
+    """
+    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):
+        """
+        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.
+
+        **Endpoint:** POST /api/video-examinations/
+
+        **Payload:**
+        ```json
+        {
+            "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
+        """
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+
+        try:
+            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')}"
+                )
+                return Response(
+                    response_serializer.data, status=status.HTTP_201_CREATED
+                )
+        except Exception as 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,
+            )
+
+    def update(self, request, *args, **kwargs):
+        """
+        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
+        """
+        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:
+            with transaction.atomic():
+                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"Error updating video examination {instance.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):
+        """
+        Delete a video examination.
+
+        **Endpoint:** DELETE /api/video-examinations/{id}/
+
+        Returns:
+            204: Examination deleted successfully
+            404: Examination not found
+        """
+        instance = self.get_object()
+        examination_id = instance.id
+
+        try:
+            with transaction.atomic():
+                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,
+                )
+        except Exception as 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,
+            )

endoreg_db/views/video/video_metadata.py

@@ -0,0 +1,101 @@
+from endoreg_db.models import VideoFile
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+from django.shortcuts import get_object_or_404
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+class VideoMetadataStatsView(APIView):
+    """
+    GET media/videos/{pk}/metadata/ - Get comprehensive video metadata.
+    
+    Merges logic from:
+    1. VideoFile model (duration, fps, resolution)
+    2. VideoState model (status, anonymization flags)
+    3. Related models (Center, Processor, SensitiveMeta)
+    """
+
+    permission_classes = [EnvironmentAwarePermission]
+
+    def get(self, request, pk):
+        # Prefetch related fields to avoid N+1 queries since we access them all
+        video = get_object_or_404(
+            VideoFile.objects.select_related(
+                'state', 
+                'center', 
+                'processor', 
+                'video_meta', 
+                'sensitive_meta'
+            ), 
+            pk=pk
+        )
+
+        # --- 1. Basic Specs (from VideoFile) ---
+        # Use model fields, defaulting if None
+        duration = video.duration if video.duration is not None else 0
+        fps = video.fps if video.fps is not None else 50 
+        
+        resolution = "BLANK"
+        if video.width and video.height:
+            resolution = f"{video.width}x{video.height}"
+
+        # --- 2. Status & State (from VideoState) ---
+        status_val = "BLANK"
+        is_anonymized = False
+        
+        if hasattr(video, 'state') and video.state:
+            # anonymization_status returns an Enum, we need the value (string)
+            raw_status = video.state.anonymization_status
+            status_val = getattr(raw_status, 'value', str(raw_status))
+            
+            # Check logical anonymization state
+            is_anonymized = (
+                status_val == 'done_processing_anonymization' or 
+                video.state.anonymized
+            )
+
+        # --- 3. Relations (Center / Processor) ---
+        center_name = "Unbekannt"
+        if video.center:
+            center_name = getattr(video.center, 'name', str(video.center))
+
+        processor_name = "Unbekannt"
+        if video.processor:
+            processor_name = getattr(video.processor, 'name', str(video.processor))
+
+        # --- 4. Deep Inference (SensitiveMeta / VideoMeta) ---
+        sensitive_count = None
+        total_frames = video.frame_count # Direct from VideoFile model
+        sensitive_ratio = None
+        outside_frame_count = 0
+        
+        outside_segments = video.get_outside_segments(only_validated=False)
+        count = outside_segments.count()
+
+        print(f"Number of outside segments: {count}")
+        # Try to get ROI data (from video_meta relation)
+        has_roi = False
+        if hasattr(video, 'video_meta') and video.video_meta:
+            has_roi = getattr(video.video_meta, 'has_roi', False)
+
+        # --- 5. Construct Response ---
+        metadata = {
+            # -- Frontend VideoMeta Requirements --
+            "id": video.pk,
+            "original_file_name": video.original_file_name or f"Video {pk}",
+            "status": str(status_val),
+            "assignedUser": "BLANK",
+            "anonymized": is_anonymized,
+            "duration": duration,
+            "fps": fps,
+            "hasROI": has_roi,
+            "outsideFrameCount": outside_frame_count,
+            "centerName": center_name,
+            "processorName": processor_name,
+            "sensitiveFrameCount": sensitive_count,
+            "totalFrames": total_frames,
+            "sensitiveRatio": sensitive_ratio,
+            "resolution": resolution,
+        }
+
+        return Response(metadata, status=status.HTTP_200_OK)

endoreg_db/views/video/video_processing_history.py

@@ -0,0 +1,25 @@
+from endoreg_db.models import VideoFile
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+
+
+from django.shortcuts import get_object_or_404
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+
+class VideoProcessingHistoryView(APIView):
+    """
+    GET /api/video-processing-history/{id}/ - Get processing history for a video
+    """
+
+    permission_classes = [EnvironmentAwarePermission]
+
+    def get(self, request, pk):
+        _video = get_object_or_404(VideoFile, pk=pk)
+
+        # For now, return empty history - can be extended with actual history tracking
+        # TODO plan when to implement this
+        history = []
+
+        return Response(history, status=status.HTTP_200_OK)

endoreg_db/views/video/video_remove_frames.py

@@ -0,0 +1,49 @@
+from endoreg_db.models import VideoFile
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+
+
+from django.shortcuts import get_object_or_404
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+
+class VideoRemoveFramesView(APIView):
+    """
+    POST /api/video-remove-frames/{id}/ - Remove frames from video using streaming processing
+    """
+
+    permission_classes = [EnvironmentAwarePermission]
+
+    def post(self, request, pk):
+        video = get_object_or_404(VideoFile, pk=pk)
+
+        selection_method = request.data.get("selection_method", "automatic")
+        detection_engine = request.data.get("detection_engine", "minicpm")
+        use_streaming = request.data.get("use_streaming", True)
+        manual_frames = request.data.get("manual_frames")
+
+        try:
+            # Start async task for frame removal
+            from endoreg_db.tasks.video_processing_tasks import remove_video_frames_task
+
+            task_data = {
+                "video_id": pk,
+                "selection_method": selection_method,
+                "detection_engine": detection_engine,
+                "use_streaming": use_streaming,
+                "manual_frames": manual_frames,
+            }
+
+            task = remove_video_frames_task.delay(**task_data)
+
+            return Response(
+                {"task_id": task.id, "status": "started"},
+                status=status.HTTP_202_ACCEPTED,
+            )
+
+        except Exception as e:
+            return Response(
+                {"error": f"Failed to start frame removal task: {str(e)}"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )