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

endoreg_db/serializers/video/{segmentation.py → video_file.py}

@@ -1,17 +1,23 @@
 from pathlib import Path
+
 from rest_framework import serializers
-from ...models import VideoFile 
+
+from ...models import VideoFile
+
 try:
     import cv2
 except ImportError:
     cv2 = None
-from django.conf import settings
 # from django.conf import settings
 from typing import TYPE_CHECKING
+
+from django.conf import settings
 from rest_framework.exceptions import ValidationError
+
 if TYPE_CHECKING:
     from endoreg_db.models import VideoFile
-    
+
+
 class VideoFileSerializer(serializers.ModelSerializer):
     """
     Serializer that dynamically handles video retrieval and streaming.
@@ -55,24 +61,24 @@ class VideoFileSerializer(serializers.ModelSerializer):
 
     # @staticmethod #using @staticmethod makes it reusable without needing to create a serializer instance.
     #  Without @staticmethod, you would need to instantiate the serializer before calling the method, which is unnecessary her
-    def get_video_selection_field(self, obj:"Video"):
+    def get_video_selection_field(self, obj: "VideoFile"):
         """
         Return the UUID of the video for use as a selection value in frontend dropdowns.
-        
+
         Parameters:
             obj (Video): The video instance being serialized.
-        
+
         Returns:
             str: The UUID of the video.
         """
-        return obj.uuid
+        return obj.video_hash
 
     def get_video_url(
         self, obj
     ):  # when we serialize a RawVideoFile object (video metadata), the get_video_url method is automatically invoked by DRF
         """
         Return the absolute API URL for accessing the video file.
-        
+
         If the video ID is invalid or the request context is missing, returns a dictionary with an error message.
         """
         if not obj.id:
@@ -82,14 +88,16 @@ class VideoFileSerializer(serializers.ModelSerializer):
             "request"
         )  # Gets the request object (provided by DRF).
         if request:
-            return request.build_absolute_uri(f"/api/video/{obj.id}/")  # Added api/ prefix
+            return request.build_absolute_uri(
+                f"/api/video/{obj.id}/"
+            )  # Added api/ prefix
 
         return {"error": "Video URL not available"}
 
-    def get_duration(self, obj:"Video"):
+    def get_duration(self, obj: "VideoFile"):
         """
         Return the duration of the video in seconds, using the stored value if available or extracting it dynamically with OpenCV.
-        
+
         If the duration is not present in the database, the method opens the video file, retrieves its frame count and frames per second (FPS), and calculates the duration. Returns `None` if the video cannot be opened or FPS is zero.
         """
         if hasattr(obj, "duration") and obj.duration:
@@ -99,7 +107,7 @@ class VideoFileSerializer(serializers.ModelSerializer):
 
         # Dynamically extract duration if not stored
         video_path = obj.active_file.path
-        
+
         cap = cv2.VideoCapture(video_path)
         try:
             if not cap.isOpened():
@@ -114,13 +122,13 @@ class VideoFileSerializer(serializers.ModelSerializer):
         finally:
             cap.release()
 
-    def get_file(self, obj:"Video"):
+    def get_file(self, obj: "VideoFile"):
         """
         Returns the relative file path of the active video file, or an error message if the file is missing or invalid.
-        
+
         Parameters:
             obj (Video): The video instance whose file path is to be retrieved.
-        
+
         Returns:
             str or dict: The relative file path as a string, or a dictionary with an error message if the file is missing or invalid.
         """
@@ -134,10 +142,10 @@ class VideoFileSerializer(serializers.ModelSerializer):
             obj.active_file.name
         ).strip()  #  Only return the file path, no URL,#obj.active_file returning a FieldFile object instead of a string
 
-    def get_full_video_path(self, obj:"Video"):
+    def get_full_video_path(self, obj: "VideoFile"):
         """
         Return the absolute filesystem path to the video's active file.
-        
+
         If the file does not exist or an error occurs during path construction, returns a dictionary with an error message.
         """
         if not obj.active_file:
@@ -145,26 +153,34 @@ class VideoFileSerializer(serializers.ModelSerializer):
 
         try:
             # Use the active_file_path property which handles both processed and raw files
-            if hasattr(obj, 'active_file_path') and obj.active_file_path:
+            if hasattr(obj, "active_file_path") and obj.active_file_path:
                 full_path = obj.active_file_path
-                return str(full_path) if full_path.exists() else {"error": f"file not found at: {full_path}"}
+                return (
+                    str(full_path)
+                    if full_path.exists()
+                    else {"error": f"file not found at: {full_path}"}
+                )
             else:
                 # Fallback: construct path manually
                 video_relative_path = str(obj.active_file.name).strip()
                 if not video_relative_path:
                     return {"error": "Video file path is empty or invalid"}
-                
+
                 # Construct the path using the file's actual path
                 full_path = obj.active_file.path
-                return str(full_path) if Path(full_path).exists() else {"error": f"file not found at: {full_path}"}
-                
+                return (
+                    str(full_path)
+                    if Path(full_path).exists()
+                    else {"error": f"file not found at: {full_path}"}
+                )
+
         except Exception as e:
             return {"error": f"Error constructing file path: {str(e)}"}
 
-    def get_sequences(self, obj:"Video"):
+    def get_sequences(self, obj: "VideoFile"):
         """
         Retrieve frame sequences for each label from the video object.
-        
+
         Returns:
             dict: A mapping of label names to lists of frame ranges, or an error message if no sequences are found.
         """
@@ -172,25 +188,25 @@ class VideoFileSerializer(serializers.ModelSerializer):
             "error": "no sequence found, check database first"
         }  #  Get from sequences, return {} if missing
 
-    def get_label_names(self, obj:"Video"):
+    def get_label_names(self, obj: "VideoFile"):
         """
         Return a list of label names present in the video's frame sequences.
-        
+
         Parameters:
             obj (Video): The video instance to extract label names from.
-        
+
         Returns:
             list[str]: List of label names, or an empty list if no sequences are found.
         """
         sequences = self.get_sequences(obj)
         return list(sequences.keys()) if sequences else []
 
-    def get_label_time_segments(self, obj:"Video"):
+    def get_label_time_segments(self, obj: "VideoFile"):
         """
         Convert frame sequences for each label into time segments with frame-level metadata.
-        
+
         For each label in the video, this method generates a list of time segments based on frame index ranges, converting them to seconds using the video's FPS. Each segment includes the raw frame indices, start and end times in seconds, and detailed information for each frame in the segment, such as filename, full file path, and a placeholder for predictions.
-        
+
         Returns:
             dict: A dictionary mapping each label to its list of time segments and associated frame metadata.
         """
@@ -201,13 +217,18 @@ class VideoFileSerializer(serializers.ModelSerializer):
 
         if not fps or fps <= 0:
             # Strict by default — only use fallback if explicitly enabled and > 0
-            if getattr(settings, "VIDEO_ALLOW_FPS_FALLBACK", False) and getattr(settings, "VIDEO_DEFAULT_FPS", 0) > 0:
+            if (
+                getattr(settings, "VIDEO_ALLOW_FPS_FALLBACK", False)
+                and getattr(settings, "VIDEO_DEFAULT_FPS", 0) > 0
+            ):
                 fps = settings.VIDEO_DEFAULT_FPS
             else:
-                raise ValidationError({
-                    "label_time_segments": "FPS unavailable — cannot calculate time segments",
-                    "video_id": getattr(obj, "id", None),
-                })
+                raise ValidationError(
+                    {
+                        "label_time_segments": "FPS unavailable — cannot calculate time segments",
+                        "video_id": getattr(obj, "id", None),
+                    }
+                )
 
         sequences = self.get_sequences(obj)  # Fetch sequence data
         frame_dir = Path(obj.frame_dir)  # Get the correct directory from the model
@@ -229,17 +250,16 @@ class VideoFileSerializer(serializers.ModelSerializer):
 
                 # Fetch predictions for frames within this range
                 for frame_num in range(start_frame, end_frame + 1):
-
-                        frame_filename = f"frame_{str(frame_num).zfill(7)}.jpg"  # Frame filename format
-                        frame_path = (
-                            frame_dir / frame_filename
-                        )  # Full path to the frame
-
-                        frame_data[frame_num] = {
-                            "frame_filename": frame_filename,
-                            "frame_file_path": str(frame_path),
-                            "predictions": None,
-                        }
+                    frame_filename = (
+                        f"frame_{str(frame_num).zfill(7)}.jpg"  # Frame filename format
+                    )
+                    frame_path = frame_dir / frame_filename  # Full path to the frame
+
+                    frame_data[frame_num] = {
+                        "frame_filename": frame_filename,
+                        "frame_file_path": str(frame_path),
+                        "predictions": None,
+                    }
 
                 # Append the converted time segment
                 label_times.append(
@@ -261,4 +281,3 @@ class VideoFileSerializer(serializers.ModelSerializer):
             }
 
         return time_segments
-

endoreg_db/serializers/video/video_file_brief.py

@@ -6,5 +6,9 @@ from rest_framework import serializers
 
 class VideoBriefSerializer(serializers.ModelSerializer):
     class Meta:
-        model  = VideoFile
-        fields = ["id", "original_file_name", "sensitive_meta_id"]  # for tables/overview
+        model = VideoFile
+        fields = [
+            "id",
+            "original_file_name",
+            "sensitive_meta_id",
+        ]  # for tables/overview

endoreg_db/serializers/video/video_file_detail.py

@@ -6,23 +6,32 @@ from endoreg_db.models.media.video.video_file import VideoFile
 from endoreg_db.serializers.video.video_file_brief import VideoBriefSerializer
 from ...utils.calc_duration_seconds import _calc_duration_vf
 
+
 class VideoDetailSerializer(VideoBriefSerializer):
     # pull selected fields from SensitiveMeta (READ-ONLY) - using SerializerMethodField to handle datetime->date conversion
-    patient_first_name = serializers.CharField(source="sensitive_meta.patient_first_name", read_only=True)
-    patient_last_name  = serializers.CharField(source="sensitive_meta.patient_last_name",  read_only=True)
-    patient_dob        = serializers.SerializerMethodField()
-    examination_date   = serializers.SerializerMethodField()
+    patient_first_name = serializers.CharField(
+        source="sensitive_meta.patient_first_name", read_only=True
+    )
+    patient_last_name = serializers.CharField(
+        source="sensitive_meta.patient_last_name", read_only=True
+    )
+    patient_dob = serializers.SerializerMethodField()
+    examination_date = serializers.SerializerMethodField()
 
-    file        = serializers.SerializerMethodField()
-    full_path   = serializers.SerializerMethodField()
-    duration    = serializers.SerializerMethodField()
-    video_url   = serializers.SerializerMethodField()
+    file = serializers.SerializerMethodField()
+    full_path = serializers.SerializerMethodField()
+    duration = serializers.SerializerMethodField()
+    video_url = serializers.SerializerMethodField()
 
     class Meta(VideoBriefSerializer.Meta):
         fields = VideoBriefSerializer.Meta.fields + [
-            "file", "full_path", "video_url",
-            "patient_first_name", "patient_last_name",
-            "patient_dob", "examination_date",
+            "file",
+            "full_path",
+            "video_url",
+            "patient_first_name",
+            "patient_last_name",
+            "patient_dob",
+            "examination_date",
             "duration",
         ]
 
@@ -38,46 +47,50 @@ class VideoDetailSerializer(VideoBriefSerializer):
     def get_video_url(self, obj):
         """
         Return the absolute URL for accessing the video streaming resource.
-        
+
         Returns:
             str or None: The absolute URL to the video streaming endpoint if a request context is available; otherwise, None.
         """
         request = self.context.get("request")
         # Use video streaming endpoint (VideoStreamView)
-        return request.build_absolute_uri(f"/api/media/videos/{obj.pk}/") if request else None
-    
-    def get_duration(self, obj:VideoFile):
+        return (
+            request.build_absolute_uri(f"/api/media/videos/{obj.pk}/")
+            if request
+            else None
+        )
+
+    def get_duration(self, obj: VideoFile):
         """
         Return the duration of the video, using the stored value if available or calculating it if not.
-        
+
         Parameters:
             obj (VideoFile): The video file instance.
-        
+
         Returns:
             float or None: Duration of the video in seconds, or None if unavailable.
         """
         return obj.duration or _calc_duration_vf(obj)
-    
+
     def get_patient_dob(self, obj):
         """
         Returns the patient's date of birth as a date object if available, or None if not present.
-        
+
         Extracts the date part from the patient's date of birth field in the sensitive metadata, handling both datetime and date types.
         """
         if obj.sensitive_meta and obj.sensitive_meta.patient_dob:
             # If it's a datetime, extract the date part
             dob = obj.sensitive_meta.patient_dob
-            return dob.date() if hasattr(dob, 'date') else dob
+            return dob.date() if hasattr(dob, "date") else dob
         return None
-    
+
     def get_examination_date(self, obj):
         """
         Returns the examination date as a date object from the sensitive metadata, or None if unavailable.
-        
+
         If the examination date is a datetime, only the date part is returned.
         """
         if obj.sensitive_meta and obj.sensitive_meta.examination_date:
             # If it's a datetime, extract the date part
             exam_date = obj.sensitive_meta.examination_date
-            return exam_date.date() if hasattr(exam_date, 'date') else exam_date
+            return exam_date.date() if hasattr(exam_date, "date") else exam_date
         return None

endoreg_db/serializers/video/video_file_list.py

@@ -1,5 +1,5 @@
 # endoreg_db/serializers/video/video_file_list.py
-from typing import Literal, Optional
+from typing import Literal
 import logging
 
 from rest_framework import serializers
@@ -38,7 +38,9 @@ class VideoFileListSerializer(serializers.ModelSerializer):
         """
         try:
             return getattr(obj, "state", None)
-        except Exception as exc:  # pragma: no cover - type of error is DB/backend-specific
+        except (
+            Exception
+        ) as exc:  # pragma: no cover - type of error is DB/backend-specific
             logger.warning(
                 "VideoFileListSerializer: unable to access state for VideoFile(id=%s): %s",
                 getattr(obj, "id", "unknown"),

endoreg_db/serializers/video/video_processing_history.py

@@ -4,6 +4,7 @@ Video Processing History Serializer
 Serializes VideoProcessingHistory model for API responses.
 Created as part of Phase 1.1: Video Correction API Endpoints.
 """
+
 from collections.abc import Mapping
 
 from rest_framework import serializers
@@ -14,60 +15,61 @@ from endoreg_db.models import VideoProcessingHistory
 class VideoProcessingHistorySerializer(serializers.ModelSerializer):
     """
     Serializer for VideoProcessingHistory model.
-    
+
     Provides operation audit trail (masking, frame removal, analysis)
     with download URLs for processed files.
     """
+
     download_url = serializers.SerializerMethodField()
     operation_display = serializers.SerializerMethodField()
     status_display = serializers.SerializerMethodField()
     duration = serializers.ReadOnlyField()
     is_complete = serializers.ReadOnlyField()
-    
+
     class Meta:
         model = VideoProcessingHistory
         fields = [
-            'id',
-            'video',
-            'operation',
-            'operation_display',
-            'status',
-            'status_display',
-            'config',
-            'output_file',
-            'download_url',
-            'details',
-            'task_id',
-            'created_at',
-            'completed_at',
-            'duration',
-            'is_complete',
+            "id",
+            "video",
+            "operation",
+            "operation_display",
+            "status",
+            "status_display",
+            "config",
+            "output_file",
+            "download_url",
+            "details",
+            "task_id",
+            "created_at",
+            "completed_at",
+            "duration",
+            "is_complete",
         ]
-        read_only_fields = ['id', 'created_at', 'completed_at']
-    
+        read_only_fields = ["id", "created_at", "completed_at"]
+
     def get_download_url(self, obj) -> str | None:
         """
         Generate download URL for processed video file.
-        
+
         Args:
             obj: VideoProcessingHistory instance
-            
+
         Returns:
             str: URL to download processed file, or None if not available
         """
         if not obj.output_file or obj.status != VideoProcessingHistory.STATUS_SUCCESS:
             return None
-        
+
         # Build URL to download endpoint (to be implemented)
         # Format: /api/media/processed-videos/{video_id}/{history_id}/
         context = self.context if isinstance(self.context, Mapping) else None
-        request = context.get('request') if context else None
+        request = context.get("request") if context else None
         if request:
             return request.build_absolute_uri(
-                f'/api/media/processed-videos/{obj.video.id}/{obj.id}/'
+                f"/api/media/processed-videos/{obj.video.id}/{obj.id}/"
             )
-        
-        return f'/api/media/processed-videos/{obj.video.id}/{obj.id}/'
+
+        return f"/api/media/processed-videos/{obj.video.id}/{obj.id}/"
 
     def get_operation_display(self, obj) -> str:
         display = getattr(obj, "get_operation_display", None)
@@ -78,37 +80,39 @@ class VideoProcessingHistorySerializer(serializers.ModelSerializer):
         display = getattr(obj, "get_status_display", None)
         result = display() if callable(display) else obj.status
         return str(result)
-    
+
     def validate_operation(self, value):
         """
         Validate operation is one of the defined choices.
-        
+
         Args:
             value: Operation type
-            
+
         Returns:
             str: Validated operation
-            
+
         Raises:
             ValidationError: If operation is invalid
         """
-        valid_operations = [choice[0] for choice in VideoProcessingHistory.OPERATION_CHOICES]
+        valid_operations = [
+            choice[0] for choice in VideoProcessingHistory.OPERATION_CHOICES
+        ]
         if value not in valid_operations:
             raise serializers.ValidationError(
                 f"Invalid operation. Must be one of: {', '.join(valid_operations)}"
             )
         return value
-    
+
     def validate_status(self, value):
         """
         Validate status is one of the defined choices.
-        
+
         Args:
             value: Status type
-            
+
         Returns:
             str: Validated status
-            
+
         Raises:
             ValidationError: If status is invalid
         """
@@ -118,17 +122,17 @@ class VideoProcessingHistorySerializer(serializers.ModelSerializer):
                 f"Invalid status. Must be one of: {', '.join(valid_statuses)}"
             )
         return value
-    
+
     def validate_config(self, value):
         """
         Validate config based on operation type.
-        
+
         Args:
             value: Config dictionary
-            
+
         Returns:
             dict: Validated config
-            
+
         Raises:
             ValidationError: If config is invalid for operation
         """
@@ -136,33 +140,33 @@ class VideoProcessingHistorySerializer(serializers.ModelSerializer):
             raise serializers.ValidationError("config must be a dictionary")
 
         initial = self.initial_data if isinstance(self.initial_data, Mapping) else {}
-        operation = initial.get('operation')
-        
+        operation = initial.get("operation")
+
         # Validate masking config
         if operation == VideoProcessingHistory.OPERATION_MASKING:
-            required_fields = ['mask_type']
-            if 'mask_type' not in value:
+            required_fields = ["mask_type"]
+            if "mask_type" not in value:
                 raise serializers.ValidationError(
                     f"Masking config must include: {', '.join(required_fields)}"
                 )
-            
+
             # If device mask, require device_name
-            if value['mask_type'] == 'device' and 'device_name' not in value:
+            if value["mask_type"] == "device" and "device_name" not in value:
                 raise serializers.ValidationError(
                     "Device mask requires 'device_name' in config"
                 )
-            
+
             # If custom ROI, require roi coordinates
-            if value['mask_type'] == 'custom' and 'roi' not in value:
+            if value["mask_type"] == "custom" and "roi" not in value:
                 raise serializers.ValidationError(
                     "Custom mask requires 'roi' coordinates in config"
                 )
-        
+
         # Validate frame removal config
         elif operation == VideoProcessingHistory.OPERATION_FRAME_REMOVAL:
-            if 'frame_list' not in value and 'detection_method' not in value:
+            if "frame_list" not in value and "detection_method" not in value:
                 raise serializers.ValidationError(
                     "Frame removal config must include 'frame_list' (manual) or 'detection_method' (automatic)"
                 )
-        
+
         return value

endoreg_db/services/__init__.py

@@ -2,4 +2,4 @@
 Services package for endoreg_db.
 
 Contains business logic services that can be reused across different parts of the application.
-"""
+"""

endoreg_db/services/anonymization.py

@@ -6,7 +6,7 @@ from typing import Optional
 from django.db import transaction
 
 from endoreg_db.models import RawPdfFile, VideoFile
-from endoreg_db.services.__old.video_import import VideoImportService
+from endoreg_db.services.video_import import VideoImportService
 from endoreg_db.services.report_import import ReportImportService
 from endoreg_db.utils.paths import STORAGE_DIR
 from endoreg_db.utils.storage import ensure_local_file, file_exists
@@ -52,7 +52,7 @@ class AnonymizationService:
                 if vf.state
                 else "not_started",
                 "fileExists": file_exists(vf.raw_file),
-                "uuid": str(vf.uuid) if vf.uuid else None,
+                "uuid": str(vf.video_hash) if vf.video_hash else None,
             }
 
         pdf = (