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

@@ -1,6 +1,5 @@
 import logging
 import shutil
-import uuid
 from pathlib import Path
 from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple
 
@@ -53,48 +52,92 @@ def _create_anonymized_frame_files(
     generated_paths = []
     frame_iterator = frames.filter(is_extracted=True).iterator()
     total_frames = frames.filter(is_extracted=True).count()
-    progress_bar = tqdm(frame_iterator, total=total_frames, desc=f"Anonymizing frames for {video.uuid}")
+    progress_bar = tqdm(
+        frame_iterator,
+        total=total_frames,
+        desc=f"Anonymizing frames for {video.video_hash}",
+    )
 
     for frame_obj in progress_bar:
         try:
             _frame_number = frame_obj.frame_number
-            target_path = anonymized_frame_dir / f"frame_{frame_obj.frame_number:07d}.jpg"
+            target_path = (
+                anonymized_frame_dir / f"frame_{frame_obj.frame_number:07d}.jpg"
+            )
             make_all_black = frame_obj.frame_number in outside_frame_numbers
 
             try:
                 source_path = frame_obj.file_path
                 if not isinstance(source_path, Path):
-                    raise TypeError(f"Frame.file_path did not return a Path object for frame {frame_obj.frame_number}")
+                    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
+                    "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
+                raise RuntimeError(
+                    f"Failed to get source path for frame {frame_obj.frame_number}"
+                ) from path_err
 
             if not source_path.exists():
                 error_msg = (
                     f"CRITICAL INCONSISTENCY: Source frame file missing for frame {frame_obj.frame_number} "
-                    f"(PK: {frame_obj.pk}, Path: {source_path}) despite is_extracted=True for video {video.uuid}. "
+                    f"(PK: {frame_obj.pk}, Path: {source_path}) despite is_extracted=True for video {video.video_hash}. "
                     f"Halting anonymization."
                 )
                 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:
-            logger.error("Error anonymizing frame %d (PK: %s): %s", frame_obj.frame_number, frame_obj.pk, e, exc_info=True)
-            raise RuntimeError(f"Failed to anonymize frame {frame_obj.frame_number}") from e
+        except (
+            FileNotFoundError,
+            IOError,
+            ValueError,
+            AttributeError,
+            TypeError,
+            Exception,
+        ) as e:
+            logger.error(
+                "Error anonymizing frame %d (PK: %s): %s",
+                frame_obj.frame_number,
+                frame_obj.pk,
+                e,
+                exc_info=True,
+            )
+            raise RuntimeError(
+                f"Failed to anonymize frame {frame_obj.frame_number}"
+            ) from e
 
     if len(generated_paths) != total_frames:
-        logger.error("Mismatch in generated frames count. Expected %d, got %d.", total_frames, len(generated_paths))
-        raise RuntimeError("Anonymized frame generation resulted in incorrect number of files.")
+        logger.error(
+            "Mismatch in generated frames count. Expected %d, got %d.",
+            total_frames,
+            len(generated_paths),
+        )
+        raise RuntimeError(
+            "Anonymized frame generation resulted in incorrect number of files."
+        )
 
     return generated_paths
 
 
-def _censor_outside_frames(video: "VideoFile", outside_label_name: str = "outside", censor_color: Tuple[int, int, int] = (0, 0, 0)) -> bool:
+def _censor_outside_frames(
+    video: "VideoFile",
+    outside_label_name: str = "outside",
+    censor_color: Tuple[int, int, int] = (0, 0, 0),
+) -> bool:
     """
     Overwrites frame files marked as 'outside' with a censored version (e.g., black).
     This modifies the original raw frames directly. Use with caution. Requires frames to be extracted.
@@ -104,14 +147,21 @@ def _censor_outside_frames(video: "VideoFile", outside_label_name: str = "outsid
         - Pre-condition: Requires state.frames_extracted=True.
         - Post-condition: No state changes.
     """
-    logger.warning("Starting direct censoring of 'outside' frames for video %s. This modifies raw frame files.", video.uuid)
+    logger.warning(
+        "Starting direct censoring of 'outside' frames for video %s. This modifies raw frame files.",
+        video.video_hash,
+    )
     state = video.get_or_create_state()
     if not state.frames_extracted:
-        raise ValueError(f"Frames not extracted for video {video.uuid}. Cannot censor.")
+        raise ValueError(
+            f"Frames not extracted for video {video.video_hash}. Cannot censor."
+        )
 
     outside_frames = _get_outside_frames(video, outside_label_name)
     if not outside_frames:
-        logger.info("No 'outside' frames found to censor for video %s.", video.uuid)
+        logger.info(
+            "No 'outside' frames found to censor for video %s.", video.video_hash
+        )
         return True
 
     censored_count = 0
@@ -120,17 +170,24 @@ def _censor_outside_frames(video: "VideoFile", outside_label_name: str = "outsid
         try:
             frame_path = frame_obj.file_path
             if not frame_path:
-                logger.warning("Could not get file path for frame %d. Skipping censoring.", frame_obj.frame_number)
+                logger.warning(
+                    "Could not get file path for frame %d. Skipping censoring.",
+                    frame_obj.frame_number,
+                )
                 error_count += 1
                 continue
 
             if not frame_path.exists():
-                logger.warning("Frame file %s not found for censoring. Skipping.", frame_path)
+                logger.warning(
+                    "Frame file %s not found for censoring. Skipping.", frame_path
+                )
                 continue
 
             img = cv2.imread(str(frame_path))
             if img is None:
-                logger.warning("Could not read frame %s for censoring. Skipping.", frame_path)
+                logger.warning(
+                    "Could not read frame %s for censoring. Skipping.", frame_path
+                )
                 continue
 
             img[:] = censor_color
@@ -142,14 +199,27 @@ 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)
+    logger.info(
+        "Finished censoring for video %s. Censored: %d, Errors: %d",
+        video.video_hash,
+        censored_count,
+        error_count,
+    )
     return error_count == 0
 
 
-def _make_temporary_anonymized_frames(video: "VideoFile", roi_processing = True) -> 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.
@@ -159,43 +229,73 @@ def _make_temporary_anonymized_frames(video: "VideoFile", roi_processing = True)
         - Post-condition: No state changes directly by this function.
     """
     if video.is_processed:
-        raise ValueError(f"Cannot create temporary anonymized frames for video {video.uuid}: already processed.")
+        raise ValueError(
+            f"Cannot create temporary anonymized frames for video {video.video_hash}: already processed."
+        )
     if not video.has_raw:
-        raise ValueError(f"Cannot create temporary anonymized frames for video {video.uuid}: Raw file is missing.")
+        raise ValueError(
+            f"Cannot create temporary anonymized frames for video {video.video_hash}: Raw file is missing."
+        )
 
     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)
+    logger.info(
+        "Creating temporary anonymized frames for video %s in %s",
+        video.video_hash,
+        temp_anonym_frame_dir,
+    )
     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}")
+            raise ValueError(f"Endoscope ROI is not valid for video {video.video_hash}")
     else:
-        endo_roi = {"x": 0, "y": 0, "width": 0, "height": 0}  # Dummy ROI to skip processing
+        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:
-        logger.info("Raw frames not extracted for %s, extracting now.", video.uuid)
+        logger.info(
+            "Raw frames not extracted for %s, extracting now.", video.video_hash
+        )
         try:
             if not video.extract_frames(overwrite=False):
-                raise RuntimeError(f"Frame extraction method returned False unexpectedly for video {video.uuid}.")
+                raise RuntimeError(
+                    f"Frame extraction method returned False unexpectedly for video {video.video_hash}."
+                )
             state.refresh_from_db()
             if not state.frames_extracted:
-                raise RuntimeError(f"Frame extraction did not update state for video {video.uuid}, cannot create anonymized frames.")
+                raise RuntimeError(
+                    f"Frame extraction did not update state for video {video.video_hash}, cannot create anonymized frames."
+                )
         except Exception as extract_e:
-            logger.error("Frame extraction failed during anonymization prep for video %s: %s", video.uuid, extract_e, exc_info=True)
-            raise RuntimeError(f"Frame extraction failed for video {video.uuid}, cannot create anonymized frames.") from extract_e
+            logger.error(
+                "Frame extraction failed during anonymization prep for video %s: %s",
+                video.video_hash,
+                extract_e,
+                exc_info=True,
+            )
+            raise RuntimeError(
+                f"Frame extraction failed for video {video.video_hash}, cannot create anonymized frames."
+            ) from extract_e
 
     all_frames = video.get_frames()
     if not all_frames.exists():
-        raise FileNotFoundError(f"No frame objects found for video {video.uuid} after extraction attempt.")
+        raise FileNotFoundError(
+            f"No frame objects found for video {video.video_hash} after extraction attempt."
+        )
 
     outside_frame_numbers = _get_outside_frame_numbers(video)
 
-    logger.info("Generating %d temporary anonymized frame files for video %s...", all_frames.filter(is_extracted=True).count(), video.uuid)
+    logger.info(
+        "Generating %d temporary anonymized frame files for video %s...",
+        all_frames.filter(is_extracted=True).count(),
+        video.video_hash,
+    )
     generated_frame_paths = _create_anonymized_frame_files(
         video=video,
         anonymized_frame_dir=temp_anonym_frame_dir,
@@ -203,7 +303,11 @@ def _make_temporary_anonymized_frames(video: "VideoFile", roi_processing = True)
         frames=all_frames,
         outside_frame_numbers=outside_frame_numbers,
     )
-    logger.info("Generated %d temporary anonymized frame files for video %s.", len(generated_frame_paths), video.uuid)
+    logger.info(
+        "Generated %d temporary anonymized frame files for video %s.",
+        len(generated_frame_paths),
+        video.video_hash,
+    )
     return temp_anonym_frame_dir, generated_frame_paths
 
 
@@ -223,25 +327,38 @@ def _anonymize(video: "VideoFile", delete_original_raw: bool = True) -> bool:
     state = video.get_or_create_state()
 
     if state.anonymized:
-        logger.info("Video %s is already marked as anonymized in state. Skipping.", video.uuid)
+        logger.info(
+            "Video %s is already marked as anonymized in state. Skipping.",
+            video.video_hash,
+        )
         return True
     if not video.has_raw:
-        raise FileNotFoundError(f"Raw file is missing for video {video.uuid}, cannot anonymize.")
+        raise FileNotFoundError(
+            f"Raw file is missing for video {video.video_hash}, cannot anonymize."
+        )
     if not state.frames_extracted:
-        raise ValueError(f"Frames not extracted for video {video.uuid}, cannot anonymize.")
+        raise ValueError(
+            f"Frames not extracted for video {video.video_hash}, cannot anonymize."
+        )
     if not video.sensitive_meta or not video.sensitive_meta.is_verified:
-        raise ValueError(f"Sensitive metadata for video {video.uuid} is not validated. Cannot anonymize.")
+        raise ValueError(
+            f"Sensitive metadata for video {video.video_hash} 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)
+    logger.info("Starting anonymization process for video %s", video.video_hash)
 
     temp_anonym_frame_dir = None
     anonymized_video_path = None
     try:
-        temp_anonym_frame_dir, generated_frame_paths = _make_temporary_anonymized_frames(video)
+        temp_anonym_frame_dir, generated_frame_paths = (
+            _make_temporary_anonymized_frames(video)
+        )
         if not generated_frame_paths:
-            raise RuntimeError(f"Failed to generate temporary anonymized frames for video {video.uuid}.")
+            raise RuntimeError(
+                f"Failed to generate temporary anonymized frames for video {video.video_hash}."
+            )
 
         anonymized_video_path = video.get_target_anonymized_video_path()
         anonymized_video_path.parent.mkdir(parents=True, exist_ok=True)
@@ -250,9 +367,15 @@ def _anonymize(video: "VideoFile", delete_original_raw: bool = True) -> bool:
 
         fps = video.get_fps()
         if fps is None:
-            raise ValueError(f"FPS could not be determined for {video.uuid}, cannot assemble video.")
+            raise ValueError(
+                f"FPS could not be determined for {video.video_hash}, cannot assemble video."
+            )
 
-        logger.info("Assembling anonymized video for %s at %s", video.uuid, anonymized_video_path)
+        logger.info(
+            "Assembling anonymized video for %s at %s",
+            video.video_hash,
+            anonymized_video_path,
+        )
         assemble_video_from_frames(
             frame_paths=generated_frame_paths,
             output_path=anonymized_video_path,
@@ -260,14 +383,25 @@ def _anonymize(video: "VideoFile", delete_original_raw: bool = True) -> bool:
         )
 
         if not anonymized_video_path.exists():
-            raise RuntimeError(f"Processed video file not found after assembly for {video.uuid}: {anonymized_video_path}")
+            raise RuntimeError(
+                f"Processed video file not found after assembly for {video.video_hash}: {anonymized_video_path}"
+            )
 
         new_processed_hash = get_video_hash(anonymized_video_path)
-        if type(video).objects.filter(processed_video_hash=new_processed_hash).exclude(pk=video.pk).exists():
-            raise ValueError(f"Processed video hash {new_processed_hash} already exists for another video (Video: {video.uuid}).")
+        if (
+            type(video)
+            .objects.filter(processed_video_hash=new_processed_hash)
+            .exclude(pk=video.pk)
+            .exists()
+        ):
+            raise ValueError(
+                f"Processed video hash {new_processed_hash} already exists for another video (Video: {video.video_hash})."
+            )
 
         video.processed_video_hash = new_processed_hash
-        video.processed_file.name = video.get_target_anonymized_video_path().relative_to(STORAGE_DIR).as_posix()
+        video.processed_file.name = (
+            video.get_target_anonymized_video_path().relative_to(STORAGE_DIR).as_posix()
+        )
 
         update_fields = [
             "processed_video_hash",
@@ -285,7 +419,9 @@ def _anonymize(video: "VideoFile", delete_original_raw: bool = True) -> bool:
 
             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_hash=video.video_hash,
+                    raw_file_path=original_raw_file_path_to_delete,
+                    raw_frame_dir=original_raw_frame_dir_to_delete,
                 )
             )
 
@@ -296,19 +432,33 @@ def _anonymize(video: "VideoFile", delete_original_raw: bool = True) -> bool:
         return True
 
     except Exception as e:
-        logger.error("Anonymization failed for video %s: %s", video.uuid, e, exc_info=True)
+        logger.error(
+            "Anonymization failed for video %s: %s", video.video_hash, e, exc_info=True
+        )
         if anonymized_video_path and anonymized_video_path.exists():
-            logger.warning("Cleaning up potentially orphaned processed file for video %s due to error: %s", video.uuid, anonymized_video_path)
+            logger.warning(
+                "Cleaning up potentially orphaned processed file for video %s due to error: %s",
+                video.video_hash,
+                anonymized_video_path,
+            )
             anonymized_video_path.unlink(missing_ok=True)
-        raise RuntimeError(f"Anonymization failed for video {video.uuid}") from e
+        raise RuntimeError(f"Anonymization failed for video {video.video_hash}") from e
 
     finally:
         if temp_anonym_frame_dir and temp_anonym_frame_dir.exists():
-            logger.info("Cleaning up temporary anonymized frame directory for video %s: %s", video.uuid, temp_anonym_frame_dir)
+            logger.info(
+                "Cleaning up temporary anonymized frame directory for video %s: %s",
+                video.video_hash,
+                temp_anonym_frame_dir,
+            )
             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_hash: "str",
+    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,32 +468,57 @@ def _cleanup_raw_assets(video_uuid: uuid.UUID, raw_file_path: Optional[Path] = N
     """
     from endoreg_db.models import VideoFile, VideoState
 
-    logger.info("Performing post-commit cleanup of raw assets for video %s.", video_uuid)
+    logger.info(
+        "Performing post-commit cleanup of raw assets for video %s.", video_hash
+    )
     try:
-        video_file = VideoFile.objects.select_related("state").filter(uuid=video_uuid).first()
+        video_file = (
+            VideoFile.objects.select_related("state")
+            .filter(content_hash=video_hash)
+            .first()
+        )
         if not video_file:
-            logger.error("VideoFile %s not found during post-commit cleanup.", video_uuid)
+            logger.error(
+                "VideoFile %s not found during post-commit cleanup.", video_hash
+            )
             return
         if not video_file.state:
-            logger.error("VideoState not found for VideoFile %s during post-commit cleanup.", video_uuid)
+            logger.error(
+                "VideoState not found for VideoFile %s during post-commit cleanup.",
+                video_hash,
+            )
             video_file.state = VideoState.objects.create(video_file=video_file)
 
         if raw_file_path and raw_file_path.exists():
             logger.info("Deleting original raw video file: %s", raw_file_path)
             raw_file_path.unlink()
         elif raw_file_path:
-            logger.warning("Original raw video file %s not found for post-commit deletion.", raw_file_path)
+            logger.warning(
+                "Original raw video file %s not found for post-commit deletion.",
+                raw_file_path,
+            )
 
         if raw_frame_dir and raw_frame_dir.exists():
             logger.info("Deleting original raw frame directory: %s", raw_frame_dir)
             shutil.rmtree(raw_frame_dir, ignore_errors=True)
         elif raw_frame_dir:
-            logger.warning("Original raw frame directory %s not found for post-commit deletion.", raw_frame_dir)
+            logger.warning(
+                "Original raw frame directory %s not found for post-commit deletion.",
+                raw_frame_dir,
+            )
 
         if video_file.state.frames_extracted:
             video_file.state.frames_extracted = False
             video_file.state.save(update_fields=["frames_extracted"])
-            logger.info("Set state.frames_extracted=False for video %s after raw asset cleanup.", video_uuid)
+            logger.info(
+                "Set state.frames_extracted=False for video %s after raw asset cleanup.",
+                video_hash,
+            )
 
     except Exception as e:
-        logger.error("Error during post-commit cleanup of raw assets for video %s: %s", video_uuid, e, exc_info=True)
+        logger.error(
+            "Error during post-commit cleanup of raw assets for video %s: %s",
+            video_hash,
+            e,
+            exc_info=True,
+        )

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

@@ -16,5 +16,10 @@ def _bulk_create_frames(video: "VideoFile", frames_to_create: List["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)
+        logger.error(
+            "Error during bulk creation of frames for video %s: %s",
+            video.video_hash,
+            e,
+            exc_info=True,
+        )
         raise

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

@@ -9,7 +9,9 @@ logger = logging.getLogger(__name__)
 __all__ = ["_create_frame_object"]
 
 
-def _create_frame_object(video: "VideoFile", frame_number: int, relative_path: str, extracted: bool = False) -> "Frame":
+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

@@ -4,7 +4,10 @@ from typing import TYPE_CHECKING
 
 from django.db import transaction
 
-from endoreg_db.models.media.video.video_file_io import _get_frame_dir_path, _get_temp_anonymized_frame_dir
+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
@@ -44,7 +47,7 @@ def _delete_frames(video: "VideoFile") -> str:
         msg = f"Frame directory not found, skipping deletion: {frame_dir}"
         logger.debug(msg)
     else:
-        msg = f"Frame directory path not set for video {video.uuid}, cannot delete standard frames."
+        msg = f"Frame directory path not set for video {video.video_hash}, cannot delete standard frames."
         logger.warning(msg)
 
     temp_anonym_frame_dir = None
@@ -52,7 +55,9 @@ def _delete_frames(video: "VideoFile") -> str:
         temp_anonym_frame_dir = _get_temp_anonymized_frame_dir(video)
         if temp_anonym_frame_dir and temp_anonym_frame_dir.exists():
             shutil.rmtree(temp_anonym_frame_dir)
-            msg = f"Deleted temporary anonymized frame directory: {temp_anonym_frame_dir}"
+            msg = (
+                f"Deleted temporary anonymized frame directory: {temp_anonym_frame_dir}"
+            )
             logger.info(msg)
             deleted_messages.append(msg)
     except Exception as e:
@@ -69,16 +74,28 @@ def _delete_frames(video: "VideoFile") -> str:
 
         if update_fields_state:
             state.save(update_fields=update_fields_state)
-            logger.info("Reset frame state flags (%s) for video %s.", ", ".join(update_fields_state), video.uuid)
+            logger.info(
+                "Reset frame state flags (%s) for video %s.",
+                ", ".join(update_fields_state),
+                video.video_hash,
+            )
             state_updated = True
         else:
-            logger.info("Frame state flags already False for video %s.", video.uuid)
+            logger.info(
+                "Frame state flags already False for video %s.", video.video_hash
+            )
             state_updated = True
 
         try:
-            update_count = Frame.objects.filter(video=video, is_extracted=True).update(is_extracted=False)
+            update_count = Frame.objects.filter(video=video, is_extracted=True).update(
+                is_extracted=False
+            )
             if update_count > 0:
-                logger.info("Marked %d Frame objects as is_extracted=False for video %s.", update_count, video.uuid)
+                logger.info(
+                    "Marked %d Frame objects as is_extracted=False for video %s.",
+                    update_count,
+                    video.video_hash,
+                )
             db_updated = True
         except Exception as db_err:
             msg = f"Failed to update is_extracted flag for Frame objects for video %s: {db_err}"
@@ -87,10 +104,14 @@ def _delete_frames(video: "VideoFile") -> str:
             db_updated = False
 
     except Exception as state_e:
-        msg = f"Failed to update state after deleting frame files for video %s: {state_e}"
+        msg = (
+            f"Failed to update state after deleting frame files for video %s: {state_e}"
+        )
         logger.error(msg, exc_info=True)
         error_messages.append(msg)
-        raise RuntimeError(f"Failed to update state during frame file deletion for video {video.uuid}") from state_e
+        raise RuntimeError(
+            f"Failed to update state during frame file deletion for video {video.video_hash}"
+        ) from state_e
 
     final_message = "; ".join(deleted_messages)
     if error_messages: