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

endoreg_db/models/upload_job.py

@@ -7,7 +7,7 @@ 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):
@@ -16,23 +16,47 @@ class UploadJob(models.Model):
         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")
+    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)")
+    file = models.FileField(
+        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")
+    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")
+    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"
+        "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")
+    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")
+    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")
+    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

endoreg_db/models/utils.py

@@ -1,15 +1,15 @@
-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
-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:
     pass
 
@@ -18,14 +18,12 @@ 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"
@@ -70,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.
@@ -88,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"]
@@ -101,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]
@@ -119,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/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,7 +44,6 @@ from .patient_finding import (
     PatientFindingWriteSerializer,
 )
 from .pdf import RawPdfAnonyTextSerializer
-from .report import ReportDataSerializer, ReportListSerializer, SecureFileUrlSerializer
 from .video.video_processing_history import VideoProcessingHistorySerializer
 from .video_examination import (
     VideoExaminationCreateSerializer,
@@ -76,8 +72,6 @@ __all__ = [
     "LabelVideoSegmentSerializer",
     "LabelVideoSegmentAnnotationSerializer",
     # Meta
-    "PDFFileForMetaSerializer",
-    "ReportMetaSerializer",
     "SensitiveMetaDetailSerializer",
     "SensitiveMetaUpdateSerializer",
     "SensitiveMetaVerificationSerializer",
@@ -101,7 +95,7 @@ __all__ = [
     "PatientFindingInterventionSerializer",
     "PatientFindingListSerializer",
     "PatientFindingWriteSerializer",
-    # PDF
+    # report
     "RawPdfAnonyTextSerializer",
     # Report
     "ReportListSerializer",

endoreg_db/serializers/label_video_segment/label_video_segment.py

@@ -142,7 +142,7 @@ class LabelVideoSegmentSerializer(serializers.ModelSerializer):
             logger.debug(f"Serializer initialized with data: {self.initial_data}")
 
 
-    def get_time_segments(self, obj: LabelVideoSegment) -> List[dict]:
+    def get_time_segments(self, obj: LabelVideoSegment) -> dict[str, dict]:
         frames = obj.frames
         time_segments = {
             "segment_id": obj.id,
@@ -225,34 +225,7 @@ class LabelVideoSegmentSerializer(serializers.ModelSerializer):
         """
         return ImageClassificationAnnotationSerializer(obj.all_frame_annotations, many=True).data
 
-    def get_label_display(self, obj:LabelVideoSegment):
-        """
-        Return the German translation of the label name for display purposes.
-        
-        If the segment has no label, returns "Unbekannt". If a translation is not available, returns the original label name.
-        """
-        if not obj.label:
-            return "Unbekannt"
-            
-        label_name = obj.label.name
-        #TODO Refactor
-        translations = {
-            'appendix': 'Appendix',
-            'blood': 'Blut',
-            'diverticule': 'Divertikel',
-            'grasper': 'Greifer',
-            'ileocaecalvalve': 'Ileozäkalklappe',
-            'ileum': 'Ileum',
-            'low_quality': 'Niedrige Bildqualität',
-            'nbi': 'Narrow Band Imaging',
-            'needle': 'Nadel',
-            'outside': 'Außerhalb',
-            'polyp': 'Polyp',
-            'snare': 'Snare',
-            'water_jet': 'Wasserstrahl',
-            'wound': 'Wunde'
-        }
-        return translations.get(label_name, label_name)
+
     
     def get_video_name(self, obj):
         """

endoreg_db/serializers/meta/__init__.py

@@ -1,7 +1,4 @@
-from .pdf_file_meta_extraction import PDFFileForMetaSerializer
-from .report_meta import (
-    ReportMetaSerializer,
-)
+
 from .sensitive_meta_detail import SensitiveMetaDetailSerializer
 from .sensitive_meta_update import SensitiveMetaUpdateSerializer
 from .sensitive_meta_verification import SensitiveMetaVerificationSerializer
@@ -10,8 +7,6 @@ from .video_meta import (
 )
 
 __all__ = [
-    "PDFFileForMetaSerializer",
-    "ReportMetaSerializer",
     "SensitiveMetaDetailSerializer",
     "SensitiveMetaUpdateSerializer",
     "SensitiveMetaVerificationSerializer",

endoreg_db/serializers/misc/sensitive_patient_data.py

@@ -1,14 +1,14 @@
-from endoreg_db.models.media import RawPdfFile, VideoFile
-
-
 from rest_framework import serializers
 
-#TODO add this "naming convention" to the documentation
+from endoreg_db.models.media import RawPdfFile, VideoFile
+
+# TODO add this "naming convention" to the documentation
 # VoP: Video or Pdf
 
+
 class VoPPatientDataSerializer(serializers.Serializer):
     """
-    Serializer that converts a VideoFile or RawPdfFile to the structure 
+    Serializer that converts a VideoFile or RawPdfFile to the structure
     the Pinia store needs for validation workflow.
     """
 
@@ -24,12 +24,12 @@ class VoPPatientDataSerializer(serializers.Serializer):
     def to_representation(self, instance):
         """
         Serialize a VideoFile or RawPdfFile instance into a structured dictionary for validation workflows.
-        
+
         Depending on the instance type, constructs a dictionary containing identifiers, sensitive metadata, text summaries, anonymized text, processing status, and error flag. For VideoFile instances, generates a text summary from associated sensitive metadata and anonymizes personal identifiers. For RawPdfFile instances, uses the instance's text fields directly. Raises a TypeError if the instance is neither type.
-        
+
         Parameters:
             instance: A VideoFile or RawPdfFile model instance to serialize.
-        
+
         Returns:
             dict: A structured representation of the instance suitable for Pinia store consumption.
         """
@@ -62,44 +62,62 @@ class VoPPatientDataSerializer(serializers.Serializer):
                 # Create anonymized version
                 anonym_text = text
                 if sm.patient_first_name:
-                    anonym_text = anonym_text.replace(sm.patient_first_name, "[FIRST_NAME]")
+                    anonym_text = anonym_text.replace(
+                        sm.patient_first_name, "[FIRST_NAME]"
+                    )
                 if sm.patient_last_name:
-                    anonym_text = anonym_text.replace(sm.patient_last_name, "[LAST_NAME]")
+                    anonym_text = anonym_text.replace(
+                        sm.patient_last_name, "[LAST_NAME]"
+                    )
                 if sm.patient_dob:
-                    anonym_text = anonym_text.replace(str(sm.patient_dob.date()), "[DOB]")
+                    anonym_text = anonym_text.replace(
+                        str(sm.patient_dob.date()), "[DOB]"
+                    )
 
             return {
                 "id": instance.pk,
-                "sensitiveMetaId": instance.sensitive_meta.pk if instance.sensitive_meta else None,
+                "sensitiveMetaId": instance.sensitive_meta.pk
+                if instance.sensitive_meta
+                else None,
                 "text": text,
                 "anonymizedText": anonym_text,
-                "reportMeta": self._serialize_sensitive_meta(instance.sensitive_meta) if instance.sensitive_meta else None,
-                "status": "processing" if instance.state and instance.state.frames_extracted else "not_started",
+                "reportMeta": self._serialize_sensitive_meta(instance.sensitive_meta)
+                if instance.sensitive_meta
+                else None,
+                "status": "processing"
+                if instance.state and instance.state.frames_extracted
+                else "not_started",
                 "error": False,
             }
 
         elif isinstance(instance, RawPdfFile):
-            # Generate PDF streaming URL using pdf_id (RawPdfFile.id)
-            pdf_stream_url = f"/api/media/pdfs/{instance.pk}/stream/"
-            
+            # Generate report streaming URL using pdf_id (RawPdfFile.id)
+            report_stream_url = f"/api/media/pdfs/{instance.pk}/stream/"
+
             return {
                 "id": instance.pk,
-                "sensitiveMetaId": instance.sensitive_meta.pk if instance.sensitive_meta else None,
+                "sensitiveMetaId": instance.sensitive_meta.pk
+                if instance.sensitive_meta
+                else None,
                 "text": instance.text or "",
                 "anonymizedText": instance.anonymized_text or "",
-                "reportMeta": self._serialize_sensitive_meta(instance.sensitive_meta) if instance.sensitive_meta else None,
+                "reportMeta": self._serialize_sensitive_meta(instance.sensitive_meta)
+                if instance.sensitive_meta
+                else None,
                 "status": "done" if instance.anonymized_text else "not_started",
                 "error": False,
-                "pdfStreamUrl": pdf_stream_url,
+                "pdfStreamUrl": report_stream_url,
             }
 
         else:
-            raise TypeError(f"Unsupported instance for VoPPatientDataSerializer: {type(instance)}")
+            raise TypeError(
+                f"Unsupported instance for VoPPatientDataSerializer: {type(instance)}"
+            )
 
     def _serialize_sensitive_meta(self, sensitive_meta):
         """
         Serialize a SensitiveMeta object into a dictionary with patient and examination details.
-        
+
         Returns:
             dict or None: A dictionary containing patient and examination metadata fields, or None if sensitive_meta is not provided.
         """
@@ -110,11 +128,17 @@ class VoPPatientDataSerializer(serializers.Serializer):
             "id": sensitive_meta.pk,
             "patientFirstName": sensitive_meta.patient_first_name or "",
             "patientLastName": sensitive_meta.patient_last_name or "",
-            "patientDob": sensitive_meta.patient_dob.isoformat() if sensitive_meta.patient_dob else "",
-            "patientGender": str(sensitive_meta.patient_gender) if sensitive_meta.patient_gender else "",
-            "examinationDate": sensitive_meta.examination_date.isoformat() if sensitive_meta.examination_date else "",
+            "patientDob": sensitive_meta.patient_dob.isoformat()
+            if sensitive_meta.patient_dob
+            else "",
+            "patientGender": str(sensitive_meta.patient_gender)
+            if sensitive_meta.patient_gender
+            else "",
+            "examinationDate": sensitive_meta.examination_date.isoformat()
+            if sensitive_meta.examination_date
+            else "",
             "centerName": sensitive_meta.center.name if sensitive_meta.center else "",
             "endoscopeType": sensitive_meta.endoscope_type or "",
             "endoscopeSn": sensitive_meta.endoscope_sn or "",
             "isVerified": getattr(sensitive_meta, "is_verified", False),
-        }
+        }

endoreg_db/serializers/patient_examination/patient_examination.py

@@ -135,7 +135,7 @@ class PatientExaminationSerializer(serializers.ModelSerializer):
     
     def get_findings(self, patient_examination_id):
         """Gibt die zugehörigen Befunde zurück"""
-        obj = PatientExamination.get_or_create_patient_examination_by_id(PatientExamination, patient_examination_id)
+        pe = PatientExamination()
+        obj = pe.get_or_create_patient_examination_by_id(patient_examination_id)
         self.instance = obj
-        response = PatientExaminationSerializer()
-        return self.instance.patient_findings.all() if self.instance else []
+        return self.instance.get_available_findings() if self.instance else []

endoreg_db/serializers/pdf/anony_text_validation.py

@@ -1,11 +1,14 @@
 from pathlib import Path
-from rest_framework import serializers
+
 from django.conf import settings
+from rest_framework import serializers
+
 from ...models import RawPdfFile
 
+
 class RawPdfAnonyTextSerializer(serializers.ModelSerializer):
     """
-    Serializer to fetch PDF metadata along with `anonymized_text` from `RawPdfFile`.
+    Serializer to fetch report metadata along with `anonymized_text` from `RawPdfFile`.
     Ensures Vue.js can process JSON efficiently.
     """
 
@@ -15,36 +18,46 @@ class RawPdfAnonyTextSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = RawPdfFile
-        fields = ['id', 'file', 'pdf_url', 'full_pdf_path', 
-                  'sensitive_meta_id', 'anonymized_text']
+        fields = [
+            "id",
+            "file",
+            "pdf_url",
+            "full_pdf_path",
+            "sensitive_meta_id",
+            "anonymized_text",
+        ]
 
     @staticmethod
     def get_next_pdf(last_id=None):
         """
-        Retrieves the first available PDF if `last_id` is NOT provided.
-        Otherwise, fetches the next available PDF where `id > last_id`.
+        Retrieves the first available report if `last_id` is NOT provided.
+        Otherwise, fetches the next available report where `id > last_id`.
         """
         query_filter = {} if last_id is None else {"id__gt": int(last_id)}
-        pdf_entry = RawPdfFile.objects.filter(**query_filter).order_by('id').first()
-        return pdf_entry  
+        pdf_entry = RawPdfFile.objects.filter(**query_filter).order_by("id").first()
+        return pdf_entry
 
     def get_pdf_url(self, obj):
         """
-        Returns the absolute URL for accessing the anonymized text PDF endpoint for the given object.
-        
+        Returns the absolute URL for accessing the anonymized text report endpoint for the given object.
+
         If the request context or file is missing, returns None.
         """
-        request = self.context.get('request')
-        return request.build_absolute_uri(f"/pdf/anony_text/?id={obj.id}") if request and obj.file else None
+        request = self.context.get("request")
+        return (
+            request.build_absolute_uri(f"/pdf/anony_text/?id={obj.id}")
+            if request and obj.file
+            else None
+        )
 
     def get_file(self, obj):
         """
-        Retrieves the relative file path of the PDF from the model instance.
-        
+        Retrieves the relative file path of the report from the model instance.
+
         Returns:
             The relative file path as a string, or None if no file is associated.
         """
-        return str(obj.file.name).strip() if obj.file else None  
+        return str(obj.file.name).strip() if obj.file else None
 
     def get_full_pdf_path(self, obj):
         """
@@ -54,32 +67,35 @@ class RawPdfAnonyTextSerializer(serializers.ModelSerializer):
             return None
         pdf_relative_path = str(obj.file.name)
         full_path = Path(settings.MEDIA_ROOT) / pdf_relative_path
-        return str(full_path) if full_path.exists() else None  
+        return str(full_path) if full_path.exists() else None
 
     def validate_anonymized_text(self, value):
         """
         Validates that the anonymized text is non-empty and does not exceed 5000 characters.
-        
+
         Raises:
             serializers.ValidationError: If the text is empty or exceeds the length limit.
         """
         if not value.strip():
             raise serializers.ValidationError("Anonymized text cannot be empty.")
-        #FIXME move this to a settings variable @Hamzaukw @maxhild
+        # FIXME move this to a settings variable @Hamzaukw @maxhild
         if len(value) > 5000:  # Arbitrary limit to prevent excessively long text
-            raise serializers.ValidationError("Anonymized text exceeds the maximum length of 5000 characters.")
+            raise serializers.ValidationError(
+                "Anonymized text exceeds the maximum length of 5000 characters."
+            )
         return value
 
     def update(self, instance, validated_data):
         """
         Update the `anonymized_text` field of a RawPdfFile instance with validated data.
-        
+
         Only the `anonymized_text` field is modified; all other fields remain unchanged.
-        
+
         Returns:
             The updated RawPdfFile instance.
         """
-        instance.anonymized_text = validated_data.get('anonymized_text', instance.anonymized_text)
+        instance.anonymized_text = validated_data.get(
+            "anonymized_text", instance.anonymized_text
+        )
         instance.save()
         return instance
-