endoreg-db 0.4.5__py3-none-any.whl → 0.8.6.3__py3-none-any.whl

endoreg_db/models/media/video/video_file_frames/_mark_frames_extracted_status.py

@@ -0,0 +1,65 @@
+import logging
+from typing import TYPE_CHECKING, Set
+from django.db import transaction
+
+if TYPE_CHECKING:
+    from endoreg_db.models import VideoFile
+
+logger = logging.getLogger(__name__)
+
+@transaction.atomic
+def _mark_frames_extracted_status(video: "VideoFile", extracted_frame_numbers: Set[int], status: bool):
+    """
+    Bulk updates the is_extracted status for a set of frame numbers.
+    """
+    from endoreg_db.models.media.frame import Frame
+    if not extracted_frame_numbers:
+        logger.warning("No frame numbers provided to update status for video %s.", video.uuid)
+        return 0
+
+    # --- Enhanced Logging ---
+    min_frame = min(extracted_frame_numbers) if extracted_frame_numbers else 'N/A'
+    max_frame = max(extracted_frame_numbers) if extracted_frame_numbers else 'N/A'
+    contains_zero = 0 in extracted_frame_numbers
+    logger.info(
+        "Attempting to mark %d Frame objects as is_extracted=%s for video %s. Frame numbers range: [%s-%s]. Contains frame 0: %s",
+        len(extracted_frame_numbers), status, video.uuid, min_frame, max_frame, contains_zero
+    )
+    # --- End Enhanced Logging ---
+
+    try:
+        # Update Frame objects based on frame_number
+        # Convert set to list for potentially better compatibility with some DB backends
+        updated_count = Frame.objects.filter(
+            video=video,
+            frame_number__in=list(extracted_frame_numbers)
+        ).update(is_extracted=status)
+
+        logger.info("Database reported updating %d Frame objects to is_extracted=%s for video %s.", updated_count, status, video.uuid)
+
+        # Verification step
+        if updated_count != len(extracted_frame_numbers):
+            logger.warning(
+                 "Mismatch during status update for video %s. Expected to update %d frames, but DB reported updating %d.",
+                 video.uuid, len(extracted_frame_numbers), updated_count
+             )
+             # --- Add detailed check for frame 0 if status is True and it should have been updated ---
+            if status is True and contains_zero and updated_count < len(extracted_frame_numbers):
+                try:
+                    # Check the status of frame 0 directly after the update attempt
+                    frame_zero = Frame.objects.get(video_file=video, frame_number=0)
+                    if not frame_zero.is_extracted:
+                        logger.error("Verification check: Frame 0 (PK: %s) was NOT updated to is_extracted=True for video %s.", frame_zero.pk, video.uuid)
+                    else:
+                        # This case should ideally not happen if updated_count < expected count, but log just in case
+                        logger.info("Verification check: Frame 0 (PK: %s) IS is_extracted=True for video %s, despite count mismatch.", frame_zero.pk, video.uuid)
+                except Frame.DoesNotExist:
+                    logger.error("Verification check: Frame 0 does not exist for video %s during status check.", video.uuid)
+                except Exception as verify_e:
+                    logger.error("Verification check: Error checking frame 0 status for video %s: %s", video.uuid, verify_e)
+             # --- End detailed check ---
+
+        return updated_count
+    except Exception as e:
+        logger.error("Failed to bulk update is_extracted status for video %s: %s", video.uuid, e, exc_info=True)
+        raise # Re-raise to ensure transaction rollback if needed

endoreg_db/models/media/video/video_file_io.py

@@ -0,0 +1,168 @@
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional
+from django.db import transaction
+
+from ...utils import data_paths, ANONYM_VIDEO_DIR, VIDEO_DIR # Import VIDEO_DIR for correct path resolution
+
+if TYPE_CHECKING:
+    from .video_file import VideoFile
+
+logger = logging.getLogger("video_file")
+
+def _get_raw_file_path(video: "VideoFile") -> Optional[Path]:
+    """
+    Resolves and returns the absolute path to the raw video file if available.
+    The FileField stores a path relative to the storage root. We need to join
+    that relative path onto the actual video directory under STORAGE_DIR.
+    """
+    try:
+        if video.has_raw and video.raw_file.name:
+            # raw_file.name is a relative storage path like 'videos/<filename>'
+            raw_rel = Path(video.raw_file.name)
+            
+            # If it already contains the video directory name, keep the tail
+            rel_name = raw_rel.name if raw_rel.parent.name == VIDEO_DIR.name else raw_rel
+            full_path = data_paths["video"] / rel_name
+            
+            # If primary path doesn't exist, check alternative locations
+            if not full_path.exists():
+                # Check if file is in sensitive subdirectory
+                sensitive_path = data_paths["video"] / "sensitive" / rel_name
+                if sensitive_path.exists():
+                    return sensitive_path.resolve()
+                
+                # Check direct raw_file.path if available
+                # Check direct raw_file.path if available
+                try:
+                    direct_path = Path(video.raw_file.path)
+                    if direct_path.exists():
+                        return direct_path.resolve()
+                except Exception as e:
+                    logger.debug("Could not access direct raw_file.path for video %s: %s", video.uuid, e)
+                    # Fallback to checking alternative paths
+                
+                # Check common alternative paths
+                alternative_paths = [
+                    Path("/home/admin/dev/lx-annotate/libs/data/videos") / rel_name,
+                    Path("/home/admin/dev/lx-annotate/libs/data/videos/sensitive") / rel_name,
+                    data_paths["video"].parent / "libs" / "data" / "videos" / rel_name,
+                ]
+                
+                for alt_path in alternative_paths:
+                    if alt_path.exists():
+                        return alt_path.resolve()
+            
+            return full_path.resolve()
+        else:
+            return None
+    except Exception as e:
+        logger.warning("Could not get path for raw file of VideoFile %s: %s", video.uuid, e)
+        return None
+
+def _get_processed_file_path(video: "VideoFile") -> Optional[Path]:
+    """Returns the absolute Path object for the processed file, if it exists."""
+    try:
+        if video.is_processed and video.processed_file.name:
+            return Path(video.processed_file.path)
+        else:
+            return None
+    except Exception as e:
+        logger.warning("Could not get path for processed file of VideoFile %s: %s", video.uuid, e)
+        return None
+
+@transaction.atomic
+def _delete_with_file(video: "VideoFile", *args, **kwargs):
+    """Deletes the VideoFile record and its associated physical files (raw, processed, frames)."""
+    # 1. Delete Frames (using the frame helper function via instance method)
+    try:
+        # delete_frames raises RuntimeError on state update failure
+        frame_delete_msg = video.delete_frames()
+        logger.info("Frame deletion result for video %s: %s", video.uuid, frame_delete_msg)
+    except Exception as frame_del_e:
+        # Log error but continue, as file deletion might still be possible
+        logger.error("Error during frame file/state deletion for video %s: %s", video.uuid, frame_del_e, exc_info=True)
+
+    # 2. Delete Raw File
+    raw_file_path = _get_raw_file_path(video)
+    if raw_file_path:
+        try:
+            if raw_file_path.exists():
+                raw_file_path.unlink()
+                logger.info("Deleted raw video file for %s: %s", video.uuid, raw_file_path)
+            else:
+                logger.warning("Raw video file not found at %s for video %s, skipping deletion.", raw_file_path, video.uuid)
+
+        except Exception as e:
+            # Log error but continue
+            logger.error("Error deleting raw video file %s for video %s: %s", raw_file_path, video.uuid, e, exc_info=True)
+
+    # 3. Delete Processed File
+    processed_file_path = _get_processed_file_path(video)
+    if processed_file_path:
+        try:
+            if processed_file_path.exists():
+                processed_file_path.unlink()
+                logger.info("Deleted processed video file for %s: %s", video.uuid, processed_file_path)
+            else:
+                logger.warning("Processed video file not found at %s for video %s, skipping deletion.", processed_file_path, video.uuid)
+        except Exception as e:
+            # Log error but continue
+            logger.error("Error deleting processed video file %s for video %s: %s", processed_file_path, video.uuid, e, exc_info=True)
+
+    # 4. Delete Database Record
+    try:
+        # Use 'super(type(video), video)' to call the parent's delete method
+        super(type(video), video).delete(*args, **kwargs)
+        logger.info("Deleted VideoFile database record PK %s (UUID: %s).", video.pk, video.uuid)
+
+        return f"Successfully deleted VideoFile {video.uuid} and attempted file cleanup."
+    except Exception as e:
+        logger.error("Error deleting VideoFile database record PK %s (UUID: %s): %s", video.pk, video.uuid, e, exc_info=True)
+        raise # Re-raise the exception for DB deletion failure
+
+def _get_base_frame_dir(video: "VideoFile") -> Path:
+    """Gets the base directory path for storing extracted frames."""
+    # Assuming data_paths['frame'] is the root directory for all frame storage
+    return data_paths["frame"] / str(video.uuid)
+
+
+def _set_frame_dir(video: "VideoFile", force_update: bool = False):
+    """Sets the frame_dir field based on the video's UUID."""
+    target_dir = _get_base_frame_dir(video)
+    target_path_str = target_dir.as_posix() # Store as POSIX path string
+
+    if not video.frame_dir or video.frame_dir != target_path_str or force_update:
+        video.frame_dir = target_path_str
+        logger.info("Set frame_dir for video %s to %s", video.uuid, video.frame_dir)
+        # Avoid saving if called from within the save method itself
+        if not getattr(video, '_saving', False):
+            video.save(update_fields=['frame_dir'])
+
+
+def _get_frame_dir_path(video: "VideoFile") -> Optional[Path]:
+    """Returns the Path object for the frame directory, if set."""
+    if not video.frame_dir:
+        _set_frame_dir(video)
+    
+    return Path(video.frame_dir) 
+
+def _get_temp_anonymized_frame_dir(video: "VideoFile") -> Path:
+    """Gets the path for the temporary directory used during anonymization frame creation."""
+    base_frame_dir = _get_base_frame_dir(video)
+    # Place temp dir alongside the final frame dir but with a prefix/suffix
+    anon_dir = base_frame_dir.parent / f"anonymizing_{base_frame_dir.name}"
+    return anon_dir
+
+
+def _get_target_anonymized_video_path(video: "VideoFile") -> Path:
+    """Determines the target path for the anonymized/processed video file."""
+    if not video.has_raw or not video.raw_file.name:
+        # If raw is gone, maybe base it on UUID? Requires careful thought.
+        # For now, assume raw is needed to determine the original filename base.
+        raise ValueError("Cannot determine target anonymized path without a raw file reference.")
+
+    # Use the filename part of the raw file's relative path
+    raw_path_relative = Path(video.raw_file.name)
+    # Place it in the ANONYM_VIDEO_DIR using the same filename
+    return ANONYM_VIDEO_DIR / raw_path_relative.name

endoreg_db/models/media/video/video_file_meta/__init__.py

@@ -0,0 +1,22 @@
+import logging
+
+# Import functions from submodule files to make them available directly
+from .text_meta import _update_text_metadata
+from .video_meta import _update_video_meta
+from .initialize_video_specs import _initialize_video_specs
+from .get_fps import _get_fps
+from .get_endo_roi import _get_endo_roi
+from .get_crop_template import _get_crop_template
+
+
+logger = logging.getLogger(__name__)
+
+# Define __all__ if you want to control what `from .video_file_meta import *` imports
+__all__ = [
+    '_update_text_metadata',
+    '_update_video_meta',
+    '_initialize_video_specs',
+    '_get_fps',
+    '_get_endo_roi',
+    '_get_crop_template',
+]

endoreg_db/models/media/video/video_file_meta/get_crop_template.py

@@ -0,0 +1,45 @@
+import logging
+from typing import TYPE_CHECKING, Optional, List, Dict
+from .get_endo_roi import _get_endo_roi
+
+if TYPE_CHECKING:
+    from ..video_file import VideoFile
+
+logger = logging.getLogger(__name__)
+
+
+def _get_crop_template(video: "VideoFile") -> Optional[List[int]]:
+    """Generates a crop template [y1, y2, x1, x2] from the endo ROI."""
+    endo_roi = _get_endo_roi(video) # Use the helper function
+    if not endo_roi:
+        logger.warning("Cannot generate crop template for video %s: Endo ROI not available.", video.uuid)
+        return None
+
+    x = endo_roi["x"]
+    y = endo_roi["y"]
+    width = endo_roi["width"]
+    height = endo_roi["height"]
+
+    # Validate dimensions
+    if None in [x, y, width, height] or width <= 0 or height <= 0:
+        logger.warning("Invalid ROI dimensions for video %s: %s", video.uuid, endo_roi)
+        return None
+
+    # Ensure crop boundaries are within image dimensions if available
+    img_h, img_w = video.height, video.width
+    if img_h and img_w:
+        y1 = max(0, y)
+        y2 = min(img_h, y + height)
+        x1 = max(0, x)
+        x2 = min(img_w, x + width)
+        if y1 >= y2 or x1 >= x2:
+            logger.warning("Calculated crop template has zero or negative size for video %s. ROI: %s, Img: %dx%d", video.uuid, endo_roi, img_w, img_h)
+            return None
+        crop_template = [y1, y2, x1, x2]
+    else:
+        # Proceed without boundary check if image dimensions unknown
+        crop_template = [y, y + height, x, x + width]
+
+
+    logger.debug("Generated crop template for video %s: %s", video.uuid, crop_template)
+    return crop_template

endoreg_db/models/media/video/video_file_meta/get_endo_roi.py

@@ -0,0 +1,39 @@
+import logging
+from typing import TYPE_CHECKING, Optional, Dict
+
+if TYPE_CHECKING:
+    from ..video_file import VideoFile
+
+logger = logging.getLogger(__name__)
+
+def _get_endo_roi(video: "VideoFile") -> Optional[Dict[str, int]]:
+    """
+    Gets the endoscope region of interest (ROI) dictionary from the linked VideoMeta.
+
+    The ROI dictionary typically contains 'x', 'y', 'width', 'height'.
+    Returns None if VideoMeta is not linked or ROI is not properly defined.
+    """
+    if not video.video_meta:
+        logger.warning("VideoMeta not linked for video %s. Cannot get endo ROI.", video.uuid)
+        return None
+
+    try:
+        # Assuming VideoMeta has a method get_endo_roi()
+        endo_roi = video.video_meta.get_endo_roi()
+        # Basic validation
+        if (
+            isinstance(endo_roi, dict)
+            and all(k in endo_roi for k in ("x", "y", "width", "height"))
+            and all(isinstance(v, int) and not isinstance(v, bool) for v in endo_roi.values())
+        ):
+            logger.debug("Retrieved endo ROI for video %s: %s", video.uuid, endo_roi)
+            return endo_roi
+        else:
+            logger.warning("Endo ROI not fully defined or invalid in VideoMeta for video %s. ROI: %s", video.uuid, endo_roi)
+            return None
+    except AttributeError:
+        logger.error("VideoMeta object for video %s does not have a 'get_endo_roi' method.", video.uuid)
+        return None
+    except Exception as e:
+        logger.error("Error getting endo ROI from VideoMeta for video %s: %s", video.uuid, e, exc_info=True)
+        return None

endoreg_db/models/media/video/video_file_meta/get_fps.py

@@ -0,0 +1,147 @@
+import logging
+from typing import TYPE_CHECKING, Optional, Dict
+import cv2
+from pathlib import Path
+
+if TYPE_CHECKING:
+    from ..video_file import VideoFile
+
+def _validate_video_path(video_path: Path):
+    """
+    Validates that the provided path is an existing video file.
+    
+    Raises:
+        TypeError: If `video_path` is not a Path object.
+        FileNotFoundError: If the file does not exist at the specified path.
+        IsADirectoryError: If the path points to a directory instead of a file.
+    """
+    if not isinstance(video_path, Path):
+        raise TypeError("video_path must be a Path object")
+    if not video_path.exists():
+        raise FileNotFoundError(f"Video file not found at {video_path}")
+    if not video_path.is_file():
+        raise IsADirectoryError(f"Path is a directory, not a file: {video_path}")
+
+
+logger = logging.getLogger(__name__)
+def _get_fps(video: "VideoFile") -> float:
+    """
+    Determine and return the frames per second (FPS) of a video associated with a VideoFile instance.
+    
+    Attempts to retrieve FPS from the instance itself, its linked VideoMeta, or by direct analysis of the raw video file using OpenCV. Updates and saves the FPS value to the instance if successfully determined. Raises a ValueError if FPS cannot be determined by any method.
+    
+    Returns:
+        float: The frames per second (FPS) of the video.
+    
+    Raises:
+        ValueError: If the FPS cannot be determined from any available source.
+    """
+    from .video_meta import _update_video_meta
+    if video.fps is not None:
+        return video.fps
+
+    logger.debug("FPS not set on instance %s, checking VideoMeta.", video.uuid)
+
+
+    if not video.video_meta:
+        logger.info("VideoMeta not linked for %s, attempting update.", video.uuid)
+
+        _update_video_meta(video, save_instance=True) # Call the helper function
+
+    # Check again after potential update
+    if video.fps is not None:
+        return video.fps
+    elif video.video_meta and video.video_meta.fps is not None:
+        logger.info("Retrieved FPS %.2f from VideoMeta for %s.", video.video_meta.fps, video.uuid)
+        video.fps = video.video_meta.fps
+        # Avoid saving if called from within the save method itself
+        if not getattr(video, '_saving', False):
+            video.save(update_fields=["fps"])
+        return video.fps
+    else:
+        logger.warning("Could not determine FPS from VideoMeta for video %s. Trying direct raw file access.", video.uuid)
+        try:
+            if video.has_raw:
+                video_path = video.get_raw_file_path() # Use helper
+                if video_path and video_path.exists():
+                    cap = cv2.VideoCapture(video_path.as_posix())
+                    if not cap.isOpened():
+                        raise IOError(f"Cannot open video file: {video_path}")
+                    try:
+                        fps = _get_fps_from_property(cap)
+
+                        if fps is None or fps <= 0:
+                            # Reset video capture to the beginning for manual calculation
+                            cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+                            fps = _calculate_fps_manually(cap, video_path)
+                    finally:
+                        cap.release()
+                    if fps and fps > 0:
+                            video.fps = fps
+                            logger.info("Determined FPS %.2f directly from file for %s.", video.fps, video.uuid)
+                            if not getattr(video, '_saving', False):
+                                video.save(update_fields=["fps"])
+                            return video.fps
+                    else:
+                        logger.warning("Could not determine a valid FPS for video file %s.", video_path)
+                elif video_path:
+                    logger.warning("Raw file path %s does not exist for direct FPS check.", video_path)
+                else:
+                    logger.warning("Raw file path is None for direct FPS check.")
+            else:
+                logger.warning("Raw file not available for direct FPS check.")
+
+        except Exception as e:
+            logger.error("Error getting FPS directly from file %s: %s", video.raw_file.name if video.has_raw else 'N/A', e)
+
+        raise ValueError(
+            f"Could not determine FPS for video {video.uuid}. "
+            "Ensure the video file is valid and accessible."
+        )
+
+
+
+# TODO Refactor to utils / check if similar function exists in utils
+def _get_fps_from_property(cap) -> float:
+    """
+    Retrieve the frames per second (FPS) from an OpenCV video capture object using the appropriate property for the OpenCV version.
+    
+    Parameters:
+        cap: An OpenCV video capture object.
+    
+    Returns:
+        float: The FPS value obtained from the video capture properties, or 0.0 if unavailable.
+    """
+    if hasattr(cv2, 'CAP_PROP_FPS'):
+        return cap.get(cv2.CAP_PROP_FPS)
+    # For older OpenCV versions
+    return cap.get(cv2.cv.CV_CAP_PROP_FPS) # type: ignore
+
+
+def _calculate_fps_manually(cap, video_path: Path) -> float:
+    """
+    Estimate the frames per second (FPS) of a video by reading all frames and dividing the total frame count by the elapsed time.
+    
+    Parameters:
+        cap: An OpenCV video capture object positioned at the start of the video.
+        video_path (Path): Path to the video file, used for logging.
+    
+    Returns:
+        float: The estimated FPS, or 0.0 if the duration is zero or calculation fails.
+    """
+    logger.warning(f"Could not get a valid FPS for {video_path}. Trying to calculate manually.")
+    # This is less accurate and slower
+    num_frames = 0
+    start_time = cv2.getTickCount()
+    while True:
+        ret, _ = cap.read()
+        if not ret:
+            break
+        num_frames += 1
+    end_time = cv2.getTickCount()
+    seconds = (end_time - start_time) / cv2.getTickFrequency()
+    if seconds > 0:
+        return num_frames / seconds
+    
+    logger.error(f"Manual FPS calculation failed for {video_path} due to zero duration.")
+    return 0.0

endoreg_db/models/media/video/video_file_meta/initialize_video_specs.py

@@ -0,0 +1,143 @@
+# --- Add Imports ---
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional
+import cv2
+# --- End Add Imports ---
+
+if TYPE_CHECKING:
+    from ..video_file import VideoFile # Correct import path
+
+# --- Add Logger ---
+logger = logging.getLogger(__name__)
+# --- End Add Logger ---
+
+def _initialize_video_specs(video: "VideoFile", use_raw: bool = True) -> bool:
+    """
+    Initializes video specifications for a VideoFile object by reading from the video file.
+    
+    Attempts to populate missing values for fps, width, height, frame count, and duration using OpenCV. Selects the raw file if available and requested, otherwise uses the active file. Updates only unset fields if valid values are obtained. Returns True if successful or if no updates are needed. Raises FileNotFoundError if the video file cannot be found, or RuntimeError if the file cannot be opened or properties cannot be read.
+    """
+    video_path: Optional[Path] = None
+    target_file_name: Optional[str] = None
+
+    if use_raw and video.has_raw:
+        video_path = video.get_raw_file_path() # Use IO helper
+        target_file_name = video.raw_file.name
+    elif video.active_file: # Fallback to active file if raw not requested or available
+        video_path = video.active_file_path # Use property relying on IO helpers
+        target_file_name = video.active_file.name
+    else:
+        logger.error("No suitable video file found for spec initialization for %s.", video.uuid)
+        return False
+
+    if not video_path:
+        # Raise exception
+        raise FileNotFoundError(f"Could not determine video file path for spec initialization for {video.uuid}.")
+
+    logger.info("Initializing video specs directly from file %s (%s) for %s", target_file_name, video_path, video.uuid)
+    try:
+        if not video_path.exists():
+            # Raise exception
+            raise FileNotFoundError(f"Video file not found at {video_path} for spec initialization (Video: {video.uuid}).")
+
+        video_cap = cv2.VideoCapture(video_path.as_posix())
+        if not video_cap.isOpened():
+            # Raise exception
+            video_cap.release() # Ensure release
+            raise RuntimeError(f"Could not open video file {video_path} with OpenCV for spec initialization (Video: {video.uuid}).")
+
+        updated = False
+        fields_to_update = []
+
+        # Get current values before checking
+        current_fps = video.fps
+        current_width = video.width
+        current_height = video.height
+        current_frame_count = video.frame_count
+        current_duration = video.duration
+
+        # --- Get values from OpenCV ---
+        try:
+            file_fps = video_cap.get(cv2.CAP_PROP_FPS)
+            file_width = int(video_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+            file_height = int(video_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            file_frame_count = int(video_cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        except Exception as cv_err:
+            logger.error("Error getting properties from OpenCV for %s (Video: %s): %s", video_path, video.uuid, cv_err, exc_info=True)
+            raise RuntimeError(f"OpenCV failed to get properties for {video_path}") from cv_err
+        finally:
+            video_cap.release() # Ensure release after getting props
+
+        # --- Update FPS ---
+        if current_fps is None and file_fps and file_fps > 0:
+            video.fps = file_fps
+            fields_to_update.append("fps")
+            updated = True
+            current_fps = file_fps # Update local var for duration calc
+
+        # --- Update Width ---
+        if current_width is None and file_width > 0:
+            video.width = file_width
+            fields_to_update.append("width")
+            updated = True
+
+        # --- Update Height ---
+        if current_height is None and file_height > 0:
+            video.height = file_height
+            fields_to_update.append("height")
+            updated = True
+
+        # --- Update Frame Count ---
+        if current_frame_count is None and file_frame_count and file_frame_count > 0:
+            video.frame_count = file_frame_count
+            fields_to_update.append("frame_count")
+            updated = True
+        elif file_frame_count is None or file_frame_count <= 0: # Log if not updated due to invalid file_frame_count
+            logger.warning(
+                "Invalid frame count (value: %s) obtained from OpenCV for %s. Video frame_count not updated.",
+                file_frame_count, video_path
+            )
+
+        # --- Update Duration ---
+        if current_duration is None: # Only if duration isn't already set
+            # Use the potentially updated video.frame_count and current_fps (which reflects video.fps or file_fps)
+            final_frame_count_for_duration = video.frame_count
+            final_fps_for_duration = current_fps # This is video.fps after potential update from file_fps
+
+            if (final_frame_count_for_duration and final_frame_count_for_duration > 0 and
+                final_fps_for_duration and final_fps_for_duration > 0):
+                video.duration = final_frame_count_for_duration / final_fps_for_duration
+                fields_to_update.append("duration")
+                updated = True
+            else:
+                # Log if duration could not be calculated, indicating which component was missing/invalid
+                if not (final_frame_count_for_duration and final_frame_count_for_duration > 0):
+                    logger.warning(
+                        "Duration not calculated for %s: frame count is unavailable or invalid (value: %s).",
+                        video_path, final_frame_count_for_duration
+                    )
+                if not (final_fps_for_duration and final_fps_for_duration > 0):
+                    logger.warning(
+                        "Duration not calculated for %s: FPS is unavailable or invalid (value: %s).",
+                        video_path, final_fps_for_duration
+                    )
+
+
+        # --- Save if updated ---
+        if updated:
+            logger.info("Updated video specs for %s from file %s: %s", video.uuid, target_file_name, ", ".join(fields_to_update))
+            video.save(update_fields=fields_to_update)
+            return True
+        else:
+            logger.info("No video specs needed updating for %s from file %s.", video.uuid, target_file_name)
+            return True
+
+    except Exception as e:
+        # Log and re-raise exception
+        logger.error("Error initializing video specs for %s from file %s: %s", video.uuid, video_path, e, exc_info=True)
+        # Ensure capture is released in case of unexpected error
+        if 'video_cap' in locals() and video_cap.isOpened():
+            video_cap.release()
+        # Re-raise as RuntimeError
+        raise RuntimeError(f"Failed to initialize video specs for {video.uuid} from {video_path}") from e