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

@@ -2,7 +2,9 @@ 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 endoreg_db.utils.video.ffmpeg_wrapper import (
+    extract_frames as ffmpeg_extract_frames,
+)
 
 if TYPE_CHECKING:
     from endoreg_db.models import VideoFile
@@ -48,19 +50,27 @@ def _extract_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.")
+            raise FileNotFoundError(
+                f"Processed video file not found at {raw_file_path} for video {video.video_hash}. 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.")
+            raise FileNotFoundError(
+                f"Raw video file not available for {video.video_hash}. 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.")
+            raise FileNotFoundError(
+                f"Raw video file not found at {raw_file_path} for video {video.video_hash}. Cannot extract frames."
+            )
 
     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}."
+        )
 
     state = video.get_or_create_state()
     frames_exist_in_db = Frame.objects.filter(video=video).exists()
@@ -70,59 +80,83 @@ def _extract_frames(
     if (state.frames_extracted or files_exist_on_disk) and not overwrite:
         logger.info(
             "Frames already extracted or files exist for video %s, and overwrite=False. Skipping extraction.",
-            video.uuid,
+            video.video_hash,
         )
         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)
+                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 current records.",
                         updated_count,
-                        video.uuid,
+                        video.video_hash,
                     )
             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,
+                    video.video_hash,
                 )
                 state.mark_frames_extracted(save=True)
         return True
 
     # Overwrite: delete existing frames/files before re-extraction.
     if overwrite:
-        logger.info("Overwrite=True. Preparing to delete existing frames/files for video %s before extraction.", video.uuid)
+        logger.info(
+            "Overwrite=True. Preparing to delete existing frames/files for video %s before extraction.",
+            video.video_hash,
+        )
         try:
             _delete_frames(video)
             with transaction.atomic():
-                updated_count = Frame.objects.filter(video=video, is_extracted=True).update(is_extracted=False)
+                updated_count = Frame.objects.filter(
+                    video=video, is_extracted=True
+                ).update(is_extracted=False)
                 if updated_count > 0:
                     logger.info(
                         "Reset %d Frame objects to is_extracted=False for video %s due to overwrite.",
                         updated_count,
-                        video.uuid,
+                        video.video_hash,
                     )
             state.refresh_from_db()
         except Exception as del_e:
-            logger.error("Failed to delete existing frames for video %s during overwrite: %s", video.uuid, del_e, exc_info=True)
-            raise RuntimeError(f"Failed to delete existing frames for video {video.uuid} during overwrite.") from del_e
+            logger.error(
+                "Failed to delete existing frames for video %s during overwrite: %s",
+                video.video_hash,
+                del_e,
+                exc_info=True,
+            )
+            raise RuntimeError(
+                f"Failed to delete existing frames for video {video.video_hash} during overwrite."
+            ) from del_e
 
     frame_dir.mkdir(parents=True, exist_ok=True)
 
     try:
-        logger.info("Starting frame extraction for video %s to %s", video.uuid, frame_dir)
+        logger.info(
+            "Starting frame extraction for video %s to %s", video.video_hash, frame_dir
+        )
         # Step 1: Perform the long-running frame extraction outside any transaction.
-        extracted_paths = ffmpeg_extract_frames(raw_file_path, frame_dir, quality=quality, ext=ext)
+        extracted_paths = ffmpeg_extract_frames(
+            raw_file_path, frame_dir, quality=quality, ext=ext
+        )
         if not extracted_paths:
             logger.warning(
                 "ffmpeg_extract_frames returned no paths for video %s. Check video duration and ffmpeg logs.",
-                video.uuid,
+                video.video_hash,
             )
             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.video_hash}, but {video.frame_count} frames were expected."
+                )
 
-        logger.info("Successfully extracted %d frames using ffmpeg for video %s.", len(extracted_paths), video.uuid)
+        logger.info(
+            "Successfully extracted %d frames using ffmpeg for video %s.",
+            len(extracted_paths),
+            video.video_hash,
+        )
 
         extracted_frame_numbers = []
         for frame_path in extracted_paths:
@@ -130,38 +164,70 @@ def _extract_frames(
                 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)
+                logger.warning(
+                    "Could not parse frame number from extracted file %s: %s",
+                    frame_path.name,
+                    e,
+                )
 
         # Step 2: Perform all the quick DB updates inside a minimal atomic transaction.
         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)
-                    logger.info("Marked %d Frame objects as is_extracted=True for video %s.", update_count, video.uuid)
+                    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.video_hash,
+                    )
                     if update_count != len(extracted_frame_numbers):
                         logger.warning(
                             "Number of updated frames (%d) does not match number of parsed extracted files (%d) for video %s.",
                             update_count,
                             len(extracted_frame_numbers),
-                            video.uuid,
+                            video.video_hash,
                         )
                 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)
+                    logger.error(
+                        "Failed to update is_extracted flag for frames of video %s: %s",
+                        video.video_hash,
+                        update_e,
+                        exc_info=True,
+                    )
             state.refresh_from_db()
             state.mark_frames_extracted()
         return True
 
     except Exception as e:
-        logger.error("Frame extraction or update failed for video %s: %s", video.uuid, e, exc_info=True)
-        logger.warning("Cleaning up frame directory %s for video %s due to extraction error.", frame_dir, video.uuid)
+        logger.error(
+            "Frame extraction or update failed for video %s: %s",
+            video.video_hash,
+            e,
+            exc_info=True,
+        )
+        logger.warning(
+            "Cleaning up frame directory %s for video %s due to extraction error.",
+            frame_dir,
+            video.video_hash,
+        )
         shutil.rmtree(frame_dir, ignore_errors=True)
         try:
             with transaction.atomic():
-                Frame.objects.filter(video=video, is_extracted=True).update(is_extracted=False)
+                Frame.objects.filter(video=video, is_extracted=True).update(
+                    is_extracted=False
+                )
                 state.refresh_from_db()
                 if state.frames_extracted:
                     state.frames_extracted = False
                     state.save(update_fields=["frames_extracted"])
         except Exception as db_err:
-            logger.error("Failed to reset flags/state in DB during error handling for video %s: %s", video.uuid, db_err)
-        raise RuntimeError(f"Frame extraction or update failed for video {video.uuid}.") from e
+            logger.error(
+                "Failed to reset flags/state in DB during error handling for video %s: %s",
+                video.video_hash,
+                db_err,
+            )
+        raise RuntimeError(
+            f"Frame extraction or update failed for video {video.video_hash}."
+        ) from e

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

@@ -15,12 +15,22 @@ def _get_frame(video: "VideoFile", frame_number: int) -> "Frame":
         # Access related manager directly
         return video.frames.get(frame_number=frame_number)
     except AttributeError:
-        logger.error("Could not access frame %d for video %s via related manager.", frame_number, video.uuid)
+        logger.error(
+            "Could not access frame %d for video %s via related manager.",
+            frame_number,
+            video.video_hash,
+        )
         # Fallback query
         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)
+        logger.error("Frame %d not found for video %s.", frame_number, video.video_hash)
         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)
+        logger.error(
+            "Error getting frame %d for video %s: %s",
+            frame_number,
+            video.video_hash,
+            e,
+            exc_info=True,
+        )
         raise  # Re-raise other exceptions

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

@@ -13,7 +13,10 @@ 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
     if not target_dir:
-        logger.warning("Cannot get frame path for video %s: Frame directory not set.", video.uuid)
+        logger.warning(
+            "Cannot get frame path for video %s: Frame directory not set.",
+            video.video_hash,
+        )
         return None
 
     frame_filename = f"frame_{frame_number:07d}.jpg"

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

@@ -14,7 +14,11 @@ 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)
     if not frame_dir or not frame_dir.exists():
-        logger.warning("Frame directory %s does not exist for video %s.", frame_dir, video.uuid)
+        logger.warning(
+            "Frame directory %s does not exist for video %s.",
+            frame_dir,
+            video.video_hash,
+        )
         return []
 
     frame_paths = list(frame_dir.glob("frame_*.jpg"))
@@ -22,7 +26,15 @@ def _get_frame_paths(video: "VideoFile") -> List[Path]:
     try:
         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.")
+        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."
+        )
         return frame_paths
     return frame_paths

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

@@ -9,7 +9,9 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-def _get_frame_range(video: "VideoFile", start_frame_number: int, end_frame_number: int) -> "QuerySet[Frame]":
+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
 
@@ -20,7 +22,10 @@ def _get_frame_range(video: "VideoFile", start_frame_number: int, end_frame_numb
             frame_number__lte=end_frame_number,
         ).order_by("frame_number")
     except AttributeError:
-        logger.error("Could not access frame range for video %s via related manager.", video.uuid)
+        logger.error(
+            "Could not access frame range for video %s via related manager.",
+            video.video_hash,
+        )
         # Fallback query
         return Frame.objects.filter(
             video_file=video,
@@ -28,5 +33,12 @@ def _get_frame_range(video: "VideoFile", start_frame_number: int, end_frame_numb
             frame_number__lte=end_frame_number,
         ).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)
+        logger.error(
+            "Error getting frame range (%d-%d) for video %s: %s",
+            start_frame_number,
+            end_frame_number,
+            video.video_hash,
+            e,
+            exc_info=True,
+        )
         return Frame.objects.none()  # Return empty queryset on error

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

@@ -17,9 +17,14 @@ def _get_frames(video: "VideoFile") -> "QuerySet[Frame]":
         # Access related manager directly
         return video.frames.order_by("frame_number")
     except AttributeError:
-        logger.error("Could not access frames for video %s. 'frames' related manager not found.", video.uuid)
+        logger.error(
+            "Could not access frames for video %s. 'frames' related manager not found.",
+            video.video_hash,
+        )
         # Fallback query
         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)
+        logger.error(
+            "Error getting frames for video %s: %s", video.video_hash, e, exc_info=True
+        )
         return Frame.objects.none()  # Return empty queryset on error

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

@@ -32,29 +32,54 @@ def _initialize_frames(video: "VideoFile", frame_paths: Optional[List[Path]] = N
         - On Failure: Does not change state (error is raised).
     """
     from endoreg_db.models import Frame
-    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
+    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
 
     if frame_paths:
-        logger.info("Initializing Frame objects based on %d provided paths for video %s.", len(frame_paths), video.uuid)
+        logger.info(
+            "Initializing Frame objects based on %d provided paths for video %s.",
+            len(frame_paths),
+            video.video_hash,
+        )
         mark_as_extracted = True
         num_expected_or_provided = len(frame_paths)
-        for frame_path in tqdm(frame_paths, desc=f"Initializing Frames from Paths {video.uuid}", unit="frame"):
+        for frame_path in tqdm(
+            frame_paths,
+            desc=f"Initializing Frames from Paths {video.video_hash}",
+            unit="frame",
+        ):
             try:
                 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)
+                logger.warning(
+                    "Could not parse frame number from %s: %s", frame_path.name, e
+                )
                 continue
     else:
         expected_frame_count = video.frame_count
         if expected_frame_count is None or expected_frame_count <= 0:
-            logger.warning("Cannot initialize frames for video %s: Frame count is %s.", video.uuid, expected_frame_count)
+            logger.warning(
+                "Cannot initialize frames for video %s: Frame count is %s.",
+                video.video_hash,
+                expected_frame_count,
+            )
             try:
                 state = video.get_or_create_state()
                 if state.frames_initialized or state.frame_count is not None:
@@ -62,53 +87,109 @@ def _initialize_frames(video: "VideoFile", frame_paths: Optional[List[Path]] = N
                     state.frame_count = None
                     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)
+                logger.error(
+                    "Failed to reset state during empty initialization for video %s: %s",
+                    video.video_hash,
+                    state_e,
+                    exc_info=True,
+                )
             return
 
-        logger.info("Initializing %d expected Frame objects for video %s (is_extracted=False).", expected_frame_count, video.uuid)
+        logger.info(
+            "Initializing %d expected Frame objects for video %s (is_extracted=False).",
+            expected_frame_count,
+            video.video_hash,
+        )
         mark_as_extracted = False
         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"):
+        for frame_number in tqdm(
+            range(expected_frame_count),
+            desc=f"Initializing Expected Frames {video.video_hash}",
+            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)
-                logger.info("Bulk create attempted for %d Frame objects for video %s (ignore_conflicts=True).", num_created_or_ignored, video.uuid)
+                logger.info(
+                    "Bulk create attempted for %d Frame objects for video %s (ignore_conflicts=True).",
+                    num_created_or_ignored,
+                    video.video_hash,
+                )
 
                 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)
+                            logger.info(
+                                "Marked %d existing Frame objects as is_extracted=True for video %s.",
+                                update_count,
+                                video.video_hash,
+                            )
 
                 try:
                     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"])
-                    logger.info("Set frames_initialized=True and frame_count=%d for video %s.", num_expected_or_provided, video.uuid)
+                    logger.info(
+                        "Set frames_initialized=True and frame_count=%d for video %s.",
+                        num_expected_or_provided,
+                        video.video_hash,
+                    )
                 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)
-                    raise RuntimeError(f"Failed to update state after frame initialization for video {video.uuid}") from state_e
+                    logger.error(
+                        "Failed to update state after frame initialization for video %s: %s",
+                        video.video_hash,
+                        state_e,
+                        exc_info=True,
+                    )
+                    raise RuntimeError(
+                        f"Failed to update state after frame initialization for video {video.video_hash}"
+                    ) from state_e
 
             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)
+                    logger.warning(
+                        "Database is locked, retrying frame initialization for video %s (attempt %d/5).",
+                        video.video_hash,
+                        attempt + 1,
+                    )
                     time.sleep(2**attempt)
                     if attempt < 4:
                         continue
                     else:
-                        raise RuntimeError(f"Failed to initialize frames for video {video.uuid}.") from e
-                logger.error("Error initializing frames for video %s: %s", video.uuid, e, exc_info=True)
-                raise RuntimeError(f"Failed to initialize frames for video {video.uuid}.") from e
+                        raise RuntimeError(
+                            f"Failed to initialize frames for video {video.video_hash}."
+                        ) from e
+                logger.error(
+                    "Error initializing frames for video %s: %s",
+                    video.video_hash,
+                    e,
+                    exc_info=True,
+                )
+                raise RuntimeError(
+                    f"Failed to initialize frames for video {video.video_hash}."
+                ) from e
 
     else:
-        logger.warning("No valid frames found/generated to initialize for video %s.", video.uuid)
+        logger.warning(
+            "No valid frames found/generated to initialize for video %s.",
+            video.video_hash,
+        )
         try:
             state = video.get_or_create_state()
             if state.frames_initialized or state.frame_count is not None:
@@ -116,4 +197,9 @@ def _initialize_frames(video: "VideoFile", frame_paths: Optional[List[Path]] = N
                 state.frame_count = None
                 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)
+            logger.error(
+                "Failed to reset state during empty initialization for video %s: %s",
+                video.video_hash,
+                state_e,
+                exc_info=True,
+            )