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

@@ -1,27 +1,27 @@
 import logging
 import shutil
-from pathlib import Path
-from typing import TYPE_CHECKING, List, Tuple, Dict, Optional, Set
 import uuid
-from django.db import transaction
+from pathlib import Path
+from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple
+
 import cv2
+from django.db import transaction
 from tqdm import tqdm
-from django.conf import settings
-
-
 
 from endoreg_db.utils.hashs import get_video_hash
-from endoreg_db.utils.validate_endo_roi import validate_endo_roi
 from endoreg_db.utils.paths import STORAGE_DIR
+from endoreg_db.utils.validate_endo_roi import validate_endo_roi
+
 from ....utils.video.ffmpeg_wrapper import assemble_video_from_frames
 from ...utils import anonymize_frame  # Import from models.utils
-from .video_file_segments import _get_outside_frames, _get_outside_frame_numbers
+from .video_file_segments import _get_outside_frame_numbers, _get_outside_frames
 
 if TYPE_CHECKING:
-    from .video_file import VideoFile
-    from ..frame import Frame
     from django.db.models import QuerySet
 
+    from ..frame import Frame
+    from .video_file import VideoFile
+
 logger = logging.getLogger(__name__)
 
 
@@ -66,7 +66,9 @@ def _create_anonymized_frame_files(
                 if not isinstance(source_path, Path):
                     raise TypeError(f"Frame.file_path did not return a Path object for frame {frame_obj.frame_number}")
             except (AttributeError, TypeError, Exception) as path_err:
-                logger.error("Could not determine source path for Frame %d (PK: %s) using frame_obj.file_path: %s", frame_obj.frame_number, frame_obj.pk, path_err)
+                logger.error(
+                    "Could not determine source path for Frame %d (PK: %s) using frame_obj.file_path: %s", frame_obj.frame_number, frame_obj.pk, path_err
+                )
                 raise RuntimeError(f"Failed to get source path for frame {frame_obj.frame_number}") from path_err
 
             if not source_path.exists():
@@ -78,13 +80,7 @@ def _create_anonymized_frame_files(
                 logger.error(error_msg)
                 raise FileNotFoundError(error_msg)
 
-            anonymize_frame(
-                raw_frame_path=source_path,
-                target_frame_path=target_path,
-                endo_roi=endo_roi,
-                all_black=make_all_black,
-                censor_color=censor_color
-            )
+            anonymize_frame(raw_frame_path=source_path, target_frame_path=target_path, endo_roi=endo_roi, all_black=make_all_black, censor_color=censor_color)
 
             generated_paths.append(target_path)
         except (FileNotFoundError, IOError, ValueError, AttributeError, TypeError, Exception) as e:
@@ -146,15 +142,14 @@ def _censor_outside_frames(video: "VideoFile", outside_label_name: str = "outsid
                 error_count += 1
 
         except Exception as e:
-            logger.error("Error censoring frame %d (%s): %s",
-                         frame_obj.frame_number, getattr(frame_obj, 'relative_path', 'N/A'), e, exc_info=True)
+            logger.error("Error censoring frame %d (%s): %s", frame_obj.frame_number, getattr(frame_obj, "relative_path", "N/A"), e, exc_info=True)
             error_count += 1
 
     logger.info("Finished censoring for video %s. Censored: %d, Errors: %d", video.uuid, censored_count, error_count)
     return error_count == 0
 
 
-def _make_temporary_anonymized_frames(video: "VideoFile") -> Tuple[Path, List[Path]]:
+def _make_temporary_anonymized_frames(video: "VideoFile", roi_processing = True) -> Tuple[Path, List[Path]]:
     """
     Creates temporary anonymized frames in a separate directory.
     Requires raw file and extracted frames. Raises ValueError or RuntimeError on failure.
@@ -171,10 +166,15 @@ def _make_temporary_anonymized_frames(video: "VideoFile") -> Tuple[Path, List[Pa
     temp_anonym_frame_dir = video.get_temp_anonymized_frame_dir()
     temp_anonym_frame_dir.mkdir(parents=True, exist_ok=True)
     logger.info("Creating temporary anonymized frames for video %s in %s", video.uuid, temp_anonym_frame_dir)
-
-    endo_roi = video.get_endo_roi()
-    if not validate_endo_roi(endo_roi_dict=endo_roi):
-        raise ValueError(f"Endoscope ROI is not valid for video {video.uuid}")
+    if roi_processing:
+        endo_roi = video.get_endo_roi()
+        if not validate_endo_roi(endo_roi_dict=endo_roi):
+            raise ValueError(f"Endoscope ROI is not valid for video {video.uuid}")
+    else:
+        endo_roi = {"x": 0, "y": 0, "width": 0, "height": 0}  # Dummy ROI to skip processing
+    assert endo_roi is not None  # For type checker
+    
+        
 
     state = video.get_or_create_state()
     if not state.frames_extracted:
@@ -211,12 +211,12 @@ def _make_temporary_anonymized_frames(video: "VideoFile") -> Tuple[Path, List[Pa
 def _anonymize(video: "VideoFile", delete_original_raw: bool = True) -> bool:
     """
     Performs full anonymization of a video by censoring frames, assembling a processed video file, updating database records, and optionally deleting original raw assets.
-    
+
     Raises:
         ValueError: If required preconditions are not met (e.g., frames not extracted, sensitive metadata not validated).
         FileNotFoundError: If the raw video file is missing.
         RuntimeError: If anonymization or video assembly fails.
-    
+
     Returns:
         bool: True if anonymization completes successfully.
     """
@@ -233,8 +233,6 @@ def _anonymize(video: "VideoFile", delete_original_raw: bool = True) -> bool:
         raise ValueError(f"Sensitive metadata for video {video.uuid} is not validated. Cannot anonymize.")
     # outside_segments = video.get_outside_segments(only_validated=False)
     # unvalidated_outside = outside_segments.filter(state__is_validated=False)
-    
-    
 
     logger.info("Starting anonymization process for video %s", video.uuid)
 
@@ -281,17 +279,18 @@ def _anonymize(video: "VideoFile", delete_original_raw: bool = True) -> bool:
             original_raw_file_path_to_delete = video.get_raw_file_path()
             original_raw_frame_dir_to_delete = video.get_frame_dir_path()
 
-            video.raw_file.name = None
+            video.raw_file.name = ""
 
             update_fields.extend(["raw_file", "video_hash"])
 
-            transaction.on_commit(lambda: _cleanup_raw_assets(
-                video_uuid=video.uuid,
-                raw_file_path=original_raw_file_path_to_delete,
-                raw_frame_dir=original_raw_frame_dir_to_delete
-            ))
+            transaction.on_commit(
+                lambda: _cleanup_raw_assets(
+                    video_uuid=video.uuid, raw_file_path=original_raw_file_path_to_delete, raw_frame_dir=original_raw_frame_dir_to_delete
+                )
+            )
 
         video.save(update_fields=update_fields)
+        assert video.state is not None  # For type checker
         video.state.mark_anonymized(save=True)
         video.refresh_from_db()
         return True
@@ -309,7 +308,7 @@ def _anonymize(video: "VideoFile", delete_original_raw: bool = True) -> bool:
             shutil.rmtree(temp_anonym_frame_dir)
 
 
-def _cleanup_raw_assets(video_uuid: uuid.UUID, raw_file_path: Optional[Path]=None, raw_frame_dir: Optional[Path]=None):
+def _cleanup_raw_assets(video_uuid: uuid.UUID, raw_file_path: Optional[Path] = None, raw_frame_dir: Optional[Path] = None):
     """
     Deletes the original raw video file and its extracted frames directory.
     Called via transaction.on_commit after successful anonymization.
@@ -318,9 +317,10 @@ def _cleanup_raw_assets(video_uuid: uuid.UUID, raw_file_path: Optional[Path]=Non
         - Sets state.frames_extracted=False.
     """
     from endoreg_db.models import VideoFile, VideoState
+
     logger.info("Performing post-commit cleanup of raw assets for video %s.", video_uuid)
     try:
-        video_file = VideoFile.objects.select_related('state').filter(uuid=video_uuid).first()
+        video_file = VideoFile.objects.select_related("state").filter(uuid=video_uuid).first()
         if not video_file:
             logger.error("VideoFile %s not found during post-commit cleanup.", video_uuid)
             return
@@ -342,7 +342,7 @@ def _cleanup_raw_assets(video_uuid: uuid.UUID, raw_file_path: Optional[Path]=Non
 
         if video_file.state.frames_extracted:
             video_file.state.frames_extracted = False
-            video_file.state.save(update_fields=['frames_extracted'])
+            video_file.state.save(update_fields=["frames_extracted"])
             logger.info("Set state.frames_extracted=False for video %s after raw asset cleanup.", video_uuid)
 
     except Exception as e:

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

@@ -19,18 +19,20 @@ Submodules:
 Usage:
     Import the required functions directly from this module to perform specific video frame operations.
 """
+
 from ._bulk_create_frames import _bulk_create_frames
 from ._create_frame_object import _create_frame_object
 from ._delete_frames import _delete_frames
 from ._extract_frames import _extract_frames
+from ._get_frame import _get_frame
 from ._get_frame_number import _get_frame_number
 from ._get_frame_path import _get_frame_path
 from ._get_frame_paths import _get_frame_paths
 from ._get_frame_range import _get_frame_range
-from ._get_frame import _get_frame
 from ._get_frames import _get_frames
 from ._initialize_frames import _initialize_frames
 from ._mark_frames_extracted_status import _mark_frames_extracted_status
+
 __all__ = [
     "_bulk_create_frames",
     "_create_frame_object",

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

@@ -1,22 +1,20 @@
-
-from endoreg_db.models.media.video.video_file_io import _get_frame_dir_path, _get_temp_anonymized_frame_dir
-
-from typing import TYPE_CHECKING, List
-
 import logging
+from typing import TYPE_CHECKING, List
 
 if TYPE_CHECKING:
-    from endoreg_db.models import VideoFile, Frame
-    
+    from endoreg_db.models import Frame, VideoFile
+
 logger = logging.getLogger(__name__)
 
+__all__ = ["_bulk_create_frames"]
 
 
 def _bulk_create_frames(video: "VideoFile", frames_to_create: List["Frame"]):
     """Helper function to perform bulk_create with ignore_conflicts."""
     from endoreg_db.models import Frame
+
     try:
         Frame.objects.bulk_create(frames_to_create, ignore_conflicts=True)
     except Exception as e:
         logger.error("Error during bulk creation of frames for video %s: %s", video.uuid, e, exc_info=True)
-        raise
+        raise

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

@@ -1,17 +1,15 @@
-
-
-from typing import TYPE_CHECKING
-
 import logging
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from endoreg_db.models import VideoFile, Frame
-    
+    from endoreg_db.models import Frame, VideoFile
+
 logger = logging.getLogger(__name__)
 
-def _create_frame_object(
-    video: "VideoFile", frame_number: int, relative_path: str, extracted: bool = False
-) -> "Frame":
+__all__ = ["_create_frame_object"]
+
+
+def _create_frame_object(video: "VideoFile", frame_number: int, relative_path: str, extracted: bool = False) -> "Frame":
     """Instantiates a Frame object (does not save it)."""
     from endoreg_db.models import Frame
 

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

@@ -1,17 +1,19 @@
-
-from endoreg_db.models.media.video.video_file_io import _get_frame_dir_path, _get_temp_anonymized_frame_dir
-from django.db import transaction
-
+import logging
 import shutil
 from typing import TYPE_CHECKING
 
-import logging
+from django.db import transaction
+
+from endoreg_db.models.media.video.video_file_io import _get_frame_dir_path, _get_temp_anonymized_frame_dir
 
 if TYPE_CHECKING:
     from endoreg_db.models import VideoFile, VideoState
 
 logger = logging.getLogger(__name__)
 
+__all__ = ["_delete_frames"]
+
+
 @transaction.atomic
 def _delete_frames(video: "VideoFile") -> str:
     """
@@ -21,6 +23,7 @@ def _delete_frames(video: "VideoFile") -> str:
     Raises RuntimeError if state update fails.
     """
     from endoreg_db.models.media.frame import Frame
+
     deleted_messages = []
     error_messages = []
     state_updated = False
@@ -44,7 +47,6 @@ def _delete_frames(video: "VideoFile") -> str:
         msg = f"Frame directory path not set for video {video.uuid}, cannot delete standard frames."
         logger.warning(msg)
 
-
     temp_anonym_frame_dir = None
     try:
         temp_anonym_frame_dir = _get_temp_anonymized_frame_dir(video)
@@ -58,13 +60,12 @@ def _delete_frames(video: "VideoFile") -> str:
         logger.error(msg, exc_info=True)
         error_messages.append(msg)
 
-
     try:
         state: "VideoState" = video.get_or_create_state()
         update_fields_state = []
         if state.frames_extracted:
             state.frames_extracted = False
-            update_fields_state.append('frames_extracted')
+            update_fields_state.append("frames_extracted")
 
         if update_fields_state:
             state.save(update_fields=update_fields_state)

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

@@ -1,53 +1,62 @@
 import logging
+from typing import TYPE_CHECKING
+
 from endoreg_db.models.media.video.video_file_io import _get_frame_dir_path
 from endoreg_db.utils.video.ffmpeg_wrapper import extract_frames as ffmpeg_extract_frames
-from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from endoreg_db.models import VideoFile
 
-from django.db import transaction
+import shutil
 
+from django.db import transaction
 
-import shutil
 logger = logging.getLogger(__name__)
 
+
 def _extract_frames(
     video: "VideoFile",
     quality: int = 2,
     overwrite: bool = False,
     ext="jpg",
     verbose=False,
+    from_processed: bool = False,
 ) -> bool:
     """
     Extract frames from a raw video file, update frame extraction status in the database, and manage related file system operations.
-    
+
     This function checks for existing extracted frames and skips extraction if appropriate, unless overwriting is requested. It handles deletion of existing frames when overwriting, invokes ffmpeg to extract frames, parses extracted frame numbers, updates corresponding database records, and manages video extraction state. Robust error handling ensures cleanup and state rollback on failure.
-    
+
     Parameters:
         video (VideoFile): The video object from which frames are to be extracted.
         quality (int, optional): Quality parameter for ffmpeg extraction. Defaults to 2.
         overwrite (bool, optional): Whether to overwrite existing extracted frames. Defaults to False.
         ext (str, optional): File extension for extracted frames. Defaults to "jpg".
-    
+
     Returns:
         bool: True if extraction and updates succeed.
-    
+
     Raises:
         FileNotFoundError: If the raw video file is missing.
         RuntimeError: If extraction or database update fails.
         ValueError: If the frame directory path cannot be determined.
     """
-    from ._delete_frames import _delete_frames
     from endoreg_db.models.media.frame import Frame
 
-    # Pre-validation checks (outside any transaction)
-    if not video.has_raw:
-        raise FileNotFoundError(f"Raw video file not available for {video.uuid}. Cannot extract frames.")
+    from ._delete_frames import _delete_frames
+
+    if from_processed:
+        raw_file_path = video.get_processed_file_path()
+        if not raw_file_path or not raw_file_path.exists():
+            raise FileNotFoundError(f"Processed video file not found at {raw_file_path} for video {video.uuid}. Cannot extract frames.")
+    else:
+        # Pre-validation checks (outside any transaction)
+        if not video.has_raw:
+            raise FileNotFoundError(f"Raw video file not available for {video.uuid}. Cannot extract frames.")
 
-    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 frames.")
+        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 frames.")
 
     frame_dir = _get_frame_dir_path(video)
     if not frame_dir:
@@ -63,33 +72,22 @@ def _extract_frames(
             "Frames already extracted or files exist for video %s, and overwrite=False. Skipping extraction.",
             video.uuid,
         )
-        if state.frames_extracted and frames_exist_in_db:
-            with transaction.atomic():
-                updated_count = Frame.objects.filter(video=video, is_extracted=False).update(is_extracted=True)
-                if updated_count > 0:
-                    logger.info(
-                        "Marked %d existing Frame objects as extracted for video %s based on state.",
-                        updated_count,
-                        video.uuid,
-                    )
-        elif not state.frames_extracted and files_exist_on_disk:
-            logger.warning(
-                "Files exist on disk for video %s but state.frames_extracted is False. Correcting state to match disk.",
-                video.uuid,
-            )
-            # Fix inconsistent state: files exist but state.frames_extracted is False
-            state.frames_extracted = True
-            state.save(update_fields=['frames_extracted'])
-            
-            # Also update Frame objects to be consistent
-            with transaction.atomic():
+        with transaction.atomic():
+            state.refresh_from_db()
+            if frames_exist_in_db:
                 updated_count = Frame.objects.filter(video=video, is_extracted=False).update(is_extracted=True)
                 if updated_count > 0:
                     logger.info(
-                        "Marked %d existing Frame objects as extracted for video %s after state correction.",
+                        "Marked %d existing Frame objects as extracted for video %s based on current records.",
                         updated_count,
                         video.uuid,
                     )
+            if files_exist_on_disk and not state.frames_extracted:
+                logger.warning(
+                    "Files exist on disk for video %s but state.frames_extracted is False. Persisting corrected state.",
+                    video.uuid,
+                )
+                state.mark_frames_extracted(save=True)
         return True
 
     # Overwrite: delete existing frames/files before re-extraction.
@@ -122,16 +120,14 @@ def _extract_frames(
                 video.uuid,
             )
             if video.frame_count is not None and video.frame_count > 0:
-                raise RuntimeError(
-                    f"ffmpeg_extract_frames returned no paths for video {video.uuid}, but {video.frame_count} frames were expected."
-                )
+                raise RuntimeError(f"ffmpeg_extract_frames returned no paths for video {video.uuid}, but {video.frame_count} frames were expected.")
 
         logger.info("Successfully extracted %d frames using ffmpeg for video %s.", len(extracted_paths), video.uuid)
 
         extracted_frame_numbers = []
         for frame_path in extracted_paths:
             try:
-                frame_number = int(frame_path.stem.split('_')[-1])
+                frame_number = int(frame_path.stem.split("_")[-1])
                 extracted_frame_numbers.append(frame_number)
             except (ValueError, IndexError) as e:
                 logger.warning("Could not parse frame number from extracted file %s: %s", frame_path.name, e)
@@ -140,9 +136,7 @@ def _extract_frames(
         with transaction.atomic():
             if extracted_frame_numbers:
                 try:
-                    update_count = Frame.objects.filter(
-                        video=video, frame_number__in=extracted_frame_numbers
-                    ).update(is_extracted=True)
+                    update_count = Frame.objects.filter(video=video, frame_number__in=extracted_frame_numbers).update(is_extracted=True)
                     logger.info("Marked %d Frame objects as is_extracted=True for video %s.", update_count, video.uuid)
                     if update_count != len(extracted_frame_numbers):
                         logger.warning(
@@ -153,9 +147,8 @@ def _extract_frames(
                         )
                 except Exception as update_e:
                     logger.error("Failed to update is_extracted flag for frames of video %s: %s", video.uuid, update_e, exc_info=True)
-            if extracted_paths:
-                state.refresh_from_db()
-                state.mark_frames_extracted()
+            state.refresh_from_db()
+            state.mark_frames_extracted()
         return True
 
     except Exception as e:

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

@@ -1,18 +1,16 @@
-from typing import TYPE_CHECKING
-
 import logging
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from endoreg_db.models import VideoFile, Frame
-    
-logger = logging.getLogger(__name__)
-
+    from endoreg_db.models import Frame, VideoFile
 
+logger = logging.getLogger(__name__)
 
 
 def _get_frame(video: "VideoFile", frame_number: int) -> "Frame":
     """Gets a specific Frame object by its frame number."""
     from endoreg_db.models import Frame
+
     try:
         # Access related manager directly
         return video.frames.get(frame_number=frame_number)
@@ -22,7 +20,7 @@ def _get_frame(video: "VideoFile", frame_number: int) -> "Frame":
         return Frame.objects.get(video_file=video, frame_number=frame_number)
     except Frame.DoesNotExist:
         logger.error("Frame %d not found for video %s.", frame_number, video.uuid)
-        raise # Re-raise DoesNotExist
+        raise  # Re-raise DoesNotExist
     except Exception as e:
         logger.error("Error getting frame %d for video %s: %s", frame_number, video.uuid, e, exc_info=True)
-        raise # Re-raise other exceptions
+        raise  # Re-raise other exceptions

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

@@ -1,27 +1,13 @@
-
-from typing import TYPE_CHECKING
-
 import logging
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from endoreg_db.models import VideoFile
-    
-logger = logging.getLogger(__name__)
-
 
+logger = logging.getLogger(__name__)
 
 
 def _get_frame_number(video: "VideoFile") -> int:
     """Counts the number of associated Frame objects in the database."""
-    try:
-        # Access related manager directly
-        return video.frames.count()
-    except AttributeError:
-        logger.error("Could not access frame count for video %s. 'frames' related manager not found.", str(video))
-        # Fallback query (less efficient)
-        frame_model = video.get_frame_model()
-        return frame_model.objects.filter(video_file=video).count()
-    except Exception as e:
-        logger.error("Error counting frames for video %s: %s", video.uuid, e, exc_info=True)
-        return 0
-    
+    # Access related manager directly
+    return video.frames.count()

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

@@ -1,20 +1,21 @@
 # --- Frame Creation/Deletion ---
 import logging
-from typing import TYPE_CHECKING, Optional
 from pathlib import Path
+from typing import TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
     from endoreg_db.models import VideoFile
 
 logger = logging.getLogger(__name__)
 
+
 def _get_frame_path(video: "VideoFile", frame_number: int) -> Optional[Path]:
     """Constructs the expected path for a given frame number."""
-    target_dir = video.get_frame_dir_path() # Use IO helper
+    target_dir = video.get_frame_dir_path()  # Use IO helper
     if not target_dir:
         logger.warning("Cannot get frame path for video %s: Frame directory not set.", video.uuid)
         return None
 
     frame_filename = f"frame_{frame_number:07d}.jpg"
     path = target_dir / frame_filename
-    return path
+    return path

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

@@ -1,14 +1,15 @@
-from endoreg_db.models.media.video.video_file_io import _get_frame_dir_path
-
-from pathlib import Path
 import logging
-
+from pathlib import Path
 from typing import TYPE_CHECKING, List
+
+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 _get_frame_paths(video: "VideoFile") -> List[Path]:
     """Returns a sorted list of Path objects for extracted frame image files."""
     frame_dir = _get_frame_dir_path(video)
@@ -16,10 +17,10 @@ def _get_frame_paths(video: "VideoFile") -> List[Path]:
         logger.warning("Frame directory %s does not exist for video %s.", frame_dir, video.uuid)
         return []
 
-    frame_paths = list(frame_dir.glob('frame_*.jpg'))
+    frame_paths = list(frame_dir.glob("frame_*.jpg"))
 
     try:
-        frame_paths.sort(key=lambda p: int(p.stem.split('_')[-1]))
+        frame_paths.sort(key=lambda p: int(p.stem.split("_")[-1]))
     except (ValueError, IndexError) as e:
         logger.error("Error sorting frame paths in %s: %s. Found paths: %s", frame_dir, e, [p.name for p in frame_paths], exc_info=True)
         logger.warning("Falling back to unsorted frame paths to preserve available data.")

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

@@ -1,20 +1,18 @@
-
+import logging
 from typing import TYPE_CHECKING
+
 from django.db.models import QuerySet
-import logging
 
 if TYPE_CHECKING:
-    from endoreg_db.models import VideoFile, Frame
-    
-logger = logging.getLogger(__name__)
-
-
+    from endoreg_db.models import Frame, VideoFile
 
+logger = logging.getLogger(__name__)
 
 
 def _get_frame_range(video: "VideoFile", start_frame_number: int, end_frame_number: int) -> "QuerySet[Frame]":
     """Gets a QuerySet of Frame objects within a specific range, ordered by frame number."""
     from endoreg_db.models import Frame
+
     try:
         # Access related manager directly
         return video.frames.filter(
@@ -31,4 +29,4 @@ def _get_frame_range(video: "VideoFile", start_frame_number: int, end_frame_numb
         ).order_by("frame_number")
     except Exception as e:
         logger.error("Error getting frame range (%d-%d) for video %s: %s", start_frame_number, end_frame_number, video.uuid, e, exc_info=True)
-        return Frame.objects.none() # Return empty queryset on error
+        return Frame.objects.none()  # Return empty queryset on error

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

@@ -1,20 +1,18 @@
-from django.db.models import QuerySet
-
+import logging
 from typing import TYPE_CHECKING
 
-import logging
+from django.db.models import QuerySet
 
 if TYPE_CHECKING:
-    from endoreg_db.models import VideoFile, Frame
-    
-logger = logging.getLogger(__name__)
-
+    from endoreg_db.models import Frame, VideoFile
 
+logger = logging.getLogger(__name__)
 
 
 def _get_frames(video: "VideoFile") -> "QuerySet[Frame]":
     """Gets a QuerySet of all associated Frame objects, ordered by frame number."""
     from endoreg_db.models import Frame
+
     try:
         # Access related manager directly
         return video.frames.order_by("frame_number")
@@ -24,4 +22,4 @@ def _get_frames(video: "VideoFile") -> "QuerySet[Frame]":
         return Frame.objects.filter(video_file=video).order_by("frame_number")
     except Exception as e:
         logger.error("Error getting frames for video %s: %s", video.uuid, e, exc_info=True)
-        return Frame.objects.none() # Return empty queryset on error
+        return Frame.objects.none()  # Return empty queryset on error