endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/models/medical/contraindication/README.md

@@ -0,0 +1 @@
+not yet properly implemented

endoreg_db/models/medical/contraindication/__init__.py

@@ -0,0 +1,29 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+
+class ContraindicationManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+
+class Contraindication(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True, null=True)
+
+    objects = ContraindicationManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models import FindingIntervention
+
+        @property
+        def contraindicating_finding_interventions(
+            self,
+        ) -> "models.manager.RelatedManager[FindingIntervention]": ...
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return str(self.name)

endoreg_db/models/medical/disease.py

@@ -0,0 +1,174 @@
+from typing import TYPE_CHECKING, List
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from .patient import PatientDisease
+
+
+class DiseaseManager(models.Manager):
+    """Manager for Disease with natural key support."""
+
+    def get_by_natural_key(self, name):
+        """
+        Retrieve a Disease instance by its natural key (name).
+
+        Args:
+            name: The natural key value used to match the model's 'name' field.
+
+        Returns:
+            The Disease instance corresponding to the provided natural key.
+        """
+        return self.get(name=name)
+
+
+class Disease(models.Model):
+    """
+    Represents a specific disease or medical condition.
+
+    Can define associated subcategories and numerical descriptors applicable to the disease itself.
+    """
+
+    name = models.CharField(max_length=255, unique=True)
+    subcategories = models.JSONField(default=dict)
+    numerical_descriptors = models.JSONField(default=dict)
+
+    objects = DiseaseManager()
+
+    if TYPE_CHECKING:
+
+        @property
+        def disease_classifications(
+            self,
+        ) -> models.QuerySet["DiseaseClassification"]: ...
+
+        @property
+        def patient_diseases(self) -> models.QuerySet["PatientDisease"]: ...
+
+    def natural_key(self):
+        """Returns the natural key (name) as a tuple."""
+        return (self.name,)
+
+    def __str__(self):
+        """Returns the name of the disease."""
+        return str(self.name)
+
+    def get_classifications(self) -> List["DiseaseClassification"]:
+        """
+        Retrieves all classification systems associated with this disease.
+
+        Returns:
+            List[DiseaseClassification]: A list of related disease classification objects.
+        """
+        classifications: List[DiseaseClassification] = [
+            _ for _ in self.disease_classifications.all()
+        ]
+        return classifications
+
+
+class DiseaseClassificationManager(models.Manager):
+    """Manager for DiseaseClassification with natural key support."""
+
+    def get_by_natural_key(self, name):
+        """
+        Retrieve a DiseaseClassification instance by its natural key (name).
+
+        Args:
+            name: A unique identifier representing the natural key of the instance.
+
+        Returns:
+            The DiseaseClassification instance corresponding to the given natural key.
+        """
+        return self.get(name=name)
+
+
+class DiseaseClassification(models.Model):
+    """
+    Represents a classification system applicable to a specific disease (e.g., Forrest classification for ulcers).
+    """
+
+    name = models.CharField(max_length=255, unique=True)
+
+    disease = models.ForeignKey(
+        Disease, on_delete=models.CASCADE, related_name="disease_classifications"
+    )
+
+    objects = DiseaseClassificationManager()
+
+    if TYPE_CHECKING:
+        disease: models.ForeignKey["Disease"]
+
+        @property
+        def disease_classification_choices(
+            self,
+        ) -> models.manager.RelatedManager["DiseaseClassificationChoice"]: ...
+
+    def natural_key(self):
+        """Returns the natural key (name) as a tuple."""
+        return (self.name,)
+
+    def __str__(self):
+        """Returns the name of the classification."""
+        return str(self.name)
+
+    def get_choices(self) -> List["DiseaseClassificationChoice"]:
+        """
+        Retrieves all choices within this classification system.
+
+        Returns:
+            List[DiseaseClassificationChoice]: A list of related disease classification choices.
+        """
+        choices: List[DiseaseClassificationChoice] = [
+            _ for _ in self.disease_classification_choices.all()
+        ]
+        return choices
+
+
+class DiseaseClassificationChoiceManager(models.Manager):
+    """Manager for DiseaseClassificationChoice with natural key support."""
+
+    def get_by_natural_key(self, name):
+        """
+        Retrieve a DiseaseClassificationChoice instance by its natural key (name).
+
+        Queries for and returns the instance whose 'name' attribute matches the provided key.
+
+        Args:
+            name: The natural key value used to match the model's 'name' field.
+
+        Returns:
+            The DiseaseClassificationChoice instance corresponding to the provided natural key.
+        """
+        return self.get(name=name)
+
+
+class DiseaseClassificationChoice(models.Model):
+    """
+    Represents a specific choice within a disease classification system (e.g., Forrest IIa).
+    """
+
+    name = models.CharField(max_length=255, unique=True)
+
+    disease_classification = models.ForeignKey(
+        DiseaseClassification,
+        on_delete=models.CASCADE,
+        related_name="disease_classification_choices",
+    )
+
+    objects = DiseaseClassificationChoiceManager()
+
+    if TYPE_CHECKING:
+        disease_classification: models.ForeignKey["DiseaseClassification"]
+
+        @property
+        def patient_diseases(
+            self,
+        ) -> models.manager.RelatedManager["PatientDisease"]: ...
+
+    def natural_key(self):
+        """Returns the natural key (name) as a tuple."""
+        return (self.name,)
+
+    def __str__(self):
+        """Returns the name of the classification choice."""
+        return str(self.name)

endoreg_db/models/medical/event.py

@@ -0,0 +1,154 @@
+from typing import TYPE_CHECKING, List
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from endoreg_db.models import PatientEvent
+
+
+class EventManager(models.Manager):
+    """
+    Manager for Event with custom query methods.
+    """
+
+    def get_by_natural_key(self, name: str) -> "Event":
+        """
+        Retrieves an Event instance using its natural key.
+
+        This method returns the event whose name matches the provided natural key.
+        It is primarily used to support Django's natural key serialization during
+        data import/export and deserialization processes.
+
+        Args:
+            name: The unique event name serving as the natural key.
+
+        Returns:
+            The Event object corresponding to the given name.
+        """
+        return self.get(name=name)
+
+
+class Event(models.Model):
+    """
+    A class representing an event.
+
+    Attributes:
+        name (str): The name of the event.
+        description (str): A description of the event.
+    """
+
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True, null=True)
+
+    objects = EventManager()
+
+    if TYPE_CHECKING:
+        patient_events: models.ForeignKey["PatientEvent"]
+
+        @property
+        def event_classifications(self) -> models.QuerySet["EventClassification"]: ...
+
+    def natural_key(self):
+        """
+        Returns a tuple representing the natural key for this instance.
+
+        The natural key consists of the instance's unique name.
+        """
+        return (self.name,)
+
+    def __str__(self):
+        """
+        Return a string representation of the instance's name.
+
+        This method converts the 'name' attribute to a string, providing a human-readable
+        representation of the model instance.
+        """
+        return str(self.name)
+
+
+class EventClassificationManager(models.Manager):
+    """Manager for EventClassification with natural key support."""
+
+    def get_by_natural_key(self, name):
+        """Retrieves an EventClassification instance by its natural key (name)."""
+        return self.get(name=name)
+
+
+class EventClassification(models.Model):
+    """
+    Represents a classification system for events (e.g., TNM staging for cancer).
+    """
+
+    name = models.CharField(max_length=255, unique=True)
+
+    objects = EventClassificationManager()
+
+    event = models.ForeignKey(
+        Event,
+        on_delete=models.CASCADE,
+        related_name="event_classifications",
+    )
+
+    if TYPE_CHECKING:
+        event: models.ForeignKey["Event"]
+
+        @property
+        def event_classification_choices(
+            self,
+        ) -> models.QuerySet["EventClassificationChoice"]: ...
+
+    def natural_key(self):
+        """Returns the natural key (name) as a tuple."""
+        return (self.name,)
+
+    def __str__(self):
+        """Returns the name of the classification."""
+        return str(self.name)
+
+    def get_choices(self) -> List["EventClassificationChoice"]:
+        """Retrieves all choices associated with this classification."""
+        choices: List[EventClassificationChoice] = [
+            _ for _ in self.event_classification_choices.all()
+        ]
+        return choices
+
+
+class EventClassificationChoiceManager(models.Manager):
+    """Manager for EventClassificationChoice with natural key support."""
+
+    def get_by_natural_key(self, name):
+        """Retrieves an EventClassificationChoice instance by its natural key (name)."""
+        return self.get(name=name)
+
+
+class EventClassificationChoice(models.Model):
+    """
+    Represents a specific choice within an event classification system (e.g., T1, N0, M0).
+
+    Can define associated subcategories and numerical descriptors.
+    """
+
+    name = models.CharField(max_length=255, unique=True)
+    subcategories = models.JSONField(default=dict)
+    numerical_descriptors = models.JSONField(default=dict)
+
+    event_classification = models.ForeignKey(
+        EventClassification,
+        on_delete=models.CASCADE,
+        related_name="event_classification_choices",
+    )
+
+    objects = EventClassificationChoiceManager()
+
+    @property
+    def event(self):
+        """Returns the associated Event instance."""
+        return self.event_classification.event
+
+    def natural_key(self):
+        """Returns the natural key (name) as a tuple."""
+        return (self.name,)
+
+    def __str__(self):
+        """Returns the name of the classification choice."""
+        return str(self.name)

endoreg_db/models/medical/examination/__init__.py

@@ -0,0 +1,20 @@
+from .examination import Examination, ExaminationRequirementSet
+from .examination_indication import (
+    ExaminationIndication,
+    ExaminationIndicationClassification,
+    ExaminationIndicationClassificationChoice,
+)
+from .examination_time import ExaminationTime
+from .examination_time_type import ExaminationTimeType
+from .examination_type import ExaminationType
+
+__all__ = [
+    "Examination",
+    "ExaminationRequirementSet",
+    "ExaminationType",
+    "ExaminationTime",
+    "ExaminationTimeType",
+    "ExaminationIndication",
+    "ExaminationIndicationClassification",
+    "ExaminationIndicationClassificationChoice",
+]

endoreg_db/models/medical/examination/examination.py

@@ -0,0 +1,183 @@
+from typing import TYPE_CHECKING, List, cast
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from endoreg_db.models import Finding
+    from endoreg_db.utils.links.requirement_link import RequirementLinks
+
+
+class ExaminationManager(models.Manager):
+    """
+    Manager for Examination with custom query methods.
+    """
+
+    def get_by_natural_key(self, name: str) -> "Examination":
+        return self.get(name=name)
+
+
+class Examination(models.Model):
+    """
+    Represents an examination with associated details.
+
+    Attributes:
+        name (str): The unique name of the examination.
+        examination_types (ManyToManyField): The types associated with the examination.
+    """
+
+    name = models.CharField(max_length=100, unique=True)
+    examination_types = models.ManyToManyField("ExaminationType", blank=True)
+    description = models.TextField(blank=True, null=True)
+    indications = models.ManyToManyField(
+        "ExaminationIndication",
+        related_name="examinations",
+        blank=True,
+    )
+    examination_times = models.ManyToManyField(
+        "ExaminationTime",
+        related_name="examinations",
+        blank=True,
+    )
+
+    findings = models.ManyToManyField(
+        "Finding",
+        blank=True,
+        related_name="examinations",
+    )
+    information_sources = models.ManyToManyField(
+        "InformationSource",
+        related_name="examinations",
+        blank=True,
+    )
+
+    objects = ExaminationManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models import (
+            ExaminationIndication,
+            ExaminationTime,
+            Finding,
+            FindingClassification,
+            InformationSource,
+        )
+
+        indications = cast(
+            "models.manager.RelatedManager[ExaminationIndication]", indications
+        )
+        examination_times = cast(
+            "models.manager.RelatedManager[ExaminationTime]", examination_times
+        )
+        findings = cast("models.manager.RelatedManager[Finding]", findings)
+        information_sources = cast(
+            "models.manager.RelatedManager[InformationSource]", information_sources
+        )
+
+        @property
+        def finding_classifications(
+            self,
+        ) -> "models.manager.RelatedManager[FindingClassification]": ...
+
+        @property
+        def exam_reqset_links(
+            self,
+        ) -> "models.manager.RelatedManager[ExaminationRequirementSet]": ...
+
+    @property
+    def links(self) -> "RequirementLinks":
+        """
+        Returns a RequirementLinks instance containing all models related to this examination.
+        This should include:
+        - Examination, Finding, FindingClassification, ExaminationIndication
+        """
+
+        from endoreg_db.utils.links.requirement_link import RequirementLinks
+
+        return RequirementLinks(
+            examinations=[self],
+            findings=list(self.findings.all()),
+            finding_classifications=list(self.finding_classifications.all()),
+            examination_indications=list(self.indications.all()),
+        )
+
+    def __str__(self) -> str:
+        """
+        String representation of the examination.
+
+        Returns:
+            str: The name of the examination.
+        """
+        return str(self.name)
+
+    def natural_key(self) -> tuple:
+        """
+        Returns the natural key for the examination.
+
+        Returns:
+            tuple: The natural key consisting of the name.
+        """
+        return (self.name,)
+
+    def get_available_findings(self) -> List["Finding"]:
+        """
+        Retrieves all findings associated with the examination.
+
+        Returns:
+            list: A list of findings related to the examination.
+        """
+        from endoreg_db.models import Finding
+
+        findings: List[Finding] = [_ for _ in self.findings.all()]
+        return findings
+
+    class Meta:
+        verbose_name = "Examination"
+        verbose_name_plural = "Examinations"
+        ordering = ["name"]
+
+
+class ExaminationRequirementSetManager(models.Manager):
+    """
+    Manager for ExaminationRequirementSet with custom query methods.
+    """
+
+    def get_by_natural_key(self, name: str) -> "ExaminationRequirementSet":
+        return self.get(name=name)
+
+
+class ExaminationRequirementSet(models.Model):
+    """
+    Through table for Examination ↔ RequirementSet link.
+    Lets you store per-link metadata (order, default, etc.)
+    """
+
+    examinations = models.ManyToManyField(
+        "Examination",
+        related_name="exam_reqset_links",
+        blank=True,
+    )
+    # requirement_set = models.ForeignKey(
+    #     "RequirementSet",
+    #     on_delete=models.CASCADE,
+    #     related_name="reqset_exam_links",
+    # )
+    # Optional metadata
+    enabled_by_default = models.BooleanField(default=False)
+
+    name = models.CharField(max_length=100, unique=True)
+
+    objects = ExaminationRequirementSetManager()
+
+    # class Meta:
+    #     unique_together = ("examination", "requirement_set")
+
+    # def __str__(self) -> str:
+    #     return f"{self.examination} ↔ {self.requirement_set} (prio={self.priority})"
+
+    def natural_key(self) -> tuple:
+        """
+        Returns the natural key for the ExaminationRequirementSet.
+
+        Returns:
+            tuple: The natural key consisting of the name.
+        """
+        return (self.name,)