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

endoreg_db/models/metadata/video_meta.py

@@ -30,11 +30,19 @@ class VideoMeta(models.Model):
     Links to hardware (processor, endoscope), center, import details, and FFmpeg technical specs.
     """
 
-    processor = models.ForeignKey("EndoscopyProcessor", on_delete=models.CASCADE, blank=True, null=True)
-    endoscope = models.ForeignKey("Endoscope", on_delete=models.CASCADE, blank=True, null=True)
+    processor = models.ForeignKey(
+        "EndoscopyProcessor", on_delete=models.CASCADE, blank=True, null=True
+    )
+    endoscope = models.ForeignKey(
+        "Endoscope", on_delete=models.CASCADE, blank=True, null=True
+    )
     center = models.ForeignKey("Center", on_delete=models.CASCADE)
-    import_meta = models.OneToOneField("VideoImportMeta", on_delete=models.CASCADE, blank=True, null=True)
-    ffmpeg_meta = models.OneToOneField("FFMpegMeta", on_delete=models.CASCADE, blank=True, null=True)
+    import_meta = models.OneToOneField(
+        "VideoImportMeta", on_delete=models.CASCADE, blank=True, null=True
+    )
+    ffmpeg_meta = models.OneToOneField(
+        "FFMpegMeta", on_delete=models.CASCADE, blank=True, null=True
+    )
 
     if TYPE_CHECKING:
         processor: models.ForeignKey["EndoscopyProcessor|None"]
@@ -47,21 +55,27 @@ class VideoMeta(models.Model):
     def center_safe(self) -> "Center":
         center = self.center
         if not center:
-            raise Center.DoesNotExist("Center does not exist for this VideoMeta instance.")
+            raise Center.DoesNotExist(
+                "Center does not exist for this VideoMeta instance."
+            )
         return center
 
     @property
     def processor_safe(self) -> "EndoscopyProcessor":
         processor = self.processor
         if not processor:
-            raise EndoscopyProcessor.DoesNotExist("EndoscopyProcessor does not exist for this VideoMeta instance.")
+            raise EndoscopyProcessor.DoesNotExist(
+                "EndoscopyProcessor does not exist for this VideoMeta instance."
+            )
         return processor
 
     @property
     def ffmpeg_meta_safe(self) -> "FFMpegMeta":
         ffmpeg_meta = self.ffmpeg_meta
         if not ffmpeg_meta:
-            raise FFMpegMeta.DoesNotExist("FFMpegMeta does not exist for this VideoMeta instance.")
+            raise FFMpegMeta.DoesNotExist(
+                "FFMpegMeta does not exist for this VideoMeta instance."
+            )
         return ffmpeg_meta
 
     @classmethod
@@ -88,14 +102,27 @@ class VideoMeta(models.Model):
             meta.initialize_ffmpeg_meta(video_path)
         except Exception as e:
             # Re-raise exceptions from ffmpeg meta initialization
-            logger.error("Failed during FFMpegMeta initialization within create_from_file for %s: %s", video_path.name, e, exc_info=True)
-            raise RuntimeError(f"Failed to initialize FFMpeg metadata for {video_path.name}") from e
+            logger.error(
+                "Failed during FFMpegMeta initialization within create_from_file for %s: %s",
+                video_path.name,
+                e,
+                exc_info=True,
+            )
+            raise RuntimeError(
+                f"Failed to initialize FFMpeg metadata for {video_path.name}"
+            ) from e
 
         if save_instance:
             meta.save()  # This ensures VideoImportMeta is created too
-            logger.info("Created and saved VideoMeta instance PK %s from %s", meta.pk, video_path.name)
+            logger.info(
+                "Created and saved VideoMeta instance PK %s from %s",
+                meta.pk,
+                video_path.name,
+            )
         else:
-            logger.info("Instantiated VideoMeta from %s (not saved yet)", video_path.name)
+            logger.info(
+                "Instantiated VideoMeta from %s (not saved yet)", video_path.name
+            )
 
         return meta
 
@@ -129,10 +156,17 @@ class VideoMeta(models.Model):
         Raises RuntimeError if FFMpegMeta creation fails.
         """
         if self.ffmpeg_meta:
-            logger.debug("FFMpegMeta already exists for VideoMeta PK %s. Skipping initialization.", self.pk)
+            logger.debug(
+                "FFMpegMeta already exists for VideoMeta PK %s. Skipping initialization.",
+                self.pk,
+            )
             return
 
-        logger.info("Initializing FFMpegMeta for VideoMeta PK %s from %s", self.pk if self.pk else "(unsaved)", video_path.name)
+        logger.info(
+            "Initializing FFMpegMeta for VideoMeta PK %s from %s",
+            self.pk if self.pk else "(unsaved)",
+            video_path.name,
+        )
         try:
             # FFMpegMeta.create_from_file now raises exceptions on failure
             ffmpeg_instance = FFMpegMeta.create_from_file(video_path)
@@ -142,27 +176,43 @@ class VideoMeta(models.Model):
             # Otherwise, the link will be saved when VideoMeta itself is saved.
             if self.pk:
                 self.save(update_fields=["ffmpeg_meta"])
-            logger.info("Successfully created and linked FFMpegMeta PK %s", self.ffmpeg_meta_safe.pk)
+            logger.info(
+                "Successfully created and linked FFMpegMeta PK %s",
+                self.ffmpeg_meta_safe.pk,
+            )
 
         except Exception as e:
             # Log the error and re-raise it
-            logger.error("Failed to create or link FFMpegMeta from %s: %s", video_path, e, exc_info=True)
-            raise RuntimeError(f"Failed to create FFMpeg metadata from {video_path}") from e
+            logger.error(
+                "Failed to create or link FFMpegMeta from %s: %s",
+                video_path,
+                e,
+                exc_info=True,
+            )
+            raise RuntimeError(
+                f"Failed to create FFMpeg metadata from {video_path}"
+            ) from e
 
     def update_meta(self, video_path: Path):
         """
         Updates the FFMpeg metadata from the file, replacing existing data.
         Raises RuntimeError if FFMpegMeta creation fails.
         """
-        logger.info("Updating FFMpegMeta for VideoMeta PK %s from %s", self.pk, video_path.name)
+        logger.info(
+            "Updating FFMpegMeta for VideoMeta PK %s from %s", self.pk, video_path.name
+        )
         existing_ffmpeg_pk = None
         if self.ffmpeg_meta:
             existing_ffmpeg_pk = self.ffmpeg_meta.pk
-            logger.debug("Deleting existing FFMpegMeta PK %s before update.", existing_ffmpeg_pk)
+            logger.debug(
+                "Deleting existing FFMpegMeta PK %s before update.", existing_ffmpeg_pk
+            )
             # Nullify the relation first before deleting the related object
             self.ffmpeg_meta = None
             self.save(update_fields=["ffmpeg_meta"])  # Save the null relation
-            FFMpegMeta.objects.filter(pk=existing_ffmpeg_pk).delete()  # Delete the old object
+            FFMpegMeta.objects.filter(
+                pk=existing_ffmpeg_pk
+            ).delete()  # Delete the old object
 
         # initialize_ffmpeg_meta handles creation, linking, saving the link, and raises exceptions
         self.initialize_ffmpeg_meta(video_path)
@@ -179,7 +229,9 @@ class VideoMeta(models.Model):
     def fps(self) -> Optional[float]:
         """Returns the frame rate (FPS) from the linked FFMpegMeta."""
         if not self.ffmpeg_meta:
-            logger.warning("FFMpegMeta not linked for VideoMeta PK %s. Cannot get FPS.", self.pk)
+            logger.warning(
+                "FFMpegMeta not linked for VideoMeta PK %s. Cannot get FPS.", self.pk
+            )
             return None
         return self.ffmpeg_meta.fps
 
@@ -201,7 +253,12 @@ class VideoMeta(models.Model):
     @property
     def frame_count(self) -> Optional[int]:
         """Calculates frame count based on duration and FPS from FFMpegMeta."""
-        if self.ffmpeg_meta and self.ffmpeg_meta.duration is not None and self.ffmpeg_meta.fps is not None and self.ffmpeg_meta.fps > 0:
+        if (
+            self.ffmpeg_meta
+            and self.ffmpeg_meta.duration is not None
+            and self.ffmpeg_meta.fps is not None
+            and self.ffmpeg_meta.fps > 0
+        ):
             return int(self.ffmpeg_meta.duration * self.ffmpeg_meta.fps)
         return None
 
@@ -214,17 +271,29 @@ class FFMpegMeta(models.Model):
     width = models.IntegerField(null=True, blank=True)
     height = models.IntegerField(null=True, blank=True)
     duration = models.FloatField(null=True, blank=True)  # Duration in seconds
-    frame_rate_num = models.IntegerField(null=True, blank=True)  # Numerator for frame rate
-    frame_rate_den = models.IntegerField(null=True, blank=True)  # Denominator for frame rate
+    frame_rate_num = models.IntegerField(
+        null=True, blank=True
+    )  # Numerator for frame rate
+    frame_rate_den = models.IntegerField(
+        null=True, blank=True
+    )  # Denominator for frame rate
     codec_name = models.CharField(max_length=50, null=True, blank=True)
     pixel_format = models.CharField(max_length=50, null=True, blank=True)
-    bit_rate = models.BigIntegerField(null=True, blank=True)  # Bit rate in bits per second
-    raw_probe_data = models.JSONField(null=True, blank=True)  # Store the full JSON output for debugging or future use
+    bit_rate = models.BigIntegerField(
+        null=True, blank=True
+    )  # Bit rate in bits per second
+    raw_probe_data = models.JSONField(
+        null=True, blank=True
+    )  # Store the full JSON output for debugging or future use
 
     @property
     def fps(self) -> Optional[float]:
         """Calculates and returns the frames per second (FPS) if possible."""
-        if self.frame_rate_num is not None and self.frame_rate_den is not None and self.frame_rate_den != 0:
+        if (
+            self.frame_rate_num is not None
+            and self.frame_rate_den is not None
+            and self.frame_rate_den != 0
+        ):
             return self.frame_rate_num / self.frame_rate_den
         return None
 
@@ -236,17 +305,30 @@ class FFMpegMeta(models.Model):
         """
         logger.info("Running ffprobe on %s", file_path)
         try:
-            probe_data = ffmpeg_wrapper.get_stream_info(file_path)  # Use the new utility
+            probe_data = ffmpeg_wrapper.get_stream_info(
+                file_path
+            )  # Use the new utility
         except Exception as probe_err:
-            logger.error("ffprobe execution failed for %s: %s", file_path, probe_err, exc_info=True)
-            raise RuntimeError(f"ffprobe execution failed for {file_path}") from probe_err
+            logger.error(
+                "ffprobe execution failed for %s: %s",
+                file_path,
+                probe_err,
+                exc_info=True,
+            )
+            raise RuntimeError(
+                f"ffprobe execution failed for {file_path}"
+            ) from probe_err
 
         if not probe_data or "streams" not in probe_data:
-            logger.error("Failed to get valid stream info from ffprobe for %s", file_path)
+            logger.error(
+                "Failed to get valid stream info from ffprobe for %s", file_path
+            )
             # Raise exception instead of returning None
             raise RuntimeError(f"Invalid stream info from ffprobe for {file_path}")
 
-        video_stream = next((s for s in probe_data["streams"] if s.get("codec_type") == "video"), None)
+        video_stream = next(
+            (s for s in probe_data["streams"] if s.get("codec_type") == "video"), None
+        )
 
         if not video_stream:
             logger.warning("No video stream found in ffprobe output for %s", file_path)
@@ -258,7 +340,11 @@ class FFMpegMeta(models.Model):
         height = video_stream.get("height")
         duration_str = video_stream.get("duration")
         # --- FIX: Handle potential format key ---
-        if duration_str is None and "format" in probe_data and "duration" in probe_data["format"]:
+        if (
+            duration_str is None
+            and "format" in probe_data
+            and "duration" in probe_data["format"]
+        ):
             duration_str = probe_data["format"]["duration"]
             logger.debug("Using duration from format block: %s", duration_str)
         # --- End Fix ---
@@ -278,17 +364,25 @@ class FFMpegMeta(models.Model):
                 frame_rate_num = int(num_str)
                 frame_rate_den = int(den_str)
                 if frame_rate_den == 0:  # Avoid division by zero
-                    logger.warning("Invalid frame rate denominator (0) for %s", file_path)
+                    logger.warning(
+                        "Invalid frame rate denominator (0) for %s", file_path
+                    )
                     frame_rate_num, frame_rate_den = None, None
             except ValueError:
-                logger.warning("Could not parse frame rate '%s' for %s", frame_rate_str, file_path)
+                logger.warning(
+                    "Could not parse frame rate '%s' for %s", frame_rate_str, file_path
+                )
                 frame_rate_num, frame_rate_den = None, None
 
         codec_name = video_stream.get("codec_name")
         pixel_format = video_stream.get("pix_fmt")
         bit_rate_str = video_stream.get("bit_rate")
         # --- FIX: Handle potential format key for bit_rate ---
-        if bit_rate_str is None and "format" in probe_data and "bit_rate" in probe_data["format"]:
+        if (
+            bit_rate_str is None
+            and "format" in probe_data
+            and "bit_rate" in probe_data["format"]
+        ):
             bit_rate_str = probe_data["format"]["bit_rate"]
             logger.debug("Using bit_rate from format block: %s", bit_rate_str)
         # --- End Fix ---
@@ -306,12 +400,23 @@ class FFMpegMeta(models.Model):
                 bit_rate=bit_rate,
                 raw_probe_data=probe_data,
             )
-            logger.info("Successfully created FFMpegMeta for %s (ID: %d)", file_path.name, instance.pk)
+            logger.info(
+                "Successfully created FFMpegMeta for %s (ID: %d)",
+                file_path.name,
+                instance.pk,
+            )
             return instance
         except Exception as e:
-            logger.error("Error creating FFMpegMeta DB record from %s: %s", file_path.name, e, exc_info=True)
+            logger.error(
+                "Error creating FFMpegMeta DB record from %s: %s",
+                file_path.name,
+                e,
+                exc_info=True,
+            )
             # Raise exception instead of returning None
-            raise RuntimeError(f"Database error creating FFMpegMeta for {file_path.name}") from e
+            raise RuntimeError(
+                f"Database error creating FFMpegMeta for {file_path.name}"
+            ) from e
 
     def __str__(self):
         """Returns a string summary of the FFmpeg metadata."""
@@ -345,7 +450,9 @@ class VideoImportMeta(models.Model):
         result_html = ""
 
         result_html += f"Video anonymized: {self.video_anonymized}\n"
-        result_html += f"Video patient data detected: {self.video_patient_data_detected}\n"
+        result_html += (
+            f"Video patient data detected: {self.video_patient_data_detected}\n"
+        )
         result_html += f"Outside detected: {self.outside_detected}\n"
         result_html += f"Patient data removed: {self.patient_data_removed}\n"
         result_html += f"Outside removed: {self.outside_removed}\n"

endoreg_db/models/metadata/video_prediction_logic.py

@@ -19,7 +19,11 @@ if TYPE_CHECKING:
     from .video_prediction_meta import VideoPredictionMeta
 
 
-def apply_running_mean_logic(instance: "VideoPredictionMeta", confidence_array: np.ndarray, window_size_in_seconds: Optional[float] = None) -> np.ndarray:
+def apply_running_mean_logic(
+    instance: "VideoPredictionMeta",
+    confidence_array: np.ndarray,
+    window_size_in_seconds: Optional[float] = None,
+) -> np.ndarray:
     """
     Apply a running mean filter to the confidence array for smoothing.
     """
@@ -27,7 +31,9 @@ def apply_running_mean_logic(instance: "VideoPredictionMeta", confidence_array:
     fps = video_obj.get_fps()
 
     if fps is None or fps <= 0:
-        logger.warning(f"Invalid FPS ({fps}) for {video_obj}. Cannot apply running mean. Returning original array.")
+        logger.warning(
+            f"Invalid FPS ({fps}) for {video_obj}. Cannot apply running mean. Returning original array."
+        )
         return confidence_array
 
     if window_size_in_seconds is None:
@@ -52,14 +58,18 @@ def apply_running_mean_logic(instance: "VideoPredictionMeta", confidence_array:
     running_mean = running_mean[start_index:end_index]
 
     if running_mean.shape != confidence_array.shape:
-        logger.warning(f"Running mean output shape {running_mean.shape} differs from input {confidence_array.shape}. Check padding/slicing.")
+        logger.warning(
+            f"Running mean output shape {running_mean.shape} differs from input {confidence_array.shape}. Check padding/slicing."
+        )
         # Return original array on shape mismatch to avoid downstream errors
         return confidence_array
 
     return running_mean
 
 
-def calculate_prediction_array_logic(instance: "VideoPredictionMeta", window_size_in_seconds: Optional[float] = None) -> Optional[np.ndarray]:
+def calculate_prediction_array_logic(
+    instance: "VideoPredictionMeta", window_size_in_seconds: Optional[float] = None
+) -> Optional[np.ndarray]:
     """
     Fetches predictions, applies smoothing, and returns the binary prediction array.
     Does not save the array itself.
@@ -72,19 +82,29 @@ def calculate_prediction_array_logic(instance: "VideoPredictionMeta", window_siz
     num_frames = video_obj.frame_count
 
     if num_frames is None or num_frames <= 0:
-        logger.warning(f"Cannot calculate prediction array for {video_obj} with invalid frame count ({num_frames}).")
+        logger.warning(
+            f"Cannot calculate prediction array for {video_obj} with invalid frame count ({num_frames})."
+        )
         return None
 
     if not label_list:
-        logger.warning(f"No labels found for model {model_meta}. Cannot calculate prediction array.")
+        logger.warning(
+            f"No labels found for model {model_meta}. Cannot calculate prediction array."
+        )
         return None
 
     prediction_array = np.zeros((num_frames, len(label_list)))
 
-    base_pred_qs = ImageClassificationAnnotation.objects.filter(model_meta=model_meta, frame__video_file=video_obj)
+    base_pred_qs = ImageClassificationAnnotation.objects.filter(
+        model_meta=model_meta, frame__video_file=video_obj
+    )
 
     for i, label in enumerate(label_list):
-        predictions = base_pred_qs.filter(label=label).order_by("frame__frame_number").values_list("frame__frame_number", "confidence")
+        predictions = (
+            base_pred_qs.filter(label=label)
+            .order_by("frame__frame_number")
+            .values_list("frame__frame_number", "confidence")
+        )
 
         # Initialize with 0.5 (neutral confidence)
         confidences = np.full(num_frames, 0.5)
@@ -94,12 +114,18 @@ def calculate_prediction_array_logic(instance: "VideoPredictionMeta", window_siz
                 confidences[frame_num] = confidence
                 found_predictions = True
             else:
-                logger.warning(f"Prediction found for out-of-bounds frame number {frame_num} (max: {num_frames - 1}). Skipping.")
+                logger.warning(
+                    f"Prediction found for out-of-bounds frame number {frame_num} (max: {num_frames - 1}). Skipping."
+                )
 
         if not found_predictions:
-            logger.warning(f"No predictions found for label '{label.name}' in {video_obj}. Using default confidence.")
+            logger.warning(
+                f"No predictions found for label '{label.name}' in {video_obj}. Using default confidence."
+            )
 
-        smooth_confidences = apply_running_mean_logic(instance, confidences, window_size_in_seconds)
+        smooth_confidences = apply_running_mean_logic(
+            instance, confidences, window_size_in_seconds
+        )
         # Threshold smoothed confidences
         binary_predictions = smooth_confidences > 0.5
         prediction_array[:, i] = binary_predictions
@@ -107,7 +133,9 @@ def calculate_prediction_array_logic(instance: "VideoPredictionMeta", window_siz
     return prediction_array
 
 
-def create_video_segments_for_label_logic(instance: "VideoPredictionMeta", segments: List[Tuple[int, int]], label: "Label"):
+def create_video_segments_for_label_logic(
+    instance: "VideoPredictionMeta", segments: List[Tuple[int, int]], label: "Label"
+):
     """
     Creates LabelVideoSegment instances for the given label and segments.
     """
@@ -128,18 +156,29 @@ def create_video_segments_for_label_logic(instance: "VideoPredictionMeta", segme
         }
         # Check for existence before creating the object instance
         if not LabelVideoSegment.objects.filter(
-            video_file=video_obj, prediction_meta=instance, label=label, start_frame_number=start_frame, end_frame_number=end_frame
+            video_file=video_obj,
+            prediction_meta=instance,
+            label=label,
+            start_frame_number=start_frame,
+            end_frame_number=end_frame,
         ).exists():
             segments_to_create.append(LabelVideoSegment(**segment_data))
 
     if segments_to_create:
         LabelVideoSegment.objects.bulk_create(segments_to_create)
-        logger.info(f"Created {len(segments_to_create)} video segments for label '{label.name}' in {video_obj}.")
+        logger.info(
+            f"Created {len(segments_to_create)} video segments for label '{label.name}' in {video_obj}."
+        )
     else:
-        logger.info(f"No new video segments needed for label '{label.name}' in {video_obj}.")
+        logger.info(
+            f"No new video segments needed for label '{label.name}' in {video_obj}."
+        )
 
 
-def create_video_segments_logic(instance: "VideoPredictionMeta", segment_length_threshold_in_s: Optional[float] = None):
+def create_video_segments_logic(
+    instance: "VideoPredictionMeta",
+    segment_length_threshold_in_s: Optional[float] = None,
+):
     """
     Generates LabelVideoSegments based on the stored prediction array.
     """
@@ -150,7 +189,9 @@ def create_video_segments_logic(instance: "VideoPredictionMeta", segment_length_
     fps = video_obj.get_fps()
 
     if fps is None or fps <= 0:
-        logger.warning(f"Cannot create video segments for {video_obj} with invalid FPS ({fps}).")
+        logger.warning(
+            f"Cannot create video segments for {video_obj} with invalid FPS ({fps})."
+        )
         return
 
     min_frame_length = int(segment_length_threshold_in_s * fps)
@@ -167,17 +208,25 @@ def create_video_segments_logic(instance: "VideoPredictionMeta", segment_length_
         instance.calculate_prediction_array()  # This will save the array internally
         prediction_array = instance.get_prediction_array()  # Fetch again
         if prediction_array is None:
-            logger.error(f"Failed to get or calculate prediction array for {instance}. Cannot create segments.")
+            logger.error(
+                f"Failed to get or calculate prediction array for {instance}. Cannot create segments."
+            )
             return
 
     if prediction_array.shape[1] != len(label_list):
-        logger.warning(f"Prediction array shape {prediction_array.shape} incompatible with label list length {len(label_list)} for {instance}.")
+        logger.warning(
+            f"Prediction array shape {prediction_array.shape} incompatible with label list length {len(label_list)} for {instance}."
+        )
         return
 
-    logger.info(f"Creating video segments for {instance} (min length: {min_frame_length} frames)...")
+    logger.info(
+        f"Creating video segments for {instance} (min length: {min_frame_length} frames)..."
+    )
     for i, label in enumerate(label_list):
         binary_predictions = prediction_array[:, i].astype(bool)
-        segments = find_segments_in_prediction_array(binary_predictions, min_frame_length)
+        segments = find_segments_in_prediction_array(
+            binary_predictions, min_frame_length
+        )
         if segments:
             create_video_segments_for_label_logic(instance, segments, label)
     logger.info(f"Finished creating video segments for {instance}.")