endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.9__py3-none-any.whl

endoreg_db/models/media/video/video_file_meta/get_fps.py

@@ -1,15 +1,17 @@
 import logging
-from typing import TYPE_CHECKING, Optional, Dict
-import cv2
 from pathlib import Path
+from typing import TYPE_CHECKING
+
+import cv2
 
 if TYPE_CHECKING:
     from ..video_file import VideoFile
 
+
 def _validate_video_path(video_path: Path):
     """
     Validates that the provided path is an existing video file.
-    
+
     Raises:
         TypeError: If `video_path` is not a Path object.
         FileNotFoundError: If the file does not exist at the specified path.
@@ -24,45 +26,53 @@ def _validate_video_path(video_path: Path):
 
 
 logger = logging.getLogger(__name__)
+
+
 def _get_fps(video: "VideoFile") -> float:
     """
     Determine and return the frames per second (FPS) of a video associated with a VideoFile instance.
-    
+
     Attempts to retrieve FPS from the instance itself, its linked VideoMeta, or by direct analysis of the raw video file using OpenCV. Updates and saves the FPS value to the instance if successfully determined. Raises a ValueError if FPS cannot be determined by any method.
-    
+
     Returns:
         float: The frames per second (FPS) of the video.
-    
+
     Raises:
         ValueError: If the FPS cannot be determined from any available source.
     """
     from .video_meta import _update_video_meta
+
     if video.fps is not None:
         return video.fps
 
     logger.debug("FPS not set on instance %s, checking VideoMeta.", video.uuid)
 
-
     if not video.video_meta:
         logger.info("VideoMeta not linked for %s, attempting update.", video.uuid)
 
-        _update_video_meta(video, save_instance=True) # Call the helper function
+        _update_video_meta(video, save_instance=True)  # Call the helper function
 
     # Check again after potential update
     if video.fps is not None:
         return video.fps
     elif video.video_meta and video.video_meta.fps is not None:
         logger.info("Retrieved FPS %.2f from VideoMeta for %s.", video.video_meta.fps, video.uuid)
-        video.fps = video.video_meta.fps
+        _fps = video.video_meta.fps
+        try:
+            _fps = float(_fps)
+        except (TypeError, ValueError):
+            logger.warning("Invalid FPS value %.2f in VideoMeta for video %s.", video.video_meta.fps, video.uuid)
+            raise ValueError(f"Could not determine FPS for video {video.uuid} due to invalid VideoMeta FPS value.")
+        video.fps = _fps
         # Avoid saving if called from within the save method itself
-        if not getattr(video, '_saving', False):
+        if not getattr(video, "_saving", False):
             video.save(update_fields=["fps"])
-        return video.fps
+        return _fps
     else:
         logger.warning("Could not determine FPS from VideoMeta for video %s. Trying direct raw file access.", video.uuid)
         try:
             if video.has_raw:
-                video_path = video.get_raw_file_path() # Use helper
+                video_path = video.get_raw_file_path()  # Use helper
                 if video_path and video_path.exists():
                     cap = cv2.VideoCapture(video_path.as_posix())
                     if not cap.isOpened():
@@ -77,11 +87,11 @@ def _get_fps(video: "VideoFile") -> float:
                     finally:
                         cap.release()
                     if fps and fps > 0:
-                            video.fps = fps
-                            logger.info("Determined FPS %.2f directly from file for %s.", video.fps, video.uuid)
-                            if not getattr(video, '_saving', False):
-                                video.save(update_fields=["fps"])
-                            return video.fps
+                        video.fps = fps
+                        logger.info("Determined FPS %.2f directly from file for %s.", video.fps, video.uuid)
+                        if not getattr(video, "_saving", False):
+                            video.save(update_fields=["fps"])
+                        return fps
                     else:
                         logger.warning("Could not determine a valid FPS for video file %s.", video_path)
                 elif video_path:
@@ -92,40 +102,33 @@ def _get_fps(video: "VideoFile") -> float:
                 logger.warning("Raw file not available for direct FPS check.")
 
         except Exception as e:
-            logger.error("Error getting FPS directly from file %s: %s", video.raw_file.name if video.has_raw else 'N/A', e)
-
-        raise ValueError(
-            f"Could not determine FPS for video {video.uuid}. "
-            "Ensure the video file is valid and accessible."
-        )
+            logger.error("Error getting FPS directly from file %s: %s", video.raw_file.name if video.has_raw else "N/A", e)
 
+        raise ValueError(f"Could not determine FPS for video {video.uuid}. Ensure the video file is valid and accessible.")
 
 
 # TODO Refactor to utils / check if similar function exists in utils
-def _get_fps_from_property(cap) -> float:
+def _get_fps_from_property(cap: cv2.VideoCapture) -> float:
     """
     Retrieve the frames per second (FPS) from an OpenCV video capture object using the appropriate property for the OpenCV version.
-    
+
     Parameters:
         cap: An OpenCV video capture object.
-    
+
     Returns:
         float: The FPS value obtained from the video capture properties, or 0.0 if unavailable.
     """
-    if hasattr(cv2, 'CAP_PROP_FPS'):
-        return cap.get(cv2.CAP_PROP_FPS)
-    # For older OpenCV versions
-    return cap.get(cv2.cv.CV_CAP_PROP_FPS) # type: ignore
+    return cap.get(cv2.CAP_PROP_FPS)
 
 
 def _calculate_fps_manually(cap, video_path: Path) -> float:
     """
     Estimate the frames per second (FPS) of a video by reading all frames and dividing the total frame count by the elapsed time.
-    
+
     Parameters:
         cap: An OpenCV video capture object positioned at the start of the video.
         video_path (Path): Path to the video file, used for logging.
-    
+
     Returns:
         float: The estimated FPS, or 0.0 if the duration is zero or calculation fails.
     """
@@ -142,6 +145,6 @@ def _calculate_fps_manually(cap, video_path: Path) -> float:
     seconds = (end_time - start_time) / cv2.getTickFrequency()
     if seconds > 0:
         return num_frames / seconds
-    
+
     logger.error(f"Manual FPS calculation failed for {video_path} due to zero duration.")
-    return 0.0
+    return 0.0

endoreg_db/models/media/video/video_file_meta/initialize_video_specs.py

@@ -2,30 +2,33 @@
 import logging
 from pathlib import Path
 from typing import TYPE_CHECKING, Optional
+
 import cv2
+
 # --- End Add Imports ---
 
 if TYPE_CHECKING:
-    from ..video_file import VideoFile # Correct import path
+    from ..video_file import VideoFile  # Correct import path
 
 # --- Add Logger ---
 logger = logging.getLogger(__name__)
 # --- End Add Logger ---
 
+
 def _initialize_video_specs(video: "VideoFile", use_raw: bool = True) -> bool:
     """
     Initializes video specifications for a VideoFile object by reading from the video file.
-    
+
     Attempts to populate missing values for fps, width, height, frame count, and duration using OpenCV. Selects the raw file if available and requested, otherwise uses the active file. Updates only unset fields if valid values are obtained. Returns True if successful or if no updates are needed. Raises FileNotFoundError if the video file cannot be found, or RuntimeError if the file cannot be opened or properties cannot be read.
     """
     video_path: Optional[Path] = None
     target_file_name: Optional[str] = None
 
     if use_raw and video.has_raw:
-        video_path = video.get_raw_file_path() # Use IO helper
+        video_path = video.get_raw_file_path()  # Use IO helper
         target_file_name = video.raw_file.name
-    elif video.active_file: # Fallback to active file if raw not requested or available
-        video_path = video.active_file_path # Use property relying on IO helpers
+    elif video.active_file:  # Fallback to active file if raw not requested or available
+        video_path = video.active_file_path  # Use property relying on IO helpers
         target_file_name = video.active_file.name
     else:
         logger.error("No suitable video file found for spec initialization for %s.", video.uuid)
@@ -44,7 +47,7 @@ def _initialize_video_specs(video: "VideoFile", use_raw: bool = True) -> bool:
         video_cap = cv2.VideoCapture(video_path.as_posix())
         if not video_cap.isOpened():
             # Raise exception
-            video_cap.release() # Ensure release
+            video_cap.release()  # Ensure release
             raise RuntimeError(f"Could not open video file {video_path} with OpenCV for spec initialization (Video: {video.uuid}).")
 
         updated = False
@@ -67,14 +70,14 @@ def _initialize_video_specs(video: "VideoFile", use_raw: bool = True) -> bool:
             logger.error("Error getting properties from OpenCV for %s (Video: %s): %s", video_path, video.uuid, cv_err, exc_info=True)
             raise RuntimeError(f"OpenCV failed to get properties for {video_path}") from cv_err
         finally:
-            video_cap.release() # Ensure release after getting props
+            video_cap.release()  # Ensure release after getting props
 
         # --- Update FPS ---
         if current_fps is None and file_fps and file_fps > 0:
             video.fps = file_fps
             fields_to_update.append("fps")
             updated = True
-            current_fps = file_fps # Update local var for duration calc
+            current_fps = file_fps  # Update local var for duration calc
 
         # --- Update Width ---
         if current_width is None and file_width > 0:
@@ -93,20 +96,16 @@ def _initialize_video_specs(video: "VideoFile", use_raw: bool = True) -> bool:
             video.frame_count = file_frame_count
             fields_to_update.append("frame_count")
             updated = True
-        elif file_frame_count is None or file_frame_count <= 0: # Log if not updated due to invalid file_frame_count
-            logger.warning(
-                "Invalid frame count (value: %s) obtained from OpenCV for %s. Video frame_count not updated.",
-                file_frame_count, video_path
-            )
+        elif file_frame_count is None or file_frame_count <= 0:  # Log if not updated due to invalid file_frame_count
+            logger.warning("Invalid frame count (value: %s) obtained from OpenCV for %s. Video frame_count not updated.", file_frame_count, video_path)
 
         # --- Update Duration ---
-        if current_duration is None: # Only if duration isn't already set
+        if current_duration is None:  # Only if duration isn't already set
             # Use the potentially updated video.frame_count and current_fps (which reflects video.fps or file_fps)
             final_frame_count_for_duration = video.frame_count
-            final_fps_for_duration = current_fps # This is video.fps after potential update from file_fps
+            final_fps_for_duration = current_fps  # This is video.fps after potential update from file_fps
 
-            if (final_frame_count_for_duration and final_frame_count_for_duration > 0 and
-                final_fps_for_duration and final_fps_for_duration > 0):
+            if final_frame_count_for_duration and final_frame_count_for_duration > 0 and final_fps_for_duration and final_fps_for_duration > 0:
                 video.duration = final_frame_count_for_duration / final_fps_for_duration
                 fields_to_update.append("duration")
                 updated = True
@@ -114,15 +113,10 @@ def _initialize_video_specs(video: "VideoFile", use_raw: bool = True) -> bool:
                 # Log if duration could not be calculated, indicating which component was missing/invalid
                 if not (final_frame_count_for_duration and final_frame_count_for_duration > 0):
                     logger.warning(
-                        "Duration not calculated for %s: frame count is unavailable or invalid (value: %s).",
-                        video_path, final_frame_count_for_duration
+                        "Duration not calculated for %s: frame count is unavailable or invalid (value: %s).", video_path, final_frame_count_for_duration
                     )
                 if not (final_fps_for_duration and final_fps_for_duration > 0):
-                    logger.warning(
-                        "Duration not calculated for %s: FPS is unavailable or invalid (value: %s).",
-                        video_path, final_fps_for_duration
-                    )
-
+                    logger.warning("Duration not calculated for %s: FPS is unavailable or invalid (value: %s).", video_path, final_fps_for_duration)
 
         # --- Save if updated ---
         if updated:
@@ -137,7 +131,7 @@ def _initialize_video_specs(video: "VideoFile", use_raw: bool = True) -> bool:
         # Log and re-raise exception
         logger.error("Error initializing video specs for %s from file %s: %s", video.uuid, video_path, e, exc_info=True)
         # Ensure capture is released in case of unexpected error
-        if 'video_cap' in locals() and video_cap.isOpened():
+        if "video_cap" in locals() and video_cap.isOpened():
             video_cap.release()
         # Re-raise as RuntimeError
         raise RuntimeError(f"Failed to initialize video specs for {video.uuid} from {video_path}") from e

endoreg_db/models/media/video/video_file_meta/text_meta.py

@@ -1,10 +1,12 @@
 import logging
 from typing import TYPE_CHECKING, Optional
+
+# --- End Fix ---
+from django.db import transaction
+
 # --- Fix Imports ---
 from ....metadata import SensitiveMeta
 from ....metadata.sensitive_meta_logic import update_or_create_sensitive_meta_from_dict
-# --- End Fix ---
-from django.db import transaction
 
 if TYPE_CHECKING:
     from ..video_file import VideoFile
@@ -38,77 +40,78 @@ def _update_text_metadata(
         logger.warning(f"Frames not extracted for video {video.uuid}. Attempting automatic frame extraction...")
         try:
             success = video.extract_frames(overwrite=False)
-            if success:
-                # Refresh state after frame extraction
-                state.refresh_from_db()
-                if state.frames_extracted:
-                    logger.info(f"Successfully extracted frames for video {video.uuid}")
-                else:
-                    # Force update the state if extraction was successful but state wasn't updated
-                    state.frames_extracted = True
-                    state.save(update_fields=['frames_extracted'])
-                    logger.info(f"Corrected frames_extracted state for video {video.uuid}")
-            else:
-                raise ValueError(f"Cannot update text metadata for video {video.uuid}: Frame extraction failed.")
-        except Exception as e:
-            logger.error(f"Failed to extract frames for video {video.uuid}: {e}")
-            raise ValueError(f"Cannot update text metadata for video {video.uuid}: Frames not extracted and automatic extraction failed: {e}")
+        except (FileNotFoundError, RuntimeError, ValueError, OSError) as exc:
+            logger.error(
+                "Failed to extract frames for video %s: %s",
+                video.uuid,
+                exc,
+                exc_info=True,
+            )
+            raise ValueError(f"Cannot update text metadata for video {video.uuid}: Frames not extracted and automatic extraction failed") from exc
+
+        if not success:
+            raise ValueError(f"Cannot update text metadata for video {video.uuid}: Frame extraction returned False")
+
+        state.refresh_from_db()
+        if not state.frames_extracted:
+            raise ValueError(f"Cannot update text metadata for video {video.uuid}: Frame extraction completed but state was not updated")
+
+        logger.info(f"Successfully extracted frames for video {video.uuid}")
 
     if state.text_meta_extracted and not overwrite:
-        logger.info("Text already extracted for video %s and overwrite=False. Skipping.", video.uuid) # Changed to info
-        return video.sensitive_meta # Return existing meta if available
+        logger.info("Text already extracted for video %s and overwrite=False. Skipping.", video.uuid)  # Changed to info
+        return video.sensitive_meta  # Return existing meta if available
     # --- End Pre-condition Checks ---
 
     # Extract text using the AI helper function
     # _extract_text_from_video_frames raises ValueError on pre-condition failure
     try:
         if not extracted_data_dict:
-            extracted_data_dict = video.extract_text_from_frames(
-                frame_fraction=ocr_frame_fraction, cap=cap
-            )
+            extracted_data_dict = video.extract_text_from_frames(frame_fraction=ocr_frame_fraction, cap=cap)
     except Exception as text_extract_e:
-         logger.error("Failed during text extraction step for video %s: %s", video.uuid, text_extract_e, exc_info=True)
-         raise RuntimeError(f"Text extraction failed for video {video.uuid}") from text_extract_e
+        logger.error("Failed during text extraction step for video %s: %s", video.uuid, text_extract_e, exc_info=True)
+        raise RuntimeError(f"Text extraction failed for video {video.uuid}") from text_extract_e
 
     # --- Atomic Update Block ---
     try:
         with transaction.atomic():
             # Refresh state in case it changed
             state.refresh_from_db()
-            sensitive_meta_instance = video.sensitive_meta # Get current instance
+            sensitive_meta_instance = video.sensitive_meta  # Get current instance
 
             if not extracted_data_dict:
                 logger.warning("No text extracted for video %s; skipping SensitiveMeta update.", video.uuid)
                 # Mark state as retrieved even if no data found, to avoid re-running unless overwrite=True
                 if not state.text_meta_extracted:
                     state.text_meta_extracted = True
-                    state.save(update_fields=['text_meta_extracted'])
-                return sensitive_meta_instance # Return existing meta if available
+                    state.save(update_fields=["text_meta_extracted"])
+                return sensitive_meta_instance  # Return existing meta if available
 
             # Add center info if not already present in extracted data
-            if 'center_name' not in extracted_data_dict and video.center:
-                extracted_data_dict['center_name'] = video.center.name
+            if "center_name" not in extracted_data_dict and video.center:
+                extracted_data_dict["center_name"] = video.center.name
             logger.debug("Data for SensitiveMeta update for video %s: %s", video.uuid, extracted_data_dict)
 
             # Pass the Class, the data dict, and the current instance (or None)
             # This function might raise exceptions if data is invalid
             sensitive_meta, created = update_or_create_sensitive_meta_from_dict(
-                SensitiveMeta, # Pass the class
+                SensitiveMeta,  # Pass the class
                 extracted_data_dict,
-                instance=sensitive_meta_instance # Pass current instance via keyword
+                instance=sensitive_meta_instance,  # Pass current instance via keyword
             )
 
             # Update VideoFile fields if necessary
             update_fields_video = []
-            if created or sensitive_meta != sensitive_meta_instance: # Check if relation needs update
+            if created or sensitive_meta != sensitive_meta_instance:  # Check if relation needs update
                 video.sensitive_meta = sensitive_meta
-                update_fields_video.append('sensitive_meta')
+                update_fields_video.append("sensitive_meta")
 
-            if not video.date and sensitive_meta and extracted_data_dict.get('date'):
-                extracted_date = extracted_data_dict.get('date')
-                if extracted_date: # Ensure date is not None or empty
+            if not video.date and sensitive_meta and extracted_data_dict.get("date"):
+                extracted_date = extracted_data_dict.get("date")
+                if extracted_date:  # Ensure date is not None or empty
                     video.date = extracted_date
                     update_fields_video.append("date")
+                    
 
             # Save VideoFile if fields changed
             if update_fields_video:
@@ -117,14 +120,14 @@ def _update_text_metadata(
             # Update state
             if not state.text_meta_extracted:
                 state.text_meta_extracted = True
-                state.save(update_fields=['text_meta_extracted'])
+                state.save(update_fields=["text_meta_extracted"])
 
             # Mark sensitive meta as processed when updated via text metadata
             if sensitive_meta:
                 state.mark_sensitive_meta_processed(save=True)
                 logger.info(f"Marked sensitive_meta_processed=True for video {video.uuid} after text metadata update")
 
-            logger.info("Successfully updated/created SensitiveMeta and state for video %s.", video.uuid) # Changed to info
+            logger.info("Successfully updated/created SensitiveMeta and state for video %s.", video.uuid)  # Changed to info
             return sensitive_meta
 
     except Exception as e:

endoreg_db/models/media/video/video_file_meta/video_meta.py

@@ -6,31 +6,36 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+
 def _update_video_meta(video: "VideoFile", save_instance: bool = True):
     """
     Updates or creates the technical VideoMeta from the raw video file.
     Raises FileNotFoundError or ValueError on pre-condition failure, RuntimeError on processing failure.
     """
-    from ....metadata import VideoMeta # Local import
+    from ....metadata import VideoMeta  # Local import
 
     logger.debug("Updating technical VideoMeta for video %s (from raw file).", video.uuid)
 
     if not video.has_raw:
         # DEFENSIVE: Log warning and skip instead of crashing
-        logger.warning(f"Raw video file path not available for {video.uuid}. Skipping VideoMeta update - this may indicate the video was processed and raw file moved.")
+        logger.warning(
+            f"Raw video file path not available for {video.uuid}. Skipping VideoMeta update - this may indicate the video was processed and raw file moved."
+        )
         return  # Graceful skip instead of FileNotFoundError
 
-    raw_video_path = video.get_raw_file_path() # Use helper
+    raw_video_path = video.get_raw_file_path()  # Use helper
     if not raw_video_path or not raw_video_path.exists():
         # DEFENSIVE: Log warning and skip instead of crashing production pipeline
-        logger.warning(f"Raw video file path {raw_video_path} does not exist for video {video.uuid}. Skipping VideoMeta update - this typically happens after video processing when raw files are moved to processed location.")
+        logger.warning(
+            f"Raw video file path {raw_video_path} does not exist for video {video.uuid}. Skipping VideoMeta update - this typically happens after video processing when raw files are moved to processed location."
+        )
         return  # Graceful skip instead of FileNotFoundError that crashes production
 
     try:
         vm = video.video_meta
         if vm:
             logger.info("Updating existing VideoMeta (PK: %s) for video %s.", vm.pk, video.uuid)
-            vm.update_meta(raw_video_path) # Assuming this method exists and raises on error
+            vm.update_meta(raw_video_path)  # Assuming this method exists and raises on error
             vm.save()
         else:
             if not video.center or not video.processor:
@@ -43,9 +48,11 @@ def _update_video_meta(video: "VideoFile", save_instance: bool = True):
                 video_path=raw_video_path,
                 center=video.center,
                 processor=video.processor,
-                save_instance=True # Let create_from_file handle saving
+                save_instance=True,  # Let create_from_file handle saving
             )
-            logger.info("Created and linked VideoMeta (PK: %s) for video %s.", video.video_meta.pk, video.uuid)
+            vm = video.video_meta
+            assert vm is not None  # For type checker
+            logger.info("Created and linked VideoMeta (PK: %s) for video %s.", vm.pk, video.uuid)
 
         # Save the VideoFile instance itself if requested and if video_meta was linked/updated
         if save_instance:

endoreg_db/models/media/video/video_file_segments.py

@@ -1,18 +1,21 @@
 import logging
-from typing import TYPE_CHECKING, List, Dict, Tuple, Set
-from icecream import ic
 from pathlib import Path
+from typing import TYPE_CHECKING, Dict, List, Set, Tuple
+
 from django.db.models import Q  # Import Q for complex queries
+from icecream import ic
 
 if TYPE_CHECKING:
-    from .video_file import VideoFile
+    from django.db.models import QuerySet
+
     from ...label import LabelVideoSegment
     from ...metadata import VideoPredictionMeta
     from ..frame import Frame
-    from django.db.models import QuerySet
+    from .video_file import VideoFile
 
 logger = logging.getLogger(__name__)
 
+
 def _convert_sequences_to_db_segments(
     video: "VideoFile",
     sequences: Dict[str, List[Tuple[int, int]]],
@@ -72,14 +75,14 @@ def _convert_sequences_to_db_segments(
                 logger.error("Error bulk creating segments for label '%s': %s", label_name, e, exc_info=True)
                 error_count += len(segments_to_create)
 
-    newly_created_segments = LabelVideoSegment.objects.filter(
-        video_file=video,
-        prediction_meta=video_prediction_meta,
-        label__name__in=processed_labels
-    )
+    newly_created_segments = LabelVideoSegment.objects.filter(video_file=video, prediction_meta=video_prediction_meta, label__name__in=processed_labels)
 
-    logger.info("Attempting to create state objects for %d potentially new segments (Video: %s, PredictionMeta: %s)",
-                newly_created_segments.count(), video.uuid, video_prediction_meta.pk)
+    logger.info(
+        "Attempting to create state objects for %d potentially new segments (Video: %s, PredictionMeta: %s)",
+        newly_created_segments.count(),
+        video.uuid,
+        video_prediction_meta.pk,
+    )
 
     for segment in newly_created_segments:
         try:
@@ -92,7 +95,12 @@ def _convert_sequences_to_db_segments(
 
     logger.info(
         "LabelVideoSegment conversion finished for video %s. Segments Created: %d, Skipped: %d, Errors: %d. States Created: %d, State Errors: %d",
-        video.uuid, created_count, skipped_count, error_count, state_created_count, state_error_count
+        video.uuid,
+        created_count,
+        skipped_count,
+        error_count,
+        state_created_count,
+        state_error_count,
     )
 
 
@@ -160,15 +168,14 @@ def _get_outside_frames(video: "VideoFile", outside_label_name: str = "outside")
 
     q_objects: Q | None = None
     for segment in outside_segments:
-        clause = Q(frame_number__gte=segment.start_frame_number,
-                   frame_number__lt=segment.end_frame_number)
+        clause = Q(frame_number__gte=segment.start_frame_number, frame_number__lt=segment.end_frame_number)
         q_objects = clause if q_objects is None else q_objects | clause
 
     if q_objects is None:
         return Frame.objects.none()
 
     try:
-        return video.frames.filter(q_objects).distinct().order_by('frame_number')
+        return video.frames.filter(q_objects).distinct().order_by("frame_number")
     except Exception as e:
         logger.error("Error filtering outside frames for video %s: %s", video.uuid, e, exc_info=True)
         return Frame.objects.none()
@@ -177,11 +184,12 @@ def _get_outside_frames(video: "VideoFile", outside_label_name: str = "outside")
 def _get_outside_frame_paths(video: "VideoFile", outside_label_name: str = "outside") -> List["Path"]:
     """Gets the file paths of frames that fall within 'outside' segments."""
     from pathlib import Path  # Local import
+
     frames = _get_outside_frames(video, outside_label_name=outside_label_name)
     frame_paths = []
     for frame in frames:
         try:
-            frame_paths.append(Path(frame.image.path))
+            frame_paths.append(Path(frame.relative_path))
         except Exception as e:
             logger.warning("Could not get path for frame %s (Number: %d): %s", frame.pk, frame.frame_number, e)
             ic(f"Could not get path for frame {frame.pk}: {e}")
@@ -206,4 +214,3 @@ def _label_segments_to_frame_annotations(video: "VideoFile"):
         logger.info("Processed %d segments for frame annotations for video %s", processed_count, video.uuid)
     except AttributeError:
         logger.error("Could not generate frame annotations for video %s. 'label_video_segments' related manager not found.", video.uuid)
-

endoreg_db/models/media/video/video_metadata.py

@@ -4,59 +4,43 @@ Video Metadata Model
 Stores analysis results for videos (sensitive frames, detection statistics).
 Created as part of Phase 1.1: Video Correction API Endpoints.
 """
+
 from django.db import models
+
 from .video_file import VideoFile
 
+
 class VideoMetadata(models.Model):
     """
     Stores analysis results for videos after sensitive frame detection.
-    
+
     This model holds the output of frame analysis operations (MiniCPM, OCR+LLM)
     and provides metrics for the correction UI.
     """
-    video = models.OneToOneField(
-        VideoFile, 
-        on_delete=models.CASCADE, 
-        related_name='metadata',
-        help_text="Video file this metadata belongs to"
-    )
-    
+
+    video = models.OneToOneField(VideoFile, on_delete=models.CASCADE, related_name="metadata", help_text="Video file this metadata belongs to")
+
     # Analysis Results
-    sensitive_frame_count = models.IntegerField(
-        null=True, 
-        blank=True,
-        help_text="Number of frames detected as containing sensitive information"
-    )
-    sensitive_ratio = models.FloatField(
-        null=True, 
-        blank=True,
-        help_text="Ratio of sensitive frames to total frames (0.0-1.0)"
-    )
-    sensitive_frame_ids = models.TextField(
-        null=True, 
-        blank=True,
-        help_text="JSON array of sensitive frame indices (0-based)"
-    )
-    
+    sensitive_frame_count = models.IntegerField(null=True, blank=True, help_text="Number of frames detected as containing sensitive information")
+    sensitive_ratio = models.FloatField(null=True, blank=True, help_text="Ratio of sensitive frames to total frames (0.0-1.0)")
+    sensitive_frame_ids = models.TextField(null=True, blank=True, help_text="JSON array of sensitive frame indices (0-based)")
+
     # Metadata
-    analyzed_at = models.DateTimeField(
-        auto_now=True,
-        help_text="Timestamp of last analysis"
-    )
-    
+    analyzed_at = models.DateTimeField(auto_now=True, help_text="Timestamp of last analysis")
+
     class Meta:
-        db_table = 'video_metadata'
-        verbose_name = 'Video Metadata'
-        verbose_name_plural = 'Video Metadata'
-    
+        db_table = "video_metadata"
+        verbose_name = "Video Metadata"
+        verbose_name_plural = "Video Metadata"
+
     def __str__(self):
         return f"Metadata for {self.video.uuid} ({self.sensitive_frame_count or 0} sensitive frames)"
-    
+
     @property
     def has_analysis(self) -> bool:
         """Check if this video has been analyzed."""
         return self.sensitive_frame_count is not None
-    
+
     @property
     def sensitive_percentage(self) -> float:
         """Get sensitivity as percentage (0-100)."""