endoreg-db 0.8.6.4__py3-none-any.whl

endoreg_db/models/medical/__init__.py

@@ -0,0 +1,146 @@
+from .disease import (Disease, DiseaseClassification, DiseaseClassificationChoice)
+from .event import (Event, EventClassification, EventClassificationChoice)
+
+from .contraindication import Contraindication
+from .examination import (
+    Examination,
+    ExaminationRequirementSet,
+    ExaminationType,
+    ExaminationIndication,
+    ExaminationIndicationClassificationChoice,
+    ExaminationIndicationClassification,
+    ExaminationTime,
+    ExaminationTimeType,
+)
+
+from .finding import (
+    Finding,
+    FindingClassificationType,
+    FindingClassification,
+    FindingClassificationChoice,
+    FindingType,
+    FindingIntervention,
+    FindingInterventionType,
+)
+
+from .patient import (
+    PatientExamination,
+    PatientFinding,
+    PatientFindingClassification,
+    PatientFindingIntervention,
+    PatientDisease,
+    PatientEvent,
+    PatientExaminationIndication,
+    PatientLabSample,
+    PatientLabSampleType,
+    PatientLabValue,
+    PatientMedication,
+    PatientMedicationSchedule,
+)
+
+from .risk import (
+    Risk,
+    RiskType,
+)
+
+from .medication import (
+    Medication,
+    MedicationManager,
+    MedicationSchedule,
+    MedicationIntakeTime,
+    MedicationIndicationType,
+    MedicationIndication,
+)
+
+from .hardware import (
+    Endoscope,
+    EndoscopeType,
+    EndoscopyProcessor,
+)
+
+from .laboratory import (
+    LabValue,
+)
+
+from .organ import (
+    Organ,
+)
+
+
+__all__ = [
+    # Disease
+    "Disease",
+    "DiseaseClassification",
+    "DiseaseClassificationChoice",
+
+    # Event
+    "Event",
+    "EventClassification",
+    "EventClassificationChoice",
+
+    # Contraindication
+    "Contraindication",
+
+    # Examination
+    "Examination",
+    "ExaminationRequirementSet",
+    "ExaminationType",
+    "ExaminationIndication",
+    "ExaminationIndicationClassificationChoice",
+    "ExaminationIndicationClassification",
+    "ExaminationTime",
+    "ExaminationTimeType",
+    
+    # Finding
+    "Finding",
+    "FindingClassificationType",
+    "FindingClassification",
+    "FindingClassificationChoice",
+    "FindingType",
+    "FindingMorphologyClassification",
+    "FindingIntervention",
+    "FindingInterventionType",
+
+    # Patient
+    ## Disease
+    "PatientDisease",
+    ## Event
+    "PatientEvent",
+    ## Examination
+    "PatientExaminationIndication",
+    "PatientExamination",
+    ## Finding
+    "PatientFinding",
+    "PatientFindingClassification",
+    "PatientFindingIntervention",
+    ## Laboratory
+    "PatientLabSample",
+    "PatientLabSampleType",
+    "PatientLabValue",
+    ## Medication
+    "PatientMedication",
+    "PatientMedicationSchedule",
+
+    # Organ
+    "Organ",
+
+    # Risk
+    "Risk",
+    "RiskType",
+
+    # Medication
+    "Medication",
+    "MedicationManager",
+    "MedicationSchedule",
+    "MedicationIntakeTime",
+    "MedicationIndicationType",
+    "MedicationIndication",
+
+    # Hardware
+    "Endoscope",
+    "EndoscopeType",
+    "EndoscopyProcessor",
+
+    # Laboratory
+    "LabValue",
+]

endoreg_db/models/medical/contraindication/__init__.py

@@ -0,0 +1,17 @@
+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()
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return str(self.name)

endoreg_db/models/medical/disease.py

@@ -0,0 +1,156 @@
+from django.db import models
+from typing import List, TYPE_CHECKING
+
+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:
+        disease_classifications: models.QuerySet["DiseaseClassification"]
+        patient_diseases: 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: "Disease"
+        disease_classification_choices: models.QuerySet["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: "DiseaseClassification"
+        patient_diseases: 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 classification choice."""
+        return str(self.name)

endoreg_db/models/medical/event.py

@@ -0,0 +1,137 @@
+from django.db import models
+from typing import List, TYPE_CHECKING
+
+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)
+    event_classification: models.ForeignKey["EventClassification"] = models.ForeignKey(
+        "EventClassification",
+        on_delete=models.CASCADE,
+        related_name="events",
+        null=True,
+        blank=True,
+    )
+    objects = EventManager()
+
+    if TYPE_CHECKING:
+        patient_events: models.QuerySet["PatientEvent"]
+
+    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()
+
+    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()
+
+    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,9 @@
+from .examination import Examination, ExaminationRequirementSet
+from .examination_type import ExaminationType
+from .examination_time import ExaminationTime
+from .examination_time_type import ExaminationTimeType
+from .examination_indication import(
+    ExaminationIndication,
+    ExaminationIndicationClassification,
+    ExaminationIndicationClassificationChoice
+)

endoreg_db/models/medical/examination/examination.py

@@ -0,0 +1,148 @@
+from django.db import models
+from typing import List
+from typing import TYPE_CHECKING
+
+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)
+
+    objects = ExaminationManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models import ExaminationIndication, Finding, FindingClassification
+        finding_classifications: models.QuerySet['FindingClassification']
+        indications: models.QuerySet[ExaminationIndication]
+        findings: models.QuerySet["Finding"]
+        exam_reqset_links: models.QuerySet["ExaminationRequirementSet"]
+
+    # # Requirement sets associated with the examination.
+    # requirement_sets = models.ManyToManyField(
+    #     "RequirementSet",
+    #     through="ExaminationRequirementSet",
+    #     related_name="examinations",
+    #     blank=True,
+    # )
+
+
+    @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,)
+