endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.0__py3-none-any.whl

endoreg_db/services/video_import.py

@@ -11,30 +11,26 @@ Changelog:
 
 import logging
 import os
-import random
 import shutil
-import sys
 import time
 from contextlib import contextmanager
 from datetime import date
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
-
+import subprocess
 from django.db import transaction
 from django.db.models.fields.files import FieldFile
-from lx_anonymizer import FrameCleaner
-from moviepy import video
 
 from endoreg_db.models import EndoscopyProcessor, SensitiveMeta, VideoFile
 from endoreg_db.models.media.video.video_file_anonymize import _cleanup_raw_assets
+from endoreg_db.utils import ensure_local_file, storage_file_exists
 from endoreg_db.utils.hashs import get_video_hash
 from endoreg_db.utils.paths import ANONYM_VIDEO_DIR, STORAGE_DIR, VIDEO_DIR
+from endoreg_db.models.state import VideoState
 
 # File lock configuration (matches PDF import)
 STALE_LOCK_SECONDS = 6000  # 100 minutes - reclaim locks older than this
-MAX_LOCK_WAIT_SECONDS = (
-    90  # New: wait up to 90s for a non-stale lock to clear before skipping
-)
+MAX_LOCK_WAIT_SECONDS = 90  # New: wait up to 90s for a non-stale lock to clear before skipping
 
 logger = logging.getLogger(__name__)
 
@@ -63,10 +59,7 @@ class VideoImportService:
             # Ensure anonym_video directory exists before listing files
             anonym_video_dir = Path(ANONYM_VIDEO_DIR)
             if anonym_video_dir.exists():
-                self.processed_files = set(
-                    str(anonym_video_dir / file)
-                    for file in os.listdir(ANONYM_VIDEO_DIR)
-                )
+                self.processed_files = set(str(anonym_video_dir / file) for file in os.listdir(ANONYM_VIDEO_DIR))
             else:
                 logger.info(f"Creating anonym_videos directory: {anonym_video_dir}")
                 anonym_video_dir.mkdir(parents=True, exist_ok=True)
@@ -80,12 +73,13 @@ class VideoImportService:
         self.processing_context: Dict[str, Any] = {}
 
         self.delete_source = True
+        self.original_file_path = None
 
         self.logger = logging.getLogger(__name__)
+        
+        self.current_video_id = Optional[int]
 
-        self.cleaner = (
-            None  # This gets instantiated in the perform_frame_cleaning method
-        )
+        self.cleaner = None  # This gets instantiated in the perform_frame_cleaning method
 
     def _require_current_video(self) -> VideoFile:
         """Return the current VideoFile or raise if it has not been initialized."""
@@ -131,9 +125,7 @@ class VideoImportService:
                             )
                             lock_path.unlink()
                         except Exception as e:
-                            logger.warning(
-                                "Failed to remove stale lock %s: %s", lock_path, e
-                            )
+                            logger.warning("Failed to remove stale lock %s: %s", lock_path, e)
                         # Loop continues and retries acquire immediately
                         continue
 
@@ -176,9 +168,7 @@ class VideoImportService:
 
         try:
             # Initialize processing context
-            self._initialize_processing_context(
-                file_path, center_name, processor_name, save_video, delete_source
-            )
+            self._initialize_processing_context(file_path, center_name, processor_name, save_video, delete_source)
 
             # Validate and prepare file (may raise ValueError if another worker holds a non-stale lock)
             try:
@@ -212,15 +202,11 @@ class VideoImportService:
 
         except Exception as e:
             # Safe file path access - handles cases where processing_context wasn't initialized
-            safe_file_path = getattr(self, "processing_context", {}).get(
-                "file_path", file_path
-            )
+            safe_file_path = getattr(self, "processing_context", {}).get("file_path", file_path)
             # Debug: Log context state for troubleshooting
             context_keys = list(getattr(self, "processing_context", {}).keys())
             self.logger.debug(f"Context keys during error: {context_keys}")
-            self.logger.error(
-                f"Video import and anonymization failed for {safe_file_path}: {e}"
-            )
+            self.logger.error(f"Video import and anonymization failed for {safe_file_path}: {e}")
             self._cleanup_on_error()
             raise
         finally:
@@ -246,6 +232,7 @@ class VideoImportService:
             "anonymization_completed": False,
             "error_reason": None,
         }
+        self.original_file_path = str(file_path)
 
         self.logger.info(f"Initialized processing context for: {file_path}")
 
@@ -297,6 +284,7 @@ class VideoImportService:
             delete_source=self.processing_context["delete_source"],
             save_video_file=self.processing_context["save_video"],
         )
+        self.current_video_id = self.current_video.pk
 
         if not self.current_video:
             raise RuntimeError("Failed to create VideoFile instance")
@@ -358,9 +346,7 @@ class VideoImportService:
 
                 timestamp = int(time.time())
                 filename = f"video_{timestamp}{suffix}"
-                self.logger.warning(
-                    "No UUID available, using timestamp-based filename: %s", filename
-                )
+                self.logger.warning("No UUID available, using timestamp-based filename: %s", filename)
             stored_raw_path = videos_dir / filename
             self.logger.debug("Using UUID-based raw filename: %s", filename)
 
@@ -377,9 +363,7 @@ class VideoImportService:
                 except Exception:
                     shutil.copy2(source_path, stored_raw_path)
                     os.remove(source_path)
-                    self.logger.info(
-                        "Copied & removed raw video to: %s", stored_raw_path
-                    )
+                    self.logger.info("Copied & removed raw video to: %s", stored_raw_path)
             else:
                 shutil.copy2(source_path, stored_raw_path)
                 self.logger.info("Copied raw video to: %s", stored_raw_path)
@@ -409,8 +393,6 @@ class VideoImportService:
         # Initialize video specifications
         video.initialize_video_specs()
 
-
-
         # Extract frames BEFORE processing to prevent pipeline 1 conflicts
         self.logger.info("Pre-extracting frames to avoid pipeline conflicts...")
         try:
@@ -418,7 +400,7 @@ class VideoImportService:
             if frames_extracted:
                 self.processing_context["frames_extracted"] = True
                 self.logger.info("Frame extraction completed successfully")
-                        # Initialize frame objects in database
+                # Initialize frame objects in database
                 video.initialize_frames(video.get_frame_paths())
 
                 # CRITICAL: Immediately save the frames_extracted state to database
@@ -432,9 +414,7 @@ class VideoImportService:
                 self.logger.warning("Frame extraction failed, but continuing...")
                 self.processing_context["frames_extracted"] = False
         except Exception as e:
-            self.logger.warning(
-                f"Frame extraction failed during setup: {e}, but continuing..."
-            )
+            self.logger.warning(f"Frame extraction failed during setup: {e}, but continuing...")
             self.processing_context["frames_extracted"] = False
 
         # Ensure default patient data
@@ -445,32 +425,22 @@ class VideoImportService:
     def _process_frames_and_metadata(self):
         """Process frames and extract metadata with anonymization."""
         # Check frame cleaning availability
-        frame_cleaning_available, frame_cleaner = (
-            self._ensure_frame_cleaning_available()
-        )
+        frame_cleaning_available, frame_cleaner = self._ensure_frame_cleaning_available()
         video = self._require_current_video()
 
         raw_file_field = video.raw_file
-        has_raw_file = isinstance(raw_file_field, FieldFile) and bool(
-            raw_file_field.name
-        )
+        has_raw_file = isinstance(raw_file_field, FieldFile) and bool(raw_file_field.name)
 
         if not (frame_cleaning_available and has_raw_file):
-            self.logger.warning(
-                "Frame cleaning not available or conditions not met, using fallback anonymization."
-            )
+            self.logger.warning("Frame cleaning not available or conditions not met, using fallback anonymization.")
             self._fallback_anonymize_video()
             return
 
         try:
-            self.logger.info(
-                "Starting frame-level anonymization with processor ROI masking..."
-            )
+            self.logger.info("Starting frame-level anonymization with processor ROI masking...")
 
             # Get processor ROI information
-            endoscope_data_roi_nested, endoscope_image_roi = (
-                self._get_processor_roi_info()
-            )
+            endoscope_data_roi_nested, endoscope_image_roi = self._get_processor_roi_info()
 
             # Perform frame cleaning with timeout to prevent blocking
             from concurrent.futures import ThreadPoolExecutor
@@ -484,21 +454,12 @@ class VideoImportService:
                 )
                 try:
                     # Increased timeout to better accommodate ffmpeg + OCR
-                    future.result(timeout=50000)
+                    future.result(timeout=5000)
                     self.processing_context["anonymization_completed"] = True
-                    self.logger.info(
-                        "Frame cleaning completed successfully within timeout"
-                    )
+                    self.logger.info("Frame cleaning completed successfully within timeout")
                 except FutureTimeoutError:
-                    self.logger.warning(
-                        "Frame cleaning timed out; entering grace period check for cleaned output"
-                    )
+                    self.logger.warning("Frame cleaning timed out; entering grace period check for cleaned output")
                     # Grace period: detect if cleaned file appears shortly after timeout
-                    raw_video_path = self.processing_context.get("raw_video_path")
-                    video_filename = self.processing_context.get(
-                        "video_filename",
-                        Path(raw_video_path).name if raw_video_path else "video.mp4",
-                    )
                     grace_seconds = 60
                     expected_cleaned_path: Optional[Path] = None
                     processed_field = video.processed_file
@@ -511,12 +472,8 @@ class VideoImportService:
                     if expected_cleaned_path is not None:
                         for _ in range(grace_seconds):
                             if expected_cleaned_path.exists():
-                                self.processing_context["cleaned_video_path"] = (
-                                    expected_cleaned_path
-                                )
-                                self.processing_context["anonymization_completed"] = (
-                                    True
-                                )
+                                self.processing_context["cleaned_video_path"] = expected_cleaned_path
+                                self.processing_context["anonymization_completed"] = True
                                 self.logger.info(
                                     "Detected cleaned video during grace period: %s",
                                     expected_cleaned_path,
@@ -527,26 +484,18 @@ class VideoImportService:
                     else:
                         self._fallback_anonymize_video()
                     if not found:
-                        raise TimeoutError(
-                            "Frame cleaning operation timed out - likely Ollama connection issue"
-                        )
+                        raise TimeoutError("Frame cleaning operation timed out - likely Ollama connection issue")
 
         except Exception as e:
-            self.logger.warning(
-                "Frame cleaning failed (reason: %s), falling back to simple copy", e
-            )
+            self.logger.warning("Frame cleaning failed (reason: %s), falling back to simple copy", e)
             # Try fallback anonymization when frame cleaning fails
             try:
                 self._fallback_anonymize_video()
             except Exception as fallback_error:
-                self.logger.error(
-                    "Fallback anonymization also failed: %s", fallback_error
-                )
+                self.logger.error("Fallback anonymization also failed: %s", fallback_error)
                 # If even fallback fails, mark as not anonymized but continue import
                 self.processing_context["anonymization_completed"] = False
-                self.processing_context["error_reason"] = (
-                    f"Frame cleaning failed: {e}, Fallback failed: {fallback_error}"
-                )
+                self.processing_context["error_reason"] = f"Frame cleaning failed: {e}, Fallback failed: {fallback_error}"
 
     def _save_anonymized_video(self):
         original_raw_file_path_to_delete = None
@@ -555,24 +504,14 @@ class VideoImportService:
         anonymized_video_path = video.get_target_anonymized_video_path()
 
         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.uuid}: {anonymized_video_path}")
 
         new_processed_hash = get_video_hash(anonymized_video_path)
-        if (
-            video.__class__.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 video.__class__.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}).")
 
         video.processed_video_hash = new_processed_hash
-        video.processed_file.name = anonymized_video_path.relative_to(
-            STORAGE_DIR
-        ).as_posix()
+        video.processed_file.name = anonymized_video_path.relative_to(STORAGE_DIR).as_posix()
 
         update_fields = [
             "processed_video_hash",
@@ -584,7 +523,7 @@ class VideoImportService:
             original_raw_file_path_to_delete = video.get_raw_file_path()
             original_raw_frame_dir_to_delete = video.get_frame_dir_path()
 
-            video.raw_file.name = None  # type: ignore[assignment]
+            video.raw_file.name = ""
 
             update_fields.extend(["raw_file", "video_hash"])
 
@@ -597,10 +536,18 @@ class VideoImportService:
             )
 
         video.save(update_fields=update_fields)
-        video.state.mark_anonymized(save=True)
-        video.refresh_from_db()
-        self.current_video = video
-        return True
+        if not isinstance(video.state, VideoState):
+            try:
+                video.get_or_create_state()
+            except ValueError as e:
+                raise RuntimeError(f"Video state not found for video {video.uuid}. Error {e}")
+
+        else:
+            video.state.mark_anonymized(save=True)
+            video.refresh_from_db()
+            self.current_video = video
+
+            return True
 
     def _fallback_anonymize_video(self):
         """
@@ -610,23 +557,15 @@ class VideoImportService:
             self.logger.info("Attempting fallback video anonymization...")
             video = self.current_video
             if video is None:
-                self.logger.warning(
-                    "No VideoFile instance available for fallback anonymization"
-                )
+                self.logger.warning("No VideoFile instance available for fallback anonymization")
 
             # Strategy 2: Simple copy (no processing, just copy raw to processed)
-            self.logger.info(
-                "Using simple copy fallback (raw video will be used as 'processed' video)"
-            )
+            self.logger.info("Using simple copy fallback (raw video will be used as 'processed' video)")
             self.processing_context["anonymization_completed"] = False
             self.processing_context["use_raw_as_processed"] = True
-            self.logger.warning(
-                "Fallback: Video will be imported without anonymization (raw copy used)"
-            )
+            self.logger.warning("Fallback: Video will be imported without anonymization (raw copy used)")
         except Exception as e:
-            self.logger.error(
-                f"Error during fallback anonymization: {e}", exc_info=True
-            )
+            self.logger.error(f"Error during fallback anonymization: {e}", exc_info=True)
             self.processing_context["anonymization_completed"] = False
             self.processing_context["error_reason"] = str(e)
 
@@ -660,18 +599,12 @@ class VideoImportService:
             state.text_meta_extracted = True
 
             # ✅ FIX: Only mark as processed if anonymization actually completed
-            anonymization_completed = self.processing_context.get(
-                "anonymization_completed", False
-            )
+            anonymization_completed = self.processing_context.get("anonymization_completed", False)
             if anonymization_completed:
                 state.mark_sensitive_meta_processed(save=False)
-                self.logger.info(
-                    "Anonymization completed - marking sensitive meta as processed"
-                )
+                self.logger.info("Anonymization completed - marking sensitive meta as processed")
             else:
-                self.logger.warning(
-                    f"Anonymization NOT completed - NOT marking as processed. Reason: {self.processing_context.get('error_reason', 'Unknown')}"
-                )
+                self.logger.warning(f"Anonymization NOT completed - NOT marking as processed. Reason: {self.processing_context.get('error_reason', 'Unknown')}")
                 # Explicitly mark as NOT processed
                 state.sensitive_meta_processed = False
 
@@ -703,9 +636,7 @@ class VideoImportService:
                 processed_video_path = Path(raw_video_path).parent / processed_filename
                 try:
                     shutil.copy2(str(raw_video_path), str(processed_video_path))
-                    self.logger.info(
-                        "Copied raw video for processing: %s", processed_video_path
-                    )
+                    self.logger.info("Copied raw video for processing: %s", processed_video_path)
                 except Exception as exc:
                     self.logger.error("Failed to copy raw video: %s", exc)
                     processed_video_path = None
@@ -725,16 +656,10 @@ class VideoImportService:
                         relative_path = anonym_target_path.relative_to(storage_root)
                         video.processed_file.name = str(relative_path)
                         video.save(update_fields=["processed_file"])
-                        self.logger.info(
-                            "Updated processed_file path to: %s", relative_path
-                        )
+                        self.logger.info("Updated processed_file path to: %s", relative_path)
                     except Exception as exc:
-                        self.logger.error(
-                            "Failed to update processed_file path: %s", exc
-                        )
-                        video.processed_file.name = (
-                            f"anonym_videos/{anonym_video_filename}"
-                        )
+                        self.logger.error("Failed to update processed_file path: %s", exc)
+                        video.processed_file.name = f"anonym_videos/{anonym_video_filename}"
                         video.save(update_fields=["processed_file"])
                         self.logger.info(
                             "Updated processed_file path using fallback: %s",
@@ -748,21 +673,15 @@ class VideoImportService:
                         anonym_target_path,
                     )
             except Exception as exc:
-                self.logger.error(
-                    "Failed to move processed video to anonym_videos: %s", exc
-                )
+                self.logger.error("Failed to move processed video to anonym_videos: %s", exc)
         else:
-            self.logger.warning(
-                "No processed video available - processed_file will remain empty"
-            )
+            self.logger.warning("No processed video available - processed_file will remain empty")
 
         try:
             from endoreg_db.utils.paths import RAW_FRAME_DIR
 
             shutil.rmtree(RAW_FRAME_DIR, ignore_errors=True)
-            self.logger.debug(
-                "Cleaned up temporary frames directory: %s", RAW_FRAME_DIR
-            )
+            self.logger.debug("Cleaned up temporary frames directory: %s", RAW_FRAME_DIR)
         except Exception as exc:
             self.logger.warning("Failed to remove directory %s: %s", RAW_FRAME_DIR, exc)
 
@@ -772,14 +691,10 @@ class VideoImportService:
                 os.remove(source_path)
                 self.logger.info("Removed remaining source file: %s", source_path)
             except Exception as exc:
-                self.logger.warning(
-                    "Failed to remove source file %s: %s", source_path, exc
-                )
+                self.logger.warning("Failed to remove source file %s: %s", source_path, exc)
 
-        if not video.processed_file or not Path(video.processed_file.path).exists():
-            self.logger.warning(
-                "No processed_file found after cleanup - video will be unprocessed"
-            )
+        if not video.processed_file or not storage_file_exists(video.processed_file):
+            self.logger.warning("No processed_file found after cleanup - video will be unprocessed")
             try:
                 video.anonymize(delete_original_raw=self.delete_source)
                 video.save(update_fields=["processed_file"])
@@ -794,14 +709,16 @@ class VideoImportService:
 
         with transaction.atomic():
             video.refresh_from_db()
-            if hasattr(video, "state") and self.processing_context.get(
-                "anonymization_completed"
-            ):
+            if hasattr(video, "state") and self.processing_context.get("anonymization_completed"):
+                if not isinstance(video.state, VideoState):
+                    try:
+                        video.get_or_create_state()
+                    except:
+                        raise RuntimeError(f"Video state not found for video {video.uuid}")
+
                 video.state.mark_sensitive_meta_processed(save=True)
 
-        self.logger.info(
-            "Import and anonymization completed for VideoFile UUID: %s", video.uuid
-        )
+        self.logger.info("Import and anonymization completed for VideoFile UUID: %s", video.uuid)
         self.logger.info("Raw video stored in: /data/videos")
         self.logger.info("Processed video stored in: /data/anonym_videos")
 
@@ -813,52 +730,77 @@ class VideoImportService:
         """Create or move a sensitive copy of the raw video file inside storage."""
 
         video = video_instance or self._require_current_video()
-
         raw_field: FieldFile | None = getattr(video, "raw_file", None)
-        source_path: Path | None = None
-        try:
-            if raw_field and raw_field.path:
-                source_path = Path(raw_field.path)
-        except Exception:
-            source_path = None
 
-        if source_path is None and file_path is not None:
-            source_path = Path(file_path)
+        def copy_into_sensitive(source: Path) -> Path:
+            target_dir = VIDEO_DIR / "sensitive"
+            if not target_dir.exists():
+                self.logger.info("Creating sensitive file directory: %s", target_dir)
+                os.makedirs(target_dir, exist_ok=True)
 
-        if source_path is None:
-            raise ValueError("No file path available for creating sensitive file")
-        if not raw_field:
-            raise ValueError(
-                "VideoFile must have a raw_file to create a sensitive file"
-            )
+            target_name = source.name or "raw_video"
+            target_file_path = target_dir / target_name
 
-        target_dir = VIDEO_DIR / "sensitive"
-        if not target_dir.exists():
-            self.logger.info("Creating sensitive file directory: %s", target_dir)
-            os.makedirs(target_dir, exist_ok=True)
+            if source != target_file_path:
+                try:
+                    shutil.copy2(source, target_file_path)
+                    self.logger.info("Copied raw file to sensitive directory: %s", target_file_path)
+                except Exception as exc:
+                    self.logger.warning("Failed to copy raw file to sensitive dir: %s", exc)
+                    shutil.copy(source, target_file_path)
+                    self.logger.info(
+                        "Fallback copy succeeded for sensitive directory: %s",
+                        target_file_path,
+                    )
+            else:
+                self.logger.debug(
+                    "Source path already in sensitive directory: %s",
+                    target_file_path,
+                )
 
-        target_file_path = target_dir / source_path.name
-        try:
-            shutil.move(str(source_path), str(target_file_path))
-            self.logger.info(
-                "Moved raw file to sensitive directory: %s", target_file_path
-            )
-        except Exception as exc:
-            self.logger.warning(
-                "Failed to move raw file to sensitive dir, copying instead: %s", exc
-            )
-            shutil.copy(str(source_path), str(target_file_path))
+            return target_file_path
+
+        target_file_path: Path | None = None
+
+        # Prefer an on-disk path from the FieldFile when available
+        if raw_field:
             try:
-                os.remove(source_path)
-            except FileNotFoundError:
-                pass
+                local_candidate = Path(raw_field.path)
+                if local_candidate.exists():
+                    target_file_path = copy_into_sensitive(local_candidate)
+            except Exception:
+                target_file_path = None
+
+            if target_file_path is None and storage_file_exists(raw_field):
+                try:
+                    with ensure_local_file(raw_field) as temp_source:
+                        target_file_path = copy_into_sensitive(Path(temp_source))
+                except Exception as exc:
+                    self.logger.warning("Failed to download raw_field for sensitive copy: %s", exc)
+
+        if target_file_path is None and file_path is not None:
+            file_candidate = Path(file_path)
+            if file_candidate.exists():
+                target_file_path = copy_into_sensitive(file_candidate)
+
+        if target_file_path is None:
+            context_path = self.processing_context.get("raw_video_path")
+            if context_path:
+                context_candidate = Path(context_path)
+                if context_candidate.exists():
+                    target_file_path = copy_into_sensitive(context_candidate)
+
+        if target_file_path is None:
+            raise ValueError("No file path available for creating sensitive file")
+        if not raw_field:
+            raise ValueError("VideoFile must have a raw_file to create a sensitive file")
 
         try:
             from endoreg_db.utils import data_paths
 
             storage_root = data_paths["storage"]
             relative_path = target_file_path.relative_to(storage_root)
-            video.raw_file.name = str(relative_path)
+            video.raw_file.name = relative_path.as_posix()
             video.save(update_fields=["raw_file"])
             self.logger.info(
                 "Updated video.raw_file to point to sensitive location: %s",
@@ -876,9 +818,7 @@ class VideoImportService:
         self.processing_context["raw_video_path"] = target_file_path
         self.processing_context["video_filename"] = target_file_path.name
 
-        self.logger.info(
-            "Created sensitive file for %s at %s", video.uuid, target_file_path
-        )
+        self.logger.info("Created sensitive file for %s at %s", video.uuid, target_file_path)
         return target_file_path
 
     def _get_processor_roi_info(
@@ -894,9 +834,7 @@ class VideoImportService:
             video_meta = getattr(video, "video_meta", None)
             processor = getattr(video_meta, "processor", None) if video_meta else None
             if processor:
-                assert isinstance(processor, EndoscopyProcessor), (
-                    "Processor is not of type EndoscopyProcessor"
-                )
+                assert isinstance(processor, EndoscopyProcessor), "Processor is not of type EndoscopyProcessor"
                 endoscope_image_roi = processor.get_roi_endoscope_image()
                 endoscope_data_roi_nested = processor.get_sensitive_rois()
                 self.logger.info(
@@ -924,34 +862,26 @@ class VideoImportService:
 
         return endoscope_data_roi_nested, endoscope_image_roi
 
-    def _ensure_default_patient_data(
-        self, video_instance: VideoFile | None = None
-    ) -> None:
+    def _ensure_default_patient_data(self, video_instance: VideoFile | None = None) -> None:
         """Ensure minimum patient data is present on the video's SensitiveMeta."""
 
         video = video_instance or self._require_current_video()
 
         sensitive_meta = getattr(video, "sensitive_meta", None)
         if not sensitive_meta:
-            self.logger.info(
-                "No SensitiveMeta found for video %s, creating default", video.uuid
-            )
+            self.logger.info("No SensitiveMeta found for video %s, creating default", video.uuid)
             default_data = {
                 "patient_first_name": "Patient",
                 "patient_last_name": "Unknown",
                 "patient_dob": date(1990, 1, 1),
                 "examination_date": date.today(),
-                "center_name": video.center.name
-                if video.center
-                else "university_hospital_wuerzburg",
+                "center_name": video.center.name if video.center else "university_hospital_wuerzburg",
             }
             try:
                 sensitive_meta = SensitiveMeta.create_from_dict(default_data)
                 video.sensitive_meta = sensitive_meta
                 video.save(update_fields=["sensitive_meta"])
-                self.logger.info(
-                    "Created default SensitiveMeta for video %s", video.uuid
-                )
+                self.logger.info("Created default SensitiveMeta for video %s", video.uuid)
             except Exception as exc:
                 self.logger.error(
                     "Failed to create default SensitiveMeta for video %s: %s",
@@ -960,32 +890,9 @@ class VideoImportService:
                 )
                 return
         else:
-            update_data: Dict[str, Any] = {}
-            if not sensitive_meta.patient_first_name:
-                update_data["patient_first_name"] = "Patient"
-            if not sensitive_meta.patient_last_name:
-                update_data["patient_last_name"] = "Unknown"
-            if not sensitive_meta.patient_dob:
-                update_data["patient_dob"] = date(1990, 1, 1)
-            if not sensitive_meta.examination_date:
-                update_data["examination_date"] = date.today()
-
-            if update_data:
-                try:
-                    sensitive_meta.update_from_dict(update_data)
-                    state = video.get_or_create_state()
-                    state.mark_sensitive_meta_processed(save=True)
-                    self.logger.info(
-                        "Updated missing SensitiveMeta fields for video %s: %s",
-                        video.uuid,
-                        list(update_data.keys()),
-                    )
-                except Exception as exc:
-                    self.logger.error(
-                        "Failed to update SensitiveMeta for video %s: %s",
-                        video.uuid,
-                        exc,
-                    )
+            state = video.get_or_create_state()
+            state.mark_sensitive_meta_processed(save=True)
+
 
     def _ensure_frame_cleaning_available(self):
         """
@@ -995,25 +902,24 @@ class VideoImportService:
             Tuple of (availability_flag, FrameCleaner_class, ReportReader_class)
         """
         try:
-            # Check if we can find lx-anonymizer
-            from lx_anonymizer import FrameCleaner  # type: ignore[import]
-
-            if FrameCleaner:
-                return True, FrameCleaner()
-
+            from lx_anonymizer import FrameCleaner
         except Exception as e:
-            self.logger.warning(
-                f"Frame cleaning not available: {e} Please install or update lx_anonymizer."
-            )
+            self.logger.warning(f"Frame cleaning not available: {e} Please install or update lx_anonymizer.")
+            _available = False
+            FrameCleaner = None
 
-        return False, None
+        assert FrameCleaner is not None
+        frame_cleaner = FrameCleaner()
+        _available = True
+
+        return _available, frame_cleaner
 
     def _perform_frame_cleaning(self, endoscope_data_roi_nested, endoscope_image_roi):
         """Perform frame cleaning and anonymization."""
         # Instantiate frame cleaner
         is_available, frame_cleaner = self._ensure_frame_cleaning_available()
 
-        if not is_available:
+        if not is_available or frame_cleaner is None:
             raise RuntimeError("Frame cleaning not available")
 
         # Prepare parameters for frame cleaning
@@ -1030,9 +936,7 @@ class VideoImportService:
         video = self._require_current_video()
         # Ensure raw_video_path is not None
         if not raw_video_path:
-            raise RuntimeError(
-                "raw_video_path is None, cannot construct cleaned_video_path"
-            )
+            raise RuntimeError("raw_video_path is None, cannot construct cleaned_video_path")
         suffix = Path(raw_video_path).suffix or ".mp4"
         cleaned_filename = f"cleaned_{video.uuid}{suffix}"
         cleaned_video_path = Path(raw_video_path).parent / cleaned_filename
@@ -1053,13 +957,9 @@ class VideoImportService:
 
         # Update sensitive metadata with extracted information
         self._update_sensitive_metadata(extracted_metadata)
-        self.logger.info(
-            f"Extracted metadata from frame cleaning: {extracted_metadata}"
-        )
+        self.logger.info(f"Extracted metadata from frame cleaning: {extracted_metadata}")
 
-        self.logger.info(
-            f"Frame cleaning with ROI masking completed: {actual_cleaned_path}"
-        )
+        self.logger.info(f"Frame cleaning with ROI masking completed: {actual_cleaned_path}")
         self.logger.info("Cleaned video will be moved to anonym_videos during cleanup")
 
     def _update_sensitive_metadata(self, extracted_metadata: Dict[str, Any]):
@@ -1096,21 +996,15 @@ class VideoImportService:
 
                         center_obj = Center.objects.get(name=center_name)
                         metadata_to_update["center"] = center_obj
-                        self.logger.debug(
-                            "Loaded center object '%s' from center_name", center_name
-                        )
+                        self.logger.debug("Loaded center object '%s' from center_name", center_name)
                         metadata_to_update.pop("center_name", None)
                     except Center.DoesNotExist:
-                        self.logger.error(
-                            "Center '%s' not found in database", center_name
-                        )
+                        self.logger.error("Center '%s' not found in database", center_name)
                         return
 
         try:
             sm.update_from_dict(metadata_to_update)
-            updated_fields = list(
-                extracted_metadata.keys()
-            )  # Only log originally extracted fields
+            updated_fields = list(extracted_metadata.keys())  # Only log originally extracted fields
         except KeyError as e:
             self.logger.warning(f"Failed to update SensitiveMeta field {e}")
             return
@@ -1126,9 +1020,7 @@ class VideoImportService:
 
                 state = video.get_or_create_state()
                 state.mark_sensitive_meta_processed(save=True)
-                self.logger.info(
-                    "Marked sensitive metadata as processed for video %s", video.uuid
-                )
+                self.logger.info("Marked sensitive metadata as processed for video %s", video.uuid)
             except Exception as e:
                 self.logger.error(f"Failed to save SensitiveMeta: {e}")
                 raise  # Re-raise to trigger fallback in calling method
@@ -1144,18 +1036,9 @@ class VideoImportService:
             video = self._require_current_video()
 
             raw_field: FieldFile | None = getattr(video, "raw_file", None)
-            raw_exists = False
-            if raw_field and getattr(raw_field, "path", None):
-                try:
-                    raw_exists = Path(raw_field.path).exists()
-                except (ValueError, OSError):
-                    raw_exists = False
-
-            video_processing_complete = (
-                video.sensitive_meta is not None
-                and video.video_meta is not None
-                and raw_exists
-            )
+            raw_exists = storage_file_exists(raw_field)
+
+            video_processing_complete = video.sensitive_meta is not None and video.video_meta is not None and raw_exists
 
             if video_processing_complete:
                 self.logger.info(
@@ -1189,15 +1072,44 @@ class VideoImportService:
     def _cleanup_on_error(self):
         """Cleanup processing context on error."""
         if self.current_video and hasattr(self.current_video, "state"):
+            if self.current_video.state is None:
+                try:
+                    self.current_video.get_or_create_state()
+                except Exception as e:
+                    self.logger.warning(f"Video state not found for video {self.current_video.uuid} during error cleanup {e}")
+                    return
+            self.current_video.state = self.current_video.get_or_create_state()
+            try:
+                if self.original_file_path is not None:
+                    assert Path(self.original_file_path).exists()
+                else:
+                    self.logger.warning("Original file path is None")
+                self.logger.info("Marked video import as failed in state")
+                raw_file_path = getattr(self.current_video.raw_file, "path", None)
+                original_file_path = self.original_file_path
+                if raw_file_path and original_file_path:
+                    shutil.copy2(str(raw_file_path), str(original_file_path))
+                else:
+                    self.logger.warning("Cannot restore original raw file: path is None")
+            except AssertionError:
+                self.logger.warning("Original file path does not exist")
             try:
+                
+                if not isinstance(self.current_video.state, VideoState):
+                    logger.error("Current video is none after Assertion for Video File")
+                    raise AssertionError
+                    
+                
                 if self.processing_context.get("processing_started"):
                     self.current_video.state.frames_extracted = False
                     self.current_video.state.frames_initialized = False
                     self.current_video.state.video_meta_extracted = False
                     self.current_video.state.text_meta_extracted = False
                     self.current_video.state.save()
+                
             except Exception as e:
                 self.logger.warning(f"Error during cleanup: {e}")
+            
 
     def _cleanup_processing_context(self):
         """
@@ -1226,9 +1138,7 @@ class VideoImportService:
                 file_path_str = str(file_path)
                 if file_path_str in self.processed_files:
                     self.processed_files.remove(file_path_str)
-                    self.logger.info(
-                        f"Removed {file_path_str} from processed files (failed processing)"
-                    )
+                    self.logger.info(f"Removed {file_path_str} from processed files (failed processing)")
 
         except Exception as e:
             self.logger.warning(f"Error during context cleanup: {e}")