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

endoreg_db/models/media/pdf/report_file.py

@@ -1,7 +1,9 @@
-from ...utils import DOCUMENT_DIR, STORAGE_DIR
-from django.db import models
 from typing import TYPE_CHECKING
 
+from django.db import models
+
+from ...utils import DOCUMENT_DIR, STORAGE_DIR
+
 if TYPE_CHECKING:
     from ...administration import (
         Center,
@@ -12,17 +14,21 @@ if TYPE_CHECKING:
     )
     from ...metadata import SensitiveMeta
 
+
 class DocumentTypeManager(models.Manager):
     """
     Custom manager for DocumentType.
     """
+
     def get_by_natural_key(self, name):
         return self.get(name=name)
 
+
 class DocumentType(models.Model):
     """
     Represents the type of a document.
     """
+
     name = models.CharField(max_length=255, unique=True)
     description = models.TextField(blank=True, null=True)
 
@@ -33,21 +39,23 @@ class DocumentType(models.Model):
 
     def __str__(self):
         return str(self.name)
-    
+
     class Meta:
         verbose_name = "Document Type"
         verbose_name_plural = "Document Types"
 
+
 class AbstractDocument(models.Model):
     """
     Abstract base class for documents.
     """
+
     meta = models.JSONField(blank=True, null=True)
     text = models.TextField(blank=True, null=True)
     date = models.DateField(blank=True, null=True)
     time = models.TimeField(blank=True, null=True)
     file = models.FileField(
-        upload_to=DOCUMENT_DIR.relative_to(STORAGE_DIR),
+        upload_to=DOCUMENT_DIR.relative_to(STORAGE_DIR).as_posix(),
         blank=True,
         null=True,
     )
@@ -67,22 +75,19 @@ class AbstractDocument(models.Model):
     )
 
     if TYPE_CHECKING:
-        center: "Center"
-        type: "DocumentType"
+        center: models.ForeignKey["Center|None"]
+        type: models.ForeignKey["DocumentType|None"]
 
     class Meta:
         abstract = True
 
 
-    
-
 class AbstractExaminationReport(AbstractDocument):
     """
     Abstract base class for examination reports.
     """
-    patient = models.ForeignKey(
-        "Patient", on_delete=models.DO_NOTHING, blank=True, null=True
-    )
+
+    patient = models.ForeignKey("Patient", on_delete=models.DO_NOTHING, blank=True, null=True)
 
     patient_examination = models.ForeignKey(
         "PatientExamination",
@@ -96,25 +101,18 @@ class AbstractExaminationReport(AbstractDocument):
         blank=True,
     )
 
-    sensitive_meta = models.ForeignKey(
-        "SensitiveMeta",
-        on_delete=models.SET_NULL,
-        null=True,
-        blank=True
-    )
+    sensitive_meta = models.ForeignKey("SensitiveMeta", on_delete=models.SET_NULL, null=True, blank=True)
 
     if TYPE_CHECKING:
-        center: "Center"
-        type: "DocumentType"
-        patient: "Patient"
-        patient_examination: "PatientExamination"
-        sensitive_meta: "SensitiveMeta"
-
+        center: models.ForeignKey["Center|None"]
+        type: models.ForeignKey["DocumentType|None"]
+        patient: models.ForeignKey["Patient|None"]
+        patient_examination: models.ForeignKey["PatientExamination|None"]
+        sensitive_meta: models.ForeignKey["SensitiveMeta|None"]
 
     class Meta:
         abstract = True
 
-    
     def get_or_create_examiner(self, examiner_first_name, examiner_last_name):
         raise NotImplementedError("Subclasses must implement this method.")
 
@@ -122,10 +120,8 @@ class AbstractExaminationReport(AbstractDocument):
         raise NotImplementedError("Subclasses must implement this method.")
 
 
-
 class AnonymExaminationReport(AbstractExaminationReport):
-
-    def get_or_create_examiner(self, examiner_first_name:str, examiner_last_name:str):
+    def get_or_create_examiner(self, examiner_first_name: str, examiner_last_name: str):
         from ...administration.person import Examiner
 
         examiner_center = self.center
@@ -139,7 +135,7 @@ class AnonymExaminationReport(AbstractExaminationReport):
         return examiner, created
 
     def set_examination_date_and_time(self, report_meta=None):
-        #TODO
+        # TODO
         if not report_meta:
             report_meta = self.meta
         # examination_date_str = report_meta["examination_date"]
@@ -152,11 +148,11 @@ class AnonymExaminationReport(AbstractExaminationReport):
         #     # TODO: get django TimeField compatible time from string (e.g. "12:00")
         #     self.time = time.fromisoformat(examination_time_str)
 
+
 class AnonymHistologyReport(AbstractExaminationReport):
     """
     Represents a histology report.
     """
 
-
     def get_or_create_examiner(self, examiner_first_name, examiner_last_name):
         raise NotImplementedError("Subclasses must implement this method.")

endoreg_db/models/media/pdf/report_reader/report_reader_config.py

@@ -1,77 +1,85 @@
 # ReportReaderConfig Class
-# Description: This class is used to store the configuration of the ReportReader
-
-# PATIENT_INFO_LINE_FLAG = "Patient: "
-# ENDOSCOPE_INFO_LINE_FLAG = "Gerät: "
-# EXAMINER_INFO_LINE_FLAG = "1. Unters.:"
-# CUT_OFF_BELOW_LINE_FLAG = "________________"
-
-
-# CUT_OFF_ABOVE_LINE_FLAGS = [
-#     ENDOSCOPE_INFO_LINE_FLAG,
-#     EXAMINER_INFO_LINE_FLAG,
-# ]
-
-# CUT_OFF_BELOW_LINE_FLAGS = [
-#         CUT_OFF_BELOW_LINE_FLAG
-#     ]
+from typing import TYPE_CHECKING, cast
 
 from django.db import models
 
-
-from typing import TYPE_CHECKING
 if TYPE_CHECKING:
-    from .report_reader_flag import ReportReaderFlag
-    from ....administration.person import FirstName, LastName
     from ....administration.center import Center
+    from ....administration.person import FirstName, LastName
     from ....metadata import PdfType
+    from .report_reader_flag import ReportReaderFlag
+
 
 class ReportReaderConfig(models.Model):
     """
-    Configuration settings for parsing PDF reports (ReportReader).
+    Configuration settings for parsing report reports (ReportReader).
 
     Stores locale, name lists, date format, and flags used to identify key information lines
     and text sections to ignore.
     """
+
     locale = models.CharField(default="de_DE", max_length=10)
-    first_names = models.ManyToManyField('FirstName', related_name='report_reader_configs')
-    last_names = models.ManyToManyField('LastName', related_name='report_reader_configs')
-    text_date_format = models.CharField(default = "%d.%m.%Y", max_length=10)
-    patient_info_line_flag = models.ForeignKey("ReportReaderFlag", related_name='report_reader_configs_patient_info_line', on_delete=models.CASCADE)
-    endoscope_info_line_flag = models.ForeignKey("ReportReaderFlag", related_name='report_reader_configs_endoscope_info_line', on_delete=models.CASCADE)
-    examiner_info_line_flag = models.ForeignKey("ReportReaderFlag", related_name='report_reader_configs_examiner_info_line', on_delete=models.CASCADE)
-    cut_off_below = models.ManyToManyField("ReportReaderFlag", related_name='report_reader_configs_cut_off_below')
-    cut_off_above = models.ManyToManyField("ReportReaderFlag", related_name='report_reader_configs_cut_off_above')
-    
+    first_names = models.ManyToManyField(
+        "FirstName", related_name="report_reader_configs"
+    )
+    last_names = models.ManyToManyField(
+        "LastName", related_name="report_reader_configs"
+    )
+    text_date_format = models.CharField(default="%d.%m.%Y", max_length=10)
+    patient_info_line_flag = models.ForeignKey(
+        "ReportReaderFlag",
+        related_name="report_reader_configs_patient_info_line",
+        on_delete=models.CASCADE,
+    )
+    endoscope_info_line_flag = models.ForeignKey(
+        "ReportReaderFlag",
+        related_name="report_reader_configs_endoscope_info_line",
+        on_delete=models.CASCADE,
+    )
+    examiner_info_line_flag = models.ForeignKey(
+        "ReportReaderFlag",
+        related_name="report_reader_configs_examiner_info_line",
+        on_delete=models.CASCADE,
+    )
+    cut_off_below = models.ManyToManyField(
+        "ReportReaderFlag", related_name="report_reader_configs_cut_off_below"
+    )
+    cut_off_above = models.ManyToManyField(
+        "ReportReaderFlag", related_name="report_reader_configs_cut_off_above"
+    )
+
     if TYPE_CHECKING:
-        first_names: models.QuerySet["FirstName"]
-        last_names: models.QuerySet["LastName"]
-        patient_info_line_flag: "ReportReaderFlag"
-        endoscope_info_line_flag: "ReportReaderFlag"
-        examiner_info_line_flag: "ReportReaderFlag"
-        cut_off_below: models.QuerySet["ReportReaderFlag"]
-        cut_off_above: models.QuerySet["ReportReaderFlag"]
-    
+        patient_info_line_flag = models.ForeignKey["ReportReaderFlag"]
+        endoscope_info_line_flag = models.ForeignKey["ReportReaderFlag"]
+        examiner_info_line_flag = models.ForeignKey["ReportReaderFlag"]
+
+        first_names = cast(models.manager.RelatedManager["FirstName"], first_names)
+        last_names = cast(models.manager.RelatedManager["LastName"], last_names)
+        cut_off_below = cast(
+            models.manager.RelatedManager["ReportReaderFlag"], cut_off_below
+        )
+        cut_off_above = cast(
+            models.manager.RelatedManager["ReportReaderFlag"], cut_off_above
+        )
 
     def __str__(self):
         """Returns a string representation including the locale and primary key."""
         _str = f"ReportReaderConfig: {self.locale} (id: {self.pk}\n"
         return _str
-    
-    def update_names_by_center(self, center:"Center", save = True):
+
+    def update_names_by_center(self, center: "Center", save=True):
         """Updates the first and last name lists based on the names associated with a Center."""
         self.first_names.set(center.first_names.all())
         self.last_names.set(center.last_names.all())
         if save:
             self.save()
 
-    def update_flags_by_pdf_type(self, pdf_type:"PdfType", save = True):
+    def update_flags_by_pdf_type(self, pdf_type: "PdfType", save=True):
         """Updates the line identification flags based on a specific PdfType."""
-        self.patient_info_line_flag = pdf_type.patient_info_line_flag
-        self.endoscope_info_line_flag = pdf_type.endoscope_info_line_flag
-        self.examiner_info_line_flag = pdf_type.examiner_info_line_flag
-        self.cut_off_below.set(pdf_type.cut_off_below.all())
-        self.cut_off_above.set(pdf_type.cut_off_above.all())
+        self.patient_info_line_flag = pdf_type.patient_info_line
+        self.endoscope_info_line_flag = pdf_type.endoscope_info_line
+        self.examiner_info_line_flag = pdf_type.examiner_info_line
+        self.cut_off_below.set(pdf_type.cut_off_below_lines.all())
+        self.cut_off_above.set(pdf_type.cut_off_above_lines.all())
         if save:
             self.save()
-

endoreg_db/models/media/pdf/report_reader/report_reader_flag.py

@@ -1,20 +1,36 @@
-# Django model for the report reader flag
-# have name and value
-# name is natural key
+from typing import TYPE_CHECKING
 
 from django.db import models
 
+if TYPE_CHECKING:
+    from endoreg_db.models import ReportReaderConfig
+
+
 class ReportReaderFlagManager(models.Manager):
     def get_by_natural_key(self, name):
         return self.get(name=name)
-    
+
+
 class ReportReaderFlag(models.Model):
     objects = ReportReaderFlagManager()
     name = models.CharField(max_length=255, unique=True)
     value = models.CharField(max_length=255)
-    
+
+    if TYPE_CHECKING:
+
+        @property
+        def report_reader_configs_patient_info_line(self) -> models.QuerySet["ReportReaderConfig"]: ...
+        @property
+        def report_reader_configs_endoscope_info_line(self) -> models.QuerySet["ReportReaderConfig"]: ...
+        @property
+        def report_reader_configs_examiner_info_line(self) -> models.QuerySet["ReportReaderConfig"]: ...
+        @property
+        def report_reader_configs_cut_off_below(self) -> models.QuerySet["ReportReaderConfig"]: ...
+        @property
+        def report_reader_configs_cut_off_above(self) -> models.QuerySet["ReportReaderConfig"]: ...
+
     def natural_key(self):
         return (self.name,)
-    
+
     def __str__(self):
-        return self.name
+        return self.name

endoreg_db/models/media/processing_history/__init__.py

@@ -0,0 +1,5 @@
+from .processing_history import ProcessingHistory
+
+__all__ = [
+    "ProcessingHistory"
+]

endoreg_db/models/media/processing_history/processing_history.py

@@ -0,0 +1,96 @@
+from typing import Optional
+
+from django.contrib.contenttypes.fields import GenericForeignKey
+from django.contrib.contenttypes.models import ContentType
+from django.db import models
+
+
+class ProcessingHistory(models.Model):
+    """
+    Generic processing history for media files (video, pdf, ...).
+
+    Stores:
+      - which object (VideoFile/RawPdfFile/other) this entry belongs to
+      - whether processing/anonymization succeeded
+      - timestamps
+    """
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    success = models.BooleanField(default=False, blank=True)
+
+    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
+    object_id = models.PositiveBigIntegerField()
+    content_object = GenericForeignKey("content_type", "object_id")
+
+    class Meta:
+        ordering = ["-created_at"]
+
+    def __str__(self) -> str:
+        return f"{self.content_type} #{self.object_id}, Success: {self.success}"
+
+    # --- public helpers that work with *objects* ---
+
+    @classmethod
+    def get_or_create_for_object(
+        cls,
+        *,
+        obj: models.Model,
+        success: Optional[bool],
+    ) -> "ProcessingHistory":
+        """
+        Get or create a ProcessingHistory entry for a concrete model instance.
+
+        - Returns existing entry for (object_id, content_type) if present
+        - Otherwise creates one with the given success flag (default False)
+        - If an entry exists and `success` is provided, it updates `success`
+        """
+        ct = ContentType.objects.get_for_model(obj, for_concrete_model=False)
+
+        ph, created = cls.objects.get_or_create(
+            object_id=obj.pk,
+            content_type=ct,
+            defaults={"success": success},
+        )
+
+        if not created and success is not None and ph.success != success:
+            ph.success = success
+            ph.save(update_fields=["success"])
+
+        return ph
+
+    @classmethod
+    def has_history(
+        cls,
+        *,
+        object_id: int,
+        content_type: ContentType,
+        success: Optional[bool] = None,
+    ) -> bool:
+        """
+        Return True if there is at least one ProcessingHistory entry for the
+        given (object_id, content_type) combination.
+
+        If `success` is not None, only entries matching that success flag are
+        considered.
+        """
+        qs = cls.objects.filter(object_id=object_id, content_type=content_type)
+        if success is not None:
+            qs = qs.filter(success=success)
+        return qs.exists()
+
+    @classmethod
+    def has_history_for_object(
+        cls,
+        *,
+        obj: models.Model,
+        success: Optional[bool] = None,
+    ) -> bool:
+        """
+        Convenience wrapper for model instances.
+        """
+        ct = ContentType.objects.get_for_model(obj, for_concrete_model=False)
+        return cls.has_history(
+            object_id=obj.pk,
+            content_type=ct,
+            success=success,
+        )

endoreg_db/models/media/video/__init__.py

@@ -1,6 +1,7 @@
 from .video_file import VideoFile
 from .video_metadata import VideoMetadata
 from .video_processing import VideoProcessingHistory
+
 __all__ = [
     "VideoFile",
     "VideoMetadata",