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.py

@@ -4,7 +4,7 @@ import logging
 import os
 import uuid
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional, Union, cast
+from typing import TYPE_CHECKING, Optional, Self, Union, cast
 
 from django.core.files import File
 from django.core.validators import FileExtensionValidator
@@ -13,10 +13,11 @@ from django.db.models import F
 from django.db.models.fields.files import FieldFile
 
 from endoreg_db.utils.calc_duration_seconds import _calc_duration_vf
+from endoreg_db.utils.video.ffmpeg_wrapper import assemble_video_from_frames
 
 from ...label import Label, LabelVideoSegment
 from ...state import VideoState
-from ...utils import ANONYM_VIDEO_DIR, VIDEO_DIR
+from endoreg_db.utils.paths import ANONYM_VIDEO_DIR, SENSITIVE_VIDEO_DIR
 
 # --- Import model-specific function modules ---
 from .create_from_file import _create_from_file
@@ -25,6 +26,7 @@ from .pipe_2 import _pipe_2
 from .video_file_ai import _extract_text_from_video_frames, _predict_video_pipeline
 from .video_file_anonymize import (
     _anonymize,
+    _censor_outside_frames,
     _cleanup_raw_assets,
     _create_anonymized_frame_files,
 )
@@ -72,6 +74,8 @@ from .video_file_meta import (
 logger = logging.getLogger(__name__)  # Changed from "video_file"
 
 if TYPE_CHECKING:
+    from django.db.models.fields.files import FieldFile
+
     from endoreg_db.models import (
         Center,
         EndoscopyProcessor,
@@ -113,7 +117,7 @@ class VideoFile(models.Model):
     objects = VideoQuerySet.as_manager()
 
     raw_file = models.FileField(
-        upload_to=VIDEO_DIR.name,  # Use .name for relative path
+        upload_to=SENSITIVE_VIDEO_DIR.name,  # Use .name for relative path
         validators=[FileExtensionValidator(allowed_extensions=["mp4"])],
         null=True,
         blank=True,
@@ -142,45 +146,45 @@ class VideoFile(models.Model):
         null=True,
         blank=True,
         related_name="video_file",
-    )  # type: ignore
-    center = models.ForeignKey("Center", on_delete=models.PROTECT)  # type: ignore
+    )
+    center = models.ForeignKey("Center", on_delete=models.PROTECT)
     processor = models.ForeignKey(
         "EndoscopyProcessor", on_delete=models.PROTECT, blank=True, null=True
-    )  # type: ignore
+    )
     video_meta = models.OneToOneField(
         "VideoMeta",
         on_delete=models.SET_NULL,
         null=True,
         blank=True,
         related_name="video_file",
-    )  # type: ignore
+    )
     examination = models.ForeignKey(
         "PatientExamination",
         on_delete=models.SET_NULL,
         blank=True,
         null=True,
         related_name="video_files",
-    )  # type: ignore
+    )
     patient = models.ForeignKey(
         "Patient",
         on_delete=models.SET_NULL,
         blank=True,
         null=True,
         related_name="video_files",
-    )  # type: ignore
+    )
     ai_model_meta = models.ForeignKey(
         "ModelMeta", on_delete=models.SET_NULL, blank=True, null=True
-    )  # type: ignore
+    )
     state = models.OneToOneField(
         "VideoState",
         on_delete=models.SET_NULL,
         null=True,
         blank=True,
         related_name="video_file",
-    )  # type: ignore
+    )
     import_meta = models.OneToOneField(
         "VideoImportMeta", on_delete=models.CASCADE, blank=True, null=True
-    )  # type: ignore
+    )
 
     original_file_name = models.CharField(max_length=255, blank=True, null=True)
     uploaded_at = models.DateTimeField(auto_now_add=True)
@@ -206,17 +210,25 @@ class VideoFile(models.Model):
     date_modified = models.DateTimeField(auto_now=True)
 
     if TYPE_CHECKING:
-        label_video_segments: "models.QuerySet[LabelVideoSegment]"
-        frames: "models.QuerySet[Frame]"
-        center: "Center"
-        processor: "EndoscopyProcessor"
-        video_meta: "VideoMeta"
-        examination: "PatientExamination"
-        patient: "Patient"
-        sensitive_meta: "SensitiveMeta"
-        state: "VideoState"
-        ai_model_meta: "ModelMeta"
-        import_meta: "VideoImportMeta"
+        from django.db.models.manager import RelatedManager
+
+        @property
+        def label_video_segments(self) -> RelatedManager[LabelVideoSegment]: ...
+
+        @property
+        def frames(self) -> RelatedManager[Frame]: ...
+
+        center: models.ForeignKey["Center"]
+        processor: models.ForeignKey["EndoscopyProcessor | None"]
+        video_meta: models.OneToOneField["VideoMeta | None"]
+        examination: models.ForeignKey["PatientExamination | None"]
+        patient: models.ForeignKey["Patient | None"]
+        sensitive_meta: models.OneToOneField["SensitiveMeta | None"]
+        state: models.OneToOneField["VideoState | None"]
+        ai_model_meta: models.ForeignKey["ModelMeta | None"]
+        import_meta: models.OneToOneField["VideoImportMeta | None"]
+        raw_file = cast(FieldFile, raw_file)
+        processed_file = cast(FieldFile, processed_file)
 
     @property
     def ffmpeg_meta(self) -> "FFMpegMeta":
@@ -257,7 +269,10 @@ class VideoFile(models.Model):
         assert _file is not None, self.NO_ACTIVE_FILE
         if not _file or not _file.name:
             raise ValueError(self.NO_FILE_ASSOCIATED)
-        return _file.url
+        url = getattr(_file, "url", None)
+        if not url:
+            raise ValueError("Active raw file URL could not be resolved.")
+        return str(url)
 
     # Pipeline Functions
     pipe_1 = _pipe_1
@@ -416,9 +431,34 @@ class VideoFile(models.Model):
             )
 
         if path is None:
-            raise ValueError("Active file path could not be resolved.")
+            raise ValueError(
+                "Active file path could not be resolved. VideoFile raw file is missing."
+            )
         return path
 
+    @property
+    def active_file_url(self) -> str:
+        """Return the URL of the active video file, if available."""
+        file_obj = self.active_file
+        if not isinstance(file_obj, FieldFile):
+            raise ValueError("Active file is not a valid Django FieldFile instance.")
+        try:
+            url = getattr(file_obj, "url", None)
+        except Exception as exc:  # storage backends may raise when missing
+            logger.warning(
+                "Active file URL unavailable for video %s: %s",
+                self.uuid,
+                exc,
+            )
+            raise ValueError(
+                "Active file URL could not be resolved for this VideoFile."
+            ) from exc
+
+        if not url:
+            raise ValueError("Active file URL is empty for this VideoFile.")
+
+        return str(url)
+
     @classmethod
     def create_from_file(
         cls, file_path: Union[str, Path], center_name: str, **kwargs
@@ -478,11 +518,16 @@ class VideoFile(models.Model):
         _delete_frames(self)
 
         # Call the original delete method to remove the instance from the database
-        active_path = self.active_file_path
-        logger.info(f"Deleting VideoFile: {self.uuid} - {active_path}")
+        try:
+            active_path = self.active_file_path
+            logger.info(f"Deleting VideoFile: {self.uuid} - {active_path}")
+
+        except ValueError:
+            logger.info(f"Deleting VideoFile: {self.uuid} - No active file path found.")
+            active_path = None
 
         # Delete associated files if they exist
-        if active_path.exists():
+        if active_path and active_path.exists():
             active_path.unlink(missing_ok=True)
 
         # Delete file storage
@@ -531,32 +576,19 @@ class VideoFile(models.Model):
         **IMPORTANT:** Only the raw video is deleted. The processed (anonymized)
         video is preserved as the final validated output.
         """
-        from datetime import date as dt_date
-
-        from endoreg_db.models import SensitiveMeta
-
-        if not self.sensitive_meta:
-            # CRITICAL FIX: Use create_from_dict with default patient data
-            default_data = {
-                "patient_first_name": "Patient",
-                "patient_last_name": "Unknown",
-                "patient_dob": dt_date(1990, 1, 1),
-                "examination_date": dt_date.today(),
-                "center": self.center,
-            }
-            self.sensitive_meta = SensitiveMeta.create_from_dict(default_data)
 
         # CRITICAL FIX: Delete RAW video file, not the processed (anonymized) one
         # CRITICAL: Update metadata BEFORE deleting raw video
-        # Metadata update may trigger frame extraction, which needs raw video
-        sensitive_meta = _update_text_metadata(
-            self, extracted_data_dict, overwrite=True
-        )
+        if extracted_data_dict and self.sensitive_meta:
+            self.sensitive_meta.update_from_dict(extracted_data_dict)
+        else:
+            return False
 
         # After validation and metadata update, only the anonymized video should remain
         from .video_file_io import _get_raw_file_path
 
         raw_path = _get_raw_file_path(self)
+
         if raw_path and raw_path.exists():
             logger.info(f"Deleting raw video file after validation: {raw_path}")
             raw_path.unlink(missing_ok=True)
@@ -567,11 +599,14 @@ class VideoFile(models.Model):
                 f"Raw video deleted for {self.uuid}. Anonymized video preserved."
             )
         else:
-            logger.warning(f"Raw video file not found for deletion: {self.uuid}")
+            logger.warning(
+                "Raw video file not found for deletion during validation %s.",
+                self.uuid,
+            )
 
-        if sensitive_meta:
+        if self.sensitive_meta:
             # Mark as processed after validation
-            self.get_or_create_state().mark_sensitive_meta_processed(save=True)
+            self.get_or_create_state().mark_anonymization_validated(save=True)
             # Save the VideoFile instance to persist changes
             self.save()
             logger.info(
@@ -602,7 +637,6 @@ class VideoFile(models.Model):
         # Create a new state if it doesn't exist
         self.state = self.get_or_create_state()
 
-        self.sensitive_meta = self.get_or_create_sensitive_meta()
         self.save()
         # Initialize frames based on the video specs
         self.initialize_frames()
@@ -626,6 +660,11 @@ class VideoFile(models.Model):
         Mark this video's processing state as having its sensitive meta fully processed.
         This proxies to the related VideoState and persists by default.
         """
+        sm = self.sensitive_meta
+        from endoreg_db.models.metadata.sensitive_meta import SensitiveMeta
+
+        if not isinstance(sm, SensitiveMeta):
+            raise AttributeError()
         state = self.get_or_create_state()
         state.mark_sensitive_meta_processed(save=save)
         return self
@@ -635,8 +674,13 @@ class VideoFile(models.Model):
         Mark the associated SensitiveMeta as verified by setting both DOB and names as verified.
         Ensures the SensitiveMeta and its state exist.
         """
-        sm = self.get_or_create_sensitive_meta()
+        sm = self.sensitive_meta
         # Use SensitiveMeta methods to update underlying SensitiveMetaState
+        from endoreg_db.models.metadata.sensitive_meta import SensitiveMeta
+
+        if not isinstance(sm, SensitiveMeta):
+            raise AttributeError()
+
         sm.mark_dob_verified()
         sm.mark_names_verified()
         return self
@@ -675,65 +719,6 @@ class VideoFile(models.Model):
 
         return state
 
-    def get_or_create_sensitive_meta(self) -> "SensitiveMeta":
-        """
-        Retrieve the associated SensitiveMeta instance for this video, creating and assigning one if it does not exist.
-
-        **Two-Phase Patient Data Pattern:**
-        This method implements a two-phase approach to handle incomplete patient data:
-
-        **Phase 1: Initial Creation (with defaults)**
-        - Creates SensitiveMeta with default patient data to prevent hash calculation errors
-        - Default values: patient_first_name="Patient", patient_last_name="Unknown", patient_dob=1990-01-01
-        - Allows video import to proceed even without extracted patient data
-        - Temporary hash and pseudo-entities are created
-
-        **Phase 2: Update (with extracted data)**
-        - Real patient data is extracted later (e.g., from video OCR via lx_anonymizer)
-        - update_from_dict() is called with actual patient information
-        - Hash is recalculated automatically using real data
-        - Correct pseudo-entities are created/linked based on new hash
-
-        **Example workflow:**
-        ```python
-        # Phase 1: Video creation
-        video = VideoFile.create_from_file_initialized(...)
-        video.initialize()  # Calls this method
-        # → SensitiveMeta created with defaults
-        # → Hash: sha256("Patient Unknown 1990-01-01...")
-
-        # Phase 2: Frame cleaning extracts real data
-        extracted = {"patient_first_name": "Max", "patient_last_name": "Mustermann", ...}
-        video.sensitive_meta.update_from_dict(extracted)
-        # → Hash: sha256("Max Mustermann 1985-03-15...") (RECALCULATED)
-        ```
-
-        Returns:
-            SensitiveMeta: The related SensitiveMeta instance.
-
-        See Also:
-            - sensitive_meta_logic.perform_save_logic() for hash calculation details
-            - sensitive_meta_logic.update_sensitive_meta_from_dict() for update mechanism
-        """
-        from datetime import date as dt_date
-
-        from endoreg_db.models import SensitiveMeta
-
-        if self.sensitive_meta is None:
-            # Use create_from_dict with default patient data
-            # to prevent "First name is required to calculate patient hash" error
-            default_data = {
-                "patient_first_name": "Patient",
-                "patient_last_name": "Unknown",
-                "patient_dob": dt_date(1990, 1, 1),
-                "examination_date": dt_date.today(),
-                "center": self.center,
-            }
-            self.sensitive_meta = SensitiveMeta.create_from_dict(default_data)
-            self.save(update_fields=["sensitive_meta"])
-            # Do not mark state as processed here; it will be set after extraction/validation steps
-        return self.sensitive_meta
-
     def get_outside_segments(
         self, only_validated: bool = False
     ) -> models.QuerySet["LabelVideoSegment"]:
@@ -767,6 +752,82 @@ class VideoFile(models.Model):
             )
             return self.label_video_segments.none()
 
+    @classmethod
+    def create_video_without_outside_frames(
+        cls, instance: "VideoFile", only_validated: bool = False
+    ) -> bool:
+        """
+        Creates a new video by excluding frames that belong to 'outside' segments.
+
+        Parameters:
+            only_validated (bool): If True, only validated segments are considered for frame exclusion.
+
+        Returns:
+            VideoFile: A new VideoFile instance with the frames excluding those labeled as 'outside'.
+        """
+        video = instance
+
+        if not video:
+            logger.warning(
+                "No processed video file available for VideoFile %s.", cls.uuid
+            )
+            return False
+        try:
+            extracted = video.extract_frames(
+                quality=2,
+                overwrite=False,
+                ext="jpg",
+                verbose=False,
+                from_processed=True,
+            )
+            assert extracted is True
+        except AssertionError:
+            extracted = video.extract_frames(
+                quality=2,
+                overwrite=False,
+                ext="jpg",
+                verbose=False,
+                from_processed=True,
+            )
+            assert extracted is True
+        try:
+            # Step 1: Get the "outside" labeled frames
+            censored = _censor_outside_frames(video)
+            frames = [instance.get_frame_dir_path()]
+            assert len(frames) != 0
+            fps = (
+                video.fps if video.fps else 120.0
+            )  # Default to 30 FPS if fps is not set
+            assert censored is True
+            assert fps is not None
+            assert video.width is not None
+            assert video.height is not None
+            # assert isinstance(frames, list[Path]) #TODO improve TypeCheck
+
+            # Step 2: Reassemble the video with frames excluding the 'outside' labeled frames
+            output_video_path = Path(f"/path/to/output/{cls.uuid}_filtered.mp4")
+            fps = cls.fps if cls.fps else 30.0  # Default to 30 FPS if fps is not set
+            new_video_file = assemble_video_from_frames(
+                frames, output_video_path, fps, width=video.width, height=video.height
+            )
+            video.processed_file = new_video_file
+            return True
+        except AssertionError as ae:
+            logger.error(
+                f"Assertion error while creating video without 'outside' frames for VideoFile {cls.uuid}: {ae}",
+                exc_info=True,
+            )
+            return False
+        except Label.DoesNotExist:
+            logger.warning("Outside label not found in the database.")
+            return False
+        except Exception as e:
+            logger.error(
+                f"Error creating video without 'outside' frames for VideoFile {cls.uuid}: {e}",
+                exc_info=True,
+            )
+            return False
+
     @classmethod
     def get_all_videos(cls) -> models.QuerySet["VideoFile"]:
         """
@@ -809,7 +870,8 @@ class VideoFile(models.Model):
             raise ValueError("FPS must be set and greater than zero.")
         return frame_number / fps
 
-    def get_video_by_id(self, video_id: int) -> "VideoFile":
+    @staticmethod
+    def get_video_by_pk(pk: int) -> "VideoFile":
         """
         Retrieve a VideoFile instance by its primary key (ID).
 
@@ -822,4 +884,4 @@ class VideoFile(models.Model):
         Raises:
             VideoFile.DoesNotExist: If no VideoFile with the given ID exists.
         """
-        return self.objects.get(pk=video_id)
+        return VideoFile.objects.get(pk=video_id)