endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/models/media/video/video_file_segments.py

@@ -0,0 +1,317 @@
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING, Dict, List, Set, Tuple
+
+from django.db.models import Q  # Import Q for complex queries
+from icecream import ic
+
+if TYPE_CHECKING:
+    from django.db.models import QuerySet
+
+    from ...label import LabelVideoSegment
+    from ...metadata import VideoPredictionMeta
+    from ..frame import Frame
+    from .video_file import VideoFile
+
+logger = logging.getLogger(__name__)
+
+# ... [Keep _convert_sequences_to_db_segments and _sequences_to_label_video_segments unchanged] ...
+def _convert_sequences_to_db_segments(
+    video: "VideoFile",
+    sequences: Dict[str, List[Tuple[int, int]]],
+    video_prediction_meta: "VideoPredictionMeta",
+):
+    """
+    Converts predicted sequences into LabelVideoSegment database objects
+    and ensures their corresponding state objects are created.
+    """
+    from ...label import Label, LabelVideoSegment  # Local import for models
+
+    logger.info(
+        "Converting sequences to LabelVideoSegments for video %s, prediction meta %s",
+        video.video_hash,
+        video_prediction_meta.pk,
+    )
+    created_count = 0
+    skipped_count = 0
+    error_count = 0
+    state_created_count = 0
+    state_error_count = 0
+
+    processed_labels = set()
+
+    for label_name, sequence_list in sequences.items():
+        if not sequence_list:
+            continue
+
+        processed_labels.add(label_name)
+
+        try:
+            label = Label.objects.get(name=label_name)  # require pre-existing label
+        except Exception as e:
+            logger.error(
+                "Could not get or create Label '%s': %s", label_name, e, exc_info=True
+            )
+            error_count += len(sequence_list)
+            continue
+
+        segments_to_create = []
+        for start_frame, end_frame in sequence_list:
+            if start_frame > end_frame or start_frame < 0:
+                logger.warning(
+                    "Skipping invalid sequence for label '%s': start=%d, end=%d",
+                    label_name,
+                    start_frame,
+                    end_frame,
+                )
+                skipped_count += 1
+                continue
+
+            segments_to_create.append(
+                LabelVideoSegment(
+                    video_file=video,
+                    label=label,
+                    start_frame_number=start_frame,
+                    end_frame_number=end_frame,
+                    prediction_meta=video_prediction_meta,
+                )
+            )
+
+        if segments_to_create:
+            try:
+                LabelVideoSegment.objects.bulk_create(
+                    segments_to_create, ignore_conflicts=True
+                )
+                created_count += len(segments_to_create)
+                logger.debug(
+                    "Bulk created %d segments for label '%s'",
+                    len(segments_to_create),
+                    label_name,
+                )
+            except Exception as e:
+                logger.error(
+                    "Error bulk creating segments for label '%s': %s",
+                    label_name,
+                    e,
+                    exc_info=True,
+                )
+                error_count += len(segments_to_create)
+
+    newly_created_segments = LabelVideoSegment.objects.filter(
+        video_file=video,
+        prediction_meta=video_prediction_meta,
+        label__name__in=processed_labels,
+    )
+
+    logger.info(
+        "Attempting to create state objects for %d potentially new segments (Video: %s, PredictionMeta: %s)",
+        newly_created_segments.count(),
+        video.video_hash,
+        video_prediction_meta.pk,
+    )
+
+    for segment in newly_created_segments:
+        try:
+            _state, created = segment.get_or_create_state()
+            if created:
+                state_created_count += 1
+        except Exception as e:
+            logger.error(
+                "Failed to get or create state for segment %s (Video: %s): %s",
+                segment.pk,
+                video.video_hash,
+                e,
+                exc_info=True,
+            )
+            state_error_count += 1
+
+    logger.info(
+        "LabelVideoSegment conversion finished for video %s. Segments Created: %d, Skipped: %d, Errors: %d. States Created: %d, State Errors: %d",
+        video.video_hash,
+        created_count,
+        skipped_count,
+        error_count,
+        state_created_count,
+        state_error_count,
+    )
+
+
+def _sequences_to_label_video_segments(
+    video: "VideoFile",
+    video_prediction_meta: "VideoPredictionMeta",
+):
+    """Converts stored sequences on the video object to LabelVideoSegments."""
+    if not video.sequences:
+        return
+
+    if not video_prediction_meta:
+        return
+
+    _convert_sequences_to_db_segments(
+        video=video,
+        sequences=video.sequences,
+        video_prediction_meta=video_prediction_meta,
+    )
+
+
+def _get_outside_segments(
+    video: "VideoFile", outside_label_name: str = "outside"
+) -> "QuerySet[LabelVideoSegment]":
+    """Gets LabelVideoSegments marked with the 'outside' label."""
+    from ...label import Label, LabelVideoSegment  # Local import for models
+
+    try:
+        outside_label = Label.objects.get(name__iexact=outside_label_name)
+        # FIX: Use direct filter instead of relying on 'label_video_segments' related name
+        # which might not exist or might be named differently (e.g. labelvideosegment_set)
+        return LabelVideoSegment.objects.filter(video_file=video, label=outside_label)
+    except Label.DoesNotExist:
+        logger.warning("Label '%s' not found in the database.", outside_label_name)
+        return LabelVideoSegment.objects.none()
+    except Exception as e:
+        logger.error(
+            "Error getting '%s' segments for video %s: %s",
+            outside_label_name,
+            video.video_hash,
+            e,
+            exc_info=True,
+        )
+        return LabelVideoSegment.objects.none()
+
+
+def _get_outside_frame_numbers(
+    video: "VideoFile", outside_label_name: str = "outside"
+) -> Set[int]:
+    """
+    Gets a set of frame numbers corresponding to segments labeled as 'outside'.
+    """
+    outside_segments = _get_outside_segments(video, outside_label_name)
+    frame_numbers = set()
+    for segment in outside_segments:
+        frame_numbers.update(
+            range(segment.start_frame_number, segment.end_frame_number + 1)
+        )
+    if frame_numbers:
+        logger.info(
+            "Found %d frame numbers marked as '%s' for video %s.",
+            len(frame_numbers),
+            outside_label_name,
+            video.video_hash,
+        )
+    else:
+        logger.info(
+            "No frame numbers marked as '%s' found for video %s.",
+            outside_label_name,
+            video.video_hash,
+        )
+    return frame_numbers
+
+
+def _get_outside_frames(
+    video: "VideoFile", outside_label_name: str = "outside"
+) -> "QuerySet[Frame]":
+    """
+    Gets a QuerySet of all unique Frame objects that fall within any segment
+    labeled with the specified 'outside_label_name'.
+    """
+    from ..frame import Frame  # Local import
+
+    outside_segments = _get_outside_segments(video, outside_label_name)
+    if not outside_segments.exists():
+        return Frame.objects.none()
+
+    q_objects: Q | None = None
+    for segment in outside_segments:
+        # FIX: Use __lte for end_frame_number to include the last frame of the segment
+        clause = Q(
+            frame_number__gte=segment.start_frame_number,
+            frame_number__lte=segment.end_frame_number,
+        )
+        q_objects = clause if q_objects is None else q_objects | clause
+
+    if q_objects is None:
+        return Frame.objects.none()
+
+    try:
+        return video.frames.filter(q_objects).distinct().order_by("frame_number")
+    except Exception as e:
+        logger.error(
+            "Error filtering outside frames for video %s: %s",
+            video.video_hash,
+            e,
+            exc_info=True,
+        )
+        return Frame.objects.none()
+
+
+def _get_outside_frame_paths(
+    video: "VideoFile", outside_label_name: str = "outside"
+) -> List["Path"]:
+    """Gets the file paths of frames that fall within 'outside' segments."""
+    from pathlib import Path  # Local import
+
+    frames = _get_outside_frames(video, outside_label_name=outside_label_name)
+    frame_paths = []
+    for frame in frames:
+        try:
+            frame_paths.append(Path(frame.relative_path))
+        except Exception as e:
+            logger.warning(
+                "Could not get path for frame %s (Number: %d): %s",
+                frame.pk,
+                frame.frame_number,
+                e,
+            )
+            ic(f"Could not get path for frame {frame.pk}: {e}")
+
+    logger.info(
+        "Found %d frame paths within '%s' segments for video %s",
+        len(frame_paths),
+        outside_label_name,
+        video.video_hash,
+    )
+    return frame_paths
+
+
+def _label_segments_to_frame_annotations(video: "VideoFile"):
+    """Generates frame annotations based on existing LabelVideoSegments."""
+    logger.info(
+        "Generating frame annotations from segments for video %s", video.video_hash
+    )
+    processed_count = 0
+    try:
+        # Use getattr to safely access the related manager, or fall back to the default name set
+        segments = getattr(video, 'label_video_segments', getattr(video, 'labelvideosegment_set', None))
+        
+        if segments:
+            for lvs in segments.all():
+                lvs_duration = lvs.get_segment_len_in_s()
+                if lvs_duration >= 3:
+                    try:
+                        lvs.generate_annotations()
+                        processed_count += 1
+                    except Exception as e:
+                        logger.error(
+                            "Error generating annotations for segment %s (Video %s): %s",
+                            lvs.pk,
+                            video.video_hash,
+                            e,
+                        )
+        else:
+             logger.error(
+                "Could not generate frame annotations for video %s. Neither 'label_video_segments' nor 'labelvideosegment_set' related manager found.",
+                video.video_hash,
+            )
+
+        logger.info(
+            "Processed %d segments for frame annotations for video %s",
+            processed_count,
+            video.video_hash,
+        )
+    except Exception as e:
+        logger.error(
+            "Unexpected error generating frame annotations for video %s: %s",
+            video.video_hash,
+            e,
+            exc_info=True
+        )

endoreg_db/models/media/video/video_metadata.py

@@ -0,0 +1,67 @@
+"""
+Video Metadata Model
+
+Stores analysis results for videos (sensitive frames, detection statistics).
+"""
+
+from django.db import models
+
+from .video_file import VideoFile
+
+
+class VideoMetadata(models.Model):
+    """
+    Stores analysis results for videos after sensitive frame detection.
+
+    This model holds the output of frame analysis operations (MiniCPM, OCR+LLM)
+    and provides metrics for the correction UI.
+    """
+
+    video = models.OneToOneField(
+        VideoFile,
+        on_delete=models.CASCADE,
+        related_name="metadata",
+        help_text="Video file this metadata belongs to",
+    )
+
+    # Analysis Results
+    sensitive_frame_count = models.IntegerField(
+        null=True,
+        blank=True,
+        help_text="Number of frames detected as containing sensitive information",
+    )
+    sensitive_ratio = models.FloatField(
+        null=True,
+        blank=True,
+        help_text="Ratio of sensitive frames to total frames (0.0-1.0)",
+    )
+    sensitive_frame_ids = models.TextField(
+        null=True,
+        blank=True,
+        help_text="JSON array of sensitive frame indices (0-based)",
+    )
+
+    # Metadata
+    analyzed_at = models.DateTimeField(
+        auto_now=True, help_text="Timestamp of last analysis"
+    )
+
+    class Meta:
+        db_table = "video_metadata"
+        verbose_name = "Video Metadata"
+        verbose_name_plural = "Video Metadata"
+
+    def __str__(self):
+        return f"Metadata for {self.video.video_hash} ({self.sensitive_frame_count or 0} sensitive frames)"
+
+    @property
+    def has_analysis(self) -> bool:
+        """Check if this video has been analyzed."""
+        return self.sensitive_frame_count is not None
+
+    @property
+    def sensitive_percentage(self) -> float:
+        """Get sensitivity as percentage (0-100)."""
+        if self.sensitive_ratio is not None:
+            return self.sensitive_ratio * 100
+        return 0.0

endoreg_db/models/media/video/video_processing.py

@@ -0,0 +1,192 @@
+"""
+Video Processing History Model
+
+Tracks all video correction operations (masking, frame removal, reprocessing).
+Created as part of Phase 1.1: Video Correction API Endpoints.
+"""
+
+import logging
+from pathlib import Path
+
+from django.conf import settings
+from django.db import models
+from django.utils import timezone
+
+from .video_file import VideoFile
+
+logger = logging.getLogger(__name__)
+
+
+class VideoProcessingHistory(models.Model):
+    """
+    History of all video processing operations.
+
+    Stores configuration and results of masking, frame removal, and reprocessing
+    operations for audit trail and download access.
+    """
+
+    # Operation Types
+    OPERATION_MASKING = "mask_overlay"
+    OPERATION_FRAME_REMOVAL = "frame_removal"
+    OPERATION_ANALYSIS = "analysis"
+    OPERATION_REPROCESSING = "reprocessing"
+
+    OPERATION_CHOICES = [
+        (OPERATION_MASKING, "Mask Overlay"),
+        (OPERATION_FRAME_REMOVAL, "Frame Removal"),
+        (OPERATION_ANALYSIS, "Sensitivity Analysis"),
+        (OPERATION_REPROCESSING, "Full Reprocessing"),
+    ]
+
+    # Status Types
+    STATUS_PENDING = "pending"
+    STATUS_RUNNING = "running"
+    STATUS_SUCCESS = "success"
+    STATUS_FAILURE = "failure"
+    STATUS_CANCELLED = "cancelled"
+
+    STATUS_CHOICES = [
+        (STATUS_PENDING, "Pending"),
+        (STATUS_RUNNING, "Running"),
+        (STATUS_SUCCESS, "Success"),
+        (STATUS_FAILURE, "Failure"),
+        (STATUS_CANCELLED, "Cancelled"),
+    ]
+
+    video = models.ForeignKey(
+        VideoFile,
+        on_delete=models.CASCADE,
+        related_name="processing_history",
+        help_text="Video file this operation was performed on",
+    )
+
+    operation = models.CharField(
+        max_length=50,
+        choices=OPERATION_CHOICES,
+        help_text="Type of processing operation",
+    )
+
+    status = models.CharField(
+        max_length=20,
+        choices=STATUS_CHOICES,
+        default=STATUS_PENDING,
+        help_text="Current status of the operation",
+    )
+
+    # Configuration & Results
+    config = models.JSONField(
+        default=dict,
+        help_text="Operation configuration (mask settings, frame list, etc.)",
+    )
+
+    output_file = models.CharField(
+        max_length=500,
+        blank=True,
+        help_text="Path to output file (relative to MEDIA_ROOT)",
+    )
+
+    details = models.TextField(
+        blank=True, help_text="Additional details or error messages"
+    )
+
+    # Celery Integration
+    task_id = models.CharField(
+        max_length=100, blank=True, help_text="Celery task ID for progress tracking"
+    )
+
+    # Timestamps
+    created_at = models.DateTimeField(
+        auto_now_add=True, help_text="When the operation was started"
+    )
+
+    completed_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="When the operation completed (success or failure)",
+    )
+
+    class Meta:
+        db_table = "video_processing_history"
+        verbose_name = "Video Processing History"
+        verbose_name_plural = "Video Processing Histories"
+        ordering = ["-created_at"]
+        indexes = [
+            models.Index(fields=["video", "-created_at"]),
+            models.Index(fields=["task_id"]),
+            models.Index(fields=["status"]),
+        ]
+
+    def __str__(self):
+        operation_display = getattr(self, "get_operation_display", None)
+        status_display = getattr(self, "get_status_display", None)
+
+        operation = (
+            operation_display() if callable(operation_display) else self.operation
+        )
+        status = status_display() if callable(status_display) else self.status
+        return f"{operation} on {self.video.video_hash} - {status}"
+
+    def mark_running(self, save=True):
+        """Mark operation as running."""
+        self.status = self.STATUS_RUNNING
+        if save:
+            self.save(update_fields=["status"])
+
+    @staticmethod
+    def _normalize_output_path(path: str | Path | None) -> str:
+        """Return a path relative to MEDIA_ROOT when possible."""
+        if not path:
+            return ""
+
+        raw_path = Path(path)
+        if not raw_path.is_absolute():
+            return raw_path.as_posix()
+        media_root = Path(settings.MEDIA_ROOT)
+
+        try:
+            relative = raw_path.resolve().relative_to(media_root.resolve())
+            return relative.as_posix()
+        except (ValueError, RuntimeError):
+            logger.warning(
+                "Storing absolute output path '%s' because it is outside MEDIA_ROOT (%s).",
+                raw_path,
+                media_root,
+            )
+            return raw_path.as_posix()
+
+    def mark_success(self, output_file=None, details=None, save=True):
+        """Mark operation as successful."""
+        self.status = self.STATUS_SUCCESS
+        self.completed_at = timezone.now()
+        if output_file:
+            self.output_file = self._normalize_output_path(output_file)
+        if details:
+            self.details = details
+        if save:
+            self.save(
+                update_fields=["status", "completed_at", "output_file", "details"]
+            )
+
+    def mark_failure(self, error_message, save=True):
+        """Mark operation as failed."""
+        self.status = self.STATUS_FAILURE
+        self.completed_at = timezone.now()
+        self.details = error_message
+        if save:
+            self.save(update_fields=["status", "completed_at", "details"])
+
+    @property
+    def duration(self):
+        """Calculate operation duration if completed."""
+        if self.completed_at and self.created_at:
+            return (self.completed_at - self.created_at).total_seconds()
+        return None
+
+    @property
+    def is_complete(self) -> bool:
+        """Check if operation is in a terminal state."""
+        return self.status in [
+            self.STATUS_SUCCESS,
+            self.STATUS_FAILURE,
+            self.STATUS_CANCELLED,
+        ]

endoreg_db/models/medical/__init__.py

@@ -0,0 +1,136 @@
+from .disease import Disease, DiseaseClassification, DiseaseClassificationChoice
+from .event import Event, EventClassification, EventClassificationChoice
+
+from .contraindication import Contraindication
+from .examination import (
+    Examination,
+    ExaminationRequirementSet,
+    ExaminationType,
+    ExaminationIndication,
+    ExaminationIndicationClassificationChoice,
+    ExaminationIndicationClassification,
+    ExaminationTime,
+    ExaminationTimeType,
+)
+
+from .finding import (
+    Finding,
+    FindingClassificationType,
+    FindingClassification,
+    FindingClassificationChoice,
+    FindingType,
+    FindingIntervention,
+    FindingInterventionType,
+)
+
+from .patient import (
+    PatientExamination,
+    PatientFinding,
+    PatientFindingClassification,
+    PatientFindingIntervention,
+    PatientDisease,
+    PatientEvent,
+    PatientExaminationIndication,
+    PatientLabSample,
+    PatientLabSampleType,
+    PatientLabValue,
+    PatientMedication,
+    PatientMedicationSchedule,
+)
+
+from .risk import (
+    Risk,
+    RiskType,
+)
+
+from .medication import (
+    Medication,
+    MedicationManager,
+    MedicationSchedule,
+    MedicationIntakeTime,
+    MedicationIndicationType,
+    MedicationIndication,
+)
+
+from .hardware import (
+    Endoscope,
+    EndoscopeType,
+    EndoscopyProcessor,
+)
+
+from .laboratory import (
+    LabValue,
+)
+
+from .organ import (
+    Organ,
+)
+
+
+__all__ = [
+    # Disease
+    "Disease",
+    "DiseaseClassification",
+    "DiseaseClassificationChoice",
+    # Event
+    "Event",
+    "EventClassification",
+    "EventClassificationChoice",
+    # Contraindication
+    "Contraindication",
+    # Examination
+    "Examination",
+    "ExaminationRequirementSet",
+    "ExaminationType",
+    "ExaminationIndication",
+    "ExaminationIndicationClassificationChoice",
+    "ExaminationIndicationClassification",
+    "ExaminationTime",
+    "ExaminationTimeType",
+    # Finding
+    "Finding",
+    "FindingClassificationType",
+    "FindingClassification",
+    "FindingClassificationChoice",
+    "FindingType",
+    "FindingMorphologyClassification",
+    "FindingIntervention",
+    "FindingInterventionType",
+    # Patient
+    ## Disease
+    "PatientDisease",
+    ## Event
+    "PatientEvent",
+    ## Examination
+    "PatientExaminationIndication",
+    "PatientExamination",
+    ## Finding
+    "PatientFinding",
+    "PatientFindingClassification",
+    "PatientFindingIntervention",
+    ## Laboratory
+    "PatientLabSample",
+    "PatientLabSampleType",
+    "PatientLabValue",
+    ## Medication
+    "PatientMedication",
+    "PatientMedicationSchedule",
+    # Organ
+    "Organ",
+    # Risk
+    "Risk",
+    "RiskType",
+    # Medication
+    "Medication",
+    "MedicationManager",
+    "MedicationSchedule",
+    "MedicationIntakeTime",
+    "MedicationIndicationType",
+    "MedicationIndication",
+    # Hardware
+    "Endoscope",
+    "EndoscopeType",
+    "EndoscopyProcessor",
+    # Laboratory
+    "LabValue",
+]