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

endoreg_db/services/video_import.py

@@ -22,10 +22,12 @@ 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 numpy import ma
+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 = 600  # 10 minutes - reclaim locks older than this
+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__)
@@ -43,7 +45,7 @@ class VideoImportService():
         - 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:
@@ -60,6 +62,8 @@ class VideoImportService():
         self.current_video = None
         self.processing_context: Dict[str, Any] = {}
         
+        self.delete_source = False
+        
         self.logger = logging.getLogger(__name__)
     
     @contextmanager
@@ -132,7 +136,7 @@ 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.
@@ -264,42 +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
-        ext = Path(self.current_video.active_file_path).suffix or ".mp4"
-        video_filename = f"{self.current_video.uuid}{ext}"
-        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("Moved raw video to: %s", raw_target_path)
-        except Exception as e:
-            self.logger.error("Failed to move video to final storage: %s", 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("Updated raw_file path to: %s", 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("Failed to update raw_file path: %s", 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("Updated raw_file path using fallback: %s", f"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."""
@@ -345,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
@@ -398,50 +453,78 @@ class VideoImportService():
                 # 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.
-        
-        This method tries multiple fallback strategies:
-        1. Use VideoFile.anonymize_video() method if available
-        2. Simple copy of raw video to anonym_videos (no processing)
-        
-        The processed video will be marked in processing_context for _cleanup_and_archive().
         """
         try:
             self.logger.info("Attempting fallback video anonymization...")
-            
-            # Strategy 1: Try VideoFile.pipe_2() method
-            if hasattr(self.current_video, 'pipe_2'):
-                self.logger.info("Trying VideoFile.pipe_2() method...")
-                
-                # Try to anonymize
-                if self.current_video.pipe_2:
-                    self.logger.info("VideoFile.pipe_2() succeeded")
+            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("VideoFile.pipe_2() returned False, trying simple copy fallback")
             else:
-                self.logger.warning("VideoFile.pipe_2() method not available")
+                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)")
-            
-            # The _cleanup_and_archive() method will handle the copy
-            # We just need to mark that no real anonymization happened
             self.processing_context['anonymization_completed'] = False
-            self.processing_context['use_raw_as_processed'] = True  # Signal for cleanup
-            
+            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...")
@@ -590,6 +673,18 @@ class VideoImportService():
                 self.logger.info("Removed remaining source file: %s", source_path)
             except Exception as 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 (in-memory tracking)
         self.processed_files.add(str(self.processing_context['file_path']))
@@ -599,6 +694,7 @@ class VideoImportService():
             self.current_video.refresh_from_db()
             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("Import and anonymization completed for VideoFile UUID: %s", self.current_video.uuid)
         self.logger.info("Raw video stored in: /data/videos")

endoreg_db/utils/paths.py

@@ -8,19 +8,12 @@ It provides a unified dictionary 'data_paths' for accessing all path objects.
 from logging import getLogger
 logger = getLogger(__name__)
 
-import os
 from pathlib import Path
 from typing import Dict
-import dotenv
 
-# Only load .env in non-pytest contexts to avoid leaking dev settings into tests
-if not os.environ.get("PYTEST_CURRENT_TEST"):
-    dotenv.load_dotenv()
-else:
-    logger.debug("Skipping .env load under pytest")
+from endoreg_db.config.env import env_path
 
-# Define BASE_DIR as the project root (endoreg_db/utils -> endoreg_db -> repo root)
-STORAGE_DIR = Path(os.getenv("STORAGE_DIR"))
+STORAGE_DIR = env_path("STORAGE_DIR", "storage")
 
 # Resolve STORAGE_DIR from env or default under BASE_DIR
 #def _resolve_storage_dir() -> Path:
@@ -36,7 +29,6 @@ STORAGE_DIR = Path(os.getenv("STORAGE_DIR"))
 STORAGE_DIR.mkdir(parents=True, exist_ok=True)
 
 PREFIX_RAW = "raw_"
-STORAGE_DIR_NAME = "data"
 IMPORT_DIR_NAME = "import"
 EXPORT_DIR_NAME = "export"
 

endoreg_db/utils/video/ffmpeg_wrapper.py

@@ -1,6 +1,8 @@
+import os
 import subprocess
 import json
 import logging
+from functools import lru_cache
 from pathlib import Path
 from typing import List, Dict, Optional, Tuple
 import cv2
@@ -13,6 +15,67 @@ logger = logging.getLogger("ffmpeg_wrapper")
 _nvenc_available = None
 _preferred_encoder = None
 
+
+@lru_cache(maxsize=1)
+def _resolve_ffmpeg_executable() -> Optional[str]:
+    """Locate the ffmpeg executable using multiple discovery strategies."""
+    # 1) Explicit overrides via env vars
+    env_candidates = [
+        os.environ.get("FFMPEG_EXECUTABLE"),
+        os.environ.get("FFMPEG_BINARY"),
+        os.environ.get("FFMPEG_PATH"),
+    ]
+
+    # 2) Django settings overrides (if Django is configured)
+    try:
+        from django.conf import settings  # type: ignore
+
+        env_candidates.extend(
+            getattr(settings, attr)
+            for attr in ("FFMPEG_EXECUTABLE", "FFMPEG_BINARY", "FFMPEG_PATH")
+            if hasattr(settings, attr)
+        )
+    except Exception:
+        # Django might not be configured for every consumer
+        pass
+
+    # Normalize and verify explicit candidates
+    for candidate in env_candidates:
+        if not candidate:
+            continue
+        candidate_path = Path(candidate)
+        if candidate_path.is_dir():
+            candidate_path = candidate_path / "ffmpeg"
+        if candidate_path.exists() and os.access(candidate_path, os.X_OK):
+            logger.debug("Using ffmpeg executable override at %s", candidate_path)
+            return str(candidate_path)
+
+    # 3) PATH lookup (shutil.which)
+    via_path = shutil.which("ffmpeg")
+    if via_path:
+        return via_path
+
+    # 4) Common fallback locations (useful for Nix-based environments)
+    nix_store = Path("/nix/store")
+    if nix_store.exists():
+        patterns = (
+            "*-ffmpeg-*/bin/ffmpeg",
+            "*-ffmpeg-headless-*/bin/ffmpeg",
+            "*-ffmpeg-headless*/bin/ffmpeg",
+        )
+        for pattern in patterns:
+            matches = sorted(nix_store.glob(pattern))
+            if matches:
+                logger.debug("Discovered ffmpeg in nix store at %s", matches[-1])
+                return str(matches[-1])
+
+    # 5) Final fallback to standard Unix locations
+    for fallback in (Path("/usr/bin/ffmpeg"), Path("/usr/local/bin/ffmpeg")):
+        if fallback.exists() and os.access(fallback, os.X_OK):
+            return str(fallback)
+
+    return None
+
 def _detect_nvenc_support() -> bool:
     """
     Detect if NVIDIA NVENC hardware acceleration is available.
@@ -163,7 +226,7 @@ def is_ffmpeg_available() -> bool:
     Returns:
         True if FFmpeg is found in the PATH; otherwise, False.
     """
-    return shutil.which("ffmpeg") is not None
+    return _resolve_ffmpeg_executable() is not None
 
 def check_ffmpeg_availability():
     """
@@ -607,8 +670,8 @@ def extract_frames(
     Returns:
         A list of Path objects for the extracted frames.
     """
-    # Check if ffmpeg command exists
-    ffmpeg_executable = shutil.which("ffmpeg")
+    # Resolve ffmpeg executable with multiple fallbacks
+    ffmpeg_executable = _resolve_ffmpeg_executable()
     if not ffmpeg_executable:
         error_msg = "ffmpeg command not found. Ensure FFmpeg is installed and in the system's PATH."
         logger.error(error_msg)
@@ -691,7 +754,7 @@ def extract_frame_range(
         logger.warning("extract_frame_range called with start_frame (%d) >= end_frame (%d). No frames to extract.", start_frame, end_frame)
         return []
 
-    ffmpeg_executable = shutil.which("ffmpeg")
+    ffmpeg_executable = _resolve_ffmpeg_executable()
     if not ffmpeg_executable:
         error_msg = "ffmpeg command not found. Ensure FFmpeg is installed and in the system's PATH."
         logger.error(error_msg)

endoreg_db/views/anonymization/validate.py

@@ -1,11 +1,18 @@
+import logging
+from typing import Any, Dict, cast
+
+from django.db import transaction
 from rest_framework import status
 from rest_framework.response import Response
 from rest_framework.views import APIView
-from django.db import transaction
-from endoreg_db.models import VideoFile, RawPdfFile
+
+from endoreg_db.models import RawPdfFile, VideoFile
 from endoreg_db.serializers.anonymization import SensitiveMetaValidateSerializer
 
 
+logger = logging.getLogger(__name__)
+
+
 class AnonymizationValidateView(APIView):
     """
     POST /api/anonymization/<int:file_id>/validate/
@@ -32,35 +39,69 @@ class AnonymizationValidateView(APIView):
         # Serializer-Validierung mit deutscher Datums-Priorität
         serializer = SensitiveMetaValidateSerializer(data=request.data or {})
         serializer.is_valid(raise_exception=True)
-        payload = serializer.validated_data
-        payload.setdefault("is_verified", True)
-
-        # Try Video first
-        if payload.get("file_type") == "video" or not payload.get("file_type"):
-            video = VideoFile.objects.filter(pk=file_id).first()
-        if video:
-            # Ensure center_name is in payload for hash calculation
-            if video.center and not payload.get("center_name"):
-                payload["center_name"] = video.center.name
-                
-            ok = video.validate_metadata_annotation(payload)
-            #if ok:
-            #    video._cleanup_raw_assets()
-            if not ok:
-                return Response({"error": "Video validation failed."}, status=status.HTTP_400_BAD_REQUEST)
-            return Response({"message": "Video validated."}, status=status.HTTP_200_OK)
-
-        # Then PDF
-        if payload.get("file_type") == "pdf" or not payload.get("file_type"):
-            pdf = RawPdfFile.objects.filter(pk=file_id).first()
-        if pdf:
-            # Ensure center_name is in payload for hash calculation
-            if pdf.center and not payload.get("center_name"):
-                payload["center_name"] = pdf.center.name
-                
-            ok = pdf.validate_metadata_annotation(payload)
-            if not ok:
-                return Response({"error": "PDF validation failed."}, status=status.HTTP_400_BAD_REQUEST)
-            return Response({"message": "PDF validated."}, status=status.HTTP_200_OK)
-
-        return Response({"error": f"Item {file_id} not found as video or pdf."}, status=status.HTTP_404_NOT_FOUND)
+        validated_data = cast(Dict[str, Any], serializer.validated_data)
+        payload: Dict[str, Any] = dict(validated_data)
+        if "is_verified" not in payload:
+            payload["is_verified"] = True
+
+        file_type = payload.get("file_type")
+
+        # Try Video first (unless explicitly requesting PDF)
+        if file_type in (None, "video"):
+            video = VideoFile.objects.select_related("center").filter(pk=file_id).first()
+            if video is not None:
+                prepared_payload = self._prepare_payload(payload, video)
+                try:
+                    ok = video.validate_metadata_annotation(prepared_payload)
+                except Exception:  # pragma: no cover - defensive safety net
+                    logger.exception("Video validation crashed for id=%s", file_id)
+                    return Response(
+                        {"error": "Video validation encountered an unexpected error."},
+                        status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    )
+
+                if not ok:
+                    return Response({"error": "Video validation failed."}, status=status.HTTP_400_BAD_REQUEST)
+
+                return Response({"message": "Video validated."}, status=status.HTTP_200_OK)
+
+            if file_type == "video":
+                return Response({"error": f"Video {file_id} not found."}, status=status.HTTP_404_NOT_FOUND)
+
+        # Then PDF (unless explicitly requesting Video)
+        if file_type in (None, "pdf"):
+            pdf = RawPdfFile.objects.select_related("center").filter(pk=file_id).first()
+            if pdf is not None:
+                prepared_payload = self._prepare_payload(payload, pdf)
+                try:
+                    ok = pdf.validate_metadata_annotation(prepared_payload)
+                except Exception:  # pragma: no cover - defensive safety net
+                    logger.exception("PDF validation crashed for id=%s", file_id)
+                    return Response(
+                        {"error": "PDF validation encountered an unexpected error."},
+                        status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    )
+
+                if not ok:
+                    return Response({"error": "PDF validation failed."}, status=status.HTTP_400_BAD_REQUEST)
+
+                return Response({"message": "PDF validated."}, status=status.HTTP_200_OK)
+
+            if file_type == "pdf":
+                return Response({"error": f"PDF {file_id} not found."}, status=status.HTTP_404_NOT_FOUND)
+
+        return Response({"error": f"Item {file_id} not found as video or pdf."}, status=status.HTTP_404_NOT_FOUND)
+
+    @staticmethod
+    def _prepare_payload(base_payload: Dict[str, Any], file_obj: Any) -> Dict[str, Any]:
+        """Return a fresh payload tailored for the given file object."""
+
+        prepared = dict(base_payload)
+        prepared.pop("file_type", None)
+
+        center = getattr(file_obj, "center", None)
+        center_name = getattr(center, "name", None)
+        if center_name and not prepared.get("center_name"):
+            prepared["center_name"] = center_name
+
+        return prepared

endoreg_db/views/video/correction.py

@@ -64,15 +64,17 @@ def update_segments_after_frame_removal(video: VideoFile, removed_frames: list)
         return {'segments_updated': 0, 'segments_deleted': 0, 'segments_unchanged': 0}
     
     removed_frames = sorted(set(removed_frames))  # Ensure sorted and unique
-    segments = LabelVideoSegment.objects.filter(video=video).order_by('start_frame')
+    segments = LabelVideoSegment.objects.filter(
+        video_file=video
+    ).order_by('start_frame_number')
     
     segments_updated = 0
     segments_deleted = 0
     segments_unchanged = 0
     
     for segment in segments:
-        original_start = segment.start_frame
-        original_end = segment.end_frame
+        original_start = segment.start_frame_number
+        original_end = segment.end_frame_number
         
         # Count frames removed before this segment
         frames_before = sum(1 for f in removed_frames if f < original_start)
@@ -99,9 +101,9 @@ def update_segments_after_frame_removal(video: VideoFile, removed_frames: list)
                 f"{original_start}-{original_end} → {new_start}-{new_end} "
                 f"(before: {frames_before}, within: {frames_within})"
             )
-            segment.start_frame = new_start
-            segment.end_frame = new_end
-            segment.save()
+            segment.start_frame_number = new_start
+            segment.end_frame_number = new_end
+            segment.save(update_fields=["start_frame_number", "end_frame_number"])
             segments_updated += 1
         else:
             # No change needed

{endoreg_db-0.8.2.dist-info → endoreg_db-0.8.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: endoreg-db
-Version: 0.8.2
+Version: 0.8.2.1
 Summary: EndoReg Db Django App
 Project-URL: Homepage, https://info.coloreg.de
 Project-URL: Repository, https://github.com/wg-lux/endoreg-db
@@ -33,7 +33,7 @@ Requires-Dist: gunicorn>=23.0.0
 Requires-Dist: icecream>=2.1.4
 Requires-Dist: librosa==0.11.0
 Requires-Dist: llvmlite>=0.44.0
-Requires-Dist: lx-anonymizer[llm,ocr]>=0.8.2
+Requires-Dist: lx-anonymizer[llm,ocr]>=0.8.2.1
 Requires-Dist: moviepy==2.2.1
 Requires-Dist: mypy>=1.16.0
 Requires-Dist: numpy>=2.2.3