endoreg-db 0.8.6.4__py3-none-any.whl

endoreg_db/views/video/reimport.py

@@ -0,0 +1,195 @@
+from celery.events import state
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
+import logging
+from pathlib import Path
+from django.db import transaction
+from ...models import VideoFile, SensitiveMeta
+from ...services.video_import import VideoImportService
+logger = logging.getLogger(__name__)
+
+class VideoReimportView(APIView):
+    """
+    API endpoint to re-import a video file and regenerate metadata.
+    This is useful when OCR failed or metadata is incomplete.
+    """
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.video_service = VideoImportService()
+
+    def post(self, request, pk):
+        """
+        Re-import a video file to regenerate SensitiveMeta and other metadata.
+        Instead of creating a new video, this updates the existing one.
+        
+        Args:
+            pk (int): Primary key of the VideoFile to reimport
+        """
+        # Validate pk parameter
+        if not pk or not isinstance(pk, int):
+            return Response(
+                {"error": "Invalid video ID provided."}, 
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        try:
+            video = VideoFile.objects.get(id=pk)
+            logger.info(f"Found video {video.uuid} (ID: {pk}) for re-import")
+        except VideoFile.DoesNotExist:
+            logger.warning(f"Video with ID {pk} not found")
+            return Response(
+                {"error": f"Video with ID {pk} not found."}, 
+                status=status.HTTP_404_NOT_FOUND
+            )
+
+        # Check if video has a raw file
+        if not video.raw_file:
+            logger.warning(f"Video {video.uuid} has no raw file")
+            return Response(
+                {"error": "Video has no raw file to re-import."}, 
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        # Check if the raw file actually exists on disk
+        raw_file_path = Path(video.raw_file.path)
+        if not raw_file_path.exists():
+            logger.error(f"Raw file not found on disk: {raw_file_path}")
+            return Response(
+                {"error": f"Video file not found on server: {raw_file_path.name}"}, 
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        # Check if video has required relationships
+        if not video.center:
+            logger.warning(f"Video {video.uuid} has no associated center")
+            return Response(
+                {"error": "Video has no associated center."}, 
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        try:
+            logger.info(f"Starting in-place re-import for video {video.uuid} (ID: {pk})")
+            
+            with transaction.atomic():
+                # Clear existing metadata to force regeneration
+                old_meta_id = None
+                if video.sensitive_meta:
+                    old_meta_id = video.sensitive_meta.id
+                    logger.info(f"Clearing existing SensitiveMeta {old_meta_id} for video {video.uuid}")
+                    video.sensitive_meta = None
+                    video.save(update_fields=['sensitive_meta'])
+                    
+                    # Delete the old SensitiveMeta record
+                    try:
+                        SensitiveMeta.objects.filter(id=old_meta_id).delete()
+                        logger.info(f"Deleted old SensitiveMeta {old_meta_id}")
+                    except Exception as e:
+                        logger.warning(f"Could not delete old SensitiveMeta {old_meta_id}: {e}")
+                
+                # Re-initialize video specs and frames
+                logger.info(f"Re-initializing video specs for {video.uuid}")
+                video.initialize_video_specs()
+                video.initialize_frames()
+                
+                # Run Pipe 1 for OCR and AI processing
+                logger.info(f"Starting Pipe 1 processing for {video.uuid}")
+            
+                try:
+                    success = video.pipe_1(
+                        model_name="image_multilabel_classification_colonoscopy_default",
+                        delete_frames_after=True,
+                        ocr_frame_fraction=0.01,
+                        ocr_cap=5
+                    )
+                except Exception as e:
+                    logger.error(f"Pipe 1 processing raised exception for {video.uuid}: {e}")
+                    return Response(
+                        {"error": f"OCR and AI processing failed: {str(e)}"},
+                        status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                    )
+                
+                if not success:
+                    logger.error(f"Pipe 1 processing failed for video {video.uuid}")
+                    return Response(
+                        {"error": "OCR and AI processing failed during re-import."}, 
+                        status=status.HTTP_500_INTERNAL_SERVER_ERROR
+                    )
+                
+                logger.info(f"Pipe 1 processing completed for {video.uuid}")
+                
+                # Ensure minimum patient data is available
+                logger.info(f"Ensuring minimum patient data for {video.uuid}")
+                self.video_service._ensure_default_patient_data(video)
+                
+                # Refresh from database to get updated data
+                video.refresh_from_db()
+                
+                # Use VideoImportService for anonymization
+                try:
+                    processor_name = video.video_meta.processor.name if video.video_meta and video.video_meta.processor else "Unknown"
+                    logger.info(f"Starting anonymization using VideoImportService for {video.uuid}")
+                    self.video_service.import_and_anonymize(
+                        file_path=raw_file_path,
+                        center_name=video.center.name,
+                        processor_name=processor_name,
+                        save_video=True,
+                        delete_source=False
+                    )
+                    
+                    logger.info(f"VideoImportService anonymization completed for {video.uuid}")
+                    
+                    
+                    return Response({
+                        "message": "Video re-import with VideoImportService completed successfully.",
+                        "video_id": pk,
+                        "uuid": str(video.uuid),
+                        "frame_cleaning_applied": True,
+                        "sensitive_meta_created": video.sensitive_meta is not None,
+                        "sensitive_meta_id": video.sensitive_meta.id if video.sensitive_meta else None,
+                        "updated_in_place": True,
+                        "status": "done"
+                    }, status=status.HTTP_200_OK)
+                    
+                except Exception as e:
+                    logger.exception(f"VideoImportService anonymization failed for video {video.uuid}: {e}")
+                    logger.warning("Continuing without anonymization due to error")
+                
+                state.mark_sensitive_meta_processed(save=True)
+                
+            # If we reach here, everything was successful
+            logger.info(f"Video re-import completed successfully for {video.uuid}")
+            video.save(update_fields=['sensitive_meta', 'date_modified'])
+            
+            return Response({
+                "message": "Video re-import completed successfully.",
+                "video_id": pk,
+                "uuid": str(video.uuid),
+                "sensitive_meta_created": video.sensitive_meta is not None,
+                "sensitive_meta_id": video.sensitive_meta.id if video.sensitive_meta else None,
+                "updated_in_place": True,
+                "status": "done"  # ⭐ Add explicit done status
+            }, status=status.HTTP_200_OK)
+
+        except Exception as e:
+            logger.error(f"Failed to re-import video {video.uuid}: {str(e)}", exc_info=True)
+            
+            # Handle specific error types
+            error_msg = str(e)
+            if any(phrase in error_msg.lower() for phrase in ["insufficient storage", "no space left", "disk full"]):
+                # Storage error - return specific error message
+                return Response({
+                    "error": f"Storage error during re-import: {error_msg}",
+                    "error_type": "storage_error",
+                    "video_id": pk,
+                    "uuid": str(video.uuid)
+                }, status=status.HTTP_507_INSUFFICIENT_STORAGE)
+            else:
+                # Other errors
+                return Response({
+                    "error": f"Re-import failed: {error_msg}",
+                    "error_type": "processing_error", 
+                    "video_id": pk,
+                    "uuid": str(video.uuid)
+                }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

endoreg_db/views/video/segmentation.py

@@ -0,0 +1,274 @@
+from pathlib import Path
+import os
+import mimetypes
+from django.http import FileResponse, Http404
+from rest_framework import viewsets, decorators, status
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework.decorators import api_view, permission_classes
+
+from ...serializers.label_video_segment.label_video_segment_update import LabelSegmentUpdateSerializer
+
+from ...serializers.label.label import LabelSerializer
+
+from ...serializers.video.video_file_list import VideoFileListSerializer
+from ...models import VideoFile, Label, LabelVideoSegment
+from ...serializers.video.segmentation import VideoFileSerializer
+from ...utils.permissions import DEBUG_PERMISSIONS
+
+# Phase 3.2: Import video streaming functionality from dedicated module
+# Phase 3.2: VideoStreamView and _stream_video_file moved to video_stream.py
+from .video_stream import _stream_video_file
+
+
+class VideoViewSet(viewsets.ReadOnlyModelViewSet):
+    """
+    /api/videos/          → list of metadata   (JSON)
+    /api/videos/<id>/     → single metadata   (JSON)
+    /videos/<id>/stream/  → raw file          (FileResponse, range-aware)
+    """
+    queryset = VideoFile.objects.all()
+    serializer_class = VideoFileListSerializer   # for the list view
+    permission_classes = DEBUG_PERMISSIONS
+
+    def list(self, request, *args, **kwargs):
+        """
+        Returns a JSON response with all video metadata and available labels.
+        
+        The response includes serialized lists of all videos and labels in the database.
+        """
+        videos = VideoFile.objects.all()
+        labels = Label.objects.all()
+
+        video_serializer = VideoFileListSerializer(videos, many=True)
+        label_serializer = LabelSerializer(labels, many=True)
+
+        return Response({
+            "videos": video_serializer.data, 
+            "labels": label_serializer.data  
+        }, status=status.HTTP_200_OK)
+
+    # ---------- JSON ---------- #
+    def retrieve(self, request, *args, **kwargs):
+        """
+        Retrieves detailed metadata for a specific video as a JSON response.
+        
+        Returns:
+            JSON representation of the requested video's metadata.
+        """
+        obj = self.get_object()
+        return Response(VideoFileSerializer(obj, context={'request': request}).data)
+
+    # ---------- BYTES ---------- #
+    @decorators.action(methods=['get'], detail=True,
+                       url_path='stream', renderer_classes=[])  # <- disable HTML & JSON renderers
+    def stream(self, request, pk=None):
+        """
+        Streams the raw video file for the specified video with HTTP range and CORS support.
+        """
+        try:
+            vf: VideoFile = self.get_object()
+            frontend_origin = os.environ.get('FRONTEND_ORIGIN', 'http://localhost:8000')
+            return _stream_video_file(vf, frontend_origin)
+        except Http404:
+            # Re-raise Http404 exceptions as they should bubble up
+            raise
+        except Exception as e:
+            # Log unexpected errors and convert to Http404
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.error(f"Unexpected error in video stream for pk={pk}: {str(e)}")
+            raise Http404("Video streaming failed")
+
+
+# Phase 3.2: VideoStreamView moved to video_stream.py - imported at top
+# Old implementation removed to avoid duplication
+
+
+class VideoLabelView(APIView):
+    """
+    API to fetch time segments (start & end times in seconds) for a specific label.
+    """
+
+    def get(self, request, video_id, label_name):
+        """
+        Retrieves time segments and frame-level predictions for a specific label on a video.
+        
+        Returns a JSON response containing the label name, a list of time segments (with frame ranges and timestamps), and frame-wise prediction data. Responds with HTTP 404 if the video or label does not exist, or HTTP 200 with empty data if no segments are found. Returns HTTP 500 with an error message for unexpected exceptions.
+        """
+        try:
+            # Verify video exists
+            video_entry = VideoFile.objects.get(id=video_id)
+            
+            # Try to get label by name
+            try:
+                label = Label.objects.get(name=label_name)
+            except Label.DoesNotExist:
+                return Response({
+                    "error": f"Label '{label_name}' not found in database"
+                }, status=status.HTTP_404_NOT_FOUND)
+            
+            # Get label video segments directly from the database
+            label_segments = LabelVideoSegment.objects.filter(
+                video_file=video_entry,
+                label=label
+            ).order_by('start_frame_number')
+            
+            if not label_segments.exists():
+                # No segments found for this label, return empty data
+                return Response({
+                    "label": label_name,
+                    "time_segments": [],
+                    "frame_predictions": {}
+                }, status=status.HTTP_200_OK)
+            
+            # Convert segments to time-based format
+            # Fix: Ensure fps is a number, not a string
+            fps_raw = getattr(video_entry, 'fps', None) or (video_entry.get_fps() if hasattr(video_entry, 'get_fps') else 25)
+            
+            # Convert fps to float if it's a string
+            try:
+                if isinstance(fps_raw, str):
+                    fps = float(fps_raw)
+                elif isinstance(fps_raw, (int, float)):
+                    fps = float(fps_raw)
+                else:
+                    fps = 25.0  # Default fallback
+            except (ValueError, TypeError):
+                fps = 25.0  # Default fallback if conversion fails
+            
+            # Ensure fps is positive
+            if fps <= 0:
+                fps = 25.0
+            
+            time_segments = []
+            frame_predictions = {}
+            
+            for segment in label_segments:
+                # Now fps is guaranteed to be a float
+                start_time = segment.start_frame_number / fps
+                end_time = segment.end_frame_number / fps
+                
+                segment_data = {
+                    "segment_id": segment.id,
+                    "segment_start": segment.start_frame_number,
+                    "segment_end": segment.end_frame_number,
+                    "start_time": round(start_time, 2),
+                    "end_time": round(end_time, 2),
+                    "frames": {}
+                }
+                
+                # Add frame-wise data if available
+                for frame_num in range(segment.start_frame_number, segment.end_frame_number + 1):
+                    frame_filename = f"frame_{str(frame_num).zfill(7)}.jpg"
+                    frame_predictions[frame_num] = {
+                        "frame_number": frame_num,
+                        "label": label_name,
+                        "confidence": 1.0  # Default confidence
+                    }
+                    
+                    # Fix: Safely construct frame_file_path to avoid string/string division errors
+                    frame_file_path = ""
+                    if hasattr(video_entry, 'frame_dir') and video_entry.frame_dir:
+                        try:
+                            # Ensure frame_dir is converted to Path properly
+                            if isinstance(video_entry.frame_dir, str):
+                                frame_dir = Path(video_entry.frame_dir)
+                            elif isinstance(video_entry.frame_dir, Path):
+                                frame_dir = video_entry.frame_dir
+                            else:
+                                # Try to convert to string first, then to Path
+                                frame_dir = Path(str(video_entry.frame_dir))
+                            
+                            frame_file_path = str(frame_dir / frame_filename)
+                        except (TypeError, ValueError) as e:
+                            # Log warning but don't fail the request
+                            import logging
+                            logger = logging.getLogger(__name__)
+                            logger.warning(f"Could not construct frame path for frame {frame_num}: {e}")
+                            frame_file_path = ""
+                    
+                    segment_data["frames"][frame_num] = {
+                        "frame_filename": frame_filename,
+                        "frame_file_path": frame_file_path,
+                        "predictions": frame_predictions[frame_num]
+                    }
+                
+                time_segments.append(segment_data)
+            
+            return Response({
+                "label": label_name,
+                "time_segments": time_segments,
+                "frame_predictions": frame_predictions
+            }, status=status.HTTP_200_OK)
+
+        except VideoFile.DoesNotExist:
+            return Response({
+                "error": "Video not found"
+            }, status=status.HTTP_404_NOT_FOUND)
+
+        except Exception as e:
+            # Log the error for debugging
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.error(f"Error in VideoLabelView for video {video_id}, label {label_name}: {str(e)}")
+            
+            return Response({
+                "error": f"Internal error: {str(e)}"
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+class UpdateLabelSegmentsView(APIView):
+    """
+    API to update or create label segments for a video.
+    """
+
+    def put(self, request, video_id, label_id):
+        """
+        Updates segments for a given video & label.
+        """
+
+        # Prepare data for serializer by combining URL params with request data
+        serializer_data = {
+            "video_id": video_id,    # From URL parameter
+            "label_id": label_id,    # From URL parameter  
+            "segments": request.data.get("segments", [])  # From request body
+        }
+
+        # Validate input data
+        serializer = LabelSegmentUpdateSerializer(data=serializer_data)
+
+        if not serializer.is_valid():
+            return Response({"error": "Invalid segment data", "details": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
+
+        # Process and save segment updates
+        try:
+            result = serializer.save()
+            return Response({
+                "message": "Segments updated successfully.",
+                "updated_segments": result["updated_segments"],
+                "new_segments": result["new_segments"],
+                "deleted_segments": result["deleted_segments"]
+            }, status=status.HTTP_200_OK)
+        except Exception as e:
+            return Response({
+                "error": f"Failed to update segments: {str(e)}"
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+           
+@api_view(['GET'])
+@permission_classes(DEBUG_PERMISSIONS)
+def rerun_segmentation(request, video_id):
+    """
+    Rerun segmentation for a specific video.
+    """
+    try:
+        video_file = VideoFile.objects.get(id=video_id)
+        video_file.pipe_1()
+        video_file.test_after_pipe_1()
+        return Response({'status': 'success', 'message': 'Segmentation rerun successfully'})
+    except VideoFile.DoesNotExist:
+        return Response({'status': 'error', 'message': 'Video file not found'}, status=status.HTTP_404_NOT_FOUND)
+    except Exception as e:
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.error(f"Error in rerun_segmentation: {e}")
+        return Response({'status': 'error', 'message': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

endoreg_db/views/video/task_status.py

@@ -0,0 +1,49 @@
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+
+
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+from celery import current_app
+
+class TaskStatusView(APIView):
+    """
+    GET /api/task-status/{task_id}/ - Get status of async task
+    """
+    #TODO refactor, this should be specified as video task status or moved to a more appropriate module
+    permission_classes = [EnvironmentAwarePermission]
+
+    def get(self, request, task_id):
+        try:
+            task_result = current_app.AsyncResult(task_id)
+
+            response_data = {
+                'task_id': task_id,
+                'status': task_result.status,
+                'progress': 0,
+                'message': 'Task pending...'
+            }
+
+            if task_result.status == 'PENDING':
+                response_data['message'] = 'Task is waiting to be processed'
+            elif task_result.status == 'PROGRESS':
+                response_data.update(task_result.result or {})
+            elif task_result.status == 'SUCCESS':
+                response_data.update({
+                    'progress': 100,
+                    'message': 'Task completed successfully',
+                    'result': task_result.result
+                })
+            elif task_result.status == 'FAILURE':
+                response_data.update({
+                    'message': str(task_result.result),
+                    'error': True
+                })
+
+            return Response(response_data, status=status.HTTP_200_OK)
+
+        except Exception as e:
+            return Response(
+                {"error": f"Failed to get task status: {str(e)}"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )

endoreg_db/views/video/timeline.py

@@ -0,0 +1,46 @@
+from django.shortcuts import render, get_object_or_404
+from ...models import VideoFile
+import json
+from ...serializers.video import VideoFileSerializer
+
+def video_timeline_view(request, video_id):
+    """
+    Fetches 'outside' label segments and passes their timestamps to the template.
+    """
+    video_entry = get_object_or_404(VideoFile, id=video_id)
+
+    # Get metadata (Assumes serializer method exists)
+    video_serializer = VideoFileSerializer(video_entry, context={'request': request})
+    label_segments = video_serializer.get_label_time_segments(video_entry)
+
+    segments = []
+    frame_markers = []  # Store frame timestamps
+    fps = 50  # Fixed FPS
+
+    # Ensure "outside" label exists
+    if "outside" in label_segments:
+        for segment in label_segments["outside"]["time_ranges"]:
+            segments.append({
+                "start_time": segment["start_time"],
+                "end_time": segment["end_time"]
+            })
+
+            # Extract frame timestamps for markers
+            for frame_num, _ in segment["frames"].items():
+                time_in_seconds = frame_num / fps
+                frame_markers.append(time_in_seconds)
+
+    # Set video duration correctly
+    video_duration = video_entry.duration if hasattr(video_entry, "duration") and video_entry.duration else 226  # Default to 226 seconds
+
+    print("Video ID:", video_id)
+    print("Segments:", segments)
+    print("Video Duration:", video_duration)
+
+    return render(request, "timeline.html", {
+        "video_id": video_id,
+        "video_url": video_serializer.get_video_url(video_entry),
+        "segments": json.dumps(segments),  # Send segment start/end times
+        "frame_markers": json.dumps(frame_markers),  # Send frame timestamps
+        "video_duration": video_duration,
+    })

endoreg_db/views/video/video_analyze.py

@@ -0,0 +1,52 @@
+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 VideoAnalyzeView(APIView):
+    """
+    POST /api/video-analyze/{id}/ - Analyze video for sensitive content
+    """
+    permission_classes = [EnvironmentAwarePermission]
+
+    def post(self, request, pk):
+        video = get_object_or_404(VideoFile, pk=pk)
+        use_minicpm = request.data.get('use_minicpm', True)
+        _detailed_analysis = request.data.get('detailed_analysis', True)
+
+        try:
+            # Import FrameCleaner here to avoid circular imports
+            from lx_anonymizer.frame_cleaner import FrameCleaner
+
+            cleaner = FrameCleaner(
+                video_path=video.file.path,
+                use_minicpm=use_minicpm
+            )
+
+            # Perform analysis
+            analysis_result = cleaner.analyze_video_sensitivity()
+
+            # Update video metadata
+            if hasattr(video, 'sensitive_frame_count'):
+                video.sensitive_frame_count = analysis_result.get('sensitive_frames', 0)
+            if hasattr(video, 'total_frames'):
+                video.total_frames = analysis_result.get('total_frames', 0)
+            if hasattr(video, 'sensitive_ratio'):
+                video.sensitive_ratio = analysis_result.get('sensitivity_ratio', 0.0)
+
+            try:
+                video.save()
+            except Exception as e:
+                print(f"Warning: Could not save video metadata: {e}")
+
+            return Response(analysis_result, status=status.HTTP_200_OK)
+
+        except Exception as e:
+            return Response(
+                {"error": f"Analysis failed: {str(e)}"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )

endoreg_db/views/video/video_apply_mask.py

@@ -0,0 +1,48 @@
+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
+            )