endoreg-db 0.6.4__py3-none-any.whl → 0.8.2__py3-none-any.whl

endoreg_db/models/{disease.py → medical/disease.py}

@@ -1,48 +1,54 @@
 from django.db import models
-from typing import List
+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 model instance by its natural key.
-        
+        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 model instance corresponding to the provided natural key.
+            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)
-    name_de = models.CharField(max_length=255, blank=True, null=True)
-    name_en = models.CharField(max_length=255, blank=True, null=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):
-        """
-        Return the natural key for this model instance.
-        
-        The natural key is defined as a tuple containing the instance's name.
-        """
+        """Returns the natural key (name) as a tuple."""
         return (self.name,)
 
     def __str__(self):
-        """
-        Return the string representation of the instance using its name attribute.
-        """
+        """Returns the name of the disease."""
         return str(self.name)
 
     def get_classifications(self) -> List["DiseaseClassification"]:
         """
-        Retrieves all classifications associated with this disease.
-        
+        Retrieves all classification systems associated with this disease.
+
         Returns:
             List[DiseaseClassification]: A list of related disease classification objects.
         """
@@ -53,23 +59,26 @@ class Disease(models.Model):
 
 
 class DiseaseClassificationManager(models.Manager):
+    """Manager for DiseaseClassification with natural key support."""
+
     def get_by_natural_key(self, name):
         """
-        Retrieves a model instance using its natural key.
-        
+        Retrieve a DiseaseClassification instance by its natural key (name).
+
         Args:
             name: A unique identifier representing the natural key of the instance.
-        
+
         Returns:
-            The model instance corresponding to the given natural key.
+            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)
-    name_de = models.CharField(max_length=255, blank=True, null=True)
-    name_en = models.CharField(max_length=255, blank=True, null=True)
 
     disease = models.ForeignKey(
         Disease, on_delete=models.CASCADE, related_name="disease_classifications"
@@ -77,28 +86,22 @@ class DiseaseClassification(models.Model):
 
     objects = DiseaseClassificationManager()
 
+    if TYPE_CHECKING:
+        disease: "Disease"
+        disease_classification_choices: models.QuerySet["DiseaseClassificationChoice"]
+
     def natural_key(self):
-        """
-        Return the natural key for the instance.
-        
-        Returns a single-element tuple containing the object's name, which is used as a
-        unique identifier for natural key-based lookups.
-        """
+        """Returns the natural key (name) as a tuple."""
         return (self.name,)
 
     def __str__(self):
-        """
-        Return the string representation of the model instance.
-        
-        This method converts the instance's name attribute to a string, ensuring a clear
-        and consistent display across Django interfaces.
-        """
+        """Returns the name of the classification."""
         return str(self.name)
 
     def get_choices(self) -> List["DiseaseClassificationChoice"]:
         """
-        Retrieves all choices associated with this disease classification.
-        
+        Retrieves all choices within this classification system.
+
         Returns:
             List[DiseaseClassificationChoice]: A list of related disease classification choices.
         """
@@ -109,18 +112,28 @@ class DiseaseClassification(models.Model):
 
 
 class DiseaseClassificationChoiceManager(models.Manager):
+    """Manager for DiseaseClassificationChoice with natural key support."""
+
     def get_by_natural_key(self, name):
-        """Retrieve an object by its natural key.
-        
+        """
+        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)
-    name_de = models.CharField(max_length=255, blank=True, null=True)
-    name_en = models.CharField(max_length=255, blank=True, null=True)
 
     disease_classification = models.ForeignKey(
         DiseaseClassification,
@@ -130,19 +143,14 @@ class DiseaseClassificationChoice(models.Model):
 
     objects = DiseaseClassificationChoiceManager()
 
+    if TYPE_CHECKING:
+        disease_classification: "DiseaseClassification"
+        patient_diseases: models.QuerySet["PatientDisease"]
+
     def natural_key(self):
-        """
-        Return a tuple representing the natural key for the instance.
-        
-        The tuple contains the unique name of the model instance, which is used to
-        identify it naturally.
-        """
+        """Returns the natural key (name) as a tuple."""
         return (self.name,)
 
     def __str__(self):
-        """
-        Return the string representation of the object's name.
-        
-        This method converts the model's 'name' attribute to a string for a human-readable display.
-        """
+        """Returns the name of the classification choice."""
         return str(self.name)

endoreg_db/models/{event.py → medical/event.py}

@@ -1,5 +1,8 @@
 from django.db import models
-from typing import List
+from typing import List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from endoreg_db.models import PatientEvent
 
 
 class EventManager(models.Manager):
@@ -30,16 +33,12 @@ class Event(models.Model):
 
     Attributes:
         name (str): The name of the event.
-        name_de (str): The German name of the event.
-        name_en (str): The English name of the event.
         description (str): A description of the event.
     """
 
     name = models.CharField(max_length=100, unique=True)
-    name_de = models.CharField(max_length=100, blank=True, null=True)
-    name_en = models.CharField(max_length=100, blank=True, null=True)
     description = models.TextField(blank=True, null=True)
-    event_classification = models.ForeignKey(
+    event_classification: models.ForeignKey["EventClassification"] = models.ForeignKey(
         "EventClassification",
         on_delete=models.CASCADE,
         related_name="events",
@@ -48,11 +47,14 @@ class Event(models.Model):
     )
     objects = EventManager()
 
+    if TYPE_CHECKING:
+        patient_events: models.QuerySet["PatientEvent"]
+
     def natural_key(self):
         """
-        Return the natural key for this instance.
+        Returns a tuple representing the natural key for this instance.
         
-        The natural key is defined as a tuple containing the instance's unique name.
+        The natural key consists of the instance's unique name.
         """
         return (self.name,)
 
@@ -67,49 +69,32 @@ class Event(models.Model):
 
 
 class EventClassificationManager(models.Manager):
+    """Manager for EventClassification with natural key support."""
+
     def get_by_natural_key(self, name):
-        """
-        Retrieves an Event instance using its natural key.
-        
-        This method returns the Event whose "name" attribute matches the provided natural key.
-        
-        Args:
-            name (str): The natural key representing the Event's name.
-        
-        Returns:
-            Event: The Event instance with the specified 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)
-    name_de = models.CharField(max_length=255, blank=True, null=True)
-    name_en = models.CharField(max_length=255, blank=True, null=True)
 
     objects = EventClassificationManager()
 
     def natural_key(self):
-        """
-        Return a tuple containing the natural key of the instance.
-        
-        The tuple consists solely of the object's name attribute, serving as its unique identifier for natural key lookups.
-        """
+        """Returns the natural key (name) as a tuple."""
         return (self.name,)
 
     def __str__(self):
-        """
-        Return the object's name as a string.
-        """
+        """Returns the name of the classification."""
         return str(self.name)
 
     def get_choices(self) -> List["EventClassificationChoice"]:
-        """
-        Retrieves the event classification choices.
-        
-        Returns:
-            List[EventClassificationChoice]: The list of choices associated with this classification.
-        """
+        """Retrieves all choices associated with this classification."""
         choices: List[EventClassificationChoice] = [
             _ for _ in self.event_classification_choices.all()
         ]
@@ -117,23 +102,21 @@ class EventClassification(models.Model):
 
 
 class EventClassificationChoiceManager(models.Manager):
+    """Manager for EventClassificationChoice with natural key support."""
+
     def get_by_natural_key(self, name):
-        """
-        Retrieves a model instance using its natural key.
-        
-        Args:
-            name: The value of the natural key corresponding to the instance's name field.
-        
-        Returns:
-            The model instance with a name matching the provided natural key.
-        """
+        """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)
-    name_de = models.CharField(max_length=255, blank=True, null=True)
-    name_en = models.CharField(max_length=255, blank=True, null=True)
     subcategories = models.JSONField(default=dict)
     numerical_descriptors = models.JSONField(default=dict)
 
@@ -146,15 +129,9 @@ class EventClassificationChoice(models.Model):
     objects = EventClassificationChoiceManager()
 
     def natural_key(self):
-        """
-        Returns the natural key for the model instance.
-        
-        The natural key is defined as a tuple containing the instance's name, uniquely identifying it.
-        """
+        """Returns the natural key (name) as a tuple."""
         return (self.name,)
 
     def __str__(self):
-        """
-        Return the string representation of the instance's name.
-        """
+        """Returns the name of the classification choice."""
         return str(self.name)

endoreg_db/models/{examination → medical/examination}/__init__.py

@@ -1,4 +1,4 @@
-from .examination import Examination
+from .examination import Examination, ExaminationRequirementSet
 from .examination_type import ExaminationType
 from .examination_time import ExaminationTime
 from .examination_time_type import ExaminationTimeType

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,)
+