endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/models/media/video/video_file_io.py

@@ -0,0 +1,272 @@
+import logging
+from contextlib import contextmanager
+from pathlib import Path
+from typing import TYPE_CHECKING, Iterator, Optional
+
+from django.db import transaction
+
+from endoreg_db.utils.paths import ANONYM_VIDEO_DIR, data_paths
+
+from ....utils import delete_field_file, ensure_local_file, storage_file_exists
+
+if TYPE_CHECKING:
+    from .video_file import VideoFile
+
+logger = logging.getLogger("video_file")
+
+
+def _get_raw_file_path(video: "VideoFile") -> Optional[Path]:
+    """Return the best-effort absolute path to the raw video on disk."""
+    if not (video.has_raw and video.raw_file.name):
+        return None
+
+    # 1) Canonical: use Django's storage path
+    try:
+        direct_path = Path(video.raw_file.path)
+        if direct_path.is_file():
+            return direct_path.resolve()
+        else:
+            logger.debug(
+                "raw_file.path for video %s is not a regular file: %s",
+                video.video_hash,
+                direct_path,
+            )
+    except Exception as exc:
+        logger.debug(
+            "Could not access raw_file.path for video %s: %s",
+            video.video_hash,
+            exc,
+        )
+
+    # 2) Fallback: use just the filename and search in known dirs
+    raw_rel = Path(video.raw_file.name)
+    filename = raw_rel.name  # strip any (possibly wrong) prefix
+
+    candidates = [
+        data_paths["import_video"] / filename,
+        data_paths["sensitive_video"] / filename,
+    ]
+
+    for candidate in candidates:
+        if candidate.is_file():
+            return candidate
+
+    logger.warning(
+        "Raw video file '%s' not found in import/sensitive paths or via stored FileField path for video %s.",
+        video.raw_file.name,
+        video.video_hash,
+    )
+    return None
+
+
+@contextmanager
+def _ensure_local_raw_file(video: "VideoFile") -> Iterator[Path]:
+    """Yield a local filesystem path for the raw file, downloading if required."""
+    if not video.has_raw:
+        raise ValueError(f"Video {video.video_hash} has no raw file")
+
+    with ensure_local_file(video.raw_file) as local_path:
+        yield local_path
+
+
+def _get_processed_file_path(video: "VideoFile") -> Optional[Path]:
+    """Returns the absolute Path object for the processed file, if it exists."""
+    processed_field = getattr(video, "processed_file", None)
+    if not (video.is_processed and processed_field and processed_field.name):
+        return None
+    try:
+        direct_path = Path(processed_field.path)
+        if direct_path.exists():
+            return direct_path.resolve()
+    except Exception as exc:
+        logger.debug(
+            "Could not access direct processed_file.path for video %s: %s",
+            video.video_hash,
+            exc,
+        )
+        direct_path = None
+
+    if processed_field and storage_file_exists(processed_field):
+        logger.debug(
+            "Processed file for %s available only via storage backend", video.video_hash
+        )
+    else:
+        logger.warning(
+            "Could not get path for processed file of VideoFile %s: %s",
+            video.video_hash,
+            "path unavailable",
+        )
+    return None
+
+
+@contextmanager
+def _ensure_local_processed_file(video: "VideoFile") -> Iterator[Path]:
+    """Yield a local path to the processed file, downloading if necessary."""
+    if not video.is_processed:
+        raise ValueError(f"Video {video.video_hash} has no processed file")
+
+    with ensure_local_file(video.processed_file) as local_path:
+        yield local_path
+
+
+@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.video_hash, 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.video_hash,
+            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.video_hash, raw_file_path
+                )
+            else:
+                logger.warning(
+                    "Raw video file not found at %s for video %s, skipping deletion.",
+                    raw_file_path,
+                    video.video_hash,
+                )
+
+        except Exception as e:
+            # Log error but continue
+            logger.error(
+                "Error deleting raw video file %s for video %s: %s",
+                raw_file_path,
+                video.video_hash,
+                e,
+                exc_info=True,
+            )
+    else:
+        if delete_field_file(getattr(video, "raw_file", None), save=False):
+            logger.info("Deleted raw file from storage for video %s", video.video_hash)
+        else:
+            logger.warning(
+                "Raw video file not found during deletion for video %s.",
+                video.video_hash,
+            )
+
+    # 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.video_hash,
+                    processed_file_path,
+                )
+            else:
+                logger.warning(
+                    "Processed video file not found at %s for video %s, skipping deletion.",
+                    processed_file_path,
+                    video.video_hash,
+                )
+        except Exception as e:
+            # Log error but continue
+            logger.error(
+                "Error deleting processed video file %s for video %s: %s",
+                processed_file_path,
+                video.video_hash,
+                e,
+                exc_info=True,
+            )
+    else:
+        if delete_field_file(getattr(video, "processed_file", None), save=False):
+            logger.info(
+                "Deleted processed file from storage for video %s", video.video_hash
+            )
+        else:
+            logger.warning(
+                "Processed file missing in storage for video %s", video.video_hash
+            )
+
+    # 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.video_hash,
+        )
+
+        return f"Successfully deleted VideoFile {video.video_hash} and attempted file cleanup."
+    except Exception as e:
+        logger.error(
+            "Error deleting VideoFile database record PK %s (UUID: %s): %s",
+            video.pk,
+            video.video_hash,
+            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.video_hash)
+
+
+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.video_hash, 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,58 @@
+import logging
+from typing import TYPE_CHECKING, List, Optional
+
+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.video_hash,
+        )
+        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.video_hash, 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.video_hash,
+                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.video_hash, crop_template
+    )
+    return crop_template

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

@@ -0,0 +1,62 @@
+import logging
+from typing import TYPE_CHECKING, Dict, Optional
+
+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.video_hash
+        )
+        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()
+            )
+        ):
+            cleaned_roi = {
+                k: int(endo_roi[k] or 0) for k in ("x", "y", "width", "height")
+            }
+            logger.debug(
+                "Retrieved endo ROI for video %s: %s", video.video_hash, cleaned_roi
+            )
+            return cleaned_roi
+        else:
+            logger.warning(
+                "Endo ROI not fully defined or invalid in VideoMeta for video %s. ROI: %s",
+                video.video_hash,
+                endo_roi,
+            )
+            return None
+    except AttributeError:
+        logger.error(
+            "VideoMeta object for video %s does not have a 'get_endo_roi' method.",
+            video.video_hash,
+        )
+        return None
+    except Exception as e:
+        logger.error(
+            "Error getting endo ROI from VideoMeta for video %s: %s",
+            video.video_hash,
+            e,
+            exc_info=True,
+        )
+        return None

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

@@ -0,0 +1,183 @@
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import cv2
+
+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.video_hash)
+
+    if not video.video_meta:
+        logger.info("VideoMeta not linked for %s, attempting update.", video.video_hash)
+
+        _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.video_hash,
+        )
+        _fps = video.video_meta.fps
+        try:
+            _fps = float(_fps)
+        except (TypeError, ValueError):
+            logger.warning(
+                "Invalid FPS value %.2f in VideoMeta for video %s.",
+                video.video_meta.fps,
+                video.video_hash,
+            )
+            raise ValueError(
+                f"Could not determine FPS for video {video.video_hash} due to invalid VideoMeta FPS value."
+            )
+        video.fps = _fps
+        # Avoid saving if called from within the save method itself
+        if not getattr(video, "_saving", False):
+            video.save(update_fields=["fps"])
+        return _fps
+    else:
+        logger.warning(
+            "Could not determine FPS from VideoMeta for video %s. Trying direct raw file access.",
+            video.video_hash,
+        )
+        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.video_hash,
+                        )
+                        if not getattr(video, "_saving", False):
+                            video.save(update_fields=["fps"])
+                        return 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.video_hash}. 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: cv2.VideoCapture) -> 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.
+    """
+    return cap.get(cv2.CAP_PROP_FPS)
+
+
+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