endoreg-db 0.8.1__py3-none-any.whl → 0.8.2__py3-none-any.whl

endoreg_db/views/video/correction.py

@@ -121,7 +121,7 @@ def update_segments_after_frame_removal(video: VideoFile, removed_frames: list)
 
 class VideoMetadataView(APIView):
     """
-    GET /api/video-metadata/{id}/
+    GET /api/media/videos/{pk}/metadata/
     
     Retrieve analysis results for a video.
     
@@ -139,9 +139,9 @@ class VideoMetadataView(APIView):
         }
     """
     
-    def get(self, request, id):
+    def get(self, request, pk):
         """Get video metadata by video ID."""
-        video = get_object_or_404(VideoFile, pk=id)
+        video = get_object_or_404(VideoFile, pk=pk)
         
         # Get or create metadata record
         metadata, created = VideoMetadata.objects.get_or_create(video=video)
@@ -152,7 +152,7 @@ class VideoMetadataView(APIView):
 
 class VideoProcessingHistoryView(APIView):
     """
-    GET /api/video-processing-history/{id}/
+    GET /api/media/videos/{pk}/processing-history/
     
     Retrieve processing history for a video.
     
@@ -179,9 +179,9 @@ class VideoProcessingHistoryView(APIView):
         ]
     """
     
-    def get(self, request, id):
+    def get(self, request, pk):
         """Get processing history for a video."""
-        video = get_object_or_404(VideoFile, pk=id)
+        video = get_object_or_404(VideoFile, pk=pk)
         
         # Get all history records, newest first
         history = VideoProcessingHistory.objects.filter(
@@ -198,7 +198,7 @@ class VideoProcessingHistoryView(APIView):
 
 class VideoAnalyzeView(APIView):
     """
-    POST /api/video-analyze/{id}/
+    POST /api/media/videos/{pk}/analyze/
     
     Analyze video for sensitive frames using MiniCPM-o 2.6 or OCR+LLM.
     
@@ -220,9 +220,9 @@ class VideoAnalyzeView(APIView):
         }
     """
     
-    def post(self, request, id):
+    def post(self, request, pk):
         """Analyze video for sensitive content."""
-        video = get_object_or_404(VideoFile, pk=id)
+        video = get_object_or_404(VideoFile, pk=pk)
         
         # Extract parameters
         detection_method = request.data.get('detection_method', 'minicpm')
@@ -270,7 +270,7 @@ class VideoAnalyzeView(APIView):
                 details=f"Found {sensitive_count} sensitive frames out of {total_frames} total frames"
             )
             
-            logger.info(f"Video {id} analyzed: {sensitive_count}/{total_frames} sensitive frames")
+            logger.info(f"Video {pk} analyzed: {sensitive_count}/{total_frames} sensitive frames")
             
             return Response({
                 'sensitive_frame_count': sensitive_count,
@@ -283,7 +283,7 @@ class VideoAnalyzeView(APIView):
             })
             
         except Exception as e:
-            logger.error(f"Video analysis failed for {id}: {str(e)}", exc_info=True)
+            logger.error(f"Video analysis failed for {pk}: {str(e)}", exc_info=True)
             
             # Create failure record
             VideoProcessingHistory.objects.create(
@@ -305,7 +305,7 @@ class VideoAnalyzeView(APIView):
 
 class VideoApplyMaskView(APIView):
     """
-    POST /api/video-apply-mask/{id}/
+    POST /api/media/videos/{pk}/apply-mask/
     
     Apply device mask or custom ROI mask to video.
     
@@ -333,9 +333,9 @@ class VideoApplyMaskView(APIView):
     Note: Currently synchronous. Will be converted to Celery task in Phase 1.2.
     """
     
-    def post(self, request, id):
+    def post(self, request, pk):
         """Apply masking to video."""
-        video = get_object_or_404(VideoFile, pk=id)
+        video = get_object_or_404(VideoFile, pk=pk)
         
         # Extract parameters
         mask_type = request.data.get('mask_type', 'device')
@@ -414,7 +414,7 @@ class VideoApplyMaskView(APIView):
                     details=f"Masking completed in {processing_time:.1f}s"
                 )
                 
-                logger.info(f"Video {id} masked successfully: {output_path}")
+                logger.info(f"Video {pk} masked successfully: {output_path}")
                 
                 return Response({
                     'task_id': None,  # Will be Celery task ID in Phase 1.2
@@ -426,7 +426,7 @@ class VideoApplyMaskView(APIView):
                 raise Exception("Masking failed - check FFmpeg logs")
                 
         except Exception as e:
-            logger.error(f"Video masking failed for {id}: {str(e)}", exc_info=True)
+            logger.error(f"Video masking failed for {pk}: {str(e)}", exc_info=True)
             
             history.mark_failure(str(e))
             
@@ -438,7 +438,7 @@ class VideoApplyMaskView(APIView):
 
 class VideoRemoveFramesView(APIView):
     """
-    POST /api/video-remove-frames/{id}/
+    POST /api/media/videos/{pk}/remove-frames/
     
     Remove specified frames from video.
     
@@ -465,9 +465,9 @@ class VideoRemoveFramesView(APIView):
     Note: Currently synchronous. Will be converted to Celery task in Phase 1.2.
     """
     
-    def post(self, request, id):
+    def post(self, request, pk):
         """Remove frames from video."""
-        video = get_object_or_404(VideoFile, pk=id)
+        video = get_object_or_404(VideoFile, pk=pk)
         
         # Extract parameters
         frame_list = request.data.get('frame_list')
@@ -571,7 +571,7 @@ class VideoRemoveFramesView(APIView):
                     details="; ".join(details_parts)
                 )
                 
-                logger.info(f"Video {id} cleaned: removed {len(frames_to_remove)} frames")
+                logger.info(f"Video {pk} cleaned: removed {len(frames_to_remove)} frames")
                 
                 return Response({
                     'task_id': None,  # Will be Celery task ID in Phase 1.2
@@ -585,7 +585,7 @@ class VideoRemoveFramesView(APIView):
                 raise Exception("Frame removal failed - check FFmpeg logs")
                 
         except Exception as e:
-            logger.error(f"Frame removal failed for {id}: {str(e)}", exc_info=True)
+            logger.error(f"Frame removal failed for {pk}: {str(e)}", exc_info=True)
             
             history.mark_failure(str(e))
             
@@ -613,7 +613,7 @@ class VideoRemoveFramesView(APIView):
 
 class VideoReprocessView(APIView):
     """
-    POST /api/video-reprocess/{id}/
+    POST /api/media/videos/{pk}/reprocess/
     
     Re-run entire anonymization pipeline for a video.
     
@@ -628,9 +628,9 @@ class VideoReprocessView(APIView):
     Note: This resets VideoState and triggers video_import service.
     """
     
-    def post(self, request, id):
+    def post(self, request, pk):
         """Reprocess video through entire anonymization pipeline."""
-        video = get_object_or_404(VideoFile, pk=id)
+        video = get_object_or_404(VideoFile, pk=pk)
         
         try:
             # Create processing history record
@@ -656,7 +656,7 @@ class VideoReprocessView(APIView):
             
             history.mark_success(details="Reprocessing initiated")
             
-            logger.info(f"Video {id} reprocessing started")
+            logger.info(f"Video {pk} reprocessing started")
             
             return Response({
                 'message': 'Reprocessing started',
@@ -664,7 +664,7 @@ class VideoReprocessView(APIView):
             })
             
         except Exception as e:
-            logger.error(f"Reprocessing failed for {id}: {str(e)}", exc_info=True)
+            logger.error(f"Reprocessing failed for {pk}: {str(e)}", exc_info=True)
             
             return Response(
                 {'error': f'Reprocessing failed: {str(e)}'},

endoreg_db/views/video/reimport.py

@@ -19,25 +19,28 @@ class VideoReimportView(APIView):
         super().__init__(**kwargs)
         self.video_service = VideoImportService()
 
-    def post(self, request, video_id):
+    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 video_id parameter
-        if not video_id or not isinstance(video_id, int):
+        # 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=video_id)
-            logger.info(f"Found video {video.uuid} (ID: {video_id}) for re-import")
+            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 {video_id} not found")
+            logger.warning(f"Video with ID {pk} not found")
             return Response(
-                {"error": f"Video with ID {video_id} not found."}, 
+                {"error": f"Video with ID {pk} not found."}, 
                 status=status.HTTP_404_NOT_FOUND
             )
 
@@ -67,7 +70,7 @@ class VideoReimportView(APIView):
             )
 
         try:
-            logger.info(f"Starting in-place re-import for video {video.uuid} (ID: {video_id})")
+            logger.info(f"Starting in-place re-import for video {video.uuid} (ID: {pk})")
             
             with transaction.atomic():
                 # Clear existing metadata to force regeneration
@@ -140,7 +143,7 @@ class VideoReimportView(APIView):
                     
                     return Response({
                         "message": "Video re-import with VideoImportService completed successfully.",
-                        "video_id": video_id,
+                        "video_id": pk,
                         "uuid": str(video.uuid),
                         "frame_cleaning_applied": True,
                         "sensitive_meta_created": video.sensitive_meta is not None,
@@ -161,7 +164,7 @@ class VideoReimportView(APIView):
             
             return Response({
                 "message": "Video re-import completed successfully.",
-                "video_id": video_id,
+                "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,
@@ -179,7 +182,7 @@ class VideoReimportView(APIView):
                 return Response({
                     "error": f"Storage error during re-import: {error_msg}",
                     "error_type": "storage_error",
-                    "video_id": video_id,
+                    "video_id": pk,
                     "uuid": str(video.uuid)
                 }, status=status.HTTP_507_INSUFFICIENT_STORAGE)
             else:
@@ -187,6 +190,6 @@ class VideoReimportView(APIView):
                 return Response({
                     "error": f"Re-import failed: {error_msg}",
                     "error_type": "processing_error", 
-                    "video_id": video_id,
+                    "video_id": pk,
                     "uuid": str(video.uuid)
                 }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

endoreg_db/views/video/video_stream.py

@@ -5,61 +5,140 @@ Separate view for streaming raw and processed video files.
 Extracted from segmentation.py for better code organization.
 
 Created: October 9, 2025
+Updated: October 15, 2025 - Added HTTP 206 Range Request Support
 """
 
-from pathlib import Path
 import os
-import mimetypes
+import re
 import logging
-from django.http import FileResponse, Http404
+import mimetypes
+from pathlib import Path
+from typing import Tuple, Optional
+from django.http import FileResponse, Http404, StreamingHttpResponse
 from rest_framework.views import APIView
 
 from ...models import VideoFile
 from ...utils.permissions import EnvironmentAwarePermission
+from ...utils.paths import STORAGE_DIR  # Import STORAGE_DIR for path resolution
 
 logger = logging.getLogger(__name__)
 
 
-def _stream_video_file(vf: VideoFile, frontend_origin: str, file_type: str = 'raw') -> FileResponse:
+def parse_range_header(range_header: str, file_size: int) -> Tuple[int, int]:
     """
-    Helper function to stream a video file with proper headers and CORS support.
+    Parse HTTP Range header and return (start, end) byte positions.
+    
+    Args:
+        range_header: HTTP Range header value (e.g., "bytes=0-1023")
+        file_size: Total file size in bytes
+        
+    Returns:
+        Tuple of (start_byte, end_byte) inclusive
+        
+    Raises:
+        ValueError: If range header is invalid
+    """
+    # Expected format: "bytes=start-end" or "bytes=start-"
+    match = re.match(r'bytes=(\d+)-(\d*)', range_header)
+    
+    if not match:
+        raise ValueError(f"Invalid Range header format: {range_header}")
+    
+    start = int(match.group(1))
+    end_str = match.group(2)
+    
+    # If end is not specified, use file size - 1
+    end = int(end_str) if end_str else file_size - 1
+    
+    # Validate range
+    if start >= file_size or start < 0:
+        raise ValueError(f"Start byte {start} is out of range (file size: {file_size})")
+    
+    if end >= file_size:
+        end = file_size - 1
+    
+    if start > end:
+        raise ValueError(f"Invalid range: start ({start}) > end ({end})")
+    
+    return start, end
+
+
+def stream_file_chunk(file_path: Path, start: int, end: int, chunk_size: int = 8192):
+    """
+    Generator that yields chunks of a file within the specified byte range.
+    
+    Args:
+        file_path: Path to the file
+        start: Start byte position (inclusive)
+        end: End byte position (inclusive)
+        chunk_size: Size of each chunk to yield
+        
+    Yields:
+        Bytes chunks from the file
+    """
+    with open(file_path, 'rb') as f:
+        f.seek(start)
+        remaining = end - start + 1  # +1 because end is inclusive
+        
+        while remaining > 0:
+            chunk = f.read(min(chunk_size, remaining))
+            if not chunk:
+                break
+            yield chunk
+            remaining -= len(chunk)
+
+
+def _stream_video_file(vf: VideoFile, frontend_origin: str, file_type: str = 'raw', range_header: Optional[str] = None) -> FileResponse | StreamingHttpResponse:
+    """
+    Helper function to stream a video file with proper headers, CORS support, and HTTP Range Requests.
     
     Args:
         vf: VideoFile model instance
         frontend_origin: Frontend origin URL for CORS headers
         file_type: Either 'raw' (original video) or 'processed' (anonymized video)
+        range_header: HTTP Range header value (e.g., "bytes=0-1023") for partial content requests
         
     Returns:
-        FileResponse: HTTP response streaming the video file
+        FileResponse: HTTP 200 response streaming the entire file (no range header)
+        StreamingHttpResponse: HTTP 206 response streaming partial content (with range header)
         
     Raises:
         Http404: If video file not found or cannot be accessed
         
     Note:
         Permissions are handled by the calling view, not in this helper function.
+        HTTP 206 Partial Content support is critical for video seeking in browsers.
     """
     try:
         # Determine which file to stream based on file_type
         if file_type == 'raw':
-            if hasattr(vf, 'active_raw_file') and vf.active_raw_file and hasattr(vf.active_raw_file, 'path'):
-                try:
-                    path = Path(vf.active_raw_file.path)
-                except (ValueError, AttributeError) as exc:
-                    raise Http404("No raw file associated with this video") from exc
+            if hasattr(vf, 'active_raw_file') and vf.active_raw_file and hasattr(vf.active_raw_file, 'name'):
+                file_ref = vf.active_raw_file
             else:
                 raise Http404("No raw video file available for this entry")
             
         elif file_type == 'processed':
-            if hasattr(vf, 'processed_file') and vf.processed_file and hasattr(vf.processed_file, 'path'):
-                try:
-                    path = Path(vf.processed_file.path)
-                except (ValueError, AttributeError) as exc:
-                    raise Http404("No processed file associated with this video") from exc
+            if hasattr(vf, 'processed_file') and vf.processed_file and hasattr(vf.processed_file, 'name'):
+                file_ref = vf.processed_file
             else:
                 raise Http404("No processed video file available for this entry")
         else:
             raise ValueError(f"Invalid file_type: {file_type}. Must be 'raw' or 'processed'.")
         
+        # FIX: Handle both relative and absolute paths
+        # Django FileField.path returns .name if MEDIA_ROOT is not set
+        # Import services store relative paths like "videos/UUID.mp4"
+        # We need to resolve to absolute path: STORAGE_DIR / "videos/UUID.mp4"
+        file_name = file_ref.name
+        
+        if file_name.startswith('/'):
+            # Already absolute path
+            path = Path(file_name)
+        else:
+            # Relative path - make absolute by prepending STORAGE_DIR
+            path = STORAGE_DIR / file_name
+            logger.debug("Resolved relative path '%s' to absolute: %s", file_name, path)
+        
         # Validate file exists on disk
         if not path.exists():
             raise Http404(f"Video file not found on disk: {path}")
@@ -76,28 +155,59 @@ def _stream_video_file(vf: VideoFile, frontend_origin: str, file_type: str = 'ra
         mime, _ = mimetypes.guess_type(str(path))
         content_type = mime or 'video/mp4'  # Default to mp4 if detection fails
         
-        try:
-            # Open file in binary mode - FileResponse will handle closing
-            file_handle = open(path, 'rb')
-            response = FileResponse(file_handle, content_type=content_type)
-            
-            # Set HTTP headers for video streaming
-            response['Content-Length'] = str(file_size)
-            response['Accept-Ranges'] = 'bytes'  # Enable HTTP range requests for seeking
-            response['Content-Disposition'] = f'inline; filename="{path.name}"'
-            
-            # CORS headers for frontend access
-            response["Access-Control-Allow-Origin"] = frontend_origin
-            response["Access-Control-Allow-Credentials"] = "true"
-            
-            return response
-            
-        except IOError as e:
-            raise Http404(f"Cannot open video file: {str(e)}")
+        # ✅ NEW: HTTP Range Request support for video seeking
+        if range_header:
+            try:
+                # Parse Range header
+                start, end = parse_range_header(range_header, file_size)
+                logger.debug("Range request: bytes=%d-%d (total: %d)", start, end, file_size)
+                
+                # Stream partial content (HTTP 206)
+                response = StreamingHttpResponse(
+                    stream_file_chunk(path, start, end),
+                    status=206,  # Partial Content
+                    content_type=content_type
+                )
+                
+                # Set Range-specific headers
+                response['Content-Range'] = f'bytes {start}-{end}/{file_size}'
+                response['Content-Length'] = str(end - start + 1)
+                response['Accept-Ranges'] = 'bytes'
+                response['Content-Disposition'] = f'inline; filename="{path.name}"'
+                
+            except ValueError as e:
+                # Invalid range header - return 416 Range Not Satisfiable
+                logger.warning("Invalid Range header: %s", str(e))
+                response = StreamingHttpResponse(
+                    status=416,  # Range Not Satisfiable
+                    content_type=content_type
+                )
+                response['Content-Range'] = f'bytes */{file_size}'
+                
+        else:
+            # No Range header - stream entire file (HTTP 200)
+            try:
+                # Open file in binary mode - FileResponse will handle closing
+                file_handle = open(path, 'rb')
+                response = FileResponse(file_handle, content_type=content_type)
+                
+                # Set HTTP headers for video streaming
+                response['Content-Length'] = str(file_size)
+                response['Accept-Ranges'] = 'bytes'  # Enable HTTP range requests for seeking
+                response['Content-Disposition'] = f'inline; filename="{path.name}"'
+                
+            except IOError as e:
+                raise Http404(f"Cannot open video file: {str(e)}")
+        
+        # CORS headers for frontend access (both HTTP 200 and 206)
+        response["Access-Control-Allow-Origin"] = frontend_origin
+        response["Access-Control-Allow-Credentials"] = "true"
+        
+        return response
             
     except Exception as e:
         # Log unexpected errors but don't expose internal details
-        logger.error(f"Unexpected error in _stream_video_file: {str(e)}")
+        logger.error("Unexpected error in _stream_video_file: %s", str(e))
         raise Http404("Video file cannot be streamed")
 
 
@@ -127,14 +237,17 @@ class VideoStreamView(APIView):
     
     def get(self, request, pk=None):
         """
-        Stream raw or anonymized video file with HTTP range and CORS support.
+        Stream raw or anonymized video file with HTTP Range Request and CORS support.
+        
+        Supports HTTP 206 Partial Content for video seeking functionality.
         
         Args:
             request: HTTP request object
             pk: Video ID (primary key)
             
         Returns:
-            FileResponse: Streaming video file
+            FileResponse: HTTP 200 streaming entire video file (no range header)
+            StreamingHttpResponse: HTTP 206 streaming partial content (with range header)
             
         Raises:
             Http404: If video not found or file cannot be accessed
@@ -142,6 +255,9 @@ class VideoStreamView(APIView):
         if pk is None:
             raise Http404("Video ID is required")
             
+        # Initialize variables in outer scope
+        video_id_int = None
+        
         try:
             # Validate video_id is numeric
             try:
@@ -151,19 +267,18 @@ class VideoStreamView(APIView):
             
             # Support both 'type' (frontend standard) and 'file_type' (legacy)
             # Priority: type > file_type > default 'raw'
+            file_type = 'raw'  # Default value
             try:
-                file_type: str = (
-                    request.query_params.get('type') or 
-                    request.query_params.get('file_type') or 
-                    'raw'
-                ).lower()
-                
-                if file_type not in ['raw', 'processed']:
-                    logger.warning(f"Invalid file_type '{file_type}', defaulting to 'raw'")
-                    file_type = 'raw'
+                file_type_param = request.query_params.get('type') or request.query_params.get('file_type')
+                if file_type_param:
+                    file_type = file_type_param.lower()
+                    
+                    if file_type not in ['raw', 'processed']:
+                        logger.warning("Invalid file_type '%s', defaulting to 'raw'", file_type)
+                        file_type = 'raw'
                     
             except Exception as e:
-                logger.warning(f"Error parsing file_type parameter: {e}, defaulting to 'raw'")
+                logger.warning("Error parsing file_type parameter: %s, defaulting to 'raw'", e)
                 file_type = 'raw'
                             
             # Fetch video from database
@@ -172,8 +287,11 @@ class VideoStreamView(APIView):
             # Get frontend origin for CORS
             frontend_origin = os.environ.get('FRONTEND_ORIGIN', 'http://localhost:8000')
             
-            # Stream the video file
-            return _stream_video_file(vf, frontend_origin, file_type)
+            # ✅ NEW: Extract Range header for HTTP 206 support
+            range_header = request.META.get('HTTP_RANGE')
+            
+            # Stream the video file with optional range support
+            return _stream_video_file(vf, frontend_origin, file_type, range_header)
             
         except VideoFile.DoesNotExist:
             raise Http404(f"Video with ID {pk} not found")
@@ -184,5 +302,5 @@ class VideoStreamView(APIView):
             
         except Exception as e:
             # Log unexpected errors and convert to Http404
-            logger.error(f"Unexpected error in VideoStreamView for video_id={pk}: {str(e)}")
+            logger.error("Unexpected error in VideoStreamView for video_id=%s: %s", pk, str(e))
             raise Http404("Video streaming failed")

{endoreg_db-0.8.1.dist-info → endoreg_db-0.8.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: endoreg-db
-Version: 0.8.1
+Version: 0.8.2
 Summary: EndoReg Db Django App
 Project-URL: Homepage, https://info.coloreg.de
 Project-URL: Repository, https://github.com/wg-lux/endoreg-db
@@ -33,7 +33,7 @@ Requires-Dist: gunicorn>=23.0.0
 Requires-Dist: icecream>=2.1.4
 Requires-Dist: librosa==0.11.0
 Requires-Dist: llvmlite>=0.44.0
-Requires-Dist: lx-anonymizer[llm,ocr]>=0.8.1
+Requires-Dist: lx-anonymizer[llm,ocr]>=0.8.2
 Requires-Dist: moviepy==2.2.1
 Requires-Dist: mypy>=1.16.0
 Requires-Dist: numpy>=2.2.3