endoreg-db 0.8.9.32__py3-none-any.whl

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

@@ -0,0 +1,198 @@
+# --- 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.video_hash,
+        )
+        return False
+
+    if not video_path:
+        # Raise exception
+        raise FileNotFoundError(
+            f"Could not determine video file path for spec initialization for {video.video_hash}."
+        )
+
+    logger.info(
+        "Initializing video specs directly from file %s (%s) for %s",
+        target_file_name,
+        video_path,
+        video.video_hash,
+    )
+    try:
+        if not video_path.exists():
+            # Raise exception
+            raise FileNotFoundError(
+                f"Video file not found at {video_path} for spec initialization (Video: {video.video_hash})."
+            )
+
+        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.video_hash})."
+            )
+
+        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.video_hash,
+                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.video_hash,
+                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.video_hash,
+                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.video_hash,
+            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.video_hash} from {video_path}"
+        ) from e

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

@@ -0,0 +1,178 @@
+import logging
+from typing import TYPE_CHECKING, Optional
+
+# --- End Fix ---
+from django.db import transaction
+
+# --- Fix Imports ---
+from ....metadata import SensitiveMeta
+from ....metadata.sensitive_meta_logic import update_or_create_sensitive_meta_from_dict
+
+if TYPE_CHECKING:
+    from ..video_file import VideoFile
+
+    # SensitiveMeta is already imported above
+
+logger = logging.getLogger(__name__)
+
+
+def _update_text_metadata(
+    video: "VideoFile",
+    extracted_data_dict: Optional[dict] = None,
+    ocr_frame_fraction: float = 0.01,
+    cap: int = 10,
+    overwrite: bool = False,
+) -> Optional["SensitiveMeta"]:
+    """
+    Extracts text from a fraction of video frames, updates or creates SensitiveMeta,
+    and potentially updates the VideoFile's date field. Requires frames to be extracted.
+    Raises ValueError if pre-conditions not met, RuntimeError on processing failure.
+
+    State Transitions:
+        - Pre-condition: Requires state.frames_extracted=True.
+        - Post-condition: Sets state.text_meta_extracted=True (even if no text found).
+    """
+    logger.debug(f"Updating text metadata for video {video.video_hash}")
+    state = video.get_or_create_state()
+
+    # --- Pre-condition Checks ---
+    if not state.frames_extracted:
+        # Attempt to extract frames automatically if they're not available
+        logger.warning(
+            f"Frames not extracted for video {video.video_hash}. Attempting automatic frame extraction..."
+        )
+        try:
+            success = video.extract_frames(overwrite=False)
+        except (FileNotFoundError, RuntimeError, ValueError, OSError) as exc:
+            logger.error(
+                "Failed to extract frames for video %s: %s",
+                video.video_hash,
+                exc,
+                exc_info=True,
+            )
+            raise ValueError(
+                f"Cannot update text metadata for video {video.video_hash}: Frames not extracted and automatic extraction failed"
+            ) from exc
+
+        if not success:
+            raise ValueError(
+                f"Cannot update text metadata for video {video.video_hash}: Frame extraction returned False"
+            )
+
+        state.refresh_from_db()
+        if not state.frames_extracted:
+            raise ValueError(
+                f"Cannot update text metadata for video {video.video_hash}: Frame extraction completed but state was not updated"
+            )
+
+        logger.info(f"Successfully extracted frames for video {video.video_hash}")
+
+    if state.text_meta_extracted and not overwrite:
+        logger.info(
+            "Text already extracted for video %s and overwrite=False. Skipping.",
+            video.video_hash,
+        )  # Changed to info
+        return video.sensitive_meta  # Return existing meta if available
+    # --- End Pre-condition Checks ---
+
+    # Extract text using the AI helper function
+    # _extract_text_from_video_frames raises ValueError on pre-condition failure
+    try:
+        if not extracted_data_dict:
+            extracted_data_dict = video.extract_text_from_frames(
+                frame_fraction=ocr_frame_fraction, cap=cap
+            )
+    except Exception as text_extract_e:
+        logger.error(
+            "Failed during text extraction step for video %s: %s",
+            video.video_hash,
+            text_extract_e,
+            exc_info=True,
+        )
+        raise RuntimeError(
+            f"Text extraction failed for video {video.video_hash}"
+        ) from text_extract_e
+
+    # --- Atomic Update Block ---
+    try:
+        with transaction.atomic():
+            # Refresh state in case it changed
+            state.refresh_from_db()
+            sensitive_meta_instance = video.sensitive_meta  # Get current instance
+
+            if not extracted_data_dict:
+                logger.warning(
+                    "No text extracted for video %s; skipping SensitiveMeta update.",
+                    video.video_hash,
+                )
+                # Mark state as retrieved even if no data found, to avoid re-running unless overwrite=True
+                if not state.text_meta_extracted:
+                    state.text_meta_extracted = True
+                    state.save(update_fields=["text_meta_extracted"])
+                return sensitive_meta_instance  # Return existing meta if available
+
+            # Add center info if not already present in extracted data
+            if "center_name" not in extracted_data_dict and video.center:
+                extracted_data_dict["center_name"] = video.center.name
+            logger.debug(
+                "Data for SensitiveMeta update for video %s: %s",
+                video.video_hash,
+                extracted_data_dict,
+            )
+
+            # Pass the Class, the data dict, and the current instance (or None)
+            # This function might raise exceptions if data is invalid
+            sensitive_meta, created = update_or_create_sensitive_meta_from_dict(
+                SensitiveMeta,  # Pass the class
+                extracted_data_dict,
+                instance=sensitive_meta_instance,  # Pass current instance via keyword
+            )
+
+            # Update VideoFile fields if necessary
+            update_fields_video = []
+            if (
+                created or sensitive_meta != sensitive_meta_instance
+            ):  # Check if relation needs update
+                video.sensitive_meta = sensitive_meta
+                update_fields_video.append("sensitive_meta")
+
+            if not video.date and sensitive_meta and extracted_data_dict.get("date"):
+                extracted_date = extracted_data_dict.get("date")
+                if extracted_date:  # Ensure date is not None or empty
+                    video.date = extracted_date
+                    update_fields_video.append("date")
+
+            # Save VideoFile if fields changed
+            if update_fields_video:
+                video.save(update_fields=update_fields_video)
+
+            # Update state
+            if not state.text_meta_extracted:
+                state.text_meta_extracted = True
+                state.save(update_fields=["text_meta_extracted"])
+
+            # Mark sensitive meta as processed when updated via text metadata
+            if sensitive_meta:
+                state.mark_sensitive_meta_processed(save=True)
+                logger.info(
+                    f"Marked sensitive_meta_processed=True for video {video.video_hash} after text metadata update"
+                )
+
+            logger.info(
+                "Successfully updated/created SensitiveMeta and state for video %s.",
+                video.video_hash,
+            )  # Changed to info
+            return sensitive_meta
+
+    except Exception as e:
+        logger.error(
+            "Failed to update/create SensitiveMeta or state for video %s: %s",
+            video.video_hash,
+            e,
+            exc_info=True,
+        )
+        # Re-raise exception for the pipeline to catch
+        raise RuntimeError(
+            f"Failed to update/create SensitiveMeta or state for video {video.video_hash}"
+        ) from e
+    # --- End Atomic Update Block ---

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

@@ -0,0 +1,105 @@
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..video_file import VideoFile
+
+logger = logging.getLogger(__name__)
+
+
+def _update_video_meta(video: "VideoFile", save_instance: bool = True):
+    """
+    Updates or creates the technical VideoMeta from the raw video file.
+    Raises FileNotFoundError or ValueError on pre-condition failure, RuntimeError on processing failure.
+    """
+    from ....metadata import VideoMeta  # Local import
+
+    logger.debug(
+        "Updating technical VideoMeta for video %s (from raw file).", video.video_hash
+    )
+
+    if not video.has_raw:
+        # DEFENSIVE: Log warning and skip instead of crashing
+        logger.warning(
+            f"Raw video file path not available for {video.video_hash}. Skipping VideoMeta update - this may indicate the video was processed and raw file moved."
+        )
+        return  # Graceful skip instead of FileNotFoundError
+
+    raw_video_path = video.get_raw_file_path()  # Use helper
+    if not raw_video_path or not raw_video_path.exists():
+        # DEFENSIVE: Log warning and skip instead of crashing production pipeline
+        logger.warning(
+            f"Raw video file path {raw_video_path} does not exist for video {video.video_hash}. Skipping VideoMeta update - this typically happens after video processing when raw files are moved to processed location."
+        )
+        return  # Graceful skip instead of FileNotFoundError that crashes production
+
+    try:
+        vm = video.video_meta
+        if vm:
+            logger.info(
+                "Updating existing VideoMeta (PK: %s) for video %s.",
+                vm.pk,
+                video.video_hash,
+            )
+            vm.update_meta(
+                raw_video_path
+            )  # Assuming this method exists and raises on error
+            vm.save()
+        else:
+            if not video.center or not video.processor:
+                # Raise exception
+                raise ValueError(
+                    f"Cannot create VideoMeta for {video.video_hash}: Center or Processor is missing."
+                )
+
+            logger.info("Creating new VideoMeta for video %s.", video.video_hash)
+            # Assuming create_from_file exists and raises on error
+            video.video_meta = VideoMeta.create_from_file(
+                video_path=raw_video_path,
+                center=video.center,
+                processor=video.processor,
+                save_instance=True,  # Let create_from_file handle saving
+            )
+            vm = video.video_meta
+            assert vm is not None  # For type checker
+            logger.info(
+                "Created and linked VideoMeta (PK: %s) for video %s.",
+                vm.pk,
+                video.video_hash,
+            )
+
+        # Save the VideoFile instance itself if requested and if video_meta was linked/updated
+        if save_instance:
+            update_fields = ["video_meta"]
+            # Check if derived fields also need updating
+            if video.video_meta:
+                meta_fields = ["fps", "duration", "frame_count", "width", "height"]
+                for field in meta_fields:
+                    # Check if field is None on video but has value on meta
+                    if (
+                        getattr(video, field) is None
+                        and getattr(video.video_meta, field, None) is not None
+                    ):
+                        # No need to set attribute here, save method handles it
+                        update_fields.append(field)
+            # Ensure update_fields has unique values before saving
+            unique_update_fields = list(set(update_fields))
+            if unique_update_fields:
+                video.save(update_fields=unique_update_fields)
+                logger.info(
+                    "Saved video %s after VideoMeta update (Fields: %s).",
+                    video.video_hash,
+                    unique_update_fields,
+                )
+
+    except Exception as e:
+        logger.error(
+            "Failed to update/create VideoMeta for video %s: %s",
+            video.video_hash,
+            e,
+            exc_info=True,
+        )
+        # Re-raise exception
+        raise RuntimeError(
+            f"Failed to update/create VideoMeta for video {video.video_hash}"
+        ) from e