endoreg-db 0.8.8.9__py3-none-any.whl → 0.8.9.2__py3-none-any.whl

endoreg_db/import_files/file_storage/state_management.py

@@ -1,7 +1,7 @@
 from endoreg_db.models.media.processing_history.processing_history import ProcessingHistory
 from endoreg_db.utils.paths import IMPORT_REPORT_DIR, IMPORT_VIDEO_DIR, ANONYM_REPORT_DIR, ANONYM_VIDEO_DIR
 
-
+import os
 import logging
 import shutil
 from pathlib import Path
@@ -187,6 +187,8 @@ def finalize_video_success(
     - Mark VideoState as anonymized + sensitive_meta_processed
     - Mark ProcessingHistory.success = True
     """
+    nuke = nuke_transcoding_dir()
+    assert(nuke is True)
     instance = ctx.current_video
     if not isinstance(instance, VideoFile):
         logger.warning("finalize_video_success called with non-VideoFile instance")
@@ -265,6 +267,8 @@ def finalize_video_success(
 
     # --- Update VideoState flags (mirrors report) ---
     state = _ensure_instance_state(instance)
+    
+
 
     with transaction.atomic():
         if state is not None:
@@ -355,46 +359,138 @@ def finalize_failure(
         ctx.file_path,
     )
 
-def delete_associated_files(ctx:ImportContext):
-    try:
-        assert isinstance(ctx.original_path, Path)
-    except AssertionError as e:
-        logger.warning(f"Original file restored from sensitive copy. This is because the original file is gone. {e}")
-        if ctx.file_type =="video":
-            if isinstance(ctx.sensitive_path, Path):
-                try:
-                    ctx.original_path = Path(shutil.copy2(ctx.sensitive_path, IMPORT_VIDEO_DIR))
-                except Exception as e:
-                    logger.error(f"Error during safety copy: {e} Original file could not be restored!")
-                    raise
-        elif ctx.file_type == "report":
-            if isinstance(ctx.sensitive_path, Path):
-                try:
-                    ctx.original_path = Path(shutil.copy2(ctx.sensitive_path, IMPORT_REPORT_DIR))
-                except Exception as e:
-                    logger.error(f"Error during safety copy: {e} Original file could not be restored!")
-                    raise
-        
-    if isinstance(ctx.anonymized_path, Path):
+def delete_associated_files(ctx: ImportContext) -> None:
+    """
+    Best-effort cleanup of anonymized, sensitive and transcoding artefacts.
+
+    - Ensure ctx.original_path points to an existing import file; if not, try to restore
+      from ctx.sensitive_path into the appropriate IMPORT_*_DIR.
+    - Delete anonymized file (if any).
+    - Nuke transcoding directory.
+    - Delete sensitive file (if any).
+
+    This function should *not* raise on non-critical cleanup errors; it logs instead.
+    Only restoration of the original import file is treated as critical.
+    """
+
+    # --- 1. Restore original import file if needed (critical) ---
+    original_missing = not isinstance(ctx.original_path, Path) or not ctx.original_path.exists()
+    if original_missing:
+        logger.warning(
+            "Original file missing in ctx (file_type=%s); "
+            "trying to restore from sensitive copy.",
+            ctx.file_type,
+        )
+
+        if not isinstance(ctx.sensitive_path, Path) or not ctx.sensitive_path.exists():
+            # This is serious: we lost both original and sensitive copy
+            msg = (
+                f"Cannot restore original file for {ctx.file_type}: "
+                "sensitive copy missing as well."
+            )
+            logger.error(msg)
+            raise RuntimeError(msg)
+
         try:
-            Path.unlink(ctx.anonymized_path)
-            assert(ctx.anonymized_path is not Path)
+            if ctx.file_type == "video":
+                target_dir = IMPORT_VIDEO_DIR
+            elif ctx.file_type == "report":
+                target_dir = IMPORT_REPORT_DIR
+            else:
+                raise ValueError(f"Unknown file_type in context: {ctx.file_type}")
 
+            target_dir.mkdir(parents=True, exist_ok=True)
+            restored_path = shutil.copy2(ctx.sensitive_path, target_dir)
+            ctx.original_path = Path(restored_path)
+            logger.info("Restored original file for %s to %s", ctx.file_type, ctx.original_path)
         except Exception as e:
-            logger.error(f"Error when unlinking anonymized path. {e}")
+            logger.error("Error during safety copy / restore of original file: %s", e, exc_info=True)
             raise
-        
-    ctx.anonymized_path = None
-    
+
+    # --- 2. Delete anonymized file (best-effort) ---
+    if isinstance(ctx.anonymized_path, Path):
+        try:
+            if ctx.anonymized_path.exists() and isinstance(ctx.anonymized_path, Path):
+                ctx.anonymized_path.unlink()
+                logger.info("Deleted anonymized file %s", ctx.anonymized_path)
+        except Exception as e:
+            logger.error("Error when unlinking anonymized path %s: %s", ctx.anonymized_path, e, exc_info=True)
+            if ctx.anonymized_path.exists() and isinstance( ctx.anonymized_path, str):
+                if isinstance(ctx.current_video, VideoFile):
+                    p = Path(path_utils.data_paths["anonym_video" / ctx.anonymized_path])
+                    p.unlink()
+                elif isinstance(ctx.current_report, RawPdfFile):
+                    p = Path(path_utils.data_paths["anonym_report" / ctx.anonymized_path])
+                    p.unlink()                    
+            if ctx.anonymized_path.exists():
+                ctx.anonymized_path.rmdir()
+        finally:
+            if ctx.anonymized_path.exists():
+                raise AssertionError("Anonym file remains after all deletion attempts.")
+            ctx.anonymized_path = None
+
+    # --- 3. Nuke transcoding directory (best-effort) ---
+    if not nuke_transcoding_dir():
+        logger.warning("Transcoding directory cleanup returned False; there may be leftover files.")
+
+    # --- 4. Delete sensitive file (best-effort) ---
     if isinstance(ctx.sensitive_path, Path):
         try:
-            Path.unlink(ctx.sensitive_path)
-            assert(ctx.sensitive_path is not Path)
-            
+            if ctx.sensitive_path.exists():
+                ctx.sensitive_path.unlink()
+                logger.info("Deleted sensitive file %s", ctx.sensitive_path)
         except Exception as e:
-            logger.error(f"Error when unlinking anonymized path. {e}")
+            logger.error("Error when unlinking sensitive path %s: %s", ctx.sensitive_path, e, exc_info=True)
+            if ctx.sensitive_path.exists() and isinstance( ctx.sensitive_path, str):
+                if isinstance(ctx.current_video, VideoFile):
+                    p = Path(path_utils.data_paths["sensitive_video" / ctx.sensitive_path])
+                    p.unlink()
+                elif isinstance(ctx.current_report, RawPdfFile):
+                    p = Path(path_utils.data_paths["sensitive_report" / ctx.sensitive_path])
+                    p.unlink()  
+                if ctx.sensitive_path.exists():
+                    ctx.sensitive_path.rmdir()
+        finally:
+            if ctx.sensitive_path.exists():
+                raise AssertionError("Sensitive file remains after all deletion attempts.")
+            ctx.sensitive_path = None
 
-            raise
-        
-    ctx.sensitive_path = None
-    
+    
+def nuke_transcoding_dir(
+    transcoding_dir: Union[str, Path, None] = None
+) -> bool:
+    """
+    Delete all files and subdirectories inside the transcoding directory.
+
+    Returns:
+        True if the directory was either empty / successfully cleaned,
+        False if something went wrong (error is logged).
+    """
+    try:
+        if transcoding_dir is None:
+            transcoding_dir = path_utils.data_paths["transcoding"]
+
+        transcoding_dir = Path(transcoding_dir)
+
+        if not transcoding_dir.exists():
+            logger.info("Transcoding dir %s does not exist; nothing to clean.", transcoding_dir)
+            return True
+
+        if not transcoding_dir.is_dir():
+            logger.error("Configured transcoding path %s is not a directory.", transcoding_dir)
+            return False
+
+        for entry in transcoding_dir.iterdir():
+            try:
+                if entry.is_file() or entry.is_symlink():
+                    entry.unlink()
+                elif entry.is_dir():
+                    shutil.rmtree(entry)
+            except Exception as e:
+                logger.warning("Failed to remove entry %s in transcoding dir: %s", entry, e)
+                # Continue trying to delete other entries
+        return True
+
+    except Exception as e:
+        logger.error("Unexpected error while nuking transcoding dir: %s", e, exc_info=True)
+        return False

endoreg_db/models/state/video.py

@@ -117,6 +117,7 @@ class VideoState(models.Model):
             return AnonymizationState.STARTED
         if self.anonymized:
             return AnonymizationState.ANONYMIZED
+        
         return AnonymizationState.NOT_STARTED
 
     def mark_processing_not_started(self) -> None:

endoreg_db/utils/video/ffmpeg_wrapper.py

@@ -31,7 +31,11 @@ def _resolve_ffmpeg_executable() -> Optional[str]:
     try:
         from django.conf import settings
 
-        env_candidates.extend(getattr(settings, attr) for attr in ("FFMPEG_EXECUTABLE", "FFMPEG_BINARY", "FFMPEG_PATH") if hasattr(settings, attr))
+        env_candidates.extend(
+            getattr(settings, attr)
+            for attr in ("FFMPEG_EXECUTABLE", "FFMPEG_BINARY", "FFMPEG_PATH")
+            if hasattr(settings, attr)
+        )
     except Exception:
         # Django might not be configured for every consumer
         pass
@@ -83,9 +87,24 @@ def _detect_nvenc_support() -> bool:
     """
     try:
         # Test NVENC availability with a minimal command (minimum size for NVENC)
-        cmd = ["ffmpeg", "-f", "lavfi", "-i", "testsrc=duration=1:size=256x256:rate=1", "-c:v", "h264_nvenc", "-preset", "p1", "-f", "null", "-"]
+        cmd = [
+            "ffmpeg",
+            "-f",
+            "lavfi",
+            "-i",
+            "testsrc=duration=1:size=256x256:rate=1",
+            "-c:v",
+            "h264_nvenc",
+            "-preset",
+            "p1",
+            "-f",
+            "null",
+            "-",
+        ]
 
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=15, check=False)
+        result = subprocess.run(
+            cmd, capture_output=True, text=True, timeout=15, check=False
+        )
 
         if result.returncode == 0:
             logger.debug("NVENC h264 encoding test successful")
@@ -141,7 +160,11 @@ def _get_preferred_encoder() -> Dict[str, str]:
     return _preferred_encoder
 
 
-def _build_encoder_args(quality_mode: str = "balanced", fallback: bool = False, custom_crf: Optional[int] = None) -> Tuple[List[str], str]:
+def _build_encoder_args(
+    quality_mode: str = "balanced",
+    fallback: bool = False,
+    custom_crf: Optional[int] = None,
+) -> Tuple[List[str], str]:
     """
     Build encoder command arguments based on available hardware and quality requirements.
 
@@ -207,7 +230,16 @@ def _build_encoder_args(quality_mode: str = "balanced", fallback: bool = False,
         if custom_crf is not None:
             quality = str(custom_crf)
 
-        return ["-c:v", encoder["name"], encoder["preset_param"], preset, encoder["quality_param"], quality, "-profile:v", "high"], encoder["type"]
+        return [
+            "-c:v",
+            encoder["name"],
+            encoder["preset_param"],
+            preset,
+            encoder["quality_param"],
+            quality,
+            "-profile:v",
+            "high",
+        ], encoder["type"]
 
 
 def is_ffmpeg_available() -> bool:
@@ -231,7 +263,9 @@ def check_ffmpeg_availability():
         True if FFmpeg is available.
     """
     if not is_ffmpeg_available():
-        error_msg = "FFmpeg is not available. Please install it and ensure it's in your PATH."
+        error_msg = (
+            "FFmpeg is not available. Please install it and ensure it's in your PATH."
+        )
         logger.error(error_msg)
         raise FileNotFoundError(error_msg)
     # logger.info("FFmpeg is available.") # Caller can log if needed
@@ -292,9 +326,15 @@ def assemble_video_from_frames(  # Renamed from assemble_video
             if first_frame is None:
                 raise IOError(f"Could not read first frame: {frame_paths[0]}")
             height, width, _ = first_frame.shape
-            logger.info("Determined video dimensions from first frame: %dx%d", width, height)
+            logger.info(
+                "Determined video dimensions from first frame: %dx%d", width, height
+            )
         except Exception as e:
-            logger.error("Error reading first frame to determine dimensions: %s", e, exc_info=True)
+            logger.error(
+                "Error reading first frame to determine dimensions: %s",
+                e,
+                exc_info=True,
+            )
             return None
 
     fourcc = cv2.VideoWriter_fourcc(*"mp4v")
@@ -305,7 +345,9 @@ def assemble_video_from_frames(  # Renamed from assemble_video
         logger.error("Could not open video writer for path: %s", output_path)
         return None
 
-    logger.info("Assembling video %s from %d frames...", output_path.name, len(frame_paths))
+    logger.info(
+        "Assembling video %s from %d frames...", output_path.name, len(frame_paths)
+    )
     try:
         for frame_path in tqdm(frame_paths, desc=f"Assembling {output_path.name}"):
             frame = cv2.imread(str(frame_path))
@@ -314,7 +356,9 @@ def assemble_video_from_frames(  # Renamed from assemble_video
                 continue
             # Ensure frame dimensions match - resize if necessary (or log error)
             if frame.shape[1] != width or frame.shape[0] != height:
-                logger.warning(f"Frame {frame_path} has dimensions {frame.shape[1]}x{frame.shape[0]}, expected {width}x{height}. Resizing.")
+                logger.warning(
+                    f"Frame {frame_path} has dimensions {frame.shape[1]}x{frame.shape[0]}, expected {width}x{height}. Resizing."
+                )
                 frame = cv2.resize(frame, (width, height))
             video_writer.write(frame)
     finally:
@@ -364,7 +408,9 @@ def transcode_video(
     if codec == "auto" or preset == "auto":
         if force_cpu:
             # Force CPU encoding
-            encoder_args, encoder_type = _build_encoder_args(quality_mode, fallback=False, custom_crf=crf)
+            encoder_args, encoder_type = _build_encoder_args(
+                quality_mode, fallback=False, custom_crf=crf
+            )
             # Override to use CPU encoder
             encoder_args[1] = "libx264"  # Replace encoder name
             encoder_args[3] = "medium" if preset == "auto" else preset  # Replace preset
@@ -372,7 +418,9 @@ def transcode_video(
                 encoder_args[5] = str(crf)  # Replace quality value
         else:
             # Use automatic hardware detection
-            encoder_args, encoder_type = _build_encoder_args(quality_mode, fallback=False, custom_crf=crf)
+            encoder_args, encoder_type = _build_encoder_args(
+                quality_mode, fallback=False, custom_crf=crf
+            )
     else:
         # Manual codec/preset specification (backward compatibility)
         encoder_args = [
@@ -402,11 +450,18 @@ def transcode_video(
         command.extend(extra_args)
     command.append(str(output_path))
 
-    logger.info("Starting transcoding: %s -> %s (using %s)", input_path.name, output_path.name, encoder_type)
+    logger.info(
+        "Starting transcoding: %s -> %s (using %s)",
+        input_path.name,
+        output_path.name,
+        encoder_type,
+    )
     logger.debug("FFmpeg command: %s", " ".join(command))
 
     try:
-        process = subprocess.Popen(command, stderr=subprocess.PIPE, text=True, universal_newlines=True)
+        process = subprocess.Popen(
+            command, stderr=subprocess.PIPE, text=True, universal_newlines=True
+        )
 
         # Progress reporting and error handling
         stderr_output = ""
@@ -420,32 +475,56 @@ def transcode_video(
             logger.info("Transcoding finished successfully: %s", output_path)
             return output_path
         else:
-            logger.error("FFmpeg transcoding failed for %s with return code %d.", input_path.name, process.returncode)
+            logger.error(
+                "FFmpeg transcoding failed for %s with return code %d.",
+                input_path.name,
+                process.returncode,
+            )
             logger.error("FFmpeg stderr:\n%s", stderr_output)
 
             # Try fallback to CPU if NVENC failed
             if encoder_type == "nvenc" and not force_cpu:
                 logger.warning("NVENC transcoding failed, trying CPU fallback...")
-                return _transcode_video_fallback(input_path, output_path, audio_codec, audio_bitrate, extra_args, quality_mode, crf)
+                return _transcode_video_fallback(
+                    input_path,
+                    output_path,
+                    audio_codec,
+                    audio_bitrate,
+                    extra_args,
+                    quality_mode,
+                    crf,
+                )
 
             # Clean up potentially corrupted output file
             if output_path.exists():
                 try:
                     output_path.unlink()
                 except OSError as e:
-                    logger.error("Failed to delete incomplete output file %s: %s", output_path, e)
+                    logger.error(
+                        "Failed to delete incomplete output file %s: %s", output_path, e
+                    )
             return None
 
     except FileNotFoundError:
-        logger.error("ffmpeg command not found. Ensure FFmpeg is installed and in the system's PATH.")
+        logger.error(
+            "ffmpeg command not found. Ensure FFmpeg is installed and in the system's PATH."
+        )
         return None
     except Exception as e:
-        logger.error("Error during transcoding of %s: %s", input_path.name, e, exc_info=True)
+        logger.error(
+            "Error during transcoding of %s: %s", input_path.name, e, exc_info=True
+        )
         return None
 
 
 def _transcode_video_fallback(
-    input_path: Path, output_path: Path, audio_codec: str, audio_bitrate: str, extra_args: Optional[List[str]], quality_mode: str, custom_crf: Optional[int]
+    input_path: Path,
+    output_path: Path,
+    audio_codec: str,
+    audio_bitrate: str,
+    extra_args: Optional[List[str]],
+    quality_mode: str,
+    custom_crf: Optional[int],
 ) -> Optional[Path]:
     """
     Fallback transcoding using CPU encoding.
@@ -464,7 +543,9 @@ def _transcode_video_fallback(
     """
     try:
         # Build CPU encoder arguments
-        encoder_args, _ = _build_encoder_args(quality_mode, fallback=True, custom_crf=custom_crf)
+        encoder_args, _ = _build_encoder_args(
+            quality_mode, fallback=True, custom_crf=custom_crf
+        )
         # Force CPU encoder
         encoder_args[1] = "libx264"
 
@@ -484,10 +565,14 @@ def _transcode_video_fallback(
             command.extend(extra_args)
         command.append(str(output_path))
 
-        logger.info("CPU fallback transcoding: %s -> %s", input_path.name, output_path.name)
+        logger.info(
+            "CPU fallback transcoding: %s -> %s", input_path.name, output_path.name
+        )
         logger.debug("Fallback FFmpeg command: %s", " ".join(command))
 
-        process = subprocess.Popen(command, stderr=subprocess.PIPE, text=True, universal_newlines=True)
+        process = subprocess.Popen(
+            command, stderr=subprocess.PIPE, text=True, universal_newlines=True
+        )
         stderr_output = ""
         if process.stderr:
             for line in process.stderr:
@@ -511,7 +596,9 @@ def _transcode_video_fallback(
     logger.debug("FFmpeg command: %s", " ".join(command))
 
     try:
-        process = subprocess.Popen(command, stderr=subprocess.PIPE, text=True, universal_newlines=True)
+        process = subprocess.Popen(
+            command, stderr=subprocess.PIPE, text=True, universal_newlines=True
+        )
 
         # Optional: Progress reporting (can be complex to parse ffmpeg output reliably)
         # For simplicity, just wait and check the return code
@@ -528,21 +615,31 @@ def _transcode_video_fallback(
             logger.info("Transcoding finished successfully: %s", output_path)
             return output_path
         else:
-            logger.error("FFmpeg transcoding failed for %s with return code %d.", input_path.name, process.returncode)
+            logger.error(
+                "FFmpeg transcoding failed for %s with return code %d.",
+                input_path.name,
+                process.returncode,
+            )
             logger.error("FFmpeg stderr:\n%s", stderr_output)
             # Clean up potentially corrupted output file
             if output_path.exists():
                 try:
                     output_path.unlink()
                 except OSError as e:
-                    logger.error("Failed to delete incomplete output file %s: %s", output_path, e)
+                    logger.error(
+                        "Failed to delete incomplete output file %s: %s", output_path, e
+                    )
             return None
 
     except FileNotFoundError:
-        logger.error("ffmpeg command not found. Ensure FFmpeg is installed and in the system's PATH.")
+        logger.error(
+            "ffmpeg command not found. Ensure FFmpeg is installed and in the system's PATH."
+        )
         return None
     except Exception as e:
-        logger.error("Error during transcoding of %s: %s", input_path.name, e, exc_info=True)
+        logger.error(
+            "Error during transcoding of %s: %s", input_path.name, e, exc_info=True
+        )
         return None
 
 
@@ -561,10 +658,15 @@ def transcode_videofile_if_required(
     """
     stream_info = get_stream_info(input_path)
     if not stream_info or "streams" not in stream_info:
-        logger.error("Could not get stream info for %s to check if transcoding is required.", input_path)
+        logger.error(
+            "Could not get stream info for %s to check if transcoding is required.",
+            input_path,
+        )
         return None
 
-    video_stream = next((s for s in stream_info["streams"] if s.get("codec_type") == "video"), None)
+    video_stream = next(
+        (s for s in stream_info["streams"] if s.get("codec_type") == "video"), None
+    )
 
     if not video_stream:
         logger.error("No video stream found in %s.", input_path)
@@ -573,7 +675,9 @@ def transcode_videofile_if_required(
     codec_name = video_stream.get("codec_name")
     pixel_format = video_stream.get("pix_fmt")
     # Check color range as well, default is usually 'tv' (limited)
-    color_range = video_stream.get("color_range", "tv")  # Default to tv if not specified
+    color_range = video_stream.get(
+        "color_range", "tv"
+    )  # Default to tv if not specified
 
     needs_transcoding = False
     transcode_reason = []
@@ -583,16 +687,25 @@ def transcode_videofile_if_required(
         transcode_reason.append(reason)
         needs_transcoding = True
     # Check both pixel format and color range for yuv420p
-    if pixel_format != required_pixel_format or (pixel_format == "yuv420p" and color_range != "pc"):
+    if pixel_format != required_pixel_format or (
+        pixel_format == "yuv420p" and color_range != "pc"
+    ):
         reason = f"Pixel format/color range mismatch (pix_fmt: {pixel_format}, color_range: {color_range} != {required_pixel_format} with color_range=pc)"
         logger.info("%s for %s. Transcoding required.", reason, input_path.name)
         transcode_reason.append(reason)
         needs_transcoding = True
 
     if needs_transcoding:
-        logger.info("Transcoding %s to %s due to: %s", input_path.name, output_path.name, "; ".join(transcode_reason))
+        logger.info(
+            "Transcoding %s to %s due to: %s",
+            input_path.name,
+            output_path.name,
+            "; ".join(transcode_reason),
+        )
         # Ensure codec and pixel format are set in options if not already present
-        transcode_options.setdefault("codec", "libx264" if required_codec == "h264" else required_codec)
+        transcode_options.setdefault(
+            "codec", "libx264" if required_codec == "h264" else required_codec
+        )
         transcode_options.setdefault("extra_args", [])
 
         # Ensure pixel format and color range are correctly set in extra_args
@@ -604,11 +717,17 @@ def transcode_videofile_if_required(
             try:
                 pix_fmt_index = extra_args.index("-pix_fmt")
                 if extra_args[pix_fmt_index + 1] != required_pixel_format:
-                    logger.warning("Overriding existing -pix_fmt '%s' with '%s'", extra_args[pix_fmt_index + 1], required_pixel_format)
+                    logger.warning(
+                        "Overriding existing -pix_fmt '%s' with '%s'",
+                        extra_args[pix_fmt_index + 1],
+                        required_pixel_format,
+                    )
                     extra_args[pix_fmt_index + 1] = required_pixel_format
             except (ValueError, IndexError):
                 # Should not happen if '-pix_fmt' is in extra_args, but handle defensively
-                logger.error("Error processing existing -pix_fmt argument. Appending required format.")
+                logger.error(
+                    "Error processing existing -pix_fmt argument. Appending required format."
+                )
                 extra_args.extend(["-pix_fmt", required_pixel_format])
 
         if "-color_range" not in extra_args:
@@ -619,16 +738,24 @@ def transcode_videofile_if_required(
             try:
                 color_range_index = extra_args.index("-color_range")
                 if extra_args[color_range_index + 1] != "pc":
-                    logger.warning("Overriding existing -color_range '%s' with 'pc'", extra_args[color_range_index + 1])
+                    logger.warning(
+                        "Overriding existing -color_range '%s' with 'pc'",
+                        extra_args[color_range_index + 1],
+                    )
                     extra_args[color_range_index + 1] = "pc"
             except (ValueError, IndexError):
-                logger.error("Error processing existing -color_range argument. Appending 'pc'.")
+                logger.error(
+                    "Error processing existing -color_range argument. Appending 'pc'."
+                )
                 extra_args.extend(["-color_range", "pc"])
 
         return transcode_video(input_path, output_path, **transcode_options)
     else:
         logger.info(
-            "Video %s already meets requirements (%s, %s, color_range=pc). No transcoding needed.", input_path.name, required_codec, required_pixel_format
+            "Video %s already meets requirements (%s, %s, color_range=pc). No transcoding needed.",
+            input_path.name,
+            required_codec,
+            required_pixel_format,
         )
         # If no transcoding is needed, should we copy/link or just return the original path?
         # For simplicity, let's assume the caller handles the file location.
@@ -638,15 +765,27 @@ def transcode_videofile_if_required(
             try:
                 output_path.parent.mkdir(parents=True, exist_ok=True)
                 shutil.copy2(input_path, output_path)
-                logger.info("Copied %s to %s as it met requirements.", input_path.name, output_path.name)
+                logger.info(
+                    "Copied %s to %s as it met requirements.",
+                    input_path.name,
+                    output_path.name,
+                )
                 return output_path
             except Exception as e:
-                logger.error("Failed to copy %s to %s: %s", input_path.name, output_path.name, e)
+                logger.error(
+                    "Failed to copy %s to %s: %s", input_path.name, output_path.name, e
+                )
                 return None
         return input_path  # Return original path if no copy needed
 
 
-def extract_frames(video_path: Path, output_dir: Path, quality: int, ext: str = "jpg", fps: Optional[float] = None) -> List[Path]:
+def extract_frames(
+    video_path: Path,
+    output_dir: Path,
+    quality: int,
+    ext: str = "jpg",
+    fps: Optional[float] = None,
+) -> List[Path]:
     """
     Extracts frames from a video file using FFmpeg.
 
@@ -702,7 +841,9 @@ def extract_frames(video_path: Path, output_dir: Path, quality: int, ext: str =
         # Return empty list on error as frames were likely not created correctly
         return []
     except Exception as e:
-        logger.error("An unexpected error occurred during FFmpeg execution: %s", e, exc_info=True)
+        logger.error(
+            "An unexpected error occurred during FFmpeg execution: %s", e, exc_info=True
+        )
         return []
 
     # Collect paths of extracted frames
@@ -743,7 +884,11 @@ def extract_frame_range(
         RuntimeError: If FFmpeg fails to extract the requested frames.
     """
     if start_frame >= end_frame:
-        logger.warning("extract_frame_range called with start_frame (%d) >= end_frame (%d). No frames to extract.", start_frame, end_frame)
+        logger.warning(
+            "extract_frame_range called with start_frame (%d) >= end_frame (%d). No frames to extract.",
+            start_frame,
+            end_frame,
+        )
         return []
 
     ffmpeg_executable = _resolve_ffmpeg_executable()
@@ -790,18 +935,30 @@ def extract_frame_range(
         logger.error("FFmpeg stderr:\n%s", e.stderr)
         logger.error("FFmpeg stdout:\n%s", e.stdout)
         # Clean up potentially partially created files in the target directory within the expected range
-        logger.warning("Attempting cleanup of potentially incomplete frames in %s", output_dir)
+        logger.warning(
+            "Attempting cleanup of potentially incomplete frames in %s", output_dir
+        )
         for i in range(start_frame, end_frame):
             potential_file = output_dir / f"frame_{i:07d}.{ext}"
             if potential_file.exists():
                 try:
                     potential_file.unlink()
                 except OSError as unlink_err:
-                    logger.error("Failed to delete potential frame %s during cleanup: %s", potential_file, unlink_err)
-        raise RuntimeError(f"FFmpeg frame range extraction failed for {video_path}") from e
+                    logger.error(
+                        "Failed to delete potential frame %s during cleanup: %s",
+                        potential_file,
+                        unlink_err,
+                    )
+        raise RuntimeError(
+            f"FFmpeg frame range extraction failed for {video_path}"
+        ) from e
     except Exception as e:
-        logger.error("An unexpected error occurred during FFmpeg execution: %s", e, exc_info=True)
-        raise RuntimeError(f"Unexpected error during FFmpeg frame range extraction for {video_path}") from e
+        logger.error(
+            "An unexpected error occurred during FFmpeg execution: %s", e, exc_info=True
+        )
+        raise RuntimeError(
+            f"Unexpected error during FFmpeg frame range extraction for {video_path}"
+        ) from e
 
     # Collect paths of extracted frames matching the pattern and expected range
     # FFmpeg might create files outside the exact range depending on version/flags,
@@ -813,9 +970,17 @@ def extract_frame_range(
             extracted_files.append(frame_file)
         else:
             # This might happen if ffmpeg fails silently for some frames or if the video ends early.
-            logger.warning("Expected frame file %s not found after extraction.", frame_file)
-
-    logger.info("Found %d extracted frame files in range [%d, %d) for video %s.", len(extracted_files), start_frame, end_frame, video_path.name)
+            logger.warning(
+                "Expected frame file %s not found after extraction.", frame_file
+            )
+
+    logger.info(
+        "Found %d extracted frame files in range [%d, %d) for video %s.",
+        len(extracted_files),
+        start_frame,
+        end_frame,
+        video_path.name,
+    )
     return extracted_files
 
 

{endoreg_db-0.8.8.9.dist-info → endoreg_db-0.8.9.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: endoreg-db
-Version: 0.8.8.9
+Version: 0.8.9.2
 Summary: EndoReg Db Django App
 Project-URL: Homepage, https://info.coloreg.de
 Project-URL: Repository, https://github.com/wg-lux/endoreg-db

{endoreg_db-0.8.8.9.dist-info → endoreg_db-0.8.9.2.dist-info}/RECORD

@@ -255,13 +255,12 @@ endoreg_db/import_files/file_storage/__init__.py,sha256=3YkOalkE6R5Y84dPOzhjJuGq
 endoreg_db/import_files/file_storage/create_report_file.py,sha256=u4nq-FrnhEnrnIyHuPk1ShTwSDxcq8vlikqFJCMdYkQ,2666
 endoreg_db/import_files/file_storage/create_video_file.py,sha256=OkSJGGdwlUvuM57EXQb4pNo8CuC8UanK_Y9E9jmJtB0,2562
 endoreg_db/import_files/file_storage/sensitive_meta_storage.py,sha256=1fHENzURgBgqEbAa_xMupS93CbIQj4AC4WUBurzQxjA,1452
-endoreg_db/import_files/file_storage/state_management.py,sha256=kl8j27UuI8v0VL9ywE6EMcAjsdyfnhUiKx5LTfvRJDI,13939
+endoreg_db/import_files/file_storage/state_management.py,sha256=1tgVIytpl4Oix8D8slIhDhl7KcfzL03Q3ZTed5OnjrU,18360
 endoreg_db/import_files/file_storage/storage.py,sha256=ITntL7AyXAovTgE1mtURgZRRBwUTIj2obrho3R-PBxg,1084
 endoreg_db/import_files/processing/__init__.py,sha256=p4R0j6aC28TNFeboyum2R9pF9P98nvMk-CQsy_0yWtA,220
 endoreg_db/import_files/processing/sensitive_meta_adapter.py,sha256=BXoiIxfSqKzze_ss6opEaW_C9TnKzwZkeyS-jJl8e_8,1768
 endoreg_db/import_files/processing/report_processing/report_anonymization.py,sha256=CBJbJ0AEVLuRg27CddN2yhaX53OTZkEBJO2E9lqyukY,3469
 endoreg_db/import_files/processing/video_processing/video_anonymization.py,sha256=POOkFSXD5rDc8eiYXnxSneXrksRVZmvQemPS4PJLF-0,4116
-endoreg_db/import_files/processing/video_processing/video_cleanup_on_error.py,sha256=tUGjGokoM-__gY-qXpTyRgP5ObSmAmdnsyQz9by2KME,4567
 endoreg_db/import_files/pseudonymization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 endoreg_db/import_files/pseudonymization/fake.py,sha256=UAObfuNT4YrUHZX8E53RLp7D3X3bpDs6f0UdoKh-8gE,1347
 endoreg_db/import_files/pseudonymization/k_anonymity.py,sha256=59d82ljv7cUmTVSA0jK0i_yov2l2yaqkpLPhZQnjGXk,5595
@@ -331,6 +330,7 @@ endoreg_db/mermaid/morphology.md,sha256=9_--hWVwXW1UB1E9od9yddyUFJonm3eCGr986nwp
 endoreg_db/mermaid/patient_creation.md,sha256=P0U50Pejxn_AATzHTJ3U9iydoEVSnpRjGEUOTRNJrGs,384
 endoreg_db/mermaid/video_segmentation_annotation.md,sha256=oouo5htDabP8m-W86C6aWXyIxi1A7zAoPqa3o5xr354,536
 endoreg_db/migrations/0001_initial.py,sha256=nhv_mB0U8cXlGgTF16sMtF4nr6NMmnq9Qn0eplvPOfc,123647
+endoreg_db/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 endoreg_db/models/__init__.py,sha256=sVRsrTj4AHjUinFOGjIUtliXzMd5u_IfnS7JWO4FN74,6567
 endoreg_db/models/upload_job.py,sha256=jWG-FuKp9yllUKrw86C-jPQyhaaLxib-V-i5TTWvKvw,3089
 endoreg_db/models/utils.py,sha256=mA-lBrwOrhQOZ1EojIquDDLUH2FoH3ZUg9B7i9U9nLw,4420
@@ -527,7 +527,7 @@ endoreg_db/models/state/audit_ledger.py,sha256=Pt8RIGg-6wb6md1Rlr5VhvIJFgc0uYNk7
 endoreg_db/models/state/label_video_segment.py,sha256=Hv8cE27yn0GOm0t4PlcamzN47GCbE2LYLLDADr7Vm3A,854
 endoreg_db/models/state/raw_pdf.py,sha256=6U4c6kyLqTh6tfKyrGQSPEQYPgu75-L9LRA55Rm0-QA,8283
 endoreg_db/models/state/sensitive_meta.py,sha256=fzzBehjJ9mcBJHrRM7y1A868qX76UADeh1mc8tLkzL0,1406
-endoreg_db/models/state/video.py,sha256=KziXPTnRrGGpgXtNyDjbzBXldTB3P666t2lSfs9RzeI,9175
+endoreg_db/models/state/video.py,sha256=x1r2QTe9PgRFI3gQj5K2IQW08cLunpjj7OI7QPODSCQ,9184
 endoreg_db/queries/__init__.py,sha256=7Qp0uKn8VLlerdYABw1p-2xphGyd-hT80O-wNUv043o,117
 endoreg_db/queries/annotations/__init__.py,sha256=76O3dAIzuSye09VNPGSNPnqPEtgXZcBAGXKdh89y0ts,95
 endoreg_db/queries/annotations/legacy.py,sha256=KOHWLDf3CLvIT9GpQi3ps4bUi3JDJUhJXH4gvw9T47E,6418
@@ -683,7 +683,7 @@ endoreg_db/utils/requirement_operator_logic/_old/lab_value_operators.py,sha256=t
 endoreg_db/utils/requirement_operator_logic/_old/model_evaluators.py,sha256=TxLcfYP71nCwFpF5XhVXVAspdl5ydXYJdVSYCoLbLh4,30228
 endoreg_db/utils/video/__init__.py,sha256=EOAcatQ8bI1f3LhkE2E3YOzmm0FHqulk0O-jjZBgZFg,823
 endoreg_db/utils/video/extract_frames.py,sha256=Pj9_pyfiwy-CFWiT4qysXn6VLCC-dQ1HpXOyyGqq0zE,3180
-endoreg_db/utils/video/ffmpeg_wrapper.py,sha256=FDA-XIYE3CcfKHptE-rs-3ajIVL4YOTZmNJmNgO_AYA,33191
+endoreg_db/utils/video/ffmpeg_wrapper.py,sha256=jwGMhw1C9u16w60N2df6lsYydx7-z0ZjyZUfVJkEjBM,35310
 endoreg_db/utils/video/names.py,sha256=m268j2Ynt94OYH6dYxeL8gzU5ODtFJD4OmzS7l0nBPU,1449
 endoreg_db/utils/video/streaming_processor.py,sha256=C-39DtxhSnL7B2cObFE5k829VLXl_Fl0KQFrFP368JA,13747
 endoreg_db/utils/video/video_splitter.py,sha256=EZEnhNjaUva_9VxjcjScgRSrxsEuifhBjlwIMLX1qaA,3698
@@ -765,7 +765,7 @@ endoreg_db/views/video/video_meta_stats.py,sha256=h8dasBKwTl3havbEz6YciEt3jkt5Wz
 endoreg_db/views/video/video_processing_history.py,sha256=mhFuS8RG5GV8E-lTtuD0qrq-bIpnUFp8vy9aERfC-J8,770
 endoreg_db/views/video/video_remove_frames.py,sha256=2FmvNrSPM0fUXiBxINN6vBUUDCqDlBkNcGR3WsLDgKo,1696
 endoreg_db/views/video/video_stream.py,sha256=_V1Gc11i6CHtc-PNjGMRPzFml4L8rDVcIHEMSNy5rD4,12162
-endoreg_db-0.8.8.9.dist-info/METADATA,sha256=DaHWSQys6xh9sOtwC20FVK3oNvz9NWTVZY_EcwHEHII,14852
-endoreg_db-0.8.8.9.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-endoreg_db-0.8.8.9.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-endoreg_db-0.8.8.9.dist-info/RECORD,,
+endoreg_db-0.8.9.2.dist-info/METADATA,sha256=zvZUsV6EIXoi6KPWdvQFcJjybDIRZgpfU45bMyMh3VM,14852
+endoreg_db-0.8.9.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+endoreg_db-0.8.9.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+endoreg_db-0.8.9.2.dist-info/RECORD,,

endoreg_db/import_files/processing/video_processing/video_cleanup_on_error.py

@@ -1,119 +0,0 @@
-# endoreg_db/services/video_processing/video_cleanup_on_error.py
-import logging
-import shutil
-from pathlib import Path
-from typing import Any, Dict, MutableSet, Optional
-
-logger = logging.getLogger(__name__)
-
-
-def cleanup_video_on_error(
-    *,
-    current_video: Any,
-    original_file_path: Optional[str | Path],
-    processing_context: Dict[str, Any],
-) -> None:
-    """
-    Cleanup processing context on error for video imports.
-
-    This is extracted from VideoImportService._cleanup_on_error and kept as
-    close as possible to the original behavior.
-    """
-    try:
-        if not current_video or not hasattr(current_video, "state"):
-            # Nothing we can sensibly do here
-            return
-
-        # Ensure state exists
-        if current_video.state is None:
-            try:
-                current_video.get_or_create_state()
-            except Exception as e:
-                logger.warning(
-                    "Video state not found for video %s during error cleanup: %s",
-                    getattr(current_video, "uuid", None),
-                    e,
-                )
-                return
-
-        current_video.state = current_video.get_or_create_state()
-
-        # Try to restore original raw file
-        try:
-            if original_file_path is not None:
-                original_path = Path(original_file_path)
-                if not original_path.exists():
-                    raise AssertionError("Original file path does not exist")
-
-                logger.info("Marked video import as failed in state")
-                raw_file_path = getattr(getattr(current_video, "raw_file", None), "path", None)
-                if raw_file_path and original_file_path:
-                    shutil.copy2(str(raw_file_path), str(original_file_path))
-                else:
-                    logger.warning("Cannot restore original raw file: path is None")
-            else:
-                logger.warning("Original file path is None")
-        except AssertionError:
-            logger.warning("Original file path does not exist")
-
-        # Reset state flags if processing had started
-        try:
-            from endoreg_db.models.state import VideoState  # local import to avoid cycles
-
-            if not isinstance(current_video.state, VideoState):
-                logger.error("Current video state is not a VideoState instance during cleanup")
-                raise AssertionError
-
-            if processing_context.get("processing_started"):
-                current_video.state.frames_extracted = False
-                current_video.state.frames_initialized = False
-                current_video.state.video_meta_extracted = False
-                current_video.state.text_meta_extracted = False
-                current_video.state.save()
-        except Exception as e:
-            logger.warning("Error during video error cleanup: %s", e)
-    except Exception as outer_exc:
-        logger.warning("Unexpected error in cleanup_video_on_error: %s", outer_exc)
-
-
-def cleanup_video_processing_context(
-    *,
-    processing_context: Dict[str, Any],
-    processed_files: MutableSet[str],
-) -> None:
-    """
-    Cleanup processing context and release file lock for video imports.
-
-    Extracted from VideoImportService._cleanup_processing_context.
-    """
-    # DEFENSIVE: ensure dict
-    if processing_context is None:
-        processing_context = {}
-
-    # Release file lock if it was acquired
-    try:
-        lock_context = processing_context.get("_lock_context")
-        if lock_context is not None:
-            try:
-                lock_context.__exit__(None, None, None)
-                logger.info("Released file lock")
-            except Exception as e:
-                logger.warning("Error releasing file lock during context cleanup: %s", e)
-    except Exception as e:
-        logger.warning("Error while handling lock release in context cleanup: %s", e)
-
-    # Remove file from processed_files set if processing failed
-    try:
-        file_path = processing_context.get("file_path")
-        anonymization_completed = processing_context.get("anonymization_completed")
-
-        if file_path and not anonymization_completed:
-            file_path_str = str(file_path)
-            if file_path_str in processed_files:
-                processed_files.remove(file_path_str)
-                logger.info(
-                    "Removed %s from processed files (failed processing)",
-                    file_path_str,
-                )
-    except Exception as e:
-        logger.warning("Error while cleaning processed_files set: %s", e)