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

endoreg_db/models/media/video/video_file_frames/_manage_frame_range.py

@@ -7,7 +7,9 @@ from django.db import transaction
 from endoreg_db.models.media.video.video_file_io import _get_frame_dir_path
 
 # Assuming ffmpeg_wrapper has or will have this function
-from endoreg_db.utils.video.ffmpeg_wrapper import extract_frame_range as ffmpeg_extract_frame_range
+from endoreg_db.utils.video.ffmpeg_wrapper import (
+    extract_frame_range as ffmpeg_extract_frame_range,
+)
 
 if TYPE_CHECKING:
     from endoreg_db.models import VideoFile
@@ -21,15 +23,30 @@ def _delete_frame_range(video: "VideoFile", start_frame: int, end_frame: int):
     and updates their is_extracted status to False. Runs within the caller's transaction.
     """
 
-    logger.info("Deleting frame files for video %s in range [%d, %d)", video.uuid, start_frame, end_frame)
-    frames_to_delete = video.frames.filter(frame_number__gte=start_frame, frame_number__lt=end_frame, is_extracted=True)
+    logger.info(
+        "Deleting frame files for video %s in range [%d, %d)",
+        video.video_hash,
+        start_frame,
+        end_frame,
+    )
+    frames_to_delete = video.frames.filter(
+        frame_number__gte=start_frame, frame_number__lt=end_frame, is_extracted=True
+    )
 
     deleted_count = 0
-    paths_to_delete = [frame.file_path for frame in frames_to_delete]  # Get paths before potential DB changes
+    paths_to_delete = [
+        frame.file_path for frame in frames_to_delete
+    ]  # Get paths before potential DB changes
 
     # Update DB first
     update_count = frames_to_delete.update(is_extracted=False)
-    logger.info("Marked %d Frame objects as is_extracted=False for video %s range [%d, %d).", update_count, video.uuid, start_frame, end_frame)
+    logger.info(
+        "Marked %d Frame objects as is_extracted=False for video %s range [%d, %d).",
+        update_count,
+        video.video_hash,
+        start_frame,
+        end_frame,
+    )
 
     # Then delete files
     for frame_path in paths_to_delete:
@@ -39,12 +56,17 @@ def _delete_frame_range(video: "VideoFile", start_frame: int, end_frame: int):
                 deleted_count += 1
         except Exception as e:
             # Log warning but continue; DB state is already updated.
-            logger.warning("Could not delete frame file %s for video %s: %s", frame_path, video.uuid, e)
+            logger.warning(
+                "Could not delete frame file %s for video %s: %s",
+                frame_path,
+                video.video_hash,
+                e,
+            )
 
     logger.info(
         "Attempted deletion of %d files for video %s range [%d, %d). Actual deleted: %d.",
         len(paths_to_delete),
-        video.uuid,
+        video.video_hash,
         start_frame,
         end_frame,
         deleted_count,
@@ -69,49 +91,88 @@ def _extract_frame_range(
     """
 
     if not video.has_raw:
-        raise FileNotFoundError(f"Raw video file not available for {video.uuid}. Cannot extract frame range.")
+        raise FileNotFoundError(
+            f"Raw video file not available for {video.video_hash}. Cannot extract frame range."
+        )
 
     raw_file_path = video.get_raw_file_path()
     if not raw_file_path or not raw_file_path.exists():
-        raise FileNotFoundError(f"Raw video file not found at {raw_file_path} for video {video.uuid}. Cannot extract frame range.")
+        raise FileNotFoundError(
+            f"Raw video file not found at {raw_file_path} for video {video.video_hash}. Cannot extract frame range."
+        )
 
     frame_dir = _get_frame_dir_path(video)
     if not frame_dir:
-        raise ValueError(f"Cannot determine frame directory path for video {video.uuid}.")
+        raise ValueError(
+            f"Cannot determine frame directory path for video {video.video_hash}."
+        )
 
     # Check frames within the range that might already exist
-    frames_in_range = video.frames.filter(frame_number__gte=start_frame, frame_number__lt=end_frame)
+    frames_in_range = video.frames.filter(
+        frame_number__gte=start_frame, frame_number__lt=end_frame
+    )
     existing_extracted_in_range = frames_in_range.filter(is_extracted=True)
 
     if existing_extracted_in_range.exists():
         if overwrite:
-            logger.info("Overwrite=True, deleting existing frame files in range [%d, %d) for video %s before extraction.", start_frame, end_frame, video.uuid)
+            logger.info(
+                "Overwrite=True, deleting existing frame files in range [%d, %d) for video %s before extraction.",
+                start_frame,
+                end_frame,
+                video.video_hash,
+            )
             _delete_frame_range(video, start_frame, end_frame)
         else:
             logger.info(
                 "Frames already exist in range [%d, %d) for video %s and overwrite=False. Skipping extraction for this range.",
                 start_frame,
                 end_frame,
-                video.uuid,
+                video.video_hash,
+            )
+            updated_count = frames_in_range.filter(is_extracted=False).update(
+                is_extracted=True
             )
-            updated_count = frames_in_range.filter(is_extracted=False).update(is_extracted=True)
             if updated_count > 0:
-                logger.info("Marked %d existing Frame objects in range [%d, %d) as extracted for video %s.", updated_count, start_frame, end_frame, video.uuid)
+                logger.info(
+                    "Marked %d existing Frame objects in range [%d, %d) as extracted for video %s.",
+                    updated_count,
+                    start_frame,
+                    end_frame,
+                    video.video_hash,
+                )
             return True  # Indicate success as frames are considered present
 
     frame_dir.mkdir(parents=True, exist_ok=True)
     extracted_paths = []
 
     try:
-        logger.info("Starting frame range extraction [%d, %d) for video %s to %s", start_frame, end_frame, video.uuid, frame_dir)
-        extracted_paths = ffmpeg_extract_frame_range(raw_file_path, frame_dir, start_frame, end_frame, quality=quality, ext=ext)
+        logger.info(
+            "Starting frame range extraction [%d, %d) for video %s to %s",
+            start_frame,
+            end_frame,
+            video.video_hash,
+            frame_dir,
+        )
+        extracted_paths = ffmpeg_extract_frame_range(
+            raw_file_path, frame_dir, start_frame, end_frame, quality=quality, ext=ext
+        )
 
         logger.info(
-            "ffmpeg extraction process completed for video %s range [%d, %d). Found %d files.", video.uuid, start_frame, end_frame, len(extracted_paths)
+            "ffmpeg extraction process completed for video %s range [%d, %d). Found %d files.",
+            video.video_hash,
+            start_frame,
+            end_frame,
+            len(extracted_paths),
         )
 
         update_count = frames_in_range.update(is_extracted=True)
-        logger.info("Marked %d Frame objects in range [%d, %d) as is_extracted=True for video %s.", update_count, start_frame, end_frame, video.uuid)
+        logger.info(
+            "Marked %d Frame objects in range [%d, %d) as is_extracted=True for video %s.",
+            update_count,
+            start_frame,
+            end_frame,
+            video.video_hash,
+        )
 
         return True
 
@@ -120,25 +181,48 @@ def _extract_frame_range(
             "Frame range extraction [%d, %d) failed for video %s: %s",
             start_frame,
             end_frame,
-            video.uuid,
+            video.video_hash,
             err,
             exc_info=True,
         )
         raise
 
     except Exception as e:
-        logger.error("Frame range extraction [%d, %d) or DB update failed for video %s: %s", start_frame, end_frame, video.uuid, e, exc_info=True)
+        logger.error(
+            "Frame range extraction [%d, %d) or DB update failed for video %s: %s",
+            start_frame,
+            end_frame,
+            video.video_hash,
+            e,
+            exc_info=True,
+        )
 
-        logger.warning("Attempting file cleanup in range [%d, %d) for video %s due to extraction error.", start_frame, end_frame, video.uuid)
-        files_to_check = extracted_paths if "extracted_paths" in locals() and extracted_paths else []
+        logger.warning(
+            "Attempting file cleanup in range [%d, %d) for video %s due to extraction error.",
+            start_frame,
+            end_frame,
+            video.video_hash,
+        )
+        files_to_check = (
+            extracted_paths if "extracted_paths" in locals() and extracted_paths else []
+        )
         if not files_to_check:
-            files_to_check = [frame_dir / f"frame_{i:07d}.{ext}" for i in range(start_frame, end_frame)]
+            files_to_check = [
+                frame_dir / f"frame_{i:07d}.{ext}"
+                for i in range(start_frame, end_frame)
+            ]
 
         for potential_file in files_to_check:
             if potential_file.exists():
                 try:
                     os.remove(potential_file)
                 except OSError as unlink_err:
-                    logger.error("Failed to delete potential frame %s during cleanup: %s", potential_file, unlink_err)
-
-        raise RuntimeError(f"Frame range extraction or update failed for video {video.uuid} range [{start_frame}, {end_frame}).") from e
+                    logger.error(
+                        "Failed to delete potential frame %s during cleanup: %s",
+                        potential_file,
+                        unlink_err,
+                    )
+
+        raise RuntimeError(
+            f"Frame range extraction or update failed for video {video.video_hash} range [{start_frame}, {end_frame})."
+        ) from e

endoreg_db/models/media/video/video_file_frames/_mark_frames_extracted_status.py

@@ -10,14 +10,18 @@ logger = logging.getLogger(__name__)
 
 
 @transaction.atomic
-def _mark_frames_extracted_status(video: "VideoFile", extracted_frame_numbers: Set[int], status: bool):
+def _mark_frames_extracted_status(
+    video: "VideoFile", extracted_frame_numbers: Set[int], status: bool
+):
     """
     Bulk updates the is_extracted status for a set of frame numbers.
     """
     from endoreg_db.models.media.frame import Frame
 
     if not extracted_frame_numbers:
-        logger.warning("No frame numbers provided to update status for video %s.", video.uuid)
+        logger.warning(
+            "No frame numbers provided to update status for video %s.", video.video_hash
+        )
         return 0
 
     # --- Enhanced Logging ---
@@ -28,7 +32,7 @@ def _mark_frames_extracted_status(video: "VideoFile", extracted_frame_numbers: S
         "Attempting to mark %d Frame objects as is_extracted=%s for video %s. Frame numbers range: [%s-%s]. Contains frame 0: %s",
         len(extracted_frame_numbers),
         status,
-        video.uuid,
+        video.video_hash,
         min_frame,
         max_frame,
         contains_zero,
@@ -38,37 +42,66 @@ def _mark_frames_extracted_status(video: "VideoFile", extracted_frame_numbers: S
     try:
         # Update Frame objects based on frame_number
         # Convert set to list for potentially better compatibility with some DB backends
-        updated_count = Frame.objects.filter(video=video, frame_number__in=list(extracted_frame_numbers)).update(is_extracted=status)
+        updated_count = Frame.objects.filter(
+            video=video, frame_number__in=list(extracted_frame_numbers)
+        ).update(is_extracted=status)
 
-        logger.info("Database reported updating %d Frame objects to is_extracted=%s for video %s.", updated_count, status, video.uuid)
+        logger.info(
+            "Database reported updating %d Frame objects to is_extracted=%s for video %s.",
+            updated_count,
+            status,
+            video.video_hash,
+        )
 
         # Verification step
         if updated_count != len(extracted_frame_numbers):
             logger.warning(
                 "Mismatch during status update for video %s. Expected to update %d frames, but DB reported updating %d.",
-                video.uuid,
+                video.video_hash,
                 len(extracted_frame_numbers),
                 updated_count,
             )
             # --- Add detailed check for frame 0 if status is True and it should have been updated ---
-            if status is True and contains_zero and updated_count < len(extracted_frame_numbers):
+            if (
+                status is True
+                and contains_zero
+                and updated_count < len(extracted_frame_numbers)
+            ):
                 try:
                     # Check the status of frame 0 directly after the update attempt
-                    frame_zero = Frame.objects.get(video_file=video, frame_number=0)
+                    frame_zero = Frame.objects.get(video=video, frame_number=0)
                     if not frame_zero.is_extracted:
-                        logger.error("Verification check: Frame 0 (PK: %s) was NOT updated to is_extracted=True for video %s.", frame_zero.pk, video.uuid)
+                        logger.error(
+                            "Verification check: Frame 0 (PK: %s) was NOT updated to is_extracted=True for video %s.",
+                            frame_zero.pk,
+                            video.video_hash,
+                        )
                     else:
                         # This case should ideally not happen if updated_count < expected count, but log just in case
                         logger.info(
-                            "Verification check: Frame 0 (PK: %s) IS is_extracted=True for video %s, despite count mismatch.", frame_zero.pk, video.uuid
+                            "Verification check: Frame 0 (PK: %s) IS is_extracted=True for video %s, despite count mismatch.",
+                            frame_zero.pk,
+                            video.video_hash,
                         )
                 except Frame.DoesNotExist:
-                    logger.error("Verification check: Frame 0 does not exist for video %s during status check.", video.uuid)
+                    logger.error(
+                        "Verification check: Frame 0 does not exist for video %s during status check.",
+                        video.video_hash,
+                    )
                 except Exception as verify_e:
-                    logger.error("Verification check: Error checking frame 0 status for video %s: %s", video.uuid, verify_e)
+                    logger.error(
+                        "Verification check: Error checking frame 0 status for video %s: %s",
+                        video.video_hash,
+                        verify_e,
+                    )
             # --- End detailed check ---
 
         return updated_count
     except Exception as e:
-        logger.error("Failed to bulk update is_extracted status for video %s: %s", video.uuid, e, exc_info=True)
+        logger.error(
+            "Failed to bulk update is_extracted status for video %s: %s",
+            video.video_hash,
+            e,
+            exc_info=True,
+        )
         raise  # Re-raise to ensure transaction rollback if needed

endoreg_db/models/media/video/video_file_io.py

@@ -5,12 +5,9 @@ from typing import TYPE_CHECKING, Iterator, Optional
 
 from django.db import transaction
 
+from endoreg_db.utils.paths import ANONYM_VIDEO_DIR, data_paths
+
 from ....utils import delete_field_file, ensure_local_file, storage_file_exists
-from endoreg_db.utils.paths import (
-    ANONYM_VIDEO_DIR,
-    SENSITIVE_VIDEO_DIR,
-    data_paths,
-)
 
 if TYPE_CHECKING:
     from .video_file import VideoFile
@@ -31,13 +28,13 @@ def _get_raw_file_path(video: "VideoFile") -> Optional[Path]:
         else:
             logger.debug(
                 "raw_file.path for video %s is not a regular file: %s",
-                video.uuid,
+                video.video_hash,
                 direct_path,
             )
     except Exception as exc:
         logger.debug(
             "Could not access raw_file.path for video %s: %s",
-            video.uuid,
+            video.video_hash,
             exc,
         )
 
@@ -50,15 +47,14 @@ def _get_raw_file_path(video: "VideoFile") -> Optional[Path]:
         data_paths["sensitive_video"] / filename,
     ]
 
-
     for candidate in candidates:
         if candidate.is_file():
-            return candidate.resolve()
+            return candidate
 
     logger.warning(
         "Raw video file '%s' not found in import/sensitive paths or via stored FileField path for video %s.",
         video.raw_file.name,
-        video.uuid,
+        video.video_hash,
     )
     return None
 
@@ -67,7 +63,7 @@ def _get_raw_file_path(video: "VideoFile") -> Optional[Path]:
 def _ensure_local_raw_file(video: "VideoFile") -> Iterator[Path]:
     """Yield a local filesystem path for the raw file, downloading if required."""
     if not video.has_raw:
-        raise ValueError(f"Video {video.uuid} has no raw file")
+        raise ValueError(f"Video {video.video_hash} has no raw file")
 
     with ensure_local_file(video.raw_file) as local_path:
         yield local_path
@@ -85,17 +81,19 @@ def _get_processed_file_path(video: "VideoFile") -> Optional[Path]:
     except Exception as exc:
         logger.debug(
             "Could not access direct processed_file.path for video %s: %s",
-            video.uuid,
+            video.video_hash,
             exc,
         )
         direct_path = None
 
     if processed_field and storage_file_exists(processed_field):
-        logger.debug("Processed file for %s available only via storage backend", video.uuid)
+        logger.debug(
+            "Processed file for %s available only via storage backend", video.video_hash
+        )
     else:
         logger.warning(
             "Could not get path for processed file of VideoFile %s: %s",
-            video.uuid,
+            video.video_hash,
             "path unavailable",
         )
     return None
@@ -105,7 +103,7 @@ def _get_processed_file_path(video: "VideoFile") -> Optional[Path]:
 def _ensure_local_processed_file(video: "VideoFile") -> Iterator[Path]:
     """Yield a local path to the processed file, downloading if necessary."""
     if not video.is_processed:
-        raise ValueError(f"Video {video.uuid} has no processed file")
+        raise ValueError(f"Video {video.video_hash} has no processed file")
 
     with ensure_local_file(video.processed_file) as local_path:
         yield local_path
@@ -118,10 +116,17 @@ def _delete_with_file(video: "VideoFile", *args, **kwargs):
     try:
         # delete_frames raises RuntimeError on state update failure
         frame_delete_msg = video.delete_frames()
-        logger.info("Frame deletion result for video %s: %s", video.uuid, frame_delete_msg)
+        logger.info(
+            "Frame deletion result for video %s: %s", video.video_hash, frame_delete_msg
+        )
     except Exception as frame_del_e:
         # Log error but continue, as file deletion might still be possible
-        logger.error("Error during frame file/state deletion for video %s: %s", video.uuid, frame_del_e, exc_info=True)
+        logger.error(
+            "Error during frame file/state deletion for video %s: %s",
+            video.video_hash,
+            frame_del_e,
+            exc_info=True,
+        )
 
     # 2. Delete Raw File
     raw_file_path = _get_raw_file_path(video)
@@ -129,18 +134,33 @@ def _delete_with_file(video: "VideoFile", *args, **kwargs):
         try:
             if raw_file_path.exists():
                 raw_file_path.unlink()
-                logger.info("Deleted raw video file for %s: %s", video.uuid, raw_file_path)
+                logger.info(
+                    "Deleted raw video file for %s: %s", video.video_hash, raw_file_path
+                )
             else:
-                logger.warning("Raw video file not found at %s for video %s, skipping deletion.", raw_file_path, video.uuid)
+                logger.warning(
+                    "Raw video file not found at %s for video %s, skipping deletion.",
+                    raw_file_path,
+                    video.video_hash,
+                )
 
         except Exception as e:
             # Log error but continue
-            logger.error("Error deleting raw video file %s for video %s: %s", raw_file_path, video.uuid, e, exc_info=True)
+            logger.error(
+                "Error deleting raw video file %s for video %s: %s",
+                raw_file_path,
+                video.video_hash,
+                e,
+                exc_info=True,
+            )
     else:
         if delete_field_file(getattr(video, "raw_file", None), save=False):
-            logger.info("Deleted raw file from storage for video %s", video.uuid)
+            logger.info("Deleted raw file from storage for video %s", video.video_hash)
         else:
-            logger.warning("Raw video file not found during deletion for video %s.", video.uuid)
+            logger.warning(
+                "Raw video file not found during deletion for video %s.",
+                video.video_hash,
+            )
 
     # 3. Delete Processed File
     processed_file_path = _get_processed_file_path(video)
@@ -148,34 +168,62 @@ def _delete_with_file(video: "VideoFile", *args, **kwargs):
         try:
             if processed_file_path.exists():
                 processed_file_path.unlink()
-                logger.info("Deleted processed video file for %s: %s", video.uuid, processed_file_path)
+                logger.info(
+                    "Deleted processed video file for %s: %s",
+                    video.video_hash,
+                    processed_file_path,
+                )
             else:
-                logger.warning("Processed video file not found at %s for video %s, skipping deletion.", processed_file_path, video.uuid)
+                logger.warning(
+                    "Processed video file not found at %s for video %s, skipping deletion.",
+                    processed_file_path,
+                    video.video_hash,
+                )
         except Exception as e:
             # Log error but continue
-            logger.error("Error deleting processed video file %s for video %s: %s", processed_file_path, video.uuid, e, exc_info=True)
+            logger.error(
+                "Error deleting processed video file %s for video %s: %s",
+                processed_file_path,
+                video.video_hash,
+                e,
+                exc_info=True,
+            )
     else:
         if delete_field_file(getattr(video, "processed_file", None), save=False):
-            logger.info("Deleted processed file from storage for video %s", video.uuid)
+            logger.info(
+                "Deleted processed file from storage for video %s", video.video_hash
+            )
         else:
-            logger.warning("Processed file missing in storage for video %s", video.uuid)
+            logger.warning(
+                "Processed file missing in storage for video %s", video.video_hash
+            )
 
     # 4. Delete Database Record
     try:
         # Use 'super(type(video), video)' to call the parent's delete method
         super(type(video), video).delete(*args, **kwargs)
-        logger.info("Deleted VideoFile database record PK %s (UUID: %s).", video.pk, video.uuid)
+        logger.info(
+            "Deleted VideoFile database record PK %s (UUID: %s).",
+            video.pk,
+            video.video_hash,
+        )
 
-        return f"Successfully deleted VideoFile {video.uuid} and attempted file cleanup."
+        return f"Successfully deleted VideoFile {video.video_hash} and attempted file cleanup."
     except Exception as e:
-        logger.error("Error deleting VideoFile database record PK %s (UUID: %s): %s", video.pk, video.uuid, e, exc_info=True)
+        logger.error(
+            "Error deleting VideoFile database record PK %s (UUID: %s): %s",
+            video.pk,
+            video.video_hash,
+            e,
+            exc_info=True,
+        )
         raise  # Re-raise the exception for DB deletion failure
 
 
 def _get_base_frame_dir(video: "VideoFile") -> Path:
     """Gets the base directory path for storing extracted frames."""
     # Assuming data_paths['frame'] is the root directory for all frame storage
-    return data_paths["frame"] / str(video.uuid)
+    return data_paths["frame"] / str(video.video_hash)
 
 
 def _set_frame_dir(video: "VideoFile", force_update: bool = False):
@@ -185,7 +233,9 @@ def _set_frame_dir(video: "VideoFile", force_update: bool = False):
 
     if not video.frame_dir or video.frame_dir != target_path_str or force_update:
         video.frame_dir = target_path_str
-        logger.info("Set frame_dir for video %s to %s", video.uuid, video.frame_dir)
+        logger.info(
+            "Set frame_dir for video %s to %s", video.video_hash, video.frame_dir
+        )
         # Avoid saving if called from within the save method itself
         if not getattr(video, "_saving", False):
             video.save(update_fields=["frame_dir"])
@@ -212,7 +262,9 @@ def _get_target_anonymized_video_path(video: "VideoFile") -> Path:
     if not video.has_raw or not video.raw_file.name:
         # If raw is gone, maybe base it on UUID? Requires careful thought.
         # For now, assume raw is needed to determine the original filename base.
-        raise ValueError("Cannot determine target anonymized path without a raw file reference.")
+        raise ValueError(
+            "Cannot determine target anonymized path without a raw file reference."
+        )
 
     # Use the filename part of the raw file's relative path
     raw_path_relative = Path(video.raw_file.name)

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

@@ -13,10 +13,10 @@ logger = logging.getLogger(__name__)
 
 # Define __all__ if you want to control what `from .video_file_meta import *` imports
 __all__ = [
-    '_update_text_metadata',
-    '_update_video_meta',
-    '_initialize_video_specs',
-    '_get_fps',
-    '_get_endo_roi',
-    '_get_crop_template',
+    "_update_text_metadata",
+    "_update_video_meta",
+    "_initialize_video_specs",
+    "_get_fps",
+    "_get_endo_roi",
+    "_get_crop_template",
 ]

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

@@ -13,7 +13,10 @@ def _get_crop_template(video: "VideoFile") -> Optional[List[int]]:
     """Generates a crop template [y1, y2, x1, x2] from the endo ROI."""
     endo_roi = _get_endo_roi(video)  # Use the helper function
     if not endo_roi:
-        logger.warning("Cannot generate crop template for video %s: Endo ROI not available.", video.uuid)
+        logger.warning(
+            "Cannot generate crop template for video %s: Endo ROI not available.",
+            video.video_hash,
+        )
         return None
 
     x = endo_roi["x"]
@@ -23,7 +26,9 @@ def _get_crop_template(video: "VideoFile") -> Optional[List[int]]:
 
     # Validate dimensions
     if None in [x, y, width, height] or width <= 0 or height <= 0:
-        logger.warning("Invalid ROI dimensions for video %s: %s", video.uuid, endo_roi)
+        logger.warning(
+            "Invalid ROI dimensions for video %s: %s", video.video_hash, endo_roi
+        )
         return None
 
     # Ensure crop boundaries are within image dimensions if available
@@ -34,12 +39,20 @@ def _get_crop_template(video: "VideoFile") -> Optional[List[int]]:
         x1 = max(0, x)
         x2 = min(img_w, x + width)
         if y1 >= y2 or x1 >= x2:
-            logger.warning("Calculated crop template has zero or negative size for video %s. ROI: %s, Img: %dx%d", video.uuid, endo_roi, img_w, img_h)
+            logger.warning(
+                "Calculated crop template has zero or negative size for video %s. ROI: %s, Img: %dx%d",
+                video.video_hash,
+                endo_roi,
+                img_w,
+                img_h,
+            )
             return None
         crop_template = [y1, y2, x1, x2]
     else:
         # Proceed without boundary check if image dimensions unknown
         crop_template = [y, y + height, x, x + width]
 
-    logger.debug("Generated crop template for video %s: %s", video.uuid, crop_template)
+    logger.debug(
+        "Generated crop template for video %s: %s", video.video_hash, crop_template
+    )
     return crop_template