endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/models/medical/finding/finding_intervention.py

@@ -0,0 +1,68 @@
+from typing import TYPE_CHECKING, cast
+
+from django.db import models
+
+
+class FindingInterventionManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+
+class FindingIntervention(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True, null=True)
+    intervention_types = models.ManyToManyField(
+        "FindingInterventionType", blank=True, related_name="interventions"
+    )
+    information_sources = models.ManyToManyField(
+        "InformationSource",
+        related_name="finding_interventions",
+        blank=True,
+    )
+    objects = FindingInterventionManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models import (
+            Contraindication,
+            FindingInterventionType,
+            InformationSource,
+            LabValue,
+        )
+
+        intervention_types = cast(
+            models.manager.RelatedManager["FindingInterventionType"], intervention_types
+        )
+        information_sources = cast(
+            models.manager.RelatedManager["InformationSource"], information_sources
+        )
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return str(self.name)
+
+
+class FindingInterventionTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+
+class FindingInterventionType(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True, null=True)
+
+    objects = FindingInterventionTypeManager()
+
+    if TYPE_CHECKING:
+
+        @property
+        def interventions(
+            self,
+        ) -> "models.manager.RelatedManager[FindingIntervention]": ...
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return str(self.name)

endoreg_db/models/medical/finding/finding_type.py

@@ -0,0 +1,38 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+
+class FindingTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        """
+        Retrieve a FindingType instance by its unique name for natural key deserialization.
+
+        Parameters:
+            name (str): The unique name of the FindingType to retrieve.
+
+        Returns:
+            FindingType: The instance matching the given name.
+        """
+        return self.get(name=name)
+
+
+class FindingType(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True, null=True)
+
+    objects = FindingTypeManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models import Examination, Finding, FindingClassification
+
+        @property
+        def finding_classifications(
+            self,
+        ) -> "models.manager.RelatedManager[FindingClassification]": ...
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name

endoreg_db/models/medical/hardware/__init__.py

@@ -0,0 +1,8 @@
+from .endoscopy_processor import EndoscopyProcessor
+from .endoscope import Endoscope, EndoscopeType
+
+__all__ = [
+    "Endoscope",
+    "EndoscopeType",
+    "EndoscopyProcessor",
+]

endoreg_db/models/medical/hardware/endoscope.py

@@ -0,0 +1,77 @@
+from typing import TYPE_CHECKING
+
+from django.db import models  #
+
+
+class EndoscopeManager(models.Manager):
+    def get_by_natural_key(self, name, sn):
+        return self.get(name=name, sn=sn)
+
+
+class Endoscope(models.Model):
+    objects = EndoscopeManager()
+
+    name = models.CharField(max_length=255)
+    sn = models.CharField(max_length=255)
+    center = models.ForeignKey(
+        "Center",
+        blank=True,
+        null=True,
+        on_delete=models.CASCADE,
+        related_name="endoscopes",
+    )
+    endoscope_type = models.ForeignKey(
+        "EndoscopeType",
+        blank=True,
+        null=True,
+        on_delete=models.CASCADE,
+        related_name="endoscopes",
+    )
+
+    if TYPE_CHECKING:
+        from endoreg_db.models import Center
+
+        center: models.ForeignKey["Center|None"]
+        endoscope_type: models.ForeignKey["EndoscopeType|None"]
+
+    def natural_key(self):
+        return (self.name, self.sn)
+
+    def __str__(self):
+        return str(self.name)
+
+    class Meta:
+        ordering = ["name"]
+        verbose_name = "Endoscope"
+        verbose_name_plural = "Endoscopes"
+
+    @property
+    def center_safe(self) -> "Center":
+        if self.center is None:
+            raise ValueError("Endoscope has no associated center.")
+        return self.center
+
+
+class EndoscopeTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+
+class EndoscopeType(models.Model):
+    objects = EndoscopeTypeManager()
+
+    name = models.CharField(max_length=255, unique=True)
+
+    if TYPE_CHECKING:
+        endoscopes: models.QuerySet["Endoscope"]
+
+    def natural_key(self) -> tuple[str]:
+        return (self.name,)
+
+    def __str__(self):
+        return str(self.name)
+
+    class Meta:
+        ordering = ["name"]
+        verbose_name = "Endoscope Type"
+        verbose_name_plural = "Endoscope Types"

endoreg_db/models/medical/hardware/endoscopy_processor.py

@@ -0,0 +1,182 @@
+from django.db import models
+
+
+class EndoscopyProcessorManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+
+class EndoscopyProcessor(models.Model):
+    objects = EndoscopyProcessorManager()
+
+    centers = models.ManyToManyField(
+        "Center",
+        blank=True,
+        related_name="endoscopy_processors",
+    )
+
+    name = models.CharField(max_length=255)
+    image_width = models.IntegerField()
+    image_height = models.IntegerField()
+    # image_fps = models.IntegerField()
+
+    # Roi for endoscope image
+    endoscope_image_x = models.IntegerField()
+    endoscope_image_y = models.IntegerField()
+    endoscope_image_width = models.IntegerField()
+    endoscope_image_height = models.IntegerField()
+
+    # Roi for examination date
+    examination_date_x = models.IntegerField()
+    examination_date_y = models.IntegerField()
+    examination_date_width = models.IntegerField()
+    examination_date_height = models.IntegerField()
+
+    # Roi for examination time
+    examination_time_x = models.IntegerField(blank=True, null=True)
+    examination_time_y = models.IntegerField(blank=True, null=True)
+    examination_time_width = models.IntegerField(blank=True, null=True)
+    examination_time_height = models.IntegerField(blank=True, null=True)
+
+    # Roi for patient first name
+    patient_first_name_x = models.IntegerField()
+    patient_first_name_y = models.IntegerField()
+    patient_first_name_width = models.IntegerField()
+    patient_first_name_height = models.IntegerField()
+
+    # Roi for patient name
+    patient_last_name_x = models.IntegerField()
+    patient_last_name_y = models.IntegerField()
+    patient_last_name_width = models.IntegerField()
+    patient_last_name_height = models.IntegerField()
+
+    # Roi for patient dob
+    patient_dob_x = models.IntegerField()
+    patient_dob_y = models.IntegerField()
+    patient_dob_width = models.IntegerField()
+    patient_dob_height = models.IntegerField()
+
+    # Roi for endoscope type
+    endoscope_type_x = models.IntegerField(blank=True, null=True)
+    endoscope_type_y = models.IntegerField(blank=True, null=True)
+    endoscope_type_width = models.IntegerField(blank=True, null=True)
+    endoscope_type_height = models.IntegerField(blank=True, null=True)
+
+    # Roi for endoscopy sn
+    endoscope_sn_x = models.IntegerField(blank=True, null=True)
+    endoscope_sn_y = models.IntegerField(blank=True, null=True)
+    endoscope_sn_width = models.IntegerField(blank=True, null=True)
+    endoscope_sn_height = models.IntegerField(blank=True, null=True)
+
+    def natural_key(self):
+        return (self.name,)
+
+    @classmethod
+    def get_by_name(cls, name):
+        return cls.objects.get(name=name)
+
+    def __str__(self) -> str:
+        if self.name is None:
+            return ""
+        return self.name
+
+    def get_roi_endoscope_image(self) -> dict[str, int | None] | None:
+        if self.endoscope_image_x is None:
+            return None
+        return {
+            "x": self.endoscope_image_x,
+            "y": self.endoscope_image_y,
+            "width": self.endoscope_image_width,
+            "height": self.endoscope_image_height,
+        }
+
+    def get_roi_examination_date(self) -> dict[str, int | None] | None:
+        if self.examination_date_x is None:
+            return None
+        return {
+            "x": self.examination_date_x,
+            "y": self.examination_date_y,
+            "width": self.examination_date_width,
+            "height": self.examination_date_height,
+        }
+
+    def get_roi_examination_time(self) -> dict[str, int | None] | None:
+        if self.examination_time_x is None:
+            return None
+        return {
+            "x": self.examination_time_x,
+            "y": self.examination_time_y,
+            "width": self.examination_time_width,
+            "height": self.examination_time_height,
+        }
+
+    def get_roi_patient_last_name(self) -> dict[str, int | None] | None:
+        if self.patient_last_name_x is None:
+            return None
+        return {
+            "x": self.patient_last_name_x,
+            "y": self.patient_last_name_y,
+            "width": self.patient_last_name_width,
+            "height": self.patient_last_name_height,
+        }
+
+    def get_roi_patient_first_name(self) -> dict[str, int | None] | None:
+        if self.patient_first_name_x is None:
+            return None
+        return {
+            "x": self.patient_first_name_x,
+            "y": self.patient_first_name_y,
+            "width": self.patient_first_name_width,
+            "height": self.patient_first_name_height,
+        }
+
+    def get_roi_patient_dob(self) -> dict[str, int | None] | None:
+        if self.patient_dob_x is None:
+            return None
+        return {
+            "x": self.patient_dob_x,
+            "y": self.patient_dob_y,
+            "width": self.patient_dob_width,
+            "height": self.patient_dob_height,
+        }
+
+    def get_roi_endoscope_type(self) -> dict[str, int | None] | None:
+        if self.endoscope_type_x is None:
+            return None
+        return {
+            "x": self.endoscope_type_x,
+            "y": self.endoscope_type_y,
+            "width": self.endoscope_type_width,
+            "height": self.endoscope_type_height,
+        }
+
+    def get_roi_endoscopy_sn(self) -> dict[str, int | None] | None:
+        if self.endoscope_sn_x is None:
+            return None
+        return {
+            "x": self.endoscope_sn_x,
+            "y": self.endoscope_sn_y,
+            "width": self.endoscope_sn_width,
+            "height": self.endoscope_sn_height,
+        }
+
+    def get_rois(self) -> dict[str, dict[str, int | None] | None]:
+        return {
+            "endoscope_image": self.get_roi_endoscope_image(),
+            "examination_date": self.get_roi_examination_date(),
+            "examination_time": self.get_roi_examination_time(),
+            "patient_first_name": self.get_roi_patient_first_name(),
+            "patient_last_name": self.get_roi_patient_last_name(),
+            "patient_dob": self.get_roi_patient_dob(),
+            "endoscope_type": self.get_roi_endoscope_type(),
+            "endoscope_sn": self.get_roi_endoscopy_sn(),
+        }
+
+    def get_sensitive_rois(self) -> dict[str, dict[str, int | None] | None]:
+        return {
+            "examination_date": self.get_roi_examination_date(),
+            "examination_time": self.get_roi_examination_time(),
+            "patient_first_name": self.get_roi_patient_first_name(),
+            "patient_last_name": self.get_roi_patient_last_name(),
+            "patient_dob": self.get_roi_patient_dob(),
+        }

endoreg_db/models/medical/laboratory/__init__.py

@@ -0,0 +1,5 @@
+from .lab_value import LabValue
+
+__all__ = [
+    "LabValue",
+]