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

endoreg_db/models/state/raw_pdf.py

@@ -0,0 +1,187 @@
+"""
+Defines state tracking models related to PDF processing, including extraction of text and metadata, AI predictions, and anonymization status for RawPdfFile instances.
+"""
+from django.db import models
+from typing import TYPE_CHECKING
+import logging
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from ..media import RawPdfFile
+    
+
+class AnonymizationStatus(str, Enum):
+    NOT_STARTED             = "not_started"
+    PROCESSING_ANONYMIZING  = "processing_anonymization"
+    DONE                    = "done"
+    VALIDATED               = "validated"
+    FAILED                  = "failed"
+    STARTED                = "started"
+
+
+class RawPdfState(models.Model):
+    """
+    Tracks the processing state of a RawPdfFile instance.
+    Uses BooleanFields for clear, distinct states.
+    """
+    text_meta_extracted = models.BooleanField(default=False, help_text="True if text metadata (OCR) has been extracted.")
+
+    # AI / Annotation related states
+    initial_prediction_completed = models.BooleanField(default=False, help_text="True if initial AI prediction has run.")
+
+    # Processing state
+    sensitive_meta_processed = models.BooleanField(default=False, help_text="True if the video has been fully processed, meaning a anonymized person was created.")
+
+    # Anonymization state
+    anonymized = models.BooleanField(default=False, help_text="True if the anonymized video file has been created.")
+    anonymization_validated = models.BooleanField(default=False, help_text="True if the anonymization process has been validated and confirmed.")
+    
+    # Processing state
+    processing_started = models.BooleanField(default=False, help_text="True if the processing has started, but not yet completed.")
+    processing_error = models.BooleanField(default=False, help_text="True if an error occurred during processing.")
+    
+    # Timestamps
+    date_created = models.DateTimeField(auto_now_add=True)
+    date_modified = models.DateTimeField(auto_now=True)
+    
+    was_created = models.BooleanField(default=True, help_text="True if this state was created for the first time.")
+
+    # PDF metadata extraction state
+    pdf_meta_extracted = models.BooleanField(default=False, help_text="True if PDF metadata has been extracted.")
+
+    if TYPE_CHECKING:
+        raw_pdf_file: "RawPdfFile"
+
+    def __str__(self):
+        """
+        Return a string summarizing the RawPdfState instance, including the related PDF file UUID and key processing state flags with timestamps.
+        """
+        try:
+            uuid = self.raw_pdf_file.id
+        except Exception:
+            uuid = None
+
+        states = [
+            f"TextMetaExtracted={self.text_meta_extracted}",
+            f"PredictionDone={self.initial_prediction_completed}",
+            f"Anonymized={self.anonymized}",
+            f"AnonymizationValidated={self.anonymization_validated}",
+            f"SensitiveMetaProcessed={self.sensitive_meta_processed}",
+            f"DateCreated={self.date_created.isoformat()}",
+            f"DateModified={self.date_modified.isoformat()}"
+        ]
+        return f"RawPdfState(Pdf:{uuid}): {', '.join(states)}"
+
+    @property
+    def anonymization_status(self) -> AnonymizationStatus:
+        """
+        Determines the current anonymization workflow status for the PDF processing state.
+        
+        Returns:
+            AnonymizationStatus: The current status, reflecting progress or failure in the anonymization process.
+        """
+        if getattr(self, "processing_error", False):
+            return AnonymizationStatus.FAILED
+        if self.anonymization_validated:
+            return AnonymizationStatus.VALIDATED
+        if self.sensitive_meta_processed:
+            return AnonymizationStatus.DONE
+        if self.anonymized:
+            return AnonymizationStatus.DONE
+        if self.initial_prediction_completed:
+            return AnonymizationStatus.PROCESSING_ANONYMIZING
+        if self.pdf_meta_extracted:
+            return AnonymizationStatus.NOT_STARTED
+        if self.processing_started:
+            return AnonymizationStatus.STARTED
+        return AnonymizationStatus.NOT_STARTED
+    
+
+    
+    def mark_processing_started(self, *, save: bool = True) -> None:
+        """
+        Mark the processing as started and optionally save the updated state.
+        
+        Parameters:
+            save (bool): If True, persist the change to the database immediately. Defaults to True.
+        """
+        self.processing_started = True
+        if save:
+            self.save(update_fields=["processing_started", "date_modified"])
+
+    # ---- Single‑responsibility mutators ---------------------------------
+    def mark_sensitive_meta_processed(self, *, save: bool = True) -> None:
+        """
+        Mark the sensitive metadata processing step as completed for this PDF state.
+        
+        Parameters:
+            save (bool): If True, immediately saves the updated state to the database.
+        """
+        self.sensitive_meta_processed = True
+        if save:
+            self.save(update_fields=["sensitive_meta_processed", "date_modified"])
+
+    def mark_anonymization_validated(self, *, save: bool = True) -> None:
+        """
+        Mark the anonymization as validated for this PDF processing state.
+        
+        Parameters:
+            save (bool): If True, immediately saves the updated state to the database.
+        """
+        self.anonymization_validated = True
+        if save:
+            self.save(update_fields=["anonymization_validated", "date_modified"])
+
+    def mark_anonymized(self, *, save: bool = True) -> None:
+        """
+        Mark the PDF as anonymized and optionally save the updated state.
+        
+        Parameters:
+            save (bool): If True, persist the change to the database immediately. Defaults to True.
+        """
+        self.anonymized = True
+        if save:
+            self.save(update_fields=["anonymized", "date_modified"])
+
+    def mark_initial_prediction_completed(self, *, save: bool = True) -> None:
+        """
+        Mark the initial AI prediction step as completed for this PDF processing state.
+        
+        Parameters:
+            save (bool): If True, immediately saves the updated state to the database.
+        """
+        self.initial_prediction_completed = True
+        if save:
+            self.save(update_fields=["initial_prediction_completed", "date_modified"])
+
+    def mark_pdf_meta_extracted(self, *, save: bool = True) -> None:
+        """
+        Mark the PDF metadata extraction step as completed for this state.
+        
+        Parameters:
+            save (bool): If True, immediately saves the updated state to the database.
+        """
+        self.pdf_meta_extracted = True
+        if save:
+            self.save(update_fields=["pdf_meta_extracted", "date_modified"])
+
+    def mark_text_meta_extracted(self, *, save: bool = True) -> None:
+        """
+        Mark the text metadata extraction step as completed for this PDF processing state.
+        
+        Parameters:
+            save (bool): If True, immediately saves the updated state to the database.
+        """
+        self.text_meta_extracted = True
+        if save:
+            self.save(update_fields=["text_meta_extracted", "date_modified"])
+    
+    
+
+    class Meta:
+        verbose_name = "Raw PDF Processing State"
+        verbose_name_plural = "Raw PDF Processing States"
+
+

endoreg_db/models/state/sensitive_meta.py

@@ -0,0 +1,46 @@
+from django.db import models
+from .abstract import AbstractState
+from typing import TYPE_CHECKING
+
+class SensitiveMetaState(AbstractState):
+    """State for sensitive meta data."""
+
+    dob_verified = models.BooleanField(default=False)
+    names_verified = models.BooleanField(default=False)
+
+    origin = models.OneToOneField(
+        "SensitiveMeta",
+        on_delete=models.CASCADE,
+        related_name="state",
+        null=True,
+        blank=True,
+    )
+
+    if TYPE_CHECKING:
+        from endoreg_db.models import SensitiveMeta
+
+        origin: "SensitiveMeta"
+
+    @property
+    def is_verified(self) -> bool:
+        """
+        Return True if both date of birth and names have been verified; otherwise, return False.
+        """
+        return self.dob_verified and self.names_verified
+
+    def mark_dob_verified(self):
+        """
+        Set the date of birth verification status to True and persist the change to the database.
+        """
+        self.dob_verified = True
+        self.save(update_fields=["dob_verified"])
+
+    def mark_names_verified(self):
+        """
+        Mark the names as verified and persist the change to the database.
+        """
+        self.names_verified = True
+        self.save(update_fields=["names_verified"])
+    class Meta:
+        verbose_name = "Sensitive Meta State"
+        verbose_name_plural = "Sensitive Meta States"

endoreg_db/models/state/video.py

@@ -0,0 +1,232 @@
+"""
+Defines state tracking models related to video processing.
+"""
+from django.db import models
+from .abstract import AbstractState
+from typing import TYPE_CHECKING, Optional
+import logging
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from ..media import VideoFile
+    
+
+class AnonymizationStatus(str, Enum):
+    NOT_STARTED             = "not_started"
+    EXTRACTING_FRAMES       = "extracting_frames"
+    PROCESSING_ANONYMIZING  = "processing_anonymization"
+    DONE                    = "done"
+    VALIDATED               = "validated"
+    FAILED                  = "failed"
+    STARTED                = "started"
+
+class VideoState(models.Model):
+    """
+    Tracks the processing state of a VideoFile instance.
+    Uses BooleanFields for clear, distinct states.
+    """
+    # Frame related states
+    if TYPE_CHECKING:
+        video_file: Optional["VideoFile"]
+        
+    frames_extracted = models.BooleanField(default=False, help_text="True if raw frames have been extracted to files.")
+    frames_initialized = models.BooleanField(default=False, help_text="True if Frame DB objects have been created.")
+    frame_count = models.PositiveIntegerField(null=True, blank=True, help_text="Number of frames extracted/initialized.")
+
+    # Metadata related states
+    video_meta_extracted = models.BooleanField(default=False, help_text="True if VideoMeta (technical specs) has been extracted.")
+    text_meta_extracted = models.BooleanField(default=False, help_text="True if text metadata (OCR) has been extracted.")
+
+    # AI / Annotation related states
+    initial_prediction_completed = models.BooleanField(default=False, help_text="True if initial AI prediction has run.")
+    lvs_created = models.BooleanField(default=False, help_text="True if LabelVideoSegments have been created from predictions.")
+    frame_annotations_generated = models.BooleanField(default=False, help_text="True if frame-level annotations have been generated from segments.")
+    
+    # Processing state
+    sensitive_meta_processed = models.BooleanField(default=False, help_text="True if the video has been fully processed, meaning a anonymized person was created.")
+
+    # Anonymization state
+    anonymized = models.BooleanField(default=False, help_text="True if the anonymized video file has been created.")
+    anonymization_validated = models.BooleanField(default=False, help_text="True if the anonymization process has been validated and confirmed.")
+    anonymization_status: AnonymizationStatus
+    
+    processing_started = models.BooleanField(default=False, help_text="True if the processing has started, but not yet completed.")
+    
+    # Timestamps
+    date_created = models.DateTimeField(auto_now_add=True)
+    date_modified = models.DateTimeField(auto_now=True)
+    
+    # Segment Annotation State
+    segment_annotations_created = models.BooleanField(default=False, help_text="True if segment annotations have been created from LabelVideoSegments.")
+    segment_annotations_validated = models.BooleanField(default=False, help_text="True if segment annotations have been validated.")
+    
+    was_created = models.BooleanField(default=True, help_text="True if this state was created for the first time.")
+    
+    objects = models.Manager()
+
+    def __str__(self):
+        # Find the related VideoFile's UUID if possible
+        video_uuid = "Unknown"
+        try:
+            # Access the related VideoFile via the reverse relation 'video_file'
+            if hasattr(self, 'video_file') and self.video_file:
+                video_uuid = self.video_file.uuid
+        except Exception:
+            pass # Ignore errors if relation doesn't exist or causes issues
+
+        states = [
+            f"FramesExtracted={self.frames_extracted}",
+            f"FramesInit={self.frames_initialized}",
+            f"VideoMetaExtracted={self.video_meta_extracted}",
+            f"TextMetaExtracted={self.text_meta_extracted}",
+            f"PredictionDone={self.initial_prediction_completed}",
+            f"LvsCreated={self.lvs_created}",
+            f"Anonymized={self.anonymized}",
+            f"AnonymizationValidated={self.anonymization_validated}",
+            f"SensitiveMetaProcessed={self.sensitive_meta_processed}",
+            f"FrameCount={self.frame_count}" if self.frame_count is not None else "FrameCount=None",
+            f"SegmentAnnotationsCreated={self.segment_annotations_created}",
+            f"SegmentAnnotationsValidated={self.segment_annotations_validated}",
+            f"DateCreated={self.date_created.isoformat()}",
+            f"DateModified={self.date_modified.isoformat()}"
+        ]
+        return f"VideoState(Video:{video_uuid}): {', '.join(states)}"
+
+    @property
+    def anonymization_status(self) -> AnonymizationStatus:
+        """
+        Fast, side‑effect‑free status resolution used by API & UI.
+        """
+        if self.anonymization_validated:
+            return AnonymizationStatus.VALIDATED
+        if self.sensitive_meta_processed:
+            return AnonymizationStatus.DONE
+        if self.frames_extracted and not self.anonymized:
+            return AnonymizationStatus.PROCESSING_ANONYMIZING
+        if self.was_created and not self.frames_extracted:
+            return AnonymizationStatus.EXTRACTING_FRAMES
+        if getattr(self, "processing_error", False):
+            return AnonymizationStatus.FAILED
+        if self.processing_started:
+            return AnonymizationStatus.STARTED
+        return AnonymizationStatus.NOT_STARTED
+
+    # ---- Single‑responsibility mutators ---------------------------------
+    def mark_sensitive_meta_processed(self, *, save: bool = True) -> None:
+        self.sensitive_meta_processed = True
+        if save:
+            self.save(update_fields=["sensitive_meta_processed", "date_modified"])
+
+    def mark_anonymization_validated(self, *, save: bool = True) -> None:
+        """
+        Mark the anonymization process as validated for this video state.
+        
+        Parameters:
+            save (bool): If True, persist the change to the database immediately.
+        """
+        self.anonymization_validated = True
+        if save:
+            self.save(update_fields=["anonymization_validated", "date_modified"])
+
+    def mark_frames_extracted(self, *, save: bool = True) -> None:
+        """
+        Mark the video as having its frames extracted.
+        
+        Parameters:
+            save (bool): If True, persist the change to the database immediately.
+        """
+        self.frames_extracted = True
+        if save:
+            self.save(update_fields=["frames_extracted", "date_modified"])
+
+    def mark_frames_not_extracted(self, *, save: bool = True) -> None:
+        """
+        Mark the video as having no extracted frames.
+        
+        If `save` is True, updates the database record for this state.
+        """
+        self.frames_extracted = False
+        if save:
+            self.save(update_fields=["frames_extracted", "date_modified"])
+
+    def mark_anonymized(self, *, save: bool = True) -> None:
+        """
+        Mark the video as anonymized by setting the anonymized flag to True.
+        
+        Parameters:
+            save (bool): If True, immediately saves the updated state to the database.
+        """
+        self.anonymized = True
+        if save:
+            self.save(update_fields=["anonymized", "date_modified"])
+
+    def mark_initial_prediction_completed(self, *, save: bool = True) -> None:
+        """
+        Mark the initial AI prediction as completed for this video state.
+        
+        Parameters:
+            save (bool): If True, persist the change to the database immediately.
+        """
+        self.initial_prediction_completed = True
+        if save:
+            self.save(update_fields=["initial_prediction_completed", "date_modified"])
+
+    def mark_video_meta_extracted(self, *, save: bool = True) -> None:
+        """
+        Mark the video metadata as extracted for this video state.
+        
+        Parameters:
+            save (bool): If True, immediately saves the updated state to the database.
+        """
+        self.video_meta_extracted = True
+        if save:
+            self.save(update_fields=["video_meta_extracted", "date_modified"])
+
+    def mark_text_meta_extracted(self, *, save: bool = True) -> None:
+        """
+        Mark the video as having its text metadata extracted.
+        
+        Parameters:
+        	save (bool): If True, immediately saves the updated state to the database.
+        """
+        self.text_meta_extracted = True
+        if save:
+            self.save(update_fields=["text_meta_extracted", "date_modified"])
+    
+    def get_or_create_state(self):
+        """
+        Get the current state of the video, or create a new one if it doesn't exist.
+        
+        Returns:
+            VideoState: The current or newly created state.
+        """
+        if not hasattr(self, 'video_file'):
+            raise ValueError("This method requires a related VideoFile instance.")
+        
+        # If the state already exists, return it
+        if self.video_file.state:
+            return self.video_file.state
+        
+        # Otherwise, create a new state
+        new_state = VideoState(video_file=self.video_file)
+        new_state.save()
+        return new_state
+    
+    def mark_processing_started(self, *, save: bool = True) -> None:
+        """
+        Mark the processing as started for this video state.
+        
+        Parameters:
+            save (bool): If True, immediately saves the updated state to the database.
+        """
+        self.processing_started = True
+        if save:
+            self.save(update_fields=["processing_started", "date_modified"])
+    
+    
+
+    class Meta:
+        verbose_name = "Video Processing State"
+        verbose_name_plural = "Video Processing States"

endoreg_db/models/upload_job.py

@@ -0,0 +1,99 @@
+import uuid
+from django.db import models
+
+
+class UploadJob(models.Model):
+    """
+    Tracks file upload jobs and their processing status.
+    Supports both PDF and video file uploads with asynchronous processing.
+    """
+    
+    class Status(models.TextChoices):
+        PENDING = 'pending', 'Pending'
+        PROCESSING = 'processing', 'Processing'
+        ANONYMIZED = 'anonymized', 'Anonymized'
+        ERROR = 'error', 'Error'
+
+    id = models.UUIDField(
+        primary_key=True, 
+        default=uuid.uuid4, 
+        editable=False,
+        help_text="Unique identifier for the upload job"
+    )
+    
+    file = models.FileField(
+        upload_to='uploads/%Y/%m/%d/',
+        help_text="Uploaded file (PDF or video)"
+    )
+    
+    status = models.CharField(
+        max_length=20,
+        choices=Status.choices,
+        default=Status.PENDING,
+        help_text="Current processing status of the upload"
+    )
+    
+    content_type = models.CharField(
+        max_length=100,
+        blank=True,
+        help_text="MIME type of the uploaded file"
+    )
+    
+    sensitive_meta = models.ForeignKey(
+        'SensitiveMeta',
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        help_text="Link to the created SensitiveMeta record after processing"
+    )
+    
+    error_detail = models.TextField(
+        blank=True,
+        help_text="Error message if processing failed"
+    )
+    
+    created_at = models.DateTimeField(
+        auto_now_add=True,
+        help_text="When the upload job was created"
+    )
+    
+    updated_at = models.DateTimeField(
+        auto_now=True,
+        help_text="When the upload job was last updated"
+    )
+
+    class Meta:
+        ordering = ['-created_at']
+        verbose_name = "Upload Job"
+        verbose_name_plural = "Upload Jobs"
+
+    def __str__(self):
+        return f"UploadJob {self.id} - {self.status} ({self.content_type})"
+
+    @property
+    def is_complete(self):
+        """Returns True if the job has finished processing (success or error)."""
+        return self.status in [self.Status.ANONYMIZED, self.Status.ERROR]
+
+    @property
+    def is_successful(self):
+        """Returns True if the job completed successfully."""
+        return self.status == self.Status.ANONYMIZED
+
+    def mark_processing(self):
+        """Mark the job as processing."""
+        self.status = self.Status.PROCESSING
+        self.save(update_fields=['status', 'updated_at'])
+
+    def mark_completed(self, sensitive_meta=None):
+        """Mark the job as successfully completed."""
+        self.status = self.Status.ANONYMIZED
+        if sensitive_meta:
+            self.sensitive_meta = sensitive_meta
+        self.save(update_fields=['status', 'sensitive_meta', 'updated_at'])
+
+    def mark_error(self, error_detail: str):
+        """Mark the job as failed with error details."""
+        self.status = self.Status.ERROR
+        self.error_detail = error_detail
+        self.save(update_fields=['status', 'error_detail', 'updated_at'])