endoreg-db 0.8.1__py3-none-any.whl → 0.8.2.1__py3-none-any.whl

endoreg_db/services/video_import.py

@@ -3,29 +3,49 @@ Video import service module.
 
 Provides high-level functions for importing and anonymizing video files,
 combining VideoFile creation with frame-level anonymization.
+
+Changelog:
+    October 14, 2025: Added file locking mechanism to prevent race conditions
+                      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 pathlib import Path
-from typing import TYPE_CHECKING, Union, Dict, Any, Optional
+from typing import Union, Dict, Any, Optional
 from django.db import transaction
-from django.core.exceptions import FieldError
 from endoreg_db.models import VideoFile, SensitiveMeta
 from endoreg_db.utils.paths import STORAGE_DIR, RAW_FRAME_DIR, VIDEO_DIR, ANONYM_VIDEO_DIR
 import random
 from lx_anonymizer.ocr import trocr_full_image_ocr
+from endoreg_db.utils.hashs import get_video_hash
+from endoreg_db.models.media.video.video_file_anonymize import _cleanup_raw_assets
+
+
+# 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
+
+logger = logging.getLogger(__name__)
 
 
 class VideoImportService():
     """
     Service for importing and anonymizing video files.
     Uses a central video instance pattern for cleaner state management.
+    
+    Features (October 14, 2025):
+        - File locking to prevent concurrent processing of the same video
+        - Stale lock detection and reclamation (600s timeout)
+        - Hash-based duplicate detection
+        - Graceful fallback processing without lx_anonymizer
     """
     
-    def __init__(self, project_root: Path = None):
+    def __init__(self, project_root: Optional[Path] = None):
         
         # Set up project root path
         if project_root:
@@ -42,11 +62,69 @@ class VideoImportService():
         self.current_video = None
         self.processing_context: Dict[str, Any] = {}
         
-        if TYPE_CHECKING:
-            from endoreg_db.models import VideoFile
-
+        self.delete_source = False
+        
         self.logger = logging.getLogger(__name__)
     
+    @contextmanager
+    def _file_lock(self, path: Path):
+        """
+        Create a file lock to prevent duplicate processing of the same video.
+        
+        This context manager creates a .lock file alongside the video file.
+        If the lock file already exists, it checks if it's stale (older than
+        STALE_LOCK_SECONDS) and reclaims it if necessary. If it's not stale,
+        we now WAIT (up to MAX_LOCK_WAIT_SECONDS) instead of failing immediately.
+        """
+        lock_path = Path(str(path) + ".lock")
+        fd = None
+        try:
+            deadline = time.time() + MAX_LOCK_WAIT_SECONDS
+            while True:
+                try:
+                    # Atomic create; fail if exists
+                    fd = os.open(lock_path, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o644)
+                    break  # acquired
+                except FileExistsError:
+                    # Check for stale lock
+                    age = None
+                    try:
+                        st = os.stat(lock_path)
+                        age = time.time() - st.st_mtime
+                    except FileNotFoundError:
+                        # Race: lock removed between exists and stat; retry acquire in next loop
+                        age = None
+                    
+                    if age is not None and age > STALE_LOCK_SECONDS:
+                        try:
+                            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)
+                        # Loop continues and retries acquire immediately
+                        continue
+                    
+                    # Not stale: wait until deadline, then give up gracefully
+                    if time.time() >= deadline:
+                        raise ValueError(f"File already being processed: {path}")
+                    time.sleep(1.0)
+            
+            os.write(fd, b"lock")
+            os.close(fd)
+            fd = None
+            yield
+        finally:
+            try:
+                if fd is not None:
+                    os.close(fd)
+                if lock_path.exists():
+                    lock_path.unlink()
+            except OSError:
+                pass
+    
     def processed(self) -> bool:
         """Indicates if the current file has already been processed."""
         return getattr(self, '_processed', False)
@@ -58,31 +136,25 @@ class VideoImportService():
         processor_name: str,
         save_video: bool = True,
         delete_source: bool = True,
-    ) -> "VideoFile":
+    ) -> "VideoFile|None":
         """
         High-level helper that orchestrates the complete video import and anonymization process.
         Uses the central video instance pattern for improved state management.
-
-        Args:
-            file_path: Path to the video file to import
-            center_name: Name of the center to associate with video
-            processor_name: Name of the processor to associate with video
-            save_video: Whether to save the video file
-            delete_source: Whether to delete the source file after import
-            
-        Returns:
-            VideoFile instance after import and anonymization
-            
-        Raises:
-            Exception: On any failure during import or anonymization
         """
         try:
             # Initialize processing context
             self._initialize_processing_context(file_path, center_name, processor_name, 
                                                save_video, delete_source)
             
-            # Validate and prepare file
-            self._validate_and_prepare_file()
+            # Validate and prepare file (may raise ValueError if another worker holds a non-stale lock)
+            try:
+                self._validate_and_prepare_file()
+            except ValueError as ve:
+                # Relaxed behavior: if another process is working on this file, skip cleanly
+                if "already being processed" in str(ve):
+                    self.logger.info(f"Skipping {file_path}: {ve}")
+                    return None
+                raise
             
             # Create or retrieve video instance
             self._create_or_retrieve_video_instance()
@@ -126,24 +198,40 @@ class VideoImportService():
         self.logger.info(f"Initialized processing context for: {file_path}")
 
     def _validate_and_prepare_file(self):
-        """Validate the video file and prepare for processing."""
+        """
+        Validate the video file and prepare for processing.
+        
+        Uses file locking to prevent concurrent processing of the same video file.
+        This prevents race conditions where multiple workers might try to process
+        the same video simultaneously.
+        
+        The lock is acquired here and held for the entire import process.
+        See _file_lock() for lock reclamation logic.
+        """
         file_path = self.processing_context['file_path']
         
-        # Check if already processed
+        # Acquire file lock to prevent concurrent processing
+        # Lock will be held until finally block in import_and_anonymize()
+        self.processing_context['_lock_context'] = self._file_lock(file_path)
+        self.processing_context['_lock_context'].__enter__()
+        
+        self.logger.info("Acquired file lock for: %s", file_path)
+        
+        # Check if already processed (memory-based check)
         if str(file_path) in self.processed_files:
-            self.logger.info(f"File {file_path} already processed, skipping")
-            self.processed = True
+            self.logger.info("File %s already processed, skipping", file_path)
+            self._processed = True
             raise ValueError(f"File already processed: {file_path}")
         
         # Check file exists
         if not file_path.exists():
             raise FileNotFoundError(f"Video file not found: {file_path}")
         
-        self.logger.info(f"File validation completed for: {file_path}")
+        self.logger.info("File validation completed for: %s", file_path)
 
     def _create_or_retrieve_video_instance(self):
         """Create or retrieve the VideoFile instance and move to final storage."""
-        from endoreg_db.models import VideoFile
+        # Removed duplicate import of VideoFile (already imported at module level)
         
         self.logger.info("Creating VideoFile instance...")
         
@@ -161,7 +249,7 @@ class VideoImportService():
         # Immediately move to final storage locations
         self._move_to_final_storage()
         
-        self.logger.info(f"Created VideoFile with UUID: {self.current_video.uuid}")
+        self.logger.info("Created VideoFile with UUID: %s", self.current_video.uuid)
         
         # Get and mark processing state
         state = VideoFile.get_or_create_state(self.current_video)
@@ -180,41 +268,90 @@ class VideoImportService():
         from endoreg_db.utils import data_paths
         
         source_path = self.processing_context['file_path']
-        
-        # Define target directories
-        videos_dir = data_paths["video"]  # /data/videos for raw files
+
+        videos_dir = data_paths["video"]
         videos_dir.mkdir(parents=True, exist_ok=True)
-        
-        # Create target path for raw video in /data/videos
-        video_filename = f"{self.current_video.uuid}_{Path(source_path).name}"
-        raw_target_path = videos_dir / video_filename
-        
-        # Move source file to raw video storage
-        try:
-            shutil.move(str(source_path), str(raw_target_path))
-            self.logger.info(f"Moved raw video to: {raw_target_path}")
-        except Exception as e:
-            self.logger.error(f"Failed to move video to final storage: {e}")
-            raise
-        
-        # Update the raw_file path in database (relative to storage root)
+
+        _current_video = self.current_video
+        assert _current_video is not None, "Current video instance is None during storage move"
+
+        stored_raw_path = None
+        if hasattr(_current_video, "get_raw_file_path"):
+            possible_path = _current_video.get_raw_file_path()
+            if possible_path:
+                try:
+                    stored_raw_path = Path(possible_path)
+                except (TypeError, ValueError):
+                    stored_raw_path = None
+
+        if stored_raw_path:
+            try:
+                storage_root = data_paths["storage"]
+                if stored_raw_path.is_absolute():
+                    if not stored_raw_path.is_relative_to(storage_root):
+                        stored_raw_path = None
+                else:
+                    if stored_raw_path.parts and stored_raw_path.parts[0] == videos_dir.name:
+                        stored_raw_path = storage_root / stored_raw_path
+                    else:
+                        stored_raw_path = videos_dir / stored_raw_path.name
+            except Exception:
+                stored_raw_path = None
+
+        if stored_raw_path and not stored_raw_path.suffix:
+            stored_raw_path = None
+
+        if not stored_raw_path:
+            uuid_str = getattr(_current_video, "uuid", None)
+            source_suffix = Path(source_path).suffix or ".mp4"
+            filename = f"{uuid_str}{source_suffix}" if uuid_str else Path(source_path).name
+            stored_raw_path = videos_dir / filename
+
+        delete_source = bool(self.processing_context.get('delete_source'))
+        stored_raw_path.parent.mkdir(parents=True, exist_ok=True)
+
+        if not stored_raw_path.exists():
+            try:
+                if source_path.exists():
+                    if delete_source:
+                        shutil.move(str(source_path), str(stored_raw_path))
+                        self.logger.info("Moved raw video to: %s", stored_raw_path)
+                    else:
+                        shutil.copy2(str(source_path), str(stored_raw_path))
+                        self.logger.info("Copied raw video to: %s", stored_raw_path)
+                else:
+                    raise FileNotFoundError(f"Neither stored raw path nor source path exists for {self.processing_context['file_path']}")
+            except Exception as e:
+                self.logger.error("Failed to place video in final storage: %s", e)
+                raise
+        else:
+            # If we already have the stored copy, respect delete_source flag without touching assets unnecessarily
+            if delete_source and source_path.exists():
+                try:
+                    os.remove(source_path)
+                    self.logger.info("Removed original source file after storing copy: %s", source_path)
+                except OSError as e:
+                    self.logger.warning("Failed to remove source file %s: %s", source_path, e)
+
+        # Ensure database path points to stored location (relative to storage root)
         try:
             storage_root = data_paths["storage"]
-            relative_path = raw_target_path.relative_to(storage_root)
-            self.current_video.raw_file.name = str(relative_path)
-            self.current_video.save(update_fields=['raw_file'])
-            self.logger.info(f"Updated raw_file path to: {relative_path}")
+            relative_path = Path(stored_raw_path).relative_to(storage_root)
+            if _current_video.raw_file.name != str(relative_path):
+                _current_video.raw_file.name = str(relative_path)
+                _current_video.save(update_fields=['raw_file'])
+                self.logger.info("Updated raw_file path to: %s", relative_path)
         except Exception as e:
-            self.logger.error(f"Failed to update raw_file path: {e}")
-            # Fallback to simple relative path
-            self.current_video.raw_file.name = f"videos/{video_filename}"
-            self.current_video.save(update_fields=['raw_file'])
-            self.logger.info(f"Updated raw_file path using fallback: videos/{video_filename}")
-            
-        
+            self.logger.error("Failed to ensure raw_file path is relative: %s", e)
+            fallback_relative = Path("videos") / Path(stored_raw_path).name
+            if _current_video.raw_file.name != fallback_relative.as_posix():
+                _current_video.raw_file.name = fallback_relative.as_posix()
+                _current_video.save(update_fields=['raw_file'])
+                self.logger.info("Updated raw_file path using fallback: %s", fallback_relative.as_posix())
+
         # Store paths for later processing
-        self.processing_context['raw_video_path'] = raw_target_path
-        self.processing_context['video_filename'] = video_filename
+        self.processing_context['raw_video_path'] = Path(stored_raw_path)
+        self.processing_context['video_filename'] = Path(stored_raw_path).name
 
     def _setup_processing_environment(self):
         """Setup the processing environment without file movement."""
@@ -260,7 +397,10 @@ class VideoImportService():
         # Check frame cleaning availability
         frame_cleaning_available, FrameCleaner, ReportReader = self._ensure_frame_cleaning_available()
         
-        if not (frame_cleaning_available and self.current_video.raw_file):
+        _current_video = self.current_video
+        assert _current_video is not None, "Current video instance is None during frame processing"
+
+        if not (frame_cleaning_available and _current_video.raw_file):
             self.logger.warning("Frame cleaning not available or conditions not met, using fallback anonymization.")
             self._fallback_anonymize_video()
             return
@@ -271,64 +411,175 @@ class VideoImportService():
             # Get processor ROI information
             processor_roi, endoscope_roi = self._get_processor_roi_info()
             
-            # Perform frame cleaning
-            self._perform_frame_cleaning(FrameCleaner, processor_roi, endoscope_roi)
+            # Perform frame cleaning with timeout to prevent blocking
+            from concurrent.futures import ThreadPoolExecutor, TimeoutError as FutureTimeoutError
             
-            self.processing_context['anonymization_completed'] = True
+            with ThreadPoolExecutor(max_workers=1) as executor:
+                future = executor.submit(self._perform_frame_cleaning, FrameCleaner, processor_roi, endoscope_roi)
+                try:
+                    # Increased timeout to better accommodate ffmpeg + OCR
+                    future.result(timeout=300)
+                    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 = self.current_video.processed_file
+                    found = False
+                    if expected_cleaned is not None:
+                        for _ in range(grace_seconds):
+                            if expected_cleaned.exists():
+                                self.processing_context['cleaned_video_path'] = expected_cleaned
+                                self.processing_context['anonymization_completed'] = True
+                                self.logger.info("Detected cleaned video during grace period: %s", expected_cleaned)
+                                found = True
+                                break
+                            time.sleep(1)
+                    else:
+                        self._fallback_anonymize_video()
+                    if not found:
+                        raise TimeoutError("Frame cleaning operation timed out - likely Ollama connection issue")
             
         except Exception as e:
-            self.logger.warning(f"Frame cleaning failed, continuing with original video: {e}")
-            self.processing_context['anonymization_completed'] = False
-            self.processing_context['error_reason'] = f"Frame cleaning failed: {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)
+                # 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}"
+
+    def _save_anonymized_video(self):
+        anonymized_video_path = self.current_video.get_target_anonymized_video_path()
+        
+        if not anonymized_video_path.exists():
+            raise RuntimeError(f"Processed video file not found after assembly for {self.current_video.uuid}: {anonymized_video_path}")
+
+        new_processed_hash = get_video_hash(anonymized_video_path)
+        if type(self.current_video).objects.filter(processed_video_hash=new_processed_hash).exclude(pk=self.current_video.pk).exists():
+            raise ValueError(f"Processed video hash {new_processed_hash} already exists for another video (Video: {self.current_video.uuid}).")
+
+        self.current_video.processed_video_hash = new_processed_hash
+        self.current_video.processed_file.name = anonymized_video_path.relative_to(STORAGE_DIR).as_posix()
+
+        update_fields = [
+            "processed_video_hash",
+            "processed_file",
+            "frame_dir",
+        ]
+
+        if self.delete_source:
+            original_raw_file_path_to_delete = self.current_video.get_raw_file_path()
+            original_raw_frame_dir_to_delete = self.current_video.get_frame_dir_path()
+
+            self.current_video.raw_file.name = None
+
+            update_fields.extend(["raw_file", "video_hash"])
+
+            transaction.on_commit(lambda: _cleanup_raw_assets(
+                video_uuid=self.current_video.uuid,
+                raw_file_path=original_raw_file_path_to_delete,
+                raw_frame_dir=original_raw_frame_dir_to_delete
+            ))
+
+        self.current_video.save(update_fields=update_fields)
+        self.current_video.state.mark_anonymized(save=True)
+        self.current_video.refresh_from_db()
+        return True
 
     def _fallback_anonymize_video(self):
-        """Fallback to create anonymized video if lx_anonymizer is not available."""
+        """
+        Fallback to create anonymized video if lx_anonymizer is not available.
+        """
         try:
-            self.logger.info("Attempting to anonymize video using fallback method.")
-            # This requires sensitive meta to be verified.
-            if self.current_video.sensitive_meta:
-                self.current_video.sensitive_meta.is_verified = True
-                self.current_video.sensitive_meta.save()
-
-            if self.current_video.anonymize_video(delete_original_raw=False):
-                self.logger.info("Fallback anonymization successful.")
-                self.processing_context['anonymization_completed'] = True
+            self.logger.info("Attempting fallback video anonymization...")
+            if self.current_video:
+                # Try VideoFile.pipe_2() method if available
+                if hasattr(self.current_video, 'pipe_2'):
+                    self.logger.info("Trying VideoFile.pipe_2() method...")
+                    if self.current_video.pipe_2():
+                        self.logger.info("VideoFile.pipe_2() succeeded")
+                        self.processing_context['anonymization_completed'] = True
+                        return
+                    else:
+                        self.logger.warning("VideoFile.pipe_2() returned False")
+                # Try direct anonymization via _anonymize
+                if _anonymize(self.current_video, delete_original_raw=self.delete_source):
+                    self.logger.info("VideoFile._anonymize() succeeded")
+                    self.processing_context['anonymization_completed'] = True
+                    return
             else:
-                self.logger.warning("Fallback anonymization failed.")
-                self.processing_context['anonymization_completed'] = False
-                self.processing_context['error_reason'] = "Fallback anonymization failed"
+                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.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)")
         except Exception as e:
             self.logger.error(f"Error during fallback anonymization: {e}", exc_info=True)
             self.processing_context['anonymization_completed'] = False
-            self.processing_context['error_reason'] = f"Fallback anonymization failed: {e}"
-
+            self.processing_context['error_reason']
     def _finalize_processing(self):
         """Finalize processing and update video state."""
         self.logger.info("Updating video processing state...")
         
         with transaction.atomic():
             # Update basic processing states
+            # Ensure state exists before accessing it
+
+            if not self.current_video:
+                try:
+                    self.current_video.refresh_from_db()
+                except Exception as e:
+                    self.logger.error(f"Failed to refresh current_video from DB: {e}")
+                if not self.current_video:
+                    raise RuntimeError("No current video instance available for finalization")
+                
+            if not self.current_video.processed_file:
+                self.logger.warning("No processed file available for current video")
+                self.current_video.processed_file = None  # Ensure field is not None
+                self.current_video.mark_sensitive_meta_processed = False
+            else:
+                self.current_video.mark_sensitive_meta_processed = True
+            
+            state = self.current_video.get_or_create_state()
+            if not state:
+                raise RuntimeError("Failed to get or create video state")
+            
             # Only mark frames as extracted if they were successfully extracted
             if self.processing_context.get('frames_extracted', False):
-                self.current_video.state.frames_extracted = True
+                state.frames_extracted = True
                 self.logger.info("Marked frames as extracted in state")
             else:
                 self.logger.warning("Frames were not extracted, not updating state")
                 
-            self.current_video.state.frames_initialized = True
-            self.current_video.state.video_meta_extracted = True
-            self.current_video.state.text_meta_extracted = True
+            # Always mark these as true (metadata extraction attempts were made)
+            state.frames_initialized = True
+            state.video_meta_extracted = True
+            state.text_meta_extracted = True
             
-            # Mark sensitive meta as processed
-            self.current_video.state.mark_sensitive_meta_processed(save=False)
-            
-            # Update completion status based on anonymization success
-            if self.processing_context['anonymization_completed']:
-                self.logger.info(f"Video {self.current_video.uuid} successfully anonymized")
+            # ✅ FIX: Only mark as processed if anonymization actually completed
+            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")
             else:
-                self.logger.warning(f"Video {self.current_video.uuid} imported but not anonymized")
+                self.logger.warning(
+                    "Anonymization NOT completed - NOT marking as processed. "
+                    f"Reason: {self.processing_context.get('error_reason', 'Unknown')}"
+                )
+                # Explicitly mark as NOT processed
+                state.sensitive_meta_processed = False
             
+            # Save all state changes
+            state.save()
+            self.logger.info("Video processing state updated")       
             # Save all state changes
             self.current_video.state.save()
             self.current_video.save()
@@ -361,61 +612,91 @@ class VideoImportService():
                 # Copy raw to processed location (will be moved to anonym_videos)
                 try:
                     shutil.copy2(str(raw_video_path), str(processed_video_path))
-                    self.logger.info(f"Copied raw video for processing: {processed_video_path}")
+                    self.logger.info("Copied raw video for processing: %s", processed_video_path)
                 except Exception as e:
-                    self.logger.error(f"Failed to copy raw video: {e}")
-                    processed_video_path = raw_video_path  # Use original as fallback
+                    self.logger.error("Failed to copy raw video: %s", e)
+                    processed_video_path = None  # FIXED: Don't use raw as fallback
         
-        # Move processed video to anonym_videos
+        # Move processed video to anonym_videos ONLY if it exists
         if processed_video_path and Path(processed_video_path).exists():
             try:
-                anonym_video_filename = f"anonym_{self.processing_context.get('video_filename', Path(processed_video_path).name)}"
+                # ✅ Clean filename: no original filename leakage
+                ext = Path(processed_video_path).suffix or ".mp4"
+                anonym_video_filename = f"anonym_{self.current_video.uuid}{ext}"
                 anonym_target_path = anonym_videos_dir / anonym_video_filename
-                
+
+                # Move processed video to anonym_videos/
                 shutil.move(str(processed_video_path), str(anonym_target_path))
-                self.logger.info(f"Moved processed video to: {anonym_target_path}")
-                
-                storage_root = data_paths["storage"]
-                relative_path = anonym_target_path.relative_to(storage_root)
-                
-                # Update the file field in database (for processed video)
-                try:
-                    self.current_video.processed_file = str(relative_path)
-                    self.current_video.save(update_fields=['processed_file'])
-                    self.logger.info(f"Updated file path to: {relative_path}")
-                except FieldError:
-                    self.logger.warning("Field 'processed_file' does not exist on VideoFile, skipping update")
-                    raise FieldError                    
+                self.logger.info("Moved processed video to: %s", anonym_target_path)
+
+                # Verify the file actually exists before updating database
+                if anonym_target_path.exists():
+                    try:
+                        storage_root = data_paths["storage"]
+                        relative_path = anonym_target_path.relative_to(storage_root)
+                        # Save relative path (e.g. anonym_videos/anonym_<uuid>.mp4)
+                        self.current_video.processed_file.name = str(relative_path)
+                        self.current_video.save(update_fields=["processed_file"])
+                        self.logger.info("Updated processed_file path to: %s", relative_path)
+                    except Exception as e:
+                        self.logger.error("Failed to update processed_file path: %s", e)
+                        # Fallback to simple relative path
+                        self.current_video.processed_file.name = f"anonym_videos/{anonym_video_filename}"
+                        self.current_video.save(update_fields=['processed_file'])
+                        self.logger.info(
+                            "Updated processed_file path using fallback: %s",
+                            f"anonym_videos/{anonym_video_filename}",
+                        )
+
+                    self.processing_context['anonymization_completed'] = True
+                else:
+                    self.logger.warning("Processed video file not found after move: %s", anonym_target_path)
             except Exception as e:
-                self.logger.error(f"Failed to move processed video to anonym_videos: {e}")
+                self.logger.error("Failed to move processed video to anonym_videos: %s", e)
+        else:
+            self.logger.warning("No processed video available - processed_file will remain empty")
+            # Leave processed_file empty/null - frontend should fall back to raw_file
         
         # Cleanup temporary directories
         try:
             from endoreg_db.utils.paths import RAW_FRAME_DIR
             shutil.rmtree(RAW_FRAME_DIR, ignore_errors=True)
-            self.logger.debug(f"Cleaned up temporary frames directory: {RAW_FRAME_DIR}")
+            self.logger.debug("Cleaned up temporary frames directory: %s", RAW_FRAME_DIR)
         except Exception as e:
-            self.logger.warning(f"Failed to remove directory {RAW_FRAME_DIR}: {e}")
+            self.logger.warning("Failed to remove directory %s: %s", RAW_FRAME_DIR, e)
         
         # Handle source file deletion - this should already be moved, but check raw_videos
         source_path = self.processing_context['file_path']
         if self.processing_context['delete_source'] and Path(source_path).exists():
             try:
                 os.remove(source_path)
-                self.logger.info(f"Removed remaining source file: {source_path}")
+                self.logger.info("Removed remaining source file: %s", source_path)
             except Exception as e:
-                self.logger.warning(f"Failed to remove source file {source_path}: {e}")
+                self.logger.warning("Failed to remove source file %s: %s", source_path, e)
+                
+        # Check if processed video exists and otherwise call anonymize
+        
+        if not self.current_video.processed_file or not Path(self.current_video.processed_file.path).exists():
+            self.logger.warning("No processed_file found after cleanup - video will be unprocessed")
+            self.current_video.anonymize(delete_original_raw=self.delete_source)
+            self.current_video.save(update_fields=['processed_file'])
+            
+        
+        self.logger.info("Cleanup and archiving completed")
         
-        # Mark as processed
+        
+        
+        # Mark as processed (in-memory tracking)
         self.processed_files.add(str(self.processing_context['file_path']))
         
         # Refresh from database and finalize state
         with transaction.atomic():
             self.current_video.refresh_from_db()
-            if hasattr(self.current_video, 'state'):
+            if hasattr(self.current_video, 'state') and self.processing_context.get('anonymization_completed'):
                 self.current_video.state.mark_sensitive_meta_processed(save=True)
+                
         
-        self.logger.info(f"Import and anonymization completed for VideoFile UUID: {self.current_video.uuid}")
+        self.logger.info("Import and anonymization completed for VideoFile UUID: %s", self.current_video.uuid)
         self.logger.info("Raw video stored in: /data/videos")
         self.logger.info("Processed video stored in: /data/anonym_videos")
     
@@ -805,13 +1086,13 @@ class VideoImportService():
         
         # Define default/placeholder values that are safe to overwrite
         SAFE_TO_OVERWRITE_VALUES = [
-            'Patient',           # Default first name
-            'Unknown',           # Default last name
+            'Vorname unbekannt',           # Default first name
+            'Nachname unbekannt',           # Default last name
             date(1990, 1, 1),   # Default DOB
             None,               # Empty values
             '',                 # Empty strings
             'N/A',              # Placeholder values
-            'Unknown Device',   # Default device name
+            'Unbekanntes Gerät',   # Default device name
         ]
         
         for meta_key, sm_field in metadata_mapping.items():
@@ -881,12 +1162,30 @@ class VideoImportService():
                 self.logger.warning(f"Error during cleanup: {e}")
 
     def _cleanup_processing_context(self):
-        """Cleanup processing context."""
+        """
+        Cleanup processing context and release file lock.
+        
+        This method is always called in the finally block of import_and_anonymize()
+        to ensure the file lock is released even if processing fails.
+        """
         try:
-            # Clean up any temporary processing artifacts
-            if self.processing_context.get('frames_extracted'):
-                # Cleanup handled in _cleanup_and_archive
-                pass
+            # Release file lock if it was acquired
+            lock_context = self.processing_context.get('_lock_context')
+            if lock_context is not None:
+                try:
+                    lock_context.__exit__(None, None, None)
+                    self.logger.info("Released file lock")
+                except Exception as e:
+                    self.logger.warning(f"Error releasing file lock: {e}")
+            
+            # Remove file from processed set if processing failed
+            file_path = self.processing_context.get('file_path')
+            if file_path and not self.processing_context.get('anonymization_completed'):
+                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)")
+            
         except Exception as e:
             self.logger.warning(f"Error during context cleanup: {e}")
         finally: