endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.9__py3-none-any.whl

endoreg_db/models/state/video.py

@@ -1,117 +1,139 @@
 """
 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
+from typing import TYPE_CHECKING, Optional
+
+from django.db import models, transaction
+
+from endoreg_db.models.state.anonymization import AnonymizationState
 
 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.")
+        video_file: models.OneToOneField["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.")
+    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.")
-    
+    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.")
+    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.")
-    
+    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_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.")
-    
+    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:
+    def anonymization_status(self) -> AnonymizationState:
         """
         Fast, side‑effect‑free status resolution used by API & UI.
         """
         if self.anonymization_validated:
-            return AnonymizationStatus.VALIDATED
+            return AnonymizationState.VALIDATED  # Validation in Frontend completed -> Views related to this /home/admin/endoreg-db/endoreg_db/views/anonymization/validate.py
         if self.sensitive_meta_processed:
-            return AnonymizationStatus.DONE
+            return AnonymizationState.DONE_PROCESSING_ANONYMIZATION  # /home/admin/endoreg-db/endoreg_db/services/video_import.py /home/admin/endoreg-db/endoreg_db/views/video/reimport.py
         if self.frames_extracted and not self.anonymized:
-            return AnonymizationStatus.PROCESSING_ANONYMIZING
+            return AnonymizationState.PROCESSING_ANONYMIZING
         if self.was_created and not self.frames_extracted:
-            return AnonymizationStatus.EXTRACTING_FRAMES
+            return AnonymizationState.EXTRACTING_FRAMES
         if getattr(self, "processing_error", False):
-            return AnonymizationStatus.FAILED
+            return AnonymizationState.FAILED
         if self.processing_started:
-            return AnonymizationStatus.STARTED
-        return AnonymizationStatus.NOT_STARTED
+            return AnonymizationState.STARTED
+        if self.anonymized:
+            return AnonymizationState.ANONYMIZED
+        return AnonymizationState.NOT_STARTED
+
+    def mark_processing_not_started(self) -> None:
+        """
+        Mark the processing as not started and optionally save the updated state.
+
+        Parameters:
+            save (bool): If True, persist the change to the database immediately. Defaults to True.
+        """
+        with transaction.atomic():
+            self.processing_started = False
+            self.anonymized = False
+            self.was_created = False
+            self.sensitive_meta_processed = False
+            self.anonymization_validated = False
+            self.frames_extracted = False
+            self.save()
 
     # ---- Single‑responsibility mutators ---------------------------------
     def mark_sensitive_meta_processed(self, *, save: bool = True) -> None:
@@ -122,7 +144,7 @@ class VideoState(models.Model):
     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.
         """
@@ -133,7 +155,7 @@ class VideoState(models.Model):
     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.
         """
@@ -144,7 +166,7 @@ class VideoState(models.Model):
     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
@@ -154,18 +176,18 @@ class VideoState(models.Model):
     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:
+        with transaction.atomic():
+            self.anonymized = True
             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.
         """
@@ -176,7 +198,7 @@ class VideoState(models.Model):
     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.
         """
@@ -187,45 +209,43 @@ class VideoState(models.Model):
     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.
+                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'):
+        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"

endoreg_db/models/upload_job.py

@@ -1,69 +1,70 @@
 import uuid
+from typing import TYPE_CHECKING, cast
+
 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.
+    Supports both report and video file uploads with asynchronous processing.
     """
-    
+
     class Status(models.TextChoices):
-        PENDING = 'pending', 'Pending'
-        PROCESSING = 'processing', 'Processing'
-        ANONYMIZED = 'anonymized', 'Anonymized'
-        ERROR = 'error', 'Error'
+        PENDING = "pending", "Pending"
+        PROCESSING = "processing", "Processing"
+        ANONYMIZED = "anonymized", "Anonymized"
+        ERROR = "error", "Error"
 
     id = models.UUIDField(
-        primary_key=True, 
-        default=uuid.uuid4, 
+        primary_key=True,
+        default=uuid.uuid4,
         editable=False,
-        help_text="Unique identifier for the upload job"
+        help_text="Unique identifier for the upload job",
     )
-    
+
     file = models.FileField(
-        upload_to='uploads/%Y/%m/%d/',
-        help_text="Uploaded file (PDF or video)"
+        upload_to="uploads/%Y/%m/%d/", help_text="Uploaded file (report or video)"
     )
-    
+
     status = models.CharField(
         max_length=20,
         choices=Status.choices,
         default=Status.PENDING,
-        help_text="Current processing status of the upload"
+        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"
+        max_length=100, blank=True, help_text="MIME type of the uploaded file"
     )
-    
+
     sensitive_meta = models.ForeignKey(
-        'SensitiveMeta',
+        "SensitiveMeta",
         null=True,
         blank=True,
         on_delete=models.SET_NULL,
-        help_text="Link to the created SensitiveMeta record after processing"
+        help_text="Link to the created SensitiveMeta record after processing",
     )
-    
+
     error_detail = models.TextField(
-        blank=True,
-        help_text="Error message if processing failed"
+        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"
+        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"
+        auto_now=True, help_text="When the upload job was last updated"
     )
 
+    if TYPE_CHECKING:
+        from django.db.models.fields.files import FieldFile
+
+        file = cast(FieldFile, file)
+
     class Meta:
-        ordering = ['-created_at']
+        ordering = ["-created_at"]
         verbose_name = "Upload Job"
         verbose_name_plural = "Upload Jobs"
 
@@ -83,17 +84,17 @@ class UploadJob(models.Model):
     def mark_processing(self):
         """Mark the job as processing."""
         self.status = self.Status.PROCESSING
-        self.save(update_fields=['status', 'updated_at'])
+        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'])
+        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'])
+        self.save(update_fields=["status", "error_detail", "updated_at"])

endoreg_db/models/utils.py

@@ -1,32 +1,29 @@
-from ..utils import (
-    data_paths,
-    DJANGO_NAME_SALT,
-)
-from django.core.files import File
-from django.core.files.storage import FileSystemStorage
 import io
 import os
-from tqdm import tqdm
-import numpy as np
-import cv2
-from typing import TYPE_CHECKING, List, Tuple
 from pathlib import Path
+from typing import TYPE_CHECKING, List, Tuple
+
+import cv2
+import numpy as np
+from django.core.files import File
+from django.core.files.storage import FileSystemStorage
+
+from ..utils import DJANGO_NAME_SALT, data_paths
+
 if TYPE_CHECKING:
-    from ..models.media import VideoFile
+    pass
 
 from logging import getLogger
 
 logger = getLogger(__name__)
 
 STORAGE_DIR = data_paths["storage"]
-FILE_STORAGE = FileSystemStorage(location = STORAGE_DIR)
-VIDEO_DIR = data_paths["video"]
-TMP_VIDEO_DIR = VIDEO_DIR / "tmp"
-ANONYM_VIDEO_DIR = data_paths["video_export"]
+FILE_STORAGE = FileSystemStorage(location=str(STORAGE_DIR))
+TRANSCODING_DIR = data_paths["transcoding"]
 FRAME_DIR = data_paths["frame"]
 WEIGHTS_DIR = data_paths["weights"]
-PDF_DIR = data_paths["raw_pdf"]
-DOCUMENT_DIR = data_paths["pdf"]
+REPORT_DIR = data_paths["import_report"]
+DOCUMENT_DIR = data_paths["documents"] #TODO Verify if this is still used and assign correct dir
 
 TEST_RUN = os.environ.get("TEST_RUN", "False")
 TEST_RUN = TEST_RUN.lower() == "true"
@@ -71,8 +68,13 @@ def find_segments_in_prediction_array(prediction_array: np.array, min_frame_len:
 
     return segments
 
+
 def anonymize_frame(
-    raw_frame_path: Path, target_frame_path: Path, endo_roi, all_black: bool = False, censor_color: Tuple[int, int, int] = (0, 0, 0) # Added censor_color param
+    raw_frame_path: Path,
+    target_frame_path: Path,
+    endo_roi,
+    all_black: bool = False,
+    censor_color: Tuple[int, int, int] = (0, 0, 0),  # Added censor_color param
 ):
     """
     Anonymize the frame by blacking out pixels outside the endoscope ROI or making the whole frame black.
@@ -89,7 +91,9 @@ def anonymize_frame(
         # Validate ROI dictionary keys
         required_keys = {"x", "y", "width", "height"}
         if not required_keys.issubset(endo_roi):
-            raise ValueError(f"Invalid endo_roi dictionary provided: {endo_roi}. Missing keys.")
+            raise ValueError(
+                f"Invalid endo_roi dictionary provided: {endo_roi}. Missing keys."
+            )
 
         x = endo_roi["x"]
         y = endo_roi["y"]
@@ -102,7 +106,9 @@ def anonymize_frame(
         x2, y2 = min(w_orig, x + width), min(h_orig, y + height)
 
         if x1 >= x2 or y1 >= y2:
-            logger.warning(f"ROI [{x},{y},{width},{height}] is outside or invalid for frame dimensions {w_orig}x{h_orig}. Resulting frame might be all black.")
+            logger.warning(
+                f"ROI [{x},{y},{width},{height}] is outside or invalid for frame dimensions {w_orig}x{h_orig}. Resulting frame might be all black."
+            )
         else:
             # copy valid endoscope roi part to black frame
             new_frame[y1:y2, x1:x2] = frame[y1:y2, x1:x2]
@@ -120,16 +126,13 @@ __all__ = [
     "DJANGO_NAME_SALT",
     "data_paths",
     "FILE_STORAGE",
-    "VIDEO_DIR",
-    "TMP_VIDEO_DIR",
     "ANONYM_VIDEO_DIR",
     "FRAME_DIR",
     "WEIGHTS_DIR",
-    "PDF_DIR",
-    "DOCUMENT_DIR",
+    "REPORT_DIR",
     "prepare_bulk_frames",
     "anonymize_frame",
     "find_segments_in_prediction_array",
     "TEST_RUN",
     "TEST_RUN_FRAME_NUMBER",
-]
+]

endoreg_db/queries/__init__.py

@@ -2,4 +2,6 @@ from .annotations import (
     generate_legacy_dataset_output
 )
 
-from .get import *
+__all__ = [
+    "generate_legacy_dataset_output"  
+]

endoreg_db/root_urls.py

@@ -1,9 +1,28 @@
+# endoreg_db/root_urls.py
+from django.contrib import admin
 from django.urls import include, path
+from django.http import HttpResponse
+from django.conf import settings
+from django.conf.urls.static import static
 
-# Import raw API urlpatterns (no prefix) from the URLs package
+# Import raw API urlpatterns (no prefix) from your API urls package
 from endoreg_db.urls import urlpatterns as api_urlpatterns
 
-# Mount the API under /api/
+def public_home(_request):
+    return HttpResponse("Public home – no login required.")
+
 urlpatterns = [
+    path("", public_home, name="public_home"),
+    #path("admin/", admin.site.urls),
+
+    # Mount ALL API endpoints under /api/
     path("api/", include((api_urlpatterns, "endoreg_db"), namespace="api")),
+
+    # OIDC (mozilla-django-oidc provides /oidc/authenticate/ and /oidc/callback/)
+    path("oidc/", include("mozilla_django_oidc.urls")),
 ]
+
+# Serve static/media only in DEBUG (at root, not under /api/)
+if settings.DEBUG:
+    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
+    urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)

endoreg_db/schemas/examination_evaluation.py

@@ -19,7 +19,7 @@ class RequirementSetEval(BaseModel):
     linked_sets: List["RequirementSetEval"] = Field(default_factory=list)
 
 class ExaminationEvalReport(BaseModel):
-    examination_id: int
+    examination_id: int | None = None
     summary: dict
     sets: List[RequirementSetEval]
     errors: List[str] = Field(default_factory=list)

endoreg_db/serializers/__init__.py

@@ -12,8 +12,7 @@ from .examination import (
 )
 from .finding import FindingSerializer
 from .finding_classification import (
-    FindingClassificationChoiceSerializer,
-    FindingClassificationSerializer,
+    FindingClassificationSerializer,  # FindingClassificationChoiceSerializer,
 )
 from .label import ImageClassificationAnnotationSerializer, LabelSerializer
 from .label_video_segment import (
@@ -21,8 +20,6 @@ from .label_video_segment import (
     LabelVideoSegmentSerializer,
 )
 from .meta import (
-    PDFFileForMetaSerializer,
-    ReportMetaSerializer,
     SensitiveMetaDetailSerializer,
     SensitiveMetaUpdateSerializer,
     SensitiveMetaVerificationSerializer,
@@ -47,8 +44,6 @@ from .patient_finding import (
     PatientFindingWriteSerializer,
 )
 from .pdf import RawPdfAnonyTextSerializer
-from .report import ReportDataSerializer, ReportListSerializer, SecureFileUrlSerializer
-from .video.video_metadata import VideoMetadataSerializer
 from .video.video_processing_history import VideoProcessingHistorySerializer
 from .video_examination import (
     VideoExaminationCreateSerializer,
@@ -77,8 +72,6 @@ __all__ = [
     "LabelVideoSegmentSerializer",
     "LabelVideoSegmentAnnotationSerializer",
     # Meta
-    "PDFFileForMetaSerializer",
-    "ReportMetaSerializer",
     "SensitiveMetaDetailSerializer",
     "SensitiveMetaUpdateSerializer",
     "SensitiveMetaVerificationSerializer",
@@ -102,14 +95,13 @@ __all__ = [
     "PatientFindingInterventionSerializer",
     "PatientFindingListSerializer",
     "PatientFindingWriteSerializer",
-    # PDF
+    # report
     "RawPdfAnonyTextSerializer",
     # Report
     "ReportListSerializer",
     "ReportDataSerializer",
     "SecureFileUrlSerializer",
     # Video Correction (Phase 1.1)
-    "VideoMetadataSerializer",
     "VideoProcessingHistorySerializer",
     # Video Examination
     "VideoExaminationSerializer",