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

endoreg_db/models/media/video/create_from_file.py

@@ -7,14 +7,17 @@ from typing import TYPE_CHECKING, Optional, Type
 
 # Import the new exceptions from the correct path
 from endoreg_db.exceptions import InsufficientStorageError, TranscodingError
-from endoreg_db.utils.paths import IMPORT_VIDEO_DIR, SENSITIVE_VIDEO_DIR, TRANSCODING_DIR
+from endoreg_db.utils.paths import (
+    IMPORT_VIDEO_DIR,
+    SENSITIVE_VIDEO_DIR,
+    TRANSCODING_DIR,
+)
 
 if TYPE_CHECKING:
     from endoreg_db.models import VideoFile
 
 import endoreg_db.utils.paths as path_utils
-from ....utils.file_operations import get_uuid_filename
-from ....utils.hashs import get_video_hash
+
 from ....utils.video.ffmpeg_wrapper import transcode_videofile_if_required
 
 logger = logging.getLogger(__name__)
@@ -57,7 +60,9 @@ def check_storage_capacity(
         # Don't fail the operation, just log the warning
 
 
-def atomic_copy_with_fallback(src_path: Path = IMPORT_VIDEO_DIR, dst_path: Path = SENSITIVE_VIDEO_DIR) -> bool:
+def atomic_copy_with_fallback(
+    src_path: Path = IMPORT_VIDEO_DIR, dst_path: Path = SENSITIVE_VIDEO_DIR
+) -> bool:
     """
     Atomically copy file from src to dst, preserving the source file.
 
@@ -192,7 +197,8 @@ def _create_from_file(
     cls_model: Type["VideoFile"],
     file_path: Path,
     center_name: str,
-    processor_name: Optional[str] = None,
+    processor_name: Optional[str],
+    video_hash: str,
     video_dir: Path = IMPORT_VIDEO_DIR,
     save: bool = True,
     delete_source: bool = False,
@@ -218,7 +224,7 @@ def _create_from_file(
     try:
         # Ensure we operate under the canonical video path root
         data_paths = _get_data_paths()
-        resolved_video_dir = _get_path(data_paths, "video", video_dir)
+        resolved_video_dir = _get_path(data_paths, "sensitive_video", video_dir)
         video_dir = Path(resolved_video_dir)
         storage_root_default = Path(video_dir).parent
         resolved_storage_root = _get_path(data_paths, "storage", storage_root_default)
@@ -251,23 +257,13 @@ def _create_from_file(
 
         logger.debug("Using file for hashing: %s", transcoded_file_path)
 
-        # 2. Calculate hash (this will be the raw_video_hash)
-        video_hash = get_video_hash(transcoded_file_path)
-        if not video_hash:
-            raise ValueError(
-                f"Could not calculate video hash for {transcoded_file_path}"
-            )
-        logger.info(
-            "Calculated raw video hash: %s for %s", video_hash, original_file_name
-        )
-
         # 3. Check if hash already exists
         if cls_model.check_hash_exists(video_hash=video_hash):
             existing_video = cls_model.objects.get(video_hash=video_hash)
             logger.warning(
                 "Video with hash %s already exists (UUID: %s)",
                 video_hash,
-                existing_video.uuid,
+                existing_video.video_hash,
             )
 
             # Check if the existing video has a valid file
@@ -292,9 +288,7 @@ def _create_from_file(
             )
             existing_video.delete()
 
-        # 4. Generate UUID and final storage path
-        new_file_name, uuid_val = get_uuid_filename(transcoded_file_path)
-        final_storage_path = video_dir / new_file_name
+        final_storage_path = video_dir / video_hash / transcoded_file_path.suffix
         final_storage_path.parent.mkdir(parents=True, exist_ok=True)
 
         # 5. Move or Copy the file to final storage using improved method
@@ -327,19 +321,6 @@ def _create_from_file(
         except Exception as e:
             raise RuntimeError(f"Failed to move file to final storage: {e}") from e
 
-        # 6. Verify hash after move/copy
-        final_hash = get_video_hash(final_storage_path)
-        if final_hash != video_hash:
-            logger.error(
-                "Hash mismatch after file operation! Expected %s, got %s",
-                video_hash,
-                final_hash,
-            )
-            final_storage_path.unlink(missing_ok=True)
-            raise RuntimeError(
-                f"Hash mismatch after file operation for {final_storage_path}"
-            )
-
         # 7. Get related objects
         try:
             center = Center.objects.get(name=center_name)
@@ -365,14 +346,11 @@ def _create_from_file(
             raise ValueError(f"Processor '{processor_name}' not found.") from e
 
         # 8. Create the VideoFile instance
-        logger.info("Creating new VideoFile instance with UUID: %s", uuid_val)
+        logger.info("Creating new VideoFile instance with hash: %s", video_hash)
         # Store FileField path relative to storage root including the videos prefix
-        # TODO Review removal, since this is now newly handled by path_utils
-        #storage_base = Path(_get_path(data_paths, "storage", final_storage_path.parent))
-        
-        relative_name = path_utils.to_storage_relative(final_storage_path)        
+
+        relative_name = path_utils.to_storage_relative(final_storage_path)
         video = cls_model(
-            uuid=uuid_val,
             raw_file=relative_name,
             processed_file=None,
             center=center,
@@ -385,10 +363,11 @@ def _create_from_file(
 
         # 9. Save the instance if requested
         if save:
-            logger.info("Saving new VideoFile instance (UUID: %s)", uuid_val)
+            logger.info("Saving new VideoFile instance (Hash:%s", video_hash)
             video.save()
             logger.info(
-                "Successfully created VideoFile PK %s (UUID: %s)", video.pk, video.uuid
+                "Successfully created VideoFile PK %s ",
+                video.pk,
             )
 
         return video

endoreg_db/models/media/video/pipe_1.py

@@ -40,18 +40,24 @@ def _pipe_1(
     video_file.refresh_from_db()
     video_file.update_video_meta()
 
-    logger.info(f"Starting Pipe 1 for video {video_file.uuid}")
+    logger.info(f"Starting Pipe 1 for video {video_file.video_hash}")
     try:
         # 1. Heavy I/O operations outside the transaction block
         logger.info("Pipe 1: Extracting frames...")
-        video_file.extract_frames(overwrite=False)  # Avoid overwriting if already extracted
+        video_file.extract_frames(
+            overwrite=False
+        )  # Avoid overwriting if already extracted
 
         logger.info("Pipe 1: Extracting text metadata...")
-        video_file.update_text_metadata(ocr_frame_fraction=ocr_frame_fraction, cap=ocr_cap, overwrite=False)
+        video_file.update_text_metadata(
+            ocr_frame_fraction=ocr_frame_fraction, cap=ocr_cap, overwrite=False
+        )
         with transaction.atomic():
             state = video_file.get_or_create_state()
             if not state.frames_extracted:
-                logger.error("Pipe 1 failed: Frame extraction did not complete successfully.")
+                logger.error(
+                    "Pipe 1 failed: Frame extraction did not complete successfully."
+                )
                 return False
 
             # 3. Perform Initial Prediction
@@ -59,7 +65,9 @@ def _pipe_1(
             try:
                 ai_model_obj = AiModel.objects.get(name=model_name)
                 if model_meta_version is not None:
-                    model_meta = ai_model_obj.metadata_versions.get(version=model_meta_version)
+                    model_meta = ai_model_obj.metadata_versions.get(
+                        version=model_meta_version
+                    )
                 else:
                     model_meta = ai_model_obj.get_latest_version()
             except AiModel.DoesNotExist:
@@ -68,7 +76,9 @@ def _pipe_1(
                     model_name = download_segmentation_model()
                     ai_model_obj = AiModel.objects.get(name=model_name)
                     if model_meta_version is not None:
-                        model_meta = ai_model_obj.metadata_versions.get(version=model_meta_version)
+                        model_meta = ai_model_obj.metadata_versions.get(
+                            version=model_meta_version
+                        )
                     else:
                         model_meta = ai_model_obj.get_latest_version()
                 except AiModel.DoesNotExist:
@@ -80,19 +90,25 @@ def _pipe_1(
                     model_name = download_segmentation_model()
                     ai_model_obj = AiModel.objects.get(name=model_name)
                     if model_meta_version is not None:
-                        model_meta = ai_model_obj.metadata_versions.get(version=model_meta_version)
+                        model_meta = ai_model_obj.metadata_versions.get(
+                            version=model_meta_version
+                        )
                     else:
                         model_meta = ai_model_obj.get_latest_version()
                 except ModelMeta.DoesNotExist:
-                    logger.error(f"Pipe 1 failed: ModelMeta version {model_meta_version} for model '{model_name}' not found.")
+                    logger.error(
+                        f"Pipe 1 failed: ModelMeta version {model_meta_version} for model '{model_name}' not found."
+                    )
                     return False
             try:
-                sequences: Optional[Dict[str, List[Tuple[int, int]]]] = video_file.predict_video(
-                    model_meta=model_meta,
-                    smooth_window_size_s=smooth_window_size_s,
-                    binarize_threshold=binarize_threshold,
-                    test_run=test_run,
-                    n_test_frames=n_test_frames,
+                sequences: Optional[Dict[str, List[Tuple[int, int]]]] = (
+                    video_file.predict_video(
+                        model_meta=model_meta,
+                        smooth_window_size_s=smooth_window_size_s,
+                        binarize_threshold=binarize_threshold,
+                        test_run=test_run,
+                        n_test_frames=n_test_frames,
+                    )
                 )
             except Exception as e:
                 logger.error(f"Pipe 1 failed during prediction: {e}", exc_info=True)
@@ -110,13 +126,19 @@ def _pipe_1(
 
             logger.info(f"Pipe 1: Sequences returned from prediction: {sequences}")
             if not sequences:
-                logger.warning("Pipe 1: Prediction returned empty sequences dictionary. No LabelVideoSegments will be created.")
+                logger.warning(
+                    "Pipe 1: Prediction returned empty sequences dictionary. No LabelVideoSegments will be created."
+                )
 
             # 4. Create LabelVideoSegments
             logger.info("Pipe 1: Creating LabelVideoSegments from predictions...")
             try:
-                video_prediction_meta = VideoPredictionMeta.objects.get(video_file=video_file, model_meta=model_meta)
-                logger.info(f"Pipe 1: Calling _convert_sequences_to_db_segments for video {video_file.uuid} with prediction meta {video_prediction_meta.pk}")
+                video_prediction_meta = VideoPredictionMeta.objects.get(
+                    video_file=video_file, model_meta=model_meta
+                )
+                logger.info(
+                    f"Pipe 1: Calling _convert_sequences_to_db_segments for video {video_file.video_hash} with prediction meta {video_prediction_meta.pk}"
+                )
                 _convert_sequences_to_db_segments(
                     video=video_file,
                     sequences=sequences,
@@ -128,18 +150,26 @@ def _pipe_1(
                 state.save(update_fields=["lvs_created"])
                 logger.info("Pipe 1: Set lvs_created state to True.")
                 logger.info("Pipe 1: LabelVideoSegment creation complete.")
-                lvs_count_after = LabelVideoSegment.objects.filter(video_file=video_file).count()
-                logger.info(f"Pipe 1: Found {lvs_count_after} LabelVideoSegments after conversion attempt.")
+                lvs_count_after = LabelVideoSegment.objects.filter(
+                    video_file=video_file
+                ).count()
+                logger.info(
+                    f"Pipe 1: Found {lvs_count_after} LabelVideoSegments after conversion attempt."
+                )
             except VideoPredictionMeta.DoesNotExist:
-                logger.error("Pipe 1 failed: Could not find VideoPredictionMeta after prediction.")
+                logger.error(
+                    "Pipe 1 failed: Could not find VideoPredictionMeta after prediction."
+                )
                 raise
 
-        logger.info(f"Pipe 1 completed successfully for video {video_file.uuid}")
+        logger.info(f"Pipe 1 completed successfully for video {video_file.video_hash}")
         success = True  # Set success flag
         return True
 
     except Exception as e:
-        logger.error(f"Pipe 1 failed for video {video_file.uuid}: {e}", exc_info=True)
+        logger.error(
+            f"Pipe 1 failed for video {video_file.video_hash}: {e}", exc_info=True
+        )
         return False
     finally:
         # 5. Optionally delete frames
@@ -155,19 +185,23 @@ def _pipe_1(
 
 
 # --- Test after Pipe 1 ---
-def _test_after_pipe_1(video_file: "VideoFile", start_frame: int = 0, end_frame: int = 100) -> bool:
+def _test_after_pipe_1(
+    video_file: "VideoFile", start_frame: int = 0, end_frame: int = 100
+) -> bool:
     """
     Simulates human annotation validation after Pipe 1.
     Creates 'outside' segments and marks sensitive meta as verified.
     """
     from ...label import Label, LabelVideoSegment
 
-    logger.info(f"Starting _test_after_pipe_1 for video {video_file.uuid}")
+    logger.info(f"Starting _test_after_pipe_1 for video {video_file.video_hash}")
     try:
         # 1. Create 'outside' LabelVideoSegments
         try:
             outside_label = Label.objects.get(name__iexact="outside")
-            logger.info(f"Creating 'outside' annotation segment [{start_frame}-{end_frame}]")
+            logger.info(
+                f"Creating 'outside' annotation segment [{start_frame}-{end_frame}]"
+            )
             # Create a segment - assuming custom_create handles saving
             outside_segment = LabelVideoSegment.objects.create(  # Assign to variable
                 video_file=video_file,
@@ -177,16 +211,22 @@ def _test_after_pipe_1(video_file: "VideoFile", start_frame: int = 0, end_frame:
                 prediction_meta=None,
             )
             # Ensure the segment has a state and mark it as validated
-            segment_state, created = outside_segment.get_or_create_state()  # Unpack the tuple
+            segment_state, created = (
+                outside_segment.get_or_create_state()
+            )  # Unpack the tuple
             segment_state.is_validated = True
             segment_state.save()
-            logger.info(f"Marked 'outside' segment {outside_segment.pk} as validated. Created: {created}")
+            logger.info(
+                f"Marked 'outside' segment {outside_segment.pk} as validated. Created: {created}"
+            )
 
         except Label.DoesNotExist:
             logger.error("_test_after_pipe_1 failed: 'outside' Label not found.")
             return False
         except Exception as e:
-            logger.error(f"_test_after_pipe_1 failed during segment creation: {e}", exc_info=True)
+            logger.error(
+                f"_test_after_pipe_1 failed during segment creation: {e}", exc_info=True
+            )
             return False
 
         # 2. Set Sensitive Metadata state to verified
@@ -205,9 +245,14 @@ def _test_after_pipe_1(video_file: "VideoFile", start_frame: int = 0, end_frame:
         else:
             logger.warning("_test_after_pipe_1: No sensitive meta found to verify.")
 
-        logger.info(f"_test_after_pipe_1 completed successfully for video {video_file.uuid}")
+        logger.info(
+            f"_test_after_pipe_1 completed successfully for video {video_file.video_hash}"
+        )
         return True
 
     except Exception as e:
-        logger.error(f"_test_after_pipe_1 failed for video {video_file.uuid}: {e}", exc_info=True)
+        logger.error(
+            f"_test_after_pipe_1 failed for video {video_file.video_hash}: {e}",
+            exc_info=True,
+        )
         return False

endoreg_db/models/media/video/pipe_2.py

@@ -22,7 +22,7 @@ def _pipe_2(video_file: "VideoFile") -> bool:
     Returns:
         bool: True if all operations complete successfully; otherwise, False.
     """
-    logger.info("Starting Pipe 2 for video %s", video_file.uuid)
+    logger.info("Starting Pipe 2 for video %s", video_file.video_hash)
     try:
         # --- Part 1: Frame Extraction ---
         # Determine if frames are needed (short transaction for state read)
@@ -31,7 +31,9 @@ def _pipe_2(video_file: "VideoFile") -> bool:
             frames_needed = not state.frames_extracted
 
         if frames_needed:
-            logger.info("Pipe 2: Frames not extracted. Extracting outside main DB transaction...")
+            logger.info(
+                "Pipe 2: Frames not extracted. Extracting outside main DB transaction..."
+            )
             if not video_file.extract_frames(overwrite=False):  # Heavy I/O work
                 logger.error("Pipe 2 failed: Frame extraction method returned False.")
                 return False
@@ -40,7 +42,9 @@ def _pipe_2(video_file: "VideoFile") -> bool:
             with transaction.atomic():
                 video_file.refresh_from_db()
                 if not video_file.state or not video_file.state.frames_extracted:
-                    logger.error("Pipe 2 failed: Frame extraction did not update state successfully.")
+                    logger.error(
+                        "Pipe 2 failed: Frame extraction did not update state successfully."
+                    )
                     return False
                 logger.info("Pipe 2: Frame extraction complete.")
         else:
@@ -55,17 +59,25 @@ def _pipe_2(video_file: "VideoFile") -> bool:
                 state.sensitive_meta_processed = False
 
         if anonymization_needed:
-            logger.info("Pipe 2: Video not anonymized. Anonymizing outside main DB transaction...")
-            anonymize_success = video_file.anonymize(delete_original_raw=True)  # Heavy I/O work
+            logger.info(
+                "Pipe 2: Video not anonymized. Anonymizing outside main DB transaction..."
+            )
+            anonymize_success = video_file.anonymize(
+                delete_original_raw=True
+            )  # Heavy I/O work
             if not anonymize_success:
-                logger.error("Pipe 2 failed: Anonymization process failed (returned False).")
+                logger.error(
+                    "Pipe 2 failed: Anonymization process failed (returned False)."
+                )
                 return False
 
             # Verify anonymization and update state (short transaction)
             with transaction.atomic():
                 video_file.refresh_from_db()
                 if not video_file.state or not video_file.state.anonymized:
-                    logger.error("Pipe 2 Error: State.anonymized is False even after anonymize() call.")
+                    logger.error(
+                        "Pipe 2 Error: State.anonymized is False even after anonymize() call."
+                    )
                     return False
                 logger.info("Pipe 2: Anonymization complete.")
         else:
@@ -86,19 +98,32 @@ def _pipe_2(video_file: "VideoFile") -> bool:
                     sm_pk = video_file.sensitive_meta.pk
                     video_file.sensitive_meta.delete()
                     video_file.sensitive_meta = None  # Important after SET_NULL
-                    video_file.save(update_fields=["sensitive_meta"])  # Persist the null relation
-                    logger.info("Pipe 2: Deleted sensitive meta object (PK: %s).", sm_pk)
+                    video_file.save(
+                        update_fields=["sensitive_meta"]
+                    )  # Persist the null relation
+                    logger.info(
+                        "Pipe 2: Deleted sensitive meta object (PK: %s).", sm_pk
+                    )
                 except Exception as e:
-                    logger.error("Pipe 2: Failed to delete sensitive meta object: %s", e, exc_info=True)
+                    logger.error(
+                        "Pipe 2: Failed to delete sensitive meta object: %s",
+                        e,
+                        exc_info=True,
+                    )
                     raise  # Reraise to ensure this transaction rolls back
             else:
                 logger.info("Pipe 2: No sensitive meta object found to delete.")
 
-            logger.info(f"Pipe 2 completed successfully for video {video_file.uuid}")
+            logger.info(
+                f"Pipe 2 completed successfully for video {video_file.video_hash}"
+            )
             return True
 
     except Exception as e:
         # This will catch exceptions from I/O operations if they raise,
         # or from the final transaction block, or any other unhandled error.
-        logger.error(f"Pipe 2 failed for video {video_file.uuid} with unhandled exception: {e}", exc_info=True)
+        logger.error(
+            f"Pipe 2 failed for video {video_file.video_hash} with unhandled exception: {e}",
+            exc_info=True,
+        )
         return False

endoreg_db/models/media/video/video_file.py

@@ -2,9 +2,8 @@
 
 import logging
 import os
-import uuid
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional, Self, Union, cast
+from typing import TYPE_CHECKING, Optional, Union, cast
 
 from django.core.files import File
 from django.core.validators import FileExtensionValidator
@@ -13,11 +12,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.paths import ANONYM_VIDEO_DIR, SENSITIVE_VIDEO_DIR
 from endoreg_db.utils.video.ffmpeg_wrapper import assemble_video_from_frames
 
 from ...label import Label, LabelVideoSegment
 from ...state import VideoState
-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
@@ -112,8 +111,6 @@ class VideoQuerySet(models.QuerySet):
 
 
 class VideoFile(models.Model):
-    uuid = models.UUIDField(default=uuid.uuid4, editable=False, unique=True)
-
     objects = VideoQuerySet.as_manager()
 
     raw_file = models.FileField(
@@ -447,7 +444,7 @@ class VideoFile(models.Model):
         except Exception as exc:  # storage backends may raise when missing
             logger.warning(
                 "Active file URL unavailable for video %s: %s",
-                self.uuid,
+                self.video_hash,
                 exc,
             )
             raise ValueError(
@@ -482,9 +479,10 @@ class VideoFile(models.Model):
         cls,
         file_path: Union[str, Path],
         center_name: str,
-        processor_name: Optional[str] = None,
+        processor_name: Optional[str],
+        video_hash: str,
         delete_source: bool = False,
-        save_video_file: bool = True,  # Add this line
+        save_video_file: bool = True,
     ):
         """
         Creates a VideoFile instance from a given video file path.
@@ -501,6 +499,7 @@ class VideoFile(models.Model):
             file_path=file_path,
             center_name=center_name,
             processor_name=processor_name,
+            video_hash=video_hash,
             delete_source=delete_source,
             save=save_video_file,  # Add this line
         )
@@ -520,10 +519,12 @@ class VideoFile(models.Model):
         # Call the original delete method to remove the instance from the database
         try:
             active_path = self.active_file_path
-            logger.info(f"Deleting VideoFile: {self.uuid} - {active_path}")
+            logger.info(f"Deleting VideoFile: {self.video_hash} - {active_path}")
 
         except ValueError:
-            logger.info(f"Deleting VideoFile: {self.uuid} - No active file path found.")
+            logger.info(
+                f"Deleting VideoFile: {self.video_hash} - No active file path found."
+            )
             active_path = None
 
         # Delete associated files if they exist
@@ -556,10 +557,10 @@ class VideoFile(models.Model):
         try:
             # Call parent delete with proper parameters
             result = super().delete(using=using, keep_parents=keep_parents)
-            logger.info(f"VideoFile {self.uuid} deleted successfully.")
+            logger.info(f"VideoFile {self.video_hash} deleted successfully.")
             return result
         except Exception as e:
-            logger.error(f"Error deleting VideoFile {self.uuid}: {e}")
+            logger.error(f"Error deleting VideoFile {self.video_hash}: {e}")
             raise
 
     def validate_metadata_annotation(
@@ -596,12 +597,12 @@ class VideoFile(models.Model):
             if self.raw_file:
                 self.raw_file.delete(save=False)
             logger.info(
-                f"Raw video deleted for {self.uuid}. Anonymized video preserved."
+                f"Raw video deleted for {self.video_hash}. Anonymized video preserved."
             )
         else:
             logger.warning(
                 "Raw video file not found for deletion during validation %s.",
-                self.uuid,
+                self.video_hash,
             )
 
         if self.sensitive_meta:
@@ -610,12 +611,12 @@ class VideoFile(models.Model):
             # Save the VideoFile instance to persist changes
             self.save()
             logger.info(
-                f"Metadata annotation validated and saved for video {self.uuid}."
+                f"Metadata annotation validated and saved for video {self.video_hash}."
             )
             return True
         else:
             logger.error(
-                f"Failed to validate metadata annotation for video {self.uuid}."
+                f"Failed to validate metadata annotation for video {self.video_hash}."
             )
             return False
 
@@ -652,7 +653,7 @@ class VideoFile(models.Model):
         state = (
             "Processed" if self.is_processed else ("Raw" if self.has_raw else "No File")
         )
-        return f"VideoFile ({state}): {file_name} (UUID: {self.uuid})"
+        return f"VideoFile ({state}): {file_name} (UUID: {self.video_hash})"
 
     # --- Convenience state/meta helpers used in tests and admin workflows ---
     def mark_sensitive_meta_processed(self, *, save: bool = True) -> "VideoFile":
@@ -746,7 +747,7 @@ class VideoFile(models.Model):
         except Exception as e:
             logger.error(
                 "Error getting outside segments for video %s: %s",
-                self.uuid,
+                self.video_hash,
                 e,
                 exc_info=True,
             )
@@ -769,7 +770,8 @@ class VideoFile(models.Model):
 
         if not video:
             logger.warning(
-                "No processed video file available for VideoFile %s.", cls.uuid
+                "No processed video file available for VideoFile %s.",
+                instance.video_hash,
             )
             return False
         try:
@@ -805,8 +807,10 @@ class VideoFile(models.Model):
             # 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
+            output_video_path = Path(f"/path/to/output/{video.video_hash}_filtered.mp4")
+            fps = (
+                video.fps if video.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
             )
@@ -814,7 +818,7 @@ class VideoFile(models.Model):
             return True
         except AssertionError as ae:
             logger.error(
-                f"Assertion error while creating video without 'outside' frames for VideoFile {cls.uuid}: {ae}",
+                f"Assertion error while creating video without 'outside' frames for VideoFile {video.video_hash}: {ae}",
                 exc_info=True,
             )
             return False
@@ -823,7 +827,7 @@ class VideoFile(models.Model):
             return False
         except Exception as e:
             logger.error(
-                f"Error creating video without 'outside' frames for VideoFile {cls.uuid}: {e}",
+                f"Error creating video without 'outside' frames for VideoFile {video.video_hash}: {e}",
                 exc_info=True,
             )
             return False
@@ -884,4 +888,12 @@ class VideoFile(models.Model):
         Raises:
             VideoFile.DoesNotExist: If no VideoFile with the given ID exists.
         """
-        return VideoFile.objects.get(pk=video_id)
+        return VideoFile.objects.get(pk=pk)
+
+    @staticmethod
+    def get_video_by_content_hash(hash: str) -> "VideoFile":
+        try:
+            return VideoFile.objects.get(video_hash=hash)
+        except Exception as e:
+            logger.error(f"Video cant be returned for known hash. {e}")
+            raise