endoreg-db 0.8.4.4__py3-none-any.whl → 0.8.8.0__py3-none-any.whl

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

@@ -1,14 +1,14 @@
-from tqdm import tqdm
-from pathlib import Path
-from typing import List
-from typing import TYPE_CHECKING, Optional
 import logging
-from django.db import OperationalError
 import time
+from pathlib import Path
+from typing import TYPE_CHECKING, List, Optional
+
+from django.db import OperationalError
+from tqdm import tqdm
 
 if TYPE_CHECKING:
     from endoreg_db.models import VideoFile
-    
+
 logger = logging.getLogger(__name__)
 
 
@@ -35,7 +35,6 @@ def _initialize_frames(video: "VideoFile", frame_paths: Optional[List[Path]] = N
     from endoreg_db.models.media.video.video_file_frames._bulk_create_frames import _bulk_create_frames
     from endoreg_db.models.media.video.video_file_frames._create_frame_object import _create_frame_object
 
-
     frames_to_create = []
     num_expected_or_provided = 0
     mark_as_extracted = False
@@ -46,11 +45,9 @@ def _initialize_frames(video: "VideoFile", frame_paths: Optional[List[Path]] = N
         num_expected_or_provided = len(frame_paths)
         for frame_path in tqdm(frame_paths, desc=f"Initializing Frames from Paths {video.uuid}", unit="frame"):
             try:
-                frame_number = int(frame_path.stem.split('_')[-1])
+                frame_number = int(frame_path.stem.split("_")[-1])
                 relative_path_str = frame_path.name
-                frames_to_create.append(
-                    _create_frame_object(video, frame_number, relative_path_str, extracted=mark_as_extracted)
-                )
+                frames_to_create.append(_create_frame_object(video, frame_number, relative_path_str, extracted=mark_as_extracted))
             except (ValueError, IndexError) as e:
                 logger.warning("Could not parse frame number from %s: %s", frame_path.name, e)
                 continue
@@ -63,7 +60,7 @@ def _initialize_frames(video: "VideoFile", frame_paths: Optional[List[Path]] = N
                 if state.frames_initialized or state.frame_count is not None:
                     state.frames_initialized = False
                     state.frame_count = None
-                    state.save(update_fields=['frames_initialized', 'frame_count'])
+                    state.save(update_fields=["frames_initialized", "frame_count"])
             except Exception as state_e:
                 logger.error("Failed to reset state during empty initialization for video %s: %s", video.uuid, state_e, exc_info=True)
             return
@@ -73,13 +70,10 @@ def _initialize_frames(video: "VideoFile", frame_paths: Optional[List[Path]] = N
         num_expected_or_provided = expected_frame_count
         for frame_number in tqdm(range(expected_frame_count), desc=f"Initializing Expected Frames {video.uuid}", unit="frame"):
             relative_path_str = f"frame_{frame_number:07d}.jpg"
-            frames_to_create.append(
-                _create_frame_object(video, frame_number, relative_path_str, extracted=mark_as_extracted)
-            )
-            
+            frames_to_create.append(_create_frame_object(video, frame_number, relative_path_str, extracted=mark_as_extracted))
+
     if frames_to_create:
         for attempt in range(5):
-
             try:
                 _bulk_create_frames(video, frames_to_create)
                 num_created_or_ignored = len(frames_to_create)
@@ -88,11 +82,7 @@ def _initialize_frames(video: "VideoFile", frame_paths: Optional[List[Path]] = N
                 if mark_as_extracted:
                     frame_numbers_to_update = [f.frame_number for f in frames_to_create]
                     if frame_numbers_to_update:
-                        update_count = Frame.objects.filter(
-                        video=video,
-                        frame_number__in=frame_numbers_to_update,
-                        is_extracted=False
-                        ).update(is_extracted=True)
+                        update_count = Frame.objects.filter(video=video, frame_number__in=frame_numbers_to_update, is_extracted=False).update(is_extracted=True)
                         if update_count > 0:
                             logger.info("Marked %d existing Frame objects as is_extracted=True for video %s.", update_count, video.uuid)
 
@@ -100,7 +90,7 @@ def _initialize_frames(video: "VideoFile", frame_paths: Optional[List[Path]] = N
                     state = video.get_or_create_state()
                     state.frames_initialized = True
                     state.frame_count = num_expected_or_provided
-                    state.save(update_fields=['frames_initialized', 'frame_count'])
+                    state.save(update_fields=["frames_initialized", "frame_count"])
                     logger.info("Set frames_initialized=True and frame_count=%d for video %s.", num_expected_or_provided, video.uuid)
                 except Exception as state_e:
                     logger.error("Failed to update state after frame initialization for video %s: %s", video.uuid, state_e, exc_info=True)
@@ -109,7 +99,7 @@ def _initialize_frames(video: "VideoFile", frame_paths: Optional[List[Path]] = N
             except OperationalError as e:
                 if "database is locked" in str(e):
                     logger.warning("Database is locked, retrying frame initialization for video %s (attempt %d/5).", video.uuid, attempt + 1)
-                    time.sleep(2 ** attempt)
+                    time.sleep(2**attempt)
                     if attempt < 4:
                         continue
                     else:
@@ -124,6 +114,6 @@ def _initialize_frames(video: "VideoFile", frame_paths: Optional[List[Path]] = N
             if state.frames_initialized or state.frame_count is not None:
                 state.frames_initialized = False
                 state.frame_count = None
-                state.save(update_fields=['frames_initialized', 'frame_count'])
+                state.save(update_fields=["frames_initialized", "frame_count"])
         except Exception as state_e:
             logger.error("Failed to reset state during empty initialization for video %s: %s", video.uuid, state_e, exc_info=True)

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

@@ -1,18 +1,20 @@
 import logging
 import os
 from typing import TYPE_CHECKING
+
 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.models.media.video.video_file_io import _get_frame_dir_path
-
 if TYPE_CHECKING:
     from endoreg_db.models import VideoFile
 
 logger = logging.getLogger(__name__)
 
+
 def _delete_frame_range(video: "VideoFile", start_frame: int, end_frame: int):
     """
     Deletes frame image files within the specified range [start_frame, end_frame)
@@ -20,19 +22,14 @@ def _delete_frame_range(video: "VideoFile", start_frame: int, end_frame: int):
     """
 
     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
-    )
+    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
 
     # 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.uuid, start_frame, end_frame)
 
     # Then delete files
     for frame_path in paths_to_delete:
@@ -44,10 +41,14 @@ def _delete_frame_range(video: "VideoFile", start_frame: int, end_frame: int):
             # 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.info("Attempted deletion of %d files for video %s range [%d, %d). Actual deleted: %d.",
-                len(paths_to_delete), video.uuid, start_frame, end_frame, deleted_count)
-
-
+    logger.info(
+        "Attempted deletion of %d files for video %s range [%d, %d). Actual deleted: %d.",
+        len(paths_to_delete),
+        video.uuid,
+        start_frame,
+        end_frame,
+        deleted_count,
+    )
 
 
 @transaction.atomic
@@ -79,10 +80,7 @@ def _extract_frame_range(
         raise ValueError(f"Cannot determine frame directory path for video {video.uuid}.")
 
     # 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():
@@ -90,7 +88,12 @@ def _extract_frame_range(
             logger.info("Overwrite=True, deleting existing frame files in range [%d, %d) for video %s before extraction.", start_frame, end_frame, video.uuid)
             _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)
+            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,
+            )
             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)
@@ -101,11 +104,11 @@ def _extract_frame_range(
 
     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
-        )
+        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))
+        logger.info(
+            "ffmpeg extraction process completed for video %s range [%d, %d). Found %d files.", video.uuid, 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)
@@ -127,7 +130,7 @@ def _extract_frame_range(
         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.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 []
+        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)]
 

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

@@ -1,5 +1,6 @@
 import logging
 from typing import TYPE_CHECKING, Set
+
 from django.db import transaction
 
 if TYPE_CHECKING:
@@ -7,43 +8,49 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+
 @transaction.atomic
 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)
         return 0
 
     # --- Enhanced Logging ---
-    min_frame = min(extracted_frame_numbers) if extracted_frame_numbers else 'N/A'
-    max_frame = max(extracted_frame_numbers) if extracted_frame_numbers else 'N/A'
+    min_frame = min(extracted_frame_numbers) if extracted_frame_numbers else "N/A"
+    max_frame = max(extracted_frame_numbers) if extracted_frame_numbers else "N/A"
     contains_zero = 0 in extracted_frame_numbers
     logger.info(
         "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, min_frame, max_frame, contains_zero
+        len(extracted_frame_numbers),
+        status,
+        video.uuid,
+        min_frame,
+        max_frame,
+        contains_zero,
     )
     # --- End Enhanced Logging ---
 
     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)
 
         # 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, len(extracted_frame_numbers), updated_count
-             )
-             # --- Add detailed check for frame 0 if status is True and it should have been updated ---
+                "Mismatch during status update for video %s. Expected to update %d frames, but DB reported updating %d.",
+                video.uuid,
+                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):
                 try:
                     # Check the status of frame 0 directly after the update attempt
@@ -52,14 +59,16 @@ def _mark_frames_extracted_status(video: "VideoFile", extracted_frame_numbers: S
                         logger.error("Verification check: Frame 0 (PK: %s) was NOT updated to is_extracted=True for video %s.", frame_zero.pk, video.uuid)
                     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)
+                        logger.info(
+                            "Verification check: Frame 0 (PK: %s) IS is_extracted=True for video %s, despite count mismatch.", frame_zero.pk, video.uuid
+                        )
                 except Frame.DoesNotExist:
                     logger.error("Verification check: Frame 0 does not exist for video %s during status check.", video.uuid)
                 except Exception as verify_e:
                     logger.error("Verification check: Error checking frame 0 status for video %s: %s", video.uuid, verify_e)
-             # --- End detailed check ---
+            # --- 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)
-        raise # Re-raise to ensure transaction rollback if needed
+        raise  # Re-raise to ensure transaction rollback if needed

endoreg_db/models/media/video/video_file_io.py

@@ -1,75 +1,110 @@
 import logging
+from contextlib import contextmanager
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Iterator, Optional
+
 from django.db import transaction
 
-from ...utils import data_paths, ANONYM_VIDEO_DIR, VIDEO_DIR # Import VIDEO_DIR for correct path resolution
+from ....utils import delete_field_file, ensure_local_file, storage_file_exists
+from ...utils import (
+    ANONYM_VIDEO_DIR,
+    VIDEO_DIR,
+    data_paths,
+)
 
 if TYPE_CHECKING:
     from .video_file import VideoFile
 
 logger = logging.getLogger("video_file")
 
+
 def _get_raw_file_path(video: "VideoFile") -> Optional[Path]:
-    """
-    Resolves and returns the absolute path to the raw video file if available.
-    The FileField stores a path relative to the storage root. We need to join
-    that relative path onto the actual video directory under STORAGE_DIR.
-    """
-    try:
-        if video.has_raw and video.raw_file.name:
-            # raw_file.name is a relative storage path like 'videos/<filename>'
-            raw_rel = Path(video.raw_file.name)
-            
-            # If it already contains the video directory name, keep the tail
-            rel_name = raw_rel.name if raw_rel.parent.name == VIDEO_DIR.name else raw_rel
-            full_path = data_paths["video"] / rel_name
-            
-            # If primary path doesn't exist, check alternative locations
-            if not full_path.exists():
-                # Check if file is in sensitive subdirectory
-                sensitive_path = data_paths["video"] / "sensitive" / rel_name
-                if sensitive_path.exists():
-                    return sensitive_path.resolve()
-                
-                # Check direct raw_file.path if available
-                # Check direct raw_file.path if available
-                try:
-                    direct_path = Path(video.raw_file.path)
-                    if direct_path.exists():
-                        return direct_path.resolve()
-                except Exception as e:
-                    logger.debug("Could not access direct raw_file.path for video %s: %s", video.uuid, e)
-                    # Fallback to checking alternative paths
-                
-                # Check common alternative paths
-                alternative_paths = [
-                    Path("/home/admin/dev/lx-annotate/libs/data/videos") / rel_name,
-                    Path("/home/admin/dev/lx-annotate/libs/data/videos/sensitive") / rel_name,
-                    data_paths["video"].parent / "libs" / "data" / "videos" / rel_name,
-                ]
-                
-                for alt_path in alternative_paths:
-                    if alt_path.exists():
-                        return alt_path.resolve()
-            
-            return full_path.resolve()
-        else:
-            return None
-    except Exception as e:
-        logger.warning("Could not get path for raw file of VideoFile %s: %s", video.uuid, e)
+    """Return the best-effort absolute path to the raw video on disk."""
+    if not (video.has_raw and video.raw_file.name):
         return None
 
+    # raw_file.name is a relative storage path like 'videos/<filename>'
+    raw_rel = Path(video.raw_file.name)
+
+    # If it already contains the video directory name, keep the tail
+    rel_name = raw_rel.name if raw_rel.parent.name == VIDEO_DIR.name else raw_rel
+    full_path = data_paths["video"] / rel_name
+
+    if full_path.exists():
+        return full_path.resolve()
+
+    sensitive_path = data_paths["video"] / "sensitive" / rel_name
+    if sensitive_path.exists():
+        return sensitive_path.resolve()
+
+    if storage_file_exists(video.raw_file):
+        try:
+            direct_path = Path(video.raw_file.path)
+            if direct_path.exists():
+                return direct_path.resolve()
+        except Exception as exc:
+            logger.debug(
+                "Could not access direct raw_file.path for video %s: %s",
+                video.uuid,
+                exc,
+            )
+
+    logger.warning(
+        "Raw video file '%s' not found under %s or via stored FileField path for video %s.",
+        rel_name,
+        data_paths["video"],
+        video.uuid,
+    )
+    return None
+
+
+@contextmanager
+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")
+
+    with ensure_local_file(video.raw_file) as local_path:
+        yield local_path
+
+
 def _get_processed_file_path(video: "VideoFile") -> Optional[Path]:
     """Returns the absolute Path object for the processed file, if it exists."""
-    try:
-        if video.is_processed and video.processed_file.name:
-            return Path(video.processed_file.path)
-        else:
-            return None
-    except Exception as e:
-        logger.warning("Could not get path for processed file of VideoFile %s: %s", video.uuid, e)
+    processed_field = getattr(video, "processed_file", None)
+    if not (video.is_processed and processed_field and processed_field.name):
         return None
+    try:
+        direct_path = Path(processed_field.path)
+        if direct_path.exists():
+            return direct_path.resolve()
+    except Exception as exc:
+        logger.debug(
+            "Could not access direct processed_file.path for video %s: %s",
+            video.uuid,
+            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)
+    else:
+        logger.warning(
+            "Could not get path for processed file of VideoFile %s: %s",
+            video.uuid,
+            "path unavailable",
+        )
+    return None
+
+
+@contextmanager
+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")
+
+    with ensure_local_file(video.processed_file) as local_path:
+        yield local_path
+
 
 @transaction.atomic
 def _delete_with_file(video: "VideoFile", *args, **kwargs):
@@ -96,6 +131,11 @@ def _delete_with_file(video: "VideoFile", *args, **kwargs):
         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)
+    else:
+        if delete_field_file(getattr(video, "raw_file", None), save=False):
+            logger.info("Deleted raw file from storage for video %s", video.uuid)
+        else:
+            logger.warning("Raw video file not found during deletion for video %s.", video.uuid)
 
     # 3. Delete Processed File
     processed_file_path = _get_processed_file_path(video)
@@ -109,6 +149,11 @@ def _delete_with_file(video: "VideoFile", *args, **kwargs):
         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)
+    else:
+        if delete_field_file(getattr(video, "processed_file", None), save=False):
+            logger.info("Deleted processed file from storage for video %s", video.uuid)
+        else:
+            logger.warning("Processed file missing in storage for video %s", video.uuid)
 
     # 4. Delete Database Record
     try:
@@ -119,7 +164,8 @@ def _delete_with_file(video: "VideoFile", *args, **kwargs):
         return f"Successfully deleted VideoFile {video.uuid} 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)
-        raise # Re-raise the exception for DB deletion failure
+        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."""
@@ -130,22 +176,23 @@ def _get_base_frame_dir(video: "VideoFile") -> Path:
 def _set_frame_dir(video: "VideoFile", force_update: bool = False):
     """Sets the frame_dir field based on the video's UUID."""
     target_dir = _get_base_frame_dir(video)
-    target_path_str = target_dir.as_posix() # Store as POSIX path string
+    target_path_str = target_dir.as_posix()  # Store as POSIX path string
 
     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)
         # Avoid saving if called from within the save method itself
-        if not getattr(video, '_saving', False):
-            video.save(update_fields=['frame_dir'])
+        if not getattr(video, "_saving", False):
+            video.save(update_fields=["frame_dir"])
 
 
 def _get_frame_dir_path(video: "VideoFile") -> Optional[Path]:
     """Returns the Path object for the frame directory, if set."""
     if not video.frame_dir:
         _set_frame_dir(video)
-    
-    return Path(video.frame_dir) 
+
+    return Path(video.frame_dir)
+
 
 def _get_temp_anonymized_frame_dir(video: "VideoFile") -> Path:
     """Gets the path for the temporary directory used during anonymization frame creation."""

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

@@ -1,5 +1,6 @@
 import logging
-from typing import TYPE_CHECKING, Optional, List, Dict
+from typing import TYPE_CHECKING, List, Optional
+
 from .get_endo_roi import _get_endo_roi
 
 if TYPE_CHECKING:
@@ -10,7 +11,7 @@ logger = logging.getLogger(__name__)
 
 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
+    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)
         return None
@@ -40,6 +41,5 @@ def _get_crop_template(video: "VideoFile") -> Optional[List[int]]:
         # 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)
     return crop_template

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

@@ -1,11 +1,12 @@
 import logging
-from typing import TYPE_CHECKING, Optional, Dict
+from typing import TYPE_CHECKING, Dict, Optional
 
 if TYPE_CHECKING:
     from ..video_file import VideoFile
 
 logger = logging.getLogger(__name__)
 
+
 def _get_endo_roi(video: "VideoFile") -> Optional[Dict[str, int]]:
     """
     Gets the endoscope region of interest (ROI) dictionary from the linked VideoMeta.
@@ -26,8 +27,9 @@ def _get_endo_roi(video: "VideoFile") -> Optional[Dict[str, int]]:
             and all(k in endo_roi for k in ("x", "y", "width", "height"))
             and all(isinstance(v, int) and not isinstance(v, bool) for v in endo_roi.values())
         ):
-            logger.debug("Retrieved endo ROI for video %s: %s", video.uuid, endo_roi)
-            return endo_roi
+            cleaned_roi = {k: int(endo_roi[k] or 0) for k in ("x", "y", "width", "height")}
+            logger.debug("Retrieved endo ROI for video %s: %s", video.uuid, cleaned_roi)
+            return cleaned_roi
         else:
             logger.warning("Endo ROI not fully defined or invalid in VideoMeta for video %s. ROI: %s", video.uuid, endo_roi)
             return None