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

endoreg_db/models/state/video.py

@@ -1,69 +1,71 @@
 """
 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
+
+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"]
-        
+        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.")
-    
+
     # 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.")
-    
+
     # 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):
@@ -71,10 +73,11 @@ class VideoState(models.Model):
         video_uuid = "Unknown"
         try:
             # Access the related VideoFile via the reverse relation 'video_file'
-            if hasattr(self, 'video_file') and self.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
+            pass  # Ignore errors if relation doesn't exist or causes issues
+            pass  # Ignore errors if relation doesn't exist or causes issues
 
         states = [
             f"FramesExtracted={self.frames_extracted}",
@@ -86,32 +89,36 @@ class VideoState(models.Model):
             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"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()}"
+            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
 
     # ---- Single‑responsibility mutators ---------------------------------
     def mark_sensitive_meta_processed(self, *, save: bool = True) -> None:
@@ -122,7 +129,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 +140,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 +151,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,7 +161,7 @@ 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.
         """
@@ -165,7 +172,7 @@ class VideoState(models.Model):
     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 +183,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 +194,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,4 +1,6 @@
 import uuid
+from typing import TYPE_CHECKING, cast
+
 from django.db import models
 
 
@@ -7,63 +9,38 @@ 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"
-    )
-    
+        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"
+        "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")
+
+    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 +60,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

@@ -6,13 +6,12 @@ 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
 if TYPE_CHECKING:
-    from ..models.media import VideoFile
+    pass
 
 from logging import getLogger
 

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/serializers/__init__.py

@@ -48,7 +48,6 @@ from .patient_finding import (
 )
 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,
@@ -109,7 +108,6 @@ __all__ = [
     "ReportDataSerializer",
     "SecureFileUrlSerializer",
     # Video Correction (Phase 1.1)
-    "VideoMetadataSerializer",
     "VideoProcessingHistorySerializer",
     # Video Examination
     "VideoExaminationSerializer",

endoreg_db/serializers/anonymization.py

@@ -7,7 +7,6 @@ Unterstützt DD.MM.YYYY als Primärformat und YYYY-MM-DD als Fallback.
 from rest_framework import serializers
 from endoreg_db.models.metadata.sensitive_meta_logic import parse_any_date
 
-
 class SensitiveMetaValidateSerializer(serializers.Serializer):
     """
     Serializer für SensitiveMeta-Validierung mit deutscher Datums-Priorität.
@@ -19,11 +18,11 @@ class SensitiveMetaValidateSerializer(serializers.Serializer):
     Alle Datumsfelder werden in date-Objekte konvertiert.
     """
     
-    patient_first_name = serializers.CharField(required=False, allow_blank=True)
-    patient_last_name = serializers.CharField(required=False, allow_blank=True)
-    patient_dob = serializers.CharField(required=False, allow_blank=True)
-    examination_date = serializers.CharField(required=False, allow_blank=True)
-    casenumber = serializers.CharField(required=False, allow_blank=True)
+    patient_first_name = serializers.CharField(required=True, allow_blank=True)
+    patient_last_name = serializers.CharField(required=True, allow_blank=True)
+    patient_dob = serializers.CharField(required=True, allow_blank=True)
+    examination_date = serializers.CharField(required=True, allow_blank=True)
+    casenumber = serializers.CharField(required=True, allow_blank=True)
     anonymized_text = serializers.CharField(required=False, allow_blank=True)
     patient_gender = serializers.CharField(required=False, allow_blank=True)
     center_name = serializers.CharField(required=False, allow_blank=True)
@@ -31,6 +30,10 @@ class SensitiveMetaValidateSerializer(serializers.Serializer):
     file_type = serializers.ChoiceField(
         choices=['video', 'pdf'], required=False
     )  # Optional: "video" oder "pdf"
+    center_name = serializers.CharField(required=False, allow_blank=True)
+    external_id = serializers.CharField(required=False, allow_blank=True)
+    external_id_origin = serializers.CharField(required=False, allow_blank=True)
+    
 
     def validate_patient_dob(self, value):
         """
@@ -40,8 +43,11 @@ class SensitiveMetaValidateSerializer(serializers.Serializer):
         - DD.MM.YYYY (z.B. "21.03.1994")
         - YYYY-MM-DD (z.B. "1994-03-21")
         """
-        if not value:
-            return None
+
+        if value == '' or not value:
+            raise serializers.ValidationError(
+                "Ungültiges Datum. Kein Input! Erlaubte Formate: DD.MM.YYYY oder YYYY-MM-DD."
+            ) 
             
         parsed_date = parse_any_date(value)
         if not parsed_date:
@@ -58,8 +64,10 @@ class SensitiveMetaValidateSerializer(serializers.Serializer):
         - DD.MM.YYYY (z.B. "15.02.2024")
         - YYYY-MM-DD (z.B. "2024-02-15")
         """
-        if not value:
-            return None
+        if value == '' or not value:
+            raise serializers.ValidationError(
+                "Ungültiges Datum. Kein Input! Erlaubte Formate: DD.MM.YYYY oder YYYY-MM-DD."
+            ) 
             
         parsed_date = parse_any_date(value)
         if not parsed_date:

endoreg_db/serializers/meta/report_meta.py

@@ -12,7 +12,7 @@ class ReportMetaSerializer(serializers.ModelSerializer):
     # Füge fehlende Zeitstempel-Felder hinzu
     created_at = serializers.SerializerMethodField()
     updated_at = serializers.SerializerMethodField()
-    casenumber = serializers.CharField(source='case_number', allow_blank=True, allow_null=True)
+    casenumber = serializers.CharField(source='casenumber', allow_blank=True, allow_null=True)
 
     class Meta:
         model = SensitiveMeta