endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.9__py3-none-any.whl

endoreg_db/models/medical/examination/examination_indication.py

@@ -1,10 +1,12 @@
+from typing import TYPE_CHECKING, List, Optional, cast
+
 from django.db import models
-from typing import List, TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
-    from endoreg_db.models import Examination, Requirement, FindingIntervention
+    from endoreg_db.models import Examination, FindingIntervention, InformationSource, Requirement
     from endoreg_db.utils.links.requirement_link import RequirementLinks
 
+
 class ExaminationIndicationManager(models.Manager):
     """
     Manager for ExaminationIndication with custom query methods.
@@ -13,10 +15,10 @@ class ExaminationIndicationManager(models.Manager):
     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.
         """
@@ -43,35 +45,41 @@ class ExaminationIndication(models.Model):
         blank=True,
     )
 
-    examinations = models.ManyToManyField(
-        "Examination",
+    expected_interventions = models.ManyToManyField(
+        "FindingIntervention",
         related_name="indications",
         blank=True,
     )
 
-    expected_interventions = models.ManyToManyField(
-        "FindingIntervention",
-        related_name="indications",
+    information_sources = models.ManyToManyField(
+        "InformationSource",
+        related_name="examination_indications",
         blank=True,
     )
 
     objects = ExaminationIndicationManager()
 
     if TYPE_CHECKING:
-        classifications: "models.ManyToManyField[ExaminationIndicationClassification, ExaminationIndicationClassification]"
-        examinations: "models.ManyToManyField[Examination, Examination]"
-        related_requirements: "models.QuerySet[Requirement]"
-        expected_interventions: "models.ManyToManyField[FindingIntervention, FindingIntervention]"
+        classifications = cast(models.manager.RelatedManager["ExaminationIndicationClassification"], classifications)
+        expected_interventions = cast(models.manager.RelatedManager["FindingIntervention"], expected_interventions)
+        information_sources = cast(models.manager.RelatedManager["InformationSource"], information_sources)
+
+        @property
+        def related_requirements(self) -> "models.manager.RelatedManager[Requirement]": ...
+
+        @property
+        def examinations(self) -> "models.manager.RelatedManager[Examination]": ...
 
     @property
     def links(self) -> "RequirementLinks":
         """
         Aggregates related requirements, classifications, examination, and interventions into a RequirementLinks object.
-        
+
         Returns:
             A RequirementLinks instance representing all entities linked to this examination indication.
         """
         from endoreg_db.utils.links.requirement_link import RequirementLinks
+
         return RequirementLinks(
             examination_indications=[self],
             examinations=list(self.examinations.all()),
@@ -93,41 +101,6 @@ class ExaminationIndication(models.Model):
         """
         return str(self.name)
 
-    def get_choices(self) -> List["ExaminationIndicationClassificationChoice"]:
-        """
-        Retrieves all classification choices for the indication.
-        
-        Aggregates and returns the choices from each classification associated with the indication.
-        
-        Returns:
-            List[ExaminationIndicationClassificationChoice]: A list of classification choices.
-        """
-        classifications = self.classifications.all()
-        choices = []
-        for classification in classifications:
-            choices.extend(classification.choices.all())
-        return choices
-
-    def get_examination(self) -> Optional["Examination"]:
-        """
-        Returns the first examination associated with this indication, or None if no examinations exist.
-        
-        Note: Since this is now a many-to-many relationship, this method returns the first examination.
-        Consider using get_examinations() for accessing all related examinations.
-        """
-        return self.examinations.first()
-
-    def get_examinations(self) -> List["Examination"]:
-        """
-        Returns all examinations associated with this indication.
-        
-        Returns:
-            List[Examination]: A list of all examinations linked to this indication.
-        """
-        return list(self.examinations.all())
-    
-
-
 
 class ExaminationIndicationClassificationManager(models.Manager):
     """
@@ -137,10 +110,10 @@ class ExaminationIndicationClassificationManager(models.Manager):
     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.
         """
@@ -159,18 +132,14 @@ class ExaminationIndicationClassification(models.Model):
 
     name = models.CharField(max_length=255, unique=True)
     description = models.TextField(blank=True, null=True)
-    examinations = models.ManyToManyField(
-        "Examination",
-        related_name="indication_classifications",
+    choices = models.ManyToManyField(
+        "ExaminationIndicationClassificationChoice",
+        related_name="classifications",
         blank=True,
     )
 
     objects = ExaminationIndicationClassificationManager()
 
-    if TYPE_CHECKING:
-        examinations: "models.ManyToManyField[Examination, Examination]"
-        choices: "models.QuerySet[ExaminationIndicationClassificationChoice]"
-
     def natural_key(self) -> tuple:
         """
         Returns the natural key for the classification.
@@ -189,48 +158,19 @@ class ExaminationIndicationClassification(models.Model):
         """
         return str(self.name)
 
-    def get_choices(self) -> List["ExaminationIndicationClassificationChoice"]:
-        """
-        Retrieves all classification choices associated with this classification.
-        
-        Returns:
-            List[ExaminationIndicationClassificationChoice]: A list of classification choice instances.
-        """
-        return list(self.choices.all())
-
-    def get_examination(self) -> Optional["Examination"]:
-        """
-        Returns the first examination associated with this classification, or None if no examinations exist.
-        
-        Note: Since this is now a many-to-many relationship, this method returns the first examination.
-        Consider using get_examinations() for accessing all related examinations.
-        """
-        return self.examinations.first()
-
-    def get_examinations(self) -> List["Examination"]:
-        """
-        Returns all examinations associated with this classification.
-        
-        Returns:
-            List[Examination]: A list of all examinations linked to this classification.
-        """
-        return list(self.examinations.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.
         """
@@ -251,11 +191,6 @@ class ExaminationIndicationClassificationChoice(models.Model):
     name = models.CharField(max_length=255, unique=True)
     subcategories = models.JSONField(default=dict)
     numerical_descriptors = models.JSONField(default=dict)
-    classification = models.ForeignKey(
-        ExaminationIndicationClassification,
-        on_delete=models.CASCADE,
-        related_name="choices",
-    )
 
     objects = ExaminationIndicationClassificationChoiceManager()
 

endoreg_db/models/medical/examination/examination_time.py

@@ -1,13 +1,20 @@
+from typing import TYPE_CHECKING, cast
+
 from django.db import models
-from rest_framework import serializers
+
+if TYPE_CHECKING:
+    from endoreg_db.models import ExaminationTimeType, InformationSource
+
 
 class ExaminationTimeManager(models.Manager):
     """
     Manager for ExaminationTime with custom query methods.
     """
+
     def get_by_natural_key(self, name: str) -> "ExaminationTime":
         return self.get(name=name)
 
+
 class ExaminationTime(models.Model):
     """
     Represents a specific time configuration for examinations.
@@ -18,12 +25,21 @@ class ExaminationTime(models.Model):
         end_time (TimeField): The ending time for the examination.
         time_types (ManyToManyField): The types associated with this examination time.
     """
+
     name = models.CharField(max_length=100, unique=True)
-    start_time = models.TimeField(blank=True, null=True)
-    time_types = models.ManyToManyField('ExaminationTimeType', blank=True)
-    end_time = models.TimeField(blank=True, null=True)
+    time_types = models.ManyToManyField("ExaminationTimeType", blank=True)
     objects = ExaminationTimeManager()
 
+    information_sources = models.ManyToManyField(
+        "InformationSource",
+        related_name="examination_times",
+        blank=True,
+    )
+
+    if TYPE_CHECKING:
+        time_types = cast(models.manager.RelatedManager["ExaminationTimeType"], time_types)
+        information_sources = cast(models.manager.RelatedManager["InformationSource"], information_sources)
+
     def __str__(self) -> str:
         """
         String representation of the examination time.
@@ -43,7 +59,6 @@ class ExaminationTime(models.Model):
         return (self.name,)
 
     class Meta:
-        verbose_name = 'Examination Time'
-        verbose_name_plural = 'Examination Times'
-        ordering = ['name']
-
+        verbose_name = "Examination Time"
+        verbose_name_plural = "Examination Times"
+        ordering = ["name"]

endoreg_db/models/medical/examination/examination_time_type.py

@@ -1,12 +1,15 @@
 from django.db import models
 
+
 class ExaminationTimeTypeManager(models.Manager):
     """
     Manager for ExaminationTimeType with custom query methods.
     """
+
     def get_by_natural_key(self, name: str) -> "ExaminationTimeType":
         return self.get(name=name)
-    
+
+
 class ExaminationTimeType(models.Model):
     """
     Represents a type of examination time.
@@ -15,9 +18,10 @@ class ExaminationTimeType(models.Model):
         name (str): The unique name of the examination time type.
         examinations: The examinations associated with this type.
     """
+
     objects = ExaminationTimeTypeManager()
     name = models.CharField(max_length=100, unique=True)
-    examinations = models.ManyToManyField('Examination', blank=True)
+    examinations = models.ManyToManyField("Examination", blank=True)
 
     def __str__(self) -> str:
         """
@@ -35,7 +39,6 @@ class ExaminationTimeType(models.Model):
         return (self.name,)
 
     class Meta:
-        verbose_name = 'Examination Time Type'
-        verbose_name_plural = 'Examination Time Types'
-        ordering = ['name']
-
+        verbose_name = "Examination Time Type"
+        verbose_name_plural = "Examination Time Types"
+        ordering = ["name"]

endoreg_db/models/medical/examination/examination_type.py

@@ -9,10 +9,10 @@ class ExaminationTypeManager(models.Manager):
     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.
         """
@@ -34,8 +34,7 @@ class ExaminationType(models.Model):
         """
         Return the string representation of the examination type using its name.
         """
-        name = self.name_en or self.name
-        name = str(name)
+        name = str(self.name)
         return name
 
     def natural_key(self) -> tuple:

endoreg_db/models/medical/finding/finding.py

@@ -1,86 +1,78 @@
 # Class to represent findings of examinations
+from typing import TYPE_CHECKING, Optional, cast
+
 from django.db import models
-from typing import List
 
-from typing import TYPE_CHECKING
 
 class FindingManager(models.Manager):
     def get_by_natural_key(self, name):
         return self.get(name=name)
 
+
 class Finding(models.Model):
     name = models.CharField(max_length=100, unique=True)
     description = models.TextField(blank=True, null=True)
-    examinations = models.ManyToManyField(
-        'Examination', 
-        blank=True, 
-        related_name='findings'
-    ) # type: ignore
-    finding_types = models.ManyToManyField(
-        'FindingType', 
-        blank=True, 
-        related_name='findings'
-    ) # type: ignore
-
-    finding_interventions = models.ManyToManyField(
-        'FindingIntervention',
-        blank=True,
-        related_name='findings'
-    ) # type: ignore
-
+    finding_types = models.ManyToManyField("FindingType", blank=True, related_name="findings")
+    finding_interventions = models.ManyToManyField("FindingIntervention", blank=True, related_name="findings")
+    caused_by_interventions = models.ManyToManyField("FindingIntervention", blank=True, related_name="causes_findings")
+    finding_classifications = models.ManyToManyField("FindingClassification", blank=True, related_name="findings")
+    information_sources = models.ManyToManyField("InformationSource", blank=True, related_name="findings")
     objects = FindingManager()
 
     if TYPE_CHECKING:
         from endoreg_db.models import (
-            Examination, FindingType, FindingIntervention, FindingClassificationType,
+            Examination,
             FindingClassification,
-            PatientFindingClassification
+            FindingClassificationType,
+            FindingIntervention,
+            FindingType,
+            InformationSource,
+            PatientFindingClassification,
         )
-    
-        finding_classifications: models.QuerySet['FindingClassification']
-        examinations: models.QuerySet[Examination]
-        finding_types: models.QuerySet[FindingType]
-        finding_interventions: models.QuerySet[FindingIntervention]
-        
+
+        finding_types = cast(models.manager.RelatedManager["FindingType"], finding_types)
+        finding_interventions = cast(models.manager.RelatedManager["FindingIntervention"], finding_interventions)
+        finding_classifications = cast(models.manager.RelatedManager["FindingClassification"], finding_classifications)
+
     def natural_key(self):
         """
         Return a tuple containing the unique natural key for this Finding instance.
-        
+
         Returns:
             tuple: A single-element tuple with the Finding's name.
         """
         return (self.name,)
-    
+
     def __str__(self):
         return self.name
-    
+
     def get_finding_types(self):
         """
         Return all finding types associated with this finding.
-        
+
         Returns:
             QuerySet: All related FindingType instances.
         """
         return self.finding_types.all()
-    
-    def get_classifications(self, classification_type: str = None) -> models.QuerySet['FindingClassification']:
+
+    def get_classifications(self, classification_type: Optional[str] = None) -> models.QuerySet["FindingClassification"]:
         """
         Retrieve all classifications associated with this finding, optionally filtered by classification type.
-        
+
         Parameters:
-        	classification_type (str, optional): If provided, only classifications with a matching type name are returned.
-        
+                classification_type (str, optional): If provided, only classifications with a matching type name are returned.
+
         Returns:
-        	List[FindingClassification]: List of related classification objects, filtered by type if specified.
+                List[FindingClassification]: List of related classification objects, filtered by type if specified.
         """
         if classification_type:
             return self.finding_classifications.filter(classification_types__name=classification_type)
         return self.finding_classifications.all()
-    
+
     def get_location_classifications(self):
         """
         Retrieve all related FindingClassification objects with classification type 'location'.
-        
+
         Returns:
             QuerySet: All FindingClassification instances linked to this finding where the classification type name is 'location' (case-insensitive).
         """
@@ -89,7 +81,7 @@ class Finding(models.Model):
     def get_morphology_classifications(self):
         """
         Retrieve all related FindingClassification objects with classification type 'morphology'.
-        
+
         Returns:
             QuerySet: A queryset of FindingClassification instances associated with this finding and classified as 'morphology'.
         """

endoreg_db/models/medical/finding/finding_classification.py

@@ -1,31 +1,23 @@
+from typing import TYPE_CHECKING, cast
+
 from django.db import models
-from typing import TYPE_CHECKING, List
+
 
 class FindingClassificationTypeManager(models.Manager):
     def get_by_natural_key(self, name):
         return self.get(name=name)
-    
+
+
 class FindingClassificationType(models.Model):
     name = models.CharField(max_length=255, unique=True)
     description = models.TextField(blank=True)
-    
     objects = FindingClassificationTypeManager()
-    
+
     def natural_key(self):
         return (self.name,)
-    
+
     def __str__(self):
         return str(self.name)
-    
-    @classmethod
-    def get_required_classifications_for_finding(cls, finding):
-        """
-        Returns all required finding classification types for a given finding.
-        """
-        required_classification_types = [
-            _ for _ in finding.required_morphology_classification_types.all()
-        ]
-        return required_classification_types
 
 
 class FindingClassificationManager(models.Manager):
@@ -36,32 +28,37 @@ class FindingClassificationManager(models.Manager):
 class FindingClassification(models.Model):
     name = models.CharField(max_length=255, unique=True)
     description = models.TextField(blank=True)
+    finding_types = models.ManyToManyField("FindingType", blank=True, related_name="finding_classifications")
+    choices = models.ManyToManyField("FindingClassificationChoice", related_name="classifications", blank=True)
+
     classification_types = models.ManyToManyField(
-        to=FindingClassificationType, 
+        to=FindingClassificationType,
         # on_delete=models.CASCADE
     )
-    choices = models.ManyToManyField(
-        'FindingClassificationChoice', 
-        related_name='classifications', 
-        blank=True
+    information_sources = models.ManyToManyField(
+        "InformationSource",
+        related_name="finding_classifications",
+        blank=True,
     )
 
-    findings = models.ManyToManyField('Finding', blank=True, related_name='finding_classifications')
-    examinations = models.ManyToManyField('Examination', blank=True, related_name='finding_classifications')
-    finding_types = models.ManyToManyField('FindingType', blank=True, related_name='finding_classifications')
+    @property
+    def examinations(self):
+        from endoreg_db.models import Examination
+
+        return Examination.objects.filter(findings__finding_classifications=self)
 
     objects = FindingClassificationManager()
 
     if TYPE_CHECKING:
-        from endoreg_db.models import (
-            Finding, Examination, FindingType, PatientFindingClassification
-        )
-        classification_types: models.ManyToManyField[FindingClassificationType]
-        findings: models.QuerySet[Finding]
-        examinations: models.QuerySet[Examination]
-        finding_types: models.QuerySet[FindingType]
-        choices: models.QuerySet['FindingClassificationChoice']
-        patient_finding_classifications: models.QuerySet['PatientFindingClassification']
+        from endoreg_db.models import Examination, Finding, FindingType, InformationSource, PatientFindingClassification
+
+        classification_types = cast(models.manager.RelatedManager["FindingClassificationType"], classification_types)
+        choices = cast(models.manager.RelatedManager["FindingClassificationChoice"], choices)
+        finding_types = cast(models.manager.RelatedManager["FindingType"], finding_types)
+        information_sources = cast(models.manager.RelatedManager["InformationSource"], information_sources)
+
+        @property
+        def findings(self) -> "models.manager.RelatedManager[Finding]": ...
 
     def natural_key(self):
         return (self.name,)
@@ -72,71 +69,44 @@ class FindingClassification(models.Model):
     def get_choices(self):
         """
         Return all choices associated with this classification.
-        
+
         Returns:
-        	QuerySet: All related FindingClassificationChoice instances.
+                QuerySet: All related FindingClassificationChoice instances.
         """
         return self.choices.all()
 
-    @property
-    def is_morphology(self):
-        """
-        Return True if any related classification type has the name "morphology" (case-insensitive).
-        """
-        return self.classification_types.filter(name__iexact="morphology").exists()
-
-    @property
-    def is_location(self):
-        """
-        Returns True if any related classification type has the name "location" (case-insensitive).
-        """
-        return self.classification_types.filter(name__iexact="location").exists()
-
 
 class FindingClassificationChoiceManager(models.Manager):
     def get_by_natural_key(self, name):
         """
         Retrieve an instance by its unique name using the natural key.
-        
+
         Parameters:
             name (str): The unique name identifying the instance.
-        
+
         Returns:
             The model instance with the specified name.
         """
         return self.get(name=name)
-    
+
+
 class FindingClassificationChoice(models.Model):
     name = models.CharField(max_length=255, unique=True)
     description = models.TextField(blank=True)
-    # classifications = models.ManyToManyField(
-    #     "FindingClassification", 
-    #     related_name='choices'
-    # )
-    
-    subcategories = models.JSONField(
-        default = dict
-    )
-
-    numerical_descriptors = models.JSONField(
-        default = dict
-    )
-
+    subcategories = models.JSONField(default=dict)
+    numerical_descriptors = models.JSONField(default=dict)
     objects = FindingClassificationChoiceManager()
 
     if TYPE_CHECKING:
-        from endoreg_db.models import (
-            PatientFindingClassification
-        )
-        classifications: models.QuerySet['FindingClassification']
-        patient_finding_classifications: models.QuerySet['PatientFindingClassification']
+        from endoreg_db.models import PatientFindingClassification
+
+        classifications: models.QuerySet["FindingClassification"]
+        patient_finding_classifications: models.QuerySet["PatientFindingClassification"]
 
-    
     def natural_key(self):
         return (self.name,)
-    
+
     def __str__(self):
         classifications_names = ", ".join([c.name for c in self.classifications.all()])
         _str = f"{self.name} ({classifications_names})"
         return _str
-