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_meta/get_endo_roi.py

@@ -15,7 +15,9 @@ def _get_endo_roi(video: "VideoFile") -> Optional[Dict[str, int]]:
     Returns None if VideoMeta is not linked or ROI is not properly defined.
     """
     if not video.video_meta:
-        logger.warning("VideoMeta not linked for video %s. Cannot get endo ROI.", video.uuid)
+        logger.warning(
+            "VideoMeta not linked for video %s. Cannot get endo ROI.", video.video_hash
+        )
         return None
 
     try:
@@ -25,17 +27,36 @@ def _get_endo_roi(video: "VideoFile") -> Optional[Dict[str, int]]:
         if (
             isinstance(endo_roi, dict)
             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())
+            and all(
+                isinstance(v, int) and not isinstance(v, bool)
+                for v in endo_roi.values()
+            )
         ):
-            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)
+            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.video_hash, 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)
+            logger.warning(
+                "Endo ROI not fully defined or invalid in VideoMeta for video %s. ROI: %s",
+                video.video_hash,
+                endo_roi,
+            )
             return None
     except AttributeError:
-        logger.error("VideoMeta object for video %s does not have a 'get_endo_roi' method.", video.uuid)
+        logger.error(
+            "VideoMeta object for video %s does not have a 'get_endo_roi' method.",
+            video.video_hash,
+        )
         return None
     except Exception as e:
-        logger.error("Error getting endo ROI from VideoMeta for video %s: %s", video.uuid, e, exc_info=True)
+        logger.error(
+            "Error getting endo ROI from VideoMeta for video %s: %s",
+            video.video_hash,
+            e,
+            exc_info=True,
+        )
         return None

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

@@ -45,10 +45,10 @@ def _get_fps(video: "VideoFile") -> float:
     if video.fps is not None:
         return video.fps
 
-    logger.debug("FPS not set on instance %s, checking VideoMeta.", video.uuid)
+    logger.debug("FPS not set on instance %s, checking VideoMeta.", video.video_hash)
 
     if not video.video_meta:
-        logger.info("VideoMeta not linked for %s, attempting update.", video.uuid)
+        logger.info("VideoMeta not linked for %s, attempting update.", video.video_hash)
 
         _update_video_meta(video, save_instance=True)  # Call the helper function
 
@@ -56,20 +56,33 @@ def _get_fps(video: "VideoFile") -> float:
     if video.fps is not None:
         return video.fps
     elif video.video_meta and video.video_meta.fps is not None:
-        logger.info("Retrieved FPS %.2f from VideoMeta for %s.", video.video_meta.fps, video.uuid)
+        logger.info(
+            "Retrieved FPS %.2f from VideoMeta for %s.",
+            video.video_meta.fps,
+            video.video_hash,
+        )
         _fps = video.video_meta.fps
         try:
             _fps = float(_fps)
         except (TypeError, ValueError):
-            logger.warning("Invalid FPS value %.2f in VideoMeta for video %s.", video.video_meta.fps, video.uuid)
-            raise ValueError(f"Could not determine FPS for video {video.uuid} due to invalid VideoMeta FPS value.")
+            logger.warning(
+                "Invalid FPS value %.2f in VideoMeta for video %s.",
+                video.video_meta.fps,
+                video.video_hash,
+            )
+            raise ValueError(
+                f"Could not determine FPS for video {video.video_hash} due to invalid VideoMeta FPS value."
+            )
         video.fps = _fps
         # Avoid saving if called from within the save method itself
         if not getattr(video, "_saving", False):
             video.save(update_fields=["fps"])
         return _fps
     else:
-        logger.warning("Could not determine FPS from VideoMeta for video %s. Trying direct raw file access.", video.uuid)
+        logger.warning(
+            "Could not determine FPS from VideoMeta for video %s. Trying direct raw file access.",
+            video.video_hash,
+        )
         try:
             if video.has_raw:
                 video_path = video.get_raw_file_path()  # Use helper
@@ -88,23 +101,39 @@ def _get_fps(video: "VideoFile") -> float:
                         cap.release()
                     if fps and fps > 0:
                         video.fps = fps
-                        logger.info("Determined FPS %.2f directly from file for %s.", video.fps, video.uuid)
+                        logger.info(
+                            "Determined FPS %.2f directly from file for %s.",
+                            video.fps,
+                            video.video_hash,
+                        )
                         if not getattr(video, "_saving", False):
                             video.save(update_fields=["fps"])
                         return fps
                     else:
-                        logger.warning("Could not determine a valid FPS for video file %s.", video_path)
+                        logger.warning(
+                            "Could not determine a valid FPS for video file %s.",
+                            video_path,
+                        )
                 elif video_path:
-                    logger.warning("Raw file path %s does not exist for direct FPS check.", video_path)
+                    logger.warning(
+                        "Raw file path %s does not exist for direct FPS check.",
+                        video_path,
+                    )
                 else:
                     logger.warning("Raw file path is None for direct FPS check.")
             else:
                 logger.warning("Raw file not available for direct FPS check.")
 
         except Exception as e:
-            logger.error("Error getting FPS directly from file %s: %s", video.raw_file.name if video.has_raw else "N/A", e)
+            logger.error(
+                "Error getting FPS directly from file %s: %s",
+                video.raw_file.name if video.has_raw else "N/A",
+                e,
+            )
 
-        raise ValueError(f"Could not determine FPS for video {video.uuid}. Ensure the video file is valid and accessible.")
+        raise ValueError(
+            f"Could not determine FPS for video {video.video_hash}. Ensure the video file is valid and accessible."
+        )
 
 
 # TODO Refactor to utils / check if similar function exists in utils
@@ -132,7 +161,9 @@ def _calculate_fps_manually(cap, video_path: Path) -> float:
     Returns:
         float: The estimated FPS, or 0.0 if the duration is zero or calculation fails.
     """
-    logger.warning(f"Could not get a valid FPS for {video_path}. Trying to calculate manually.")
+    logger.warning(
+        f"Could not get a valid FPS for {video_path}. Trying to calculate manually."
+    )
     # This is less accurate and slower
     num_frames = 0
     start_time = cv2.getTickCount()
@@ -146,5 +177,7 @@ def _calculate_fps_manually(cap, video_path: Path) -> float:
     if seconds > 0:
         return num_frames / seconds
 
-    logger.error(f"Manual FPS calculation failed for {video_path} due to zero duration.")
+    logger.error(
+        f"Manual FPS calculation failed for {video_path} due to zero duration."
+    )
     return 0.0

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

@@ -31,24 +31,38 @@ def _initialize_video_specs(video: "VideoFile", use_raw: bool = True) -> bool:
         video_path = video.active_file_path  # Use property relying on IO helpers
         target_file_name = video.active_file.name
     else:
-        logger.error("No suitable video file found for spec initialization for %s.", video.uuid)
+        logger.error(
+            "No suitable video file found for spec initialization for %s.",
+            video.video_hash,
+        )
         return False
 
     if not video_path:
         # Raise exception
-        raise FileNotFoundError(f"Could not determine video file path for spec initialization for {video.uuid}.")
-
-    logger.info("Initializing video specs directly from file %s (%s) for %s", target_file_name, video_path, video.uuid)
+        raise FileNotFoundError(
+            f"Could not determine video file path for spec initialization for {video.video_hash}."
+        )
+
+    logger.info(
+        "Initializing video specs directly from file %s (%s) for %s",
+        target_file_name,
+        video_path,
+        video.video_hash,
+    )
     try:
         if not video_path.exists():
             # Raise exception
-            raise FileNotFoundError(f"Video file not found at {video_path} for spec initialization (Video: {video.uuid}).")
+            raise FileNotFoundError(
+                f"Video file not found at {video_path} for spec initialization (Video: {video.video_hash})."
+            )
 
         video_cap = cv2.VideoCapture(video_path.as_posix())
         if not video_cap.isOpened():
             # Raise exception
             video_cap.release()  # Ensure release
-            raise RuntimeError(f"Could not open video file {video_path} with OpenCV for spec initialization (Video: {video.uuid}).")
+            raise RuntimeError(
+                f"Could not open video file {video_path} with OpenCV for spec initialization (Video: {video.video_hash})."
+            )
 
         updated = False
         fields_to_update = []
@@ -67,8 +81,16 @@ def _initialize_video_specs(video: "VideoFile", use_raw: bool = True) -> bool:
             file_height = int(video_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
             file_frame_count = int(video_cap.get(cv2.CAP_PROP_FRAME_COUNT))
         except Exception as cv_err:
-            logger.error("Error getting properties from OpenCV for %s (Video: %s): %s", video_path, video.uuid, cv_err, exc_info=True)
-            raise RuntimeError(f"OpenCV failed to get properties for {video_path}") from cv_err
+            logger.error(
+                "Error getting properties from OpenCV for %s (Video: %s): %s",
+                video_path,
+                video.video_hash,
+                cv_err,
+                exc_info=True,
+            )
+            raise RuntimeError(
+                f"OpenCV failed to get properties for {video_path}"
+            ) from cv_err
         finally:
             video_cap.release()  # Ensure release after getting props
 
@@ -96,42 +118,81 @@ def _initialize_video_specs(video: "VideoFile", use_raw: bool = True) -> bool:
             video.frame_count = file_frame_count
             fields_to_update.append("frame_count")
             updated = True
-        elif file_frame_count is None or file_frame_count <= 0:  # Log if not updated due to invalid file_frame_count
-            logger.warning("Invalid frame count (value: %s) obtained from OpenCV for %s. Video frame_count not updated.", file_frame_count, video_path)
+        elif (
+            file_frame_count is None or file_frame_count <= 0
+        ):  # Log if not updated due to invalid file_frame_count
+            logger.warning(
+                "Invalid frame count (value: %s) obtained from OpenCV for %s. Video frame_count not updated.",
+                file_frame_count,
+                video_path,
+            )
 
         # --- Update Duration ---
         if current_duration is None:  # Only if duration isn't already set
             # Use the potentially updated video.frame_count and current_fps (which reflects video.fps or file_fps)
             final_frame_count_for_duration = video.frame_count
-            final_fps_for_duration = current_fps  # This is video.fps after potential update from file_fps
-
-            if final_frame_count_for_duration and final_frame_count_for_duration > 0 and final_fps_for_duration and final_fps_for_duration > 0:
+            final_fps_for_duration = (
+                current_fps  # This is video.fps after potential update from file_fps
+            )
+
+            if (
+                final_frame_count_for_duration
+                and final_frame_count_for_duration > 0
+                and final_fps_for_duration
+                and final_fps_for_duration > 0
+            ):
                 video.duration = final_frame_count_for_duration / final_fps_for_duration
                 fields_to_update.append("duration")
                 updated = True
             else:
                 # Log if duration could not be calculated, indicating which component was missing/invalid
-                if not (final_frame_count_for_duration and final_frame_count_for_duration > 0):
+                if not (
+                    final_frame_count_for_duration
+                    and final_frame_count_for_duration > 0
+                ):
                     logger.warning(
-                        "Duration not calculated for %s: frame count is unavailable or invalid (value: %s).", video_path, final_frame_count_for_duration
+                        "Duration not calculated for %s: frame count is unavailable or invalid (value: %s).",
+                        video_path,
+                        final_frame_count_for_duration,
                     )
                 if not (final_fps_for_duration and final_fps_for_duration > 0):
-                    logger.warning("Duration not calculated for %s: FPS is unavailable or invalid (value: %s).", video_path, final_fps_for_duration)
+                    logger.warning(
+                        "Duration not calculated for %s: FPS is unavailable or invalid (value: %s).",
+                        video_path,
+                        final_fps_for_duration,
+                    )
 
         # --- Save if updated ---
         if updated:
-            logger.info("Updated video specs for %s from file %s: %s", video.uuid, target_file_name, ", ".join(fields_to_update))
+            logger.info(
+                "Updated video specs for %s from file %s: %s",
+                video.video_hash,
+                target_file_name,
+                ", ".join(fields_to_update),
+            )
             video.save(update_fields=fields_to_update)
             return True
         else:
-            logger.info("No video specs needed updating for %s from file %s.", video.uuid, target_file_name)
+            logger.info(
+                "No video specs needed updating for %s from file %s.",
+                video.video_hash,
+                target_file_name,
+            )
             return True
 
     except Exception as e:
         # Log and re-raise exception
-        logger.error("Error initializing video specs for %s from file %s: %s", video.uuid, video_path, e, exc_info=True)
+        logger.error(
+            "Error initializing video specs for %s from file %s: %s",
+            video.video_hash,
+            video_path,
+            e,
+            exc_info=True,
+        )
         # Ensure capture is released in case of unexpected error
         if "video_cap" in locals() and video_cap.isOpened():
             video_cap.release()
         # Re-raise as RuntimeError
-        raise RuntimeError(f"Failed to initialize video specs for {video.uuid} from {video_path}") from e
+        raise RuntimeError(
+            f"Failed to initialize video specs for {video.video_hash} from {video_path}"
+        ) from e

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

@@ -10,6 +10,7 @@ from ....metadata.sensitive_meta_logic import update_or_create_sensitive_meta_fr
 
 if TYPE_CHECKING:
     from ..video_file import VideoFile
+
     # SensitiveMeta is already imported above
 
 logger = logging.getLogger(__name__)
@@ -31,35 +32,46 @@ def _update_text_metadata(
         - Pre-condition: Requires state.frames_extracted=True.
         - Post-condition: Sets state.text_meta_extracted=True (even if no text found).
     """
-    logger.debug(f"Updating text metadata for video {video.uuid}")
+    logger.debug(f"Updating text metadata for video {video.video_hash}")
     state = video.get_or_create_state()
 
     # --- Pre-condition Checks ---
     if not state.frames_extracted:
         # Attempt to extract frames automatically if they're not available
-        logger.warning(f"Frames not extracted for video {video.uuid}. Attempting automatic frame extraction...")
+        logger.warning(
+            f"Frames not extracted for video {video.video_hash}. Attempting automatic frame extraction..."
+        )
         try:
             success = video.extract_frames(overwrite=False)
         except (FileNotFoundError, RuntimeError, ValueError, OSError) as exc:
             logger.error(
                 "Failed to extract frames for video %s: %s",
-                video.uuid,
+                video.video_hash,
                 exc,
                 exc_info=True,
             )
-            raise ValueError(f"Cannot update text metadata for video {video.uuid}: Frames not extracted and automatic extraction failed") from exc
+            raise ValueError(
+                f"Cannot update text metadata for video {video.video_hash}: Frames not extracted and automatic extraction failed"
+            ) from exc
 
         if not success:
-            raise ValueError(f"Cannot update text metadata for video {video.uuid}: Frame extraction returned False")
+            raise ValueError(
+                f"Cannot update text metadata for video {video.video_hash}: Frame extraction returned False"
+            )
 
         state.refresh_from_db()
         if not state.frames_extracted:
-            raise ValueError(f"Cannot update text metadata for video {video.uuid}: Frame extraction completed but state was not updated")
+            raise ValueError(
+                f"Cannot update text metadata for video {video.video_hash}: Frame extraction completed but state was not updated"
+            )
 
-        logger.info(f"Successfully extracted frames for video {video.uuid}")
+        logger.info(f"Successfully extracted frames for video {video.video_hash}")
 
     if state.text_meta_extracted and not overwrite:
-        logger.info("Text already extracted for video %s and overwrite=False. Skipping.", video.uuid)  # Changed to info
+        logger.info(
+            "Text already extracted for video %s and overwrite=False. Skipping.",
+            video.video_hash,
+        )  # Changed to info
         return video.sensitive_meta  # Return existing meta if available
     # --- End Pre-condition Checks ---
 
@@ -67,10 +79,19 @@ def _update_text_metadata(
     # _extract_text_from_video_frames raises ValueError on pre-condition failure
     try:
         if not extracted_data_dict:
-            extracted_data_dict = video.extract_text_from_frames(frame_fraction=ocr_frame_fraction, cap=cap)
+            extracted_data_dict = video.extract_text_from_frames(
+                frame_fraction=ocr_frame_fraction, cap=cap
+            )
     except Exception as text_extract_e:
-        logger.error("Failed during text extraction step for video %s: %s", video.uuid, text_extract_e, exc_info=True)
-        raise RuntimeError(f"Text extraction failed for video {video.uuid}") from text_extract_e
+        logger.error(
+            "Failed during text extraction step for video %s: %s",
+            video.video_hash,
+            text_extract_e,
+            exc_info=True,
+        )
+        raise RuntimeError(
+            f"Text extraction failed for video {video.video_hash}"
+        ) from text_extract_e
 
     # --- Atomic Update Block ---
     try:
@@ -80,7 +101,10 @@ def _update_text_metadata(
             sensitive_meta_instance = video.sensitive_meta  # Get current instance
 
             if not extracted_data_dict:
-                logger.warning("No text extracted for video %s; skipping SensitiveMeta update.", video.uuid)
+                logger.warning(
+                    "No text extracted for video %s; skipping SensitiveMeta update.",
+                    video.video_hash,
+                )
                 # Mark state as retrieved even if no data found, to avoid re-running unless overwrite=True
                 if not state.text_meta_extracted:
                     state.text_meta_extracted = True
@@ -90,7 +114,11 @@ def _update_text_metadata(
             # Add center info if not already present in extracted data
             if "center_name" not in extracted_data_dict and video.center:
                 extracted_data_dict["center_name"] = video.center.name
-            logger.debug("Data for SensitiveMeta update for video %s: %s", video.uuid, extracted_data_dict)
+            logger.debug(
+                "Data for SensitiveMeta update for video %s: %s",
+                video.video_hash,
+                extracted_data_dict,
+            )
 
             # Pass the Class, the data dict, and the current instance (or None)
             # This function might raise exceptions if data is invalid
@@ -102,7 +130,9 @@ def _update_text_metadata(
 
             # Update VideoFile fields if necessary
             update_fields_video = []
-            if created or sensitive_meta != sensitive_meta_instance:  # Check if relation needs update
+            if (
+                created or sensitive_meta != sensitive_meta_instance
+            ):  # Check if relation needs update
                 video.sensitive_meta = sensitive_meta
                 update_fields_video.append("sensitive_meta")
 
@@ -111,7 +141,6 @@ def _update_text_metadata(
                 if extracted_date:  # Ensure date is not None or empty
                     video.date = extracted_date
                     update_fields_video.append("date")
-                    
 
             # Save VideoFile if fields changed
             if update_fields_video:
@@ -125,13 +154,25 @@ def _update_text_metadata(
             # Mark sensitive meta as processed when updated via text metadata
             if sensitive_meta:
                 state.mark_sensitive_meta_processed(save=True)
-                logger.info(f"Marked sensitive_meta_processed=True for video {video.uuid} after text metadata update")
-
-            logger.info("Successfully updated/created SensitiveMeta and state for video %s.", video.uuid)  # Changed to info
+                logger.info(
+                    f"Marked sensitive_meta_processed=True for video {video.video_hash} after text metadata update"
+                )
+
+            logger.info(
+                "Successfully updated/created SensitiveMeta and state for video %s.",
+                video.video_hash,
+            )  # Changed to info
             return sensitive_meta
 
     except Exception as e:
-        logger.error("Failed to update/create SensitiveMeta or state for video %s: %s", video.uuid, e, exc_info=True)
+        logger.error(
+            "Failed to update/create SensitiveMeta or state for video %s: %s",
+            video.video_hash,
+            e,
+            exc_info=True,
+        )
         # Re-raise exception for the pipeline to catch
-        raise RuntimeError(f"Failed to update/create SensitiveMeta or state for video {video.uuid}") from e
+        raise RuntimeError(
+            f"Failed to update/create SensitiveMeta or state for video {video.video_hash}"
+        ) from e
     # --- End Atomic Update Block ---

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

@@ -14,12 +14,14 @@ def _update_video_meta(video: "VideoFile", save_instance: bool = True):
     """
     from ....metadata import VideoMeta  # Local import
 
-    logger.debug("Updating technical VideoMeta for video %s (from raw file).", video.uuid)
+    logger.debug(
+        "Updating technical VideoMeta for video %s (from raw file).", video.video_hash
+    )
 
     if not video.has_raw:
         # DEFENSIVE: Log warning and skip instead of crashing
         logger.warning(
-            f"Raw video file path not available for {video.uuid}. Skipping VideoMeta update - this may indicate the video was processed and raw file moved."
+            f"Raw video file path not available for {video.video_hash}. Skipping VideoMeta update - this may indicate the video was processed and raw file moved."
         )
         return  # Graceful skip instead of FileNotFoundError
 
@@ -27,22 +29,30 @@ def _update_video_meta(video: "VideoFile", save_instance: bool = True):
     if not raw_video_path or not raw_video_path.exists():
         # DEFENSIVE: Log warning and skip instead of crashing production pipeline
         logger.warning(
-            f"Raw video file path {raw_video_path} does not exist for video {video.uuid}. Skipping VideoMeta update - this typically happens after video processing when raw files are moved to processed location."
+            f"Raw video file path {raw_video_path} does not exist for video {video.video_hash}. Skipping VideoMeta update - this typically happens after video processing when raw files are moved to processed location."
         )
         return  # Graceful skip instead of FileNotFoundError that crashes production
 
     try:
         vm = video.video_meta
         if vm:
-            logger.info("Updating existing VideoMeta (PK: %s) for video %s.", vm.pk, video.uuid)
-            vm.update_meta(raw_video_path)  # Assuming this method exists and raises on error
+            logger.info(
+                "Updating existing VideoMeta (PK: %s) for video %s.",
+                vm.pk,
+                video.video_hash,
+            )
+            vm.update_meta(
+                raw_video_path
+            )  # Assuming this method exists and raises on error
             vm.save()
         else:
             if not video.center or not video.processor:
                 # Raise exception
-                raise ValueError(f"Cannot create VideoMeta for {video.uuid}: Center or Processor is missing.")
+                raise ValueError(
+                    f"Cannot create VideoMeta for {video.video_hash}: Center or Processor is missing."
+                )
 
-            logger.info("Creating new VideoMeta for video %s.", video.uuid)
+            logger.info("Creating new VideoMeta for video %s.", video.video_hash)
             # Assuming create_from_file exists and raises on error
             video.video_meta = VideoMeta.create_from_file(
                 video_path=raw_video_path,
@@ -52,7 +62,11 @@ def _update_video_meta(video: "VideoFile", save_instance: bool = True):
             )
             vm = video.video_meta
             assert vm is not None  # For type checker
-            logger.info("Created and linked VideoMeta (PK: %s) for video %s.", vm.pk, video.uuid)
+            logger.info(
+                "Created and linked VideoMeta (PK: %s) for video %s.",
+                vm.pk,
+                video.video_hash,
+            )
 
         # Save the VideoFile instance itself if requested and if video_meta was linked/updated
         if save_instance:
@@ -62,16 +76,30 @@ def _update_video_meta(video: "VideoFile", save_instance: bool = True):
                 meta_fields = ["fps", "duration", "frame_count", "width", "height"]
                 for field in meta_fields:
                     # Check if field is None on video but has value on meta
-                    if getattr(video, field) is None and getattr(video.video_meta, field, None) is not None:
+                    if (
+                        getattr(video, field) is None
+                        and getattr(video.video_meta, field, None) is not None
+                    ):
                         # No need to set attribute here, save method handles it
                         update_fields.append(field)
             # Ensure update_fields has unique values before saving
             unique_update_fields = list(set(update_fields))
             if unique_update_fields:
                 video.save(update_fields=unique_update_fields)
-                logger.info("Saved video %s after VideoMeta update (Fields: %s).", video.uuid, unique_update_fields)
+                logger.info(
+                    "Saved video %s after VideoMeta update (Fields: %s).",
+                    video.video_hash,
+                    unique_update_fields,
+                )
 
     except Exception as e:
-        logger.error("Failed to update/create VideoMeta for video %s: %s", video.uuid, e, exc_info=True)
+        logger.error(
+            "Failed to update/create VideoMeta for video %s: %s",
+            video.video_hash,
+            e,
+            exc_info=True,
+        )
         # Re-raise exception
-        raise RuntimeError(f"Failed to update/create VideoMeta for video {video.uuid}") from e
+        raise RuntimeError(
+            f"Failed to update/create VideoMeta for video {video.video_hash}"
+        ) from e