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

endoreg_db/services/video_import.py

@@ -9,25 +9,24 @@ Changelog:
                       during concurrent video imports (matches PDF import pattern)
 """
 
-from datetime import date
 import logging
-import sys
 import os
 import shutil
 import time
 from contextlib import contextmanager
+from datetime import date
 from pathlib import Path
-from typing import Union, Dict, Any, Optional, List, Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union
+import subprocess
 from django.db import transaction
-from lx_anonymizer import FrameCleaner
-from moviepy import video
-from endoreg_db.models import VideoFile, SensitiveMeta
-from endoreg_db.utils.paths import STORAGE_DIR, VIDEO_DIR, ANONYM_VIDEO_DIR
-import random
-from endoreg_db.utils.hashs import get_video_hash
-from endoreg_db.models.media.video.video_file_anonymize import _cleanup_raw_assets
 from django.db.models.fields.files import FieldFile
-from endoreg_db.models import EndoscopyProcessor
+
+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
@@ -74,8 +73,11 @@ 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
 
@@ -116,7 +118,11 @@ class VideoImportService:
 
                     if age is not None and age > STALE_LOCK_SECONDS:
                         try:
-                            logger.warning("Stale lock detected for %s (age %.0fs). Reclaiming lock...", path, age)
+                            logger.warning(
+                                "Stale lock detected for %s (age %.0fs). Reclaiming lock...",
+                                path,
+                                age,
+                            )
                             lock_path.unlink()
                         except Exception as e:
                             logger.warning("Failed to remove stale lock %s: %s", lock_path, e)
@@ -206,7 +212,14 @@ class VideoImportService:
         finally:
             self._cleanup_processing_context()
 
-    def _initialize_processing_context(self, file_path: Union[Path, str], center_name: str, processor_name: str, save_video: bool, delete_source: bool):
+    def _initialize_processing_context(
+        self,
+        file_path: Union[Path, str],
+        center_name: str,
+        processor_name: str,
+        save_video: bool,
+        delete_source: bool,
+    ):
         """Initialize the processing context for the current video import."""
         self.processing_context = {
             "file_path": Path(file_path),
@@ -219,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}")
 
@@ -270,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")
@@ -319,12 +334,21 @@ class VideoImportService:
         except Exception:
             stored_raw_path = None
 
-        # Fallback: derive from UUID + suffix
+        # Fallback: derive from UUID + suffix - ALWAYS use UUID for consistency
         if not stored_raw_path:
             suffix = source_path.suffix or ".mp4"
             uuid_str = getattr(_current_video, "uuid", None)
-            filename = f"{uuid_str}{suffix}" if uuid_str else source_path.name
+            if uuid_str:
+                filename = f"{uuid_str}{suffix}"
+            else:
+                # Emergency fallback with timestamp to avoid conflicts
+                import time
+
+                timestamp = int(time.time())
+                filename = f"video_{timestamp}{suffix}"
+                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)
 
         delete_source = bool(self.processing_context.get("delete_source", True))
         stored_raw_path.parent.mkdir(parents=True, exist_ok=True)
@@ -369,9 +393,6 @@ class VideoImportService:
         # Initialize video specifications
         video.initialize_video_specs()
 
-        # Initialize frame objects in database
-        video.initialize_frames()
-
         # Extract frames BEFORE processing to prevent pipeline 1 conflicts
         self.logger.info("Pre-extracting frames to avoid pipeline conflicts...")
         try:
@@ -379,6 +400,8 @@ class VideoImportService:
             if frames_extracted:
                 self.processing_context["frames_extracted"] = True
                 self.logger.info("Frame extraction completed successfully")
+                # Initialize frame objects in database
+                video.initialize_frames(video.get_frame_paths())
 
                 # CRITICAL: Immediately save the frames_extracted state to database
                 # to prevent refresh_from_db() in pipeline 1 from overriding it
@@ -420,20 +443,23 @@ class VideoImportService:
             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, TimeoutError as FutureTimeoutError
+            from concurrent.futures import ThreadPoolExecutor
+            from concurrent.futures import TimeoutError as FutureTimeoutError
 
             with ThreadPoolExecutor(max_workers=1) as executor:
-                future = executor.submit(self._perform_frame_cleaning, endoscope_data_roi_nested, endoscope_image_roi)
+                future = executor.submit(
+                    self._perform_frame_cleaning,
+                    endoscope_data_roi_nested,
+                    endoscope_image_roi,
+                )
                 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")
                 except FutureTimeoutError:
                     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
@@ -448,7 +474,10 @@ class VideoImportService:
                             if expected_cleaned_path.exists():
                                 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)
+                                self.logger.info(
+                                    "Detected cleaned video during grace period: %s",
+                                    expected_cleaned_path,
+                                )
                                 found = True
                                 break
                             time.sleep(1)
@@ -494,21 +523,31 @@ 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"])
 
             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_uuid=video.uuid,
+                    raw_file_path=original_raw_file_path_to_delete,
+                    raw_frame_dir=original_raw_frame_dir_to_delete,
                 )
             )
 
         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):
         """
@@ -539,7 +578,11 @@ class VideoImportService:
             try:
                 video.refresh_from_db()
             except Exception as refresh_error:
-                self.logger.warning("Could not refresh VideoFile %s from DB: %s", video.uuid, refresh_error)
+                self.logger.warning(
+                    "Could not refresh VideoFile %s from DB: %s",
+                    video.uuid,
+                    refresh_error,
+                )
 
             state = video.get_or_create_state()
 
@@ -587,8 +630,9 @@ class VideoImportService:
         else:
             raw_video_path = self.processing_context.get("raw_video_path")
             if raw_video_path and Path(raw_video_path).exists():
-                video_filename = self.processing_context.get("video_filename", Path(raw_video_path).name)
-                processed_filename = f"processed_{video_filename}"
+                # Use UUID-based naming to avoid conflicts
+                suffix = Path(raw_video_path).suffix or ".mp4"
+                processed_filename = f"processed_{video.uuid}{suffix}"
                 processed_video_path = Path(raw_video_path).parent / processed_filename
                 try:
                     shutil.copy2(str(raw_video_path), str(processed_video_path))
@@ -624,7 +668,10 @@ class VideoImportService:
 
                     self.processing_context["anonymization_completed"] = True
                 else:
-                    self.logger.warning("Processed video file not found after move: %s", anonym_target_path)
+                    self.logger.warning(
+                        "Processed video file not found after move: %s",
+                        anonym_target_path,
+                    )
             except Exception as exc:
                 self.logger.error("Failed to move processed video to anonym_videos: %s", exc)
         else:
@@ -646,7 +693,7 @@ class VideoImportService:
             except Exception as 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():
+        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)
@@ -663,6 +710,12 @@ class VideoImportService:
         with transaction.atomic():
             video.refresh_from_db()
             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)
@@ -677,48 +730,82 @@ 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
+
+            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_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)
+            return 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))
+        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", relative_path)
+            self.logger.info(
+                "Updated video.raw_file to point to sensitive location: %s",
+                relative_path,
+            )
         except Exception as exc:
             self.logger.warning("Failed to set relative path, using fallback: %s", exc)
             video.raw_file.name = f"videos/sensitive/{target_file_path.name}"
@@ -734,7 +821,9 @@ class VideoImportService:
         self.logger.info("Created sensitive file for %s at %s", video.uuid, target_file_path)
         return target_file_path
 
-    def _get_processor_roi_info(self) -> Tuple[Optional[List[List[Dict[str, Any]]]], Optional[Dict[str, Any]]]:
+    def _get_processor_roi_info(
+        self,
+    ) -> Tuple[Optional[List[List[Dict[str, Any]]]], Optional[Dict[str, Any]]]:
         """Get processor ROI information for masking."""
         endoscope_data_roi_nested = None
         endoscope_image_roi = None
@@ -748,7 +837,10 @@ class VideoImportService:
                 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("Retrieved processor ROI information: endoscope_image_roi=%s", endoscope_image_roi)
+                self.logger.info(
+                    "Retrieved processor ROI information: endoscope_image_roi=%s",
+                    endoscope_image_roi,
+                )
             else:
                 self.logger.warning(
                     "No processor found for video %s, proceeding without ROI masking",
@@ -791,31 +883,16 @@ class VideoImportService:
                 video.save(update_fields=["sensitive_meta"])
                 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", video.uuid, exc)
+                self.logger.error(
+                    "Failed to create default SensitiveMeta for video %s: %s",
+                    video.uuid,
+                    exc,
+                )
                 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):
         """
@@ -825,23 +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.")
+            _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
@@ -854,12 +932,15 @@ class VideoImportService:
             except Exception:
                 raise RuntimeError(f"Raw video path not found: {raw_video_path}")
 
-        # Create temporary output path for cleaned video
-        video_filename = self.processing_context.get("video_filename", Path(raw_video_path).name)
-        cleaned_filename = f"cleaned_{video_filename}"
+        # Create temporary output path for cleaned video using UUID to avoid naming conflicts
+        video = self._require_current_video()
+        # Ensure raw_video_path is not None
         if not raw_video_path:
-            raise RuntimeError("raw_video_path is None after fallback, 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
+        self.logger.debug("Using UUID-based cleaned filename: %s", cleaned_filename)
 
         # Clean video with ROI masking (heavy I/O operation)
         actual_cleaned_path, extracted_metadata = frame_cleaner.clean_video(
@@ -896,21 +977,58 @@ class VideoImportService:
         sm = sensitive_meta
         updated_fields = []
 
+        # Ensure center is set from video.center if not in extracted_metadata
+        metadata_to_update = extracted_metadata.copy()
+
+        # FIX: Set center object instead of center_name string
+        if not hasattr(sm, "center") or not sm.center:
+            if video.center:
+                metadata_to_update["center"] = video.center
+                self.logger.debug(
+                    "Added center object '%s' to metadata for SensitiveMeta update",
+                    video.center.name,
+                )
+            else:
+                center_name = metadata_to_update.get("center_name")
+                if center_name:
+                    try:
+                        from ..models.administration import Center
+
+                        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)
+                        metadata_to_update.pop("center_name", None)
+                    except Center.DoesNotExist:
+                        self.logger.error("Center '%s' not found in database", center_name)
+                        return
+
         try:
-            sm.update_from_dict(extracted_metadata)
-            updated_fields = list(extracted_metadata.keys())
+            sm.update_from_dict(metadata_to_update)
+            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
 
         if updated_fields:
-            sm.save(update_fields=updated_fields)
-            self.logger.info("Updated SensitiveMeta fields for video %s: %s", video.uuid, updated_fields)
+            try:
+                sm.save()  # Remove update_fields to allow all necessary fields to be saved
+                self.logger.info(
+                    "Updated SensitiveMeta fields for video %s: %s",
+                    video.uuid,
+                    updated_fields,
+                )
 
-            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)
+                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)
+            except Exception as e:
+                self.logger.error(f"Failed to save SensitiveMeta: {e}")
+                raise  # Re-raise to trigger fallback in calling method
         else:
-            self.logger.info("No SensitiveMeta fields updated for video %s - all existing values preserved", video.uuid)
+            self.logger.info(
+                "No SensitiveMeta fields updated for video %s - all existing values preserved",
+                video.uuid,
+            )
 
     def _signal_completion(self):
         """Signal completion to the tracking system."""
@@ -918,21 +1036,23 @@ 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
+            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("Video %s processing completed successfully - ready for validation", video.uuid)
+                self.logger.info(
+                    "Video %s processing completed successfully - ready for validation",
+                    video.uuid,
+                )
 
                 # Update completion flags if they exist
                 completion_fields = []
-                for field_name in ["import_completed", "processing_complete", "ready_for_validation"]:
+                for field_name in [
+                    "import_completed",
+                    "processing_complete",
+                    "ready_for_validation",
+                ]:
                     if hasattr(video, field_name):
                         setattr(video, field_name, True)
                         completion_fields.append(field_name)
@@ -952,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):
         """