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

endoreg_db/models/disease.py

@@ -1,10 +1,21 @@
 from django.db import models
 from typing import List
 
+
 class DiseaseManager(models.Manager):
     def get_by_natural_key(self, name):
+        """
+        Retrieve a model instance by its natural key.
+        
+        Args:
+            name: The natural key value used to match the model's 'name' field.
+        
+        Returns:
+            The model instance corresponding to the provided natural key.
+        """
         return self.get(name=name)
 
+
 class Disease(models.Model):
     name = models.CharField(max_length=255, unique=True)
     name_de = models.CharField(max_length=255, blank=True, null=True)
@@ -15,65 +26,123 @@ class Disease(models.Model):
     objects = DiseaseManager()
 
     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.
+        """
         return (self.name,)
 
     def __str__(self):
-        return self.name
-    
-    
-
+        """
+        Return the string representation of the instance using its name attribute.
+        """
+        return str(self.name)
+
+    def get_classifications(self) -> List["DiseaseClassification"]:
+        """
+        Retrieves all classifications 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
 
 
-    
-    def get_classifications(self)->List['DiseaseClassification']:
-        classifications: List[DiseaseClassification] = [_ for _ in self.disease_classifications.all()]
-        return classifications
-    
 class DiseaseClassificationManager(models.Manager):
     def get_by_natural_key(self, name):
+        """
+        Retrieves a model instance using its natural key.
+        
+        Args:
+            name: A unique identifier representing the natural key of the instance.
+        
+        Returns:
+            The model instance corresponding to the given natural key.
+        """
         return self.get(name=name)
 
+
 class DiseaseClassification(models.Model):
     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'
+        Disease, on_delete=models.CASCADE, related_name="disease_classifications"
     )
 
     objects = DiseaseClassificationManager()
 
     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.
+        """
         return (self.name,)
 
     def __str__(self):
-        return self.name
-    
-    def get_choices(self)->List['DiseaseClassificationChoice']:
-        choices:List[DiseaseClassificationChoice] = [_ for _ in self.disease_classification_choices.all()]
+        """
+        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.
+        """
+        return str(self.name)
+
+    def get_choices(self) -> List["DiseaseClassificationChoice"]:
+        """
+        Retrieves all choices associated with this disease classification.
+        
+        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):
     def get_by_natural_key(self, name):
+        """Retrieve an object by its natural key.
+        
+        Queries for and returns the instance whose 'name' attribute matches the provided key.
+        """
         return self.get(name=name)
 
+
 class DiseaseClassificationChoice(models.Model):
     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, on_delete=models.CASCADE,
-        related_name='disease_classification_choices'
+        DiseaseClassification,
+        on_delete=models.CASCADE,
+        related_name="disease_classification_choices",
     )
 
     objects = DiseaseClassificationChoiceManager()
 
     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.
+        """
         return (self.name,)
 
     def __str__(self):
-        return self.name
+        """
+        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.
+        """
+        return str(self.name)

endoreg_db/models/event.py

@@ -1,6 +1,29 @@
 from django.db import models
 from typing import List
 
+
+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.
@@ -11,63 +34,127 @@ class Event(models.Model):
         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(
-        'EventClassification', on_delete=models.CASCADE, related_name='events',
-        null=True, blank=True
+        "EventClassification",
+        on_delete=models.CASCADE,
+        related_name="events",
+        null=True,
+        blank=True,
     )
+    objects = EventManager()
 
     def natural_key(self):
+        """
+        Return the natural key for this instance.
+        
+        The natural key is defined as a tuple containing the instance's unique name.
+        """
         return (self.name,)
 
     def __str__(self):
-        return self.name
-    
+        """
+        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):
     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.
+        """
         return self.get(name=name)
-    
+
+
 class EventClassification(models.Model):
     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.
+        """
         return (self.name,)
-    
+
     def __str__(self):
-        return self.name
-    
-    def get_choices(self)->List['EventClassificationChoice']:
-        choices:List[EventClassificationChoice] = [_ for _ in self.event_classification_choices.all()]
+        """
+        Return the object's name as a string.
+        """
+        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.
+        """
+        choices: List[EventClassificationChoice] = [
+            _ for _ in self.event_classification_choices.all()
+        ]
         return choices
-    
+
+
 class EventClassificationChoiceManager(models.Manager):
     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.
+        """
         return self.get(name=name)
-    
+
+
 class EventClassificationChoice(models.Model):
     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)
-    
+
     event_classification = models.ForeignKey(
-        EventClassification, on_delete=models.CASCADE,
-        related_name='event_classification_choices'
+        EventClassification,
+        on_delete=models.CASCADE,
+        related_name="event_classification_choices",
     )
-    
+
     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.
+        """
         return (self.name,)
-    
+
     def __str__(self):
-        return self.name
+        """
+        Return the string representation of the instance's name.
+        """
+        return str(self.name)

endoreg_db/models/examination/examination_indication.py

@@ -1,13 +1,28 @@
 from django.db import models
-from typing import List
+from typing import List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from endoreg_db.models import Examination, Requirement, FindingIntervention
+
 
 class ExaminationIndicationManager(models.Manager):
     """
     Manager for ExaminationIndication with custom query methods.
     """
+
     def get_by_natural_key(self, name: str) -> "ExaminationIndication":
+        """
+        Retrieves an ExaminationIndication instance by its natural key.
+        
+        Args:
+            name: The unique name identifying the examination indication.
+        
+        Returns:
+            The ExaminationIndication instance corresponding to the specified name.
+        """
         return self.get(name=name)
-    
+
+
 class ExaminationIndication(models.Model):
     """
     Represents an indication for an examination.
@@ -18,22 +33,40 @@ class ExaminationIndication(models.Model):
         name_en (str): The English name of the indication.
         classification (ForeignKey): The classification associated with the indication.
         examination (ForeignKey): The examination associated with the indication.
+        expected_interventions (ManyToManyField): Expected interventions for this indication.
     """
+
     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)
-    classification = models.ForeignKey(
-        'ExaminationIndicationClassification', on_delete=models.CASCADE,
-        related_name='indications',
-        blank=True, null=True
+    description = models.TextField(blank=True, null=True)
+
+    classifications = models.ManyToManyField(
+        "ExaminationIndicationClassification",
+        related_name="indications",
+        blank=True,
     )
+
     examination = models.ForeignKey(
-        'Examination', on_delete=models.CASCADE,
-        related_name='indications',
+        "Examination",
+        on_delete=models.CASCADE,
+        related_name="indications",
     )
-    
+
+    expected_interventions = models.ManyToManyField(
+        "FindingIntervention",
+        related_name="indications",
+        blank=True,
+    )
+
     objects = ExaminationIndicationManager()
-    
+
+    if TYPE_CHECKING:
+        classifications: "models.ManyToManyField[ExaminationIndicationClassification]"
+        examination: "Examination"
+        related_requirements: "models.QuerySet[Requirement]"
+        expected_interventions: "models.ManyToManyField[FindingIntervention]"
+
     def natural_key(self) -> tuple:
         """
         Returns the natural key for the indication.
@@ -50,18 +83,24 @@ class ExaminationIndication(models.Model):
         Returns:
             str: The name of the indication.
         """
-        return self.name
+        return str(self.name)
 
-    def get_choices(self) -> List['ExaminationIndicationClassificationChoice']:
+    def get_choices(self) -> List["ExaminationIndicationClassificationChoice"]:
         """
-        Retrieves all choices associated with the classification.
-
+        Retrieves all classification choices for the indication.
+        
+        Aggregates and returns the choices from each classification associated with the indication.
+        
         Returns:
-            list: A list of classification choices.
+            List[ExaminationIndicationClassificationChoice]: A list of classification choices.
         """
-        return list(self.classification.choices.all()) if self.classification else []
+        classifications = self.classifications.all()
+        choices = []
+        for classification in classifications:
+            choices.extend(classification.choices.all())
+        return choices
 
-    def get_examination(self) -> 'Examination':
+    def get_examination(self) -> "Examination":
         """
         Retrieves the associated examination.
 
@@ -70,13 +109,25 @@ class ExaminationIndication(models.Model):
         """
         return self.examination
 
+
 class ExaminationIndicationClassificationManager(models.Manager):
     """
     Manager for ExaminationIndicationClassification with custom query methods.
     """
+
     def get_by_natural_key(self, name: str) -> "ExaminationIndicationClassification":
+        """
+        Retrieves an ExaminationIndicationClassification by its natural key.
+        
+        Args:
+            name: The unique name identifying the classification.
+        
+        Returns:
+            The ExaminationIndicationClassification instance corresponding to the given name.
+        """
         return self.get(name=name)
 
+
 class ExaminationIndicationClassification(models.Model):
     """
     Represents a classification for examination indications.
@@ -86,13 +137,25 @@ class ExaminationIndicationClassification(models.Model):
         name_de (str): The German name of the classification.
         name_en (str): The English name of the classification.
     """
+
     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)
-    
-    
+    description = models.TextField(blank=True, null=True)
+    examination = models.ForeignKey(
+        "Examination",
+        on_delete=models.CASCADE,
+        related_name="indication_classifications",
+        blank=True,
+        null=True,
+    )
+
+    if TYPE_CHECKING:
+        examination: "Examination"
+        choices: "models.QuerySet[ExaminationIndicationClassificationChoice]"
+
     objects = ExaminationIndicationClassificationManager()
-    
+
     def natural_key(self) -> tuple:
         """
         Returns the natural key for the classification.
@@ -109,24 +172,38 @@ class ExaminationIndicationClassification(models.Model):
         Returns:
             str: The name of the classification.
         """
-        return self.name
+        return str(self.name)
 
-    def get_choices(self) -> List['ExaminationIndicationClassificationChoice']:
+    def get_choices(self) -> List["ExaminationIndicationClassificationChoice"]:
         """
-        Retrieves all choices associated with this classification.
-
+        Retrieves all classification choices associated with this classification.
+        
         Returns:
-            list: A list of classification choices.
+            List[ExaminationIndicationClassificationChoice]: A list of classification choice instances.
         """
         return list(self.choices.all())
 
+
 class ExaminationIndicationClassificationChoiceManager(models.Manager):
     """
     Manager for ExaminationIndicationClassificationChoice with custom query methods.
     """
-    def get_by_natural_key(self, name: str) -> "ExaminationIndicationClassificationChoice":
+
+    def get_by_natural_key(
+        self, name: str
+    ) -> "ExaminationIndicationClassificationChoice":
+        """
+        Retrieves an ExaminationIndicationClassificationChoice instance by its natural key.
+        
+        Args:
+            name: The unique name serving as the natural key for the classification choice.
+        
+        Returns:
+            An ExaminationIndicationClassificationChoice instance corresponding to the given name.
+        """
         return self.get(name=name)
 
+
 class ExaminationIndicationClassificationChoice(models.Model):
     """
     Represents a choice within an examination indication classification.
@@ -139,14 +216,16 @@ class ExaminationIndicationClassificationChoice(models.Model):
         numerical_descriptors (JSONField): Numerical descriptors for the choice.
         classification (ForeignKey): The classification to which this choice belongs.
     """
+
     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)
     classification = models.ForeignKey(
-        ExaminationIndicationClassification, on_delete=models.CASCADE,
-        related_name='choices'
+        ExaminationIndicationClassification,
+        on_delete=models.CASCADE,
+        related_name="choices",
     )
 
     objects = ExaminationIndicationClassificationChoiceManager()
@@ -167,4 +246,4 @@ class ExaminationIndicationClassificationChoice(models.Model):
         Returns:
             str: The name of the classification choice.
         """
-        return self.name
+        return str(self.name)

endoreg_db/models/examination/examination_type.py

@@ -1,12 +1,24 @@
 from django.db import models
 
+
 class ExaminationTypeManager(models.Manager):
     """
     Manager for ExaminationType with custom query methods.
     """
+
     def get_by_natural_key(self, name: str) -> "ExaminationType":
+        """
+        Retrieves an ExaminationType instance using its natural key.
+        
+        Args:
+            name: The natural identifier for the ExaminationType, typically the unique name.
+        
+        Returns:
+            The ExaminationType instance that matches the given name.
+        """
         return self.get(name=name)
-    
+
+
 class ExaminationType(models.Model):
     """
     Represents a type of examination.
@@ -16,6 +28,7 @@ class ExaminationType(models.Model):
         name_de (str): The German name of the examination type.
         name_en (str): The English name of the examination type.
     """
+
     objects = ExaminationTypeManager()
     name = models.CharField(max_length=100, unique=True)
     name_de = models.CharField(max_length=100, blank=True, null=True)
@@ -23,12 +36,13 @@ class ExaminationType(models.Model):
 
     def __str__(self) -> str:
         """
-        String representation of the examination type.
-
-        Returns:
-            str: The name of the examination type.
+        Return the string representation of the examination type.
+        
+        If an English name is provided, it is returned; otherwise, the default name is used.
         """
-        return self.name_en or self.name
+        name = self.name_en or self.name
+        name = str(name)
+        return name
 
     def natural_key(self) -> tuple:
         """

endoreg_db/models/information_source.py

@@ -1,16 +1,41 @@
 from django.db import models
 
+
 def get_prediction_information_source():
+    """
+    Retrieve the prediction information source.
+    
+    This function queries the InformationSource model for an entry with the name
+    "prediction" using Django's ORM and asserts that the retrieved object is valid.
+    It returns the matching InformationSource instance.
+    
+    Returns:
+        InformationSource: The InformationSource object with name "prediction".
+    
+    Raises:
+        AssertionError: If no prediction information source is found.
+    """
     _source = InformationSource.objects.get(name="prediction")
 
     # make sure to return only one object
     assert _source, "No prediction information source found"
     return _source
 
+
 class InformationSourceManager(models.Manager):
     def get_by_natural_key(self, name):
+        """
+        Retrieves a model instance using its natural key.
+        
+        Args:
+            name: The natural key value corresponding to the model's 'name' field.
+        
+        Returns:
+            The model instance that matches the provided natural key.
+        """
         return self.get(name=name)
 
+
 class InformationSource(models.Model):
     objects = InformationSourceManager()
 
@@ -23,7 +48,18 @@ class InformationSource(models.Model):
     date = models.DateField(blank=True, null=True)
 
     def natural_key(self):
+        """
+        Returns the natural key tuple for the information source.
+        
+        The tuple contains the object's name, which uniquely identifies it for 
+        serialization and natural key lookup.
+        """
         return (self.name,)
 
     def __str__(self):
-        return self.name
+        """
+        Return the string representation of the InformationSource instance.
+        
+        This method returns the instance's name attribute converted explicitly to a string.
+        """
+        return str(self.name)