endoreg-db 0.8.4.4__py3-none-any.whl → 0.8.8.0__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, 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.
         """
@@ -58,20 +60,23 @@ class ExaminationIndication(models.Model):
     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)
+        examinations = cast(models.manager.RelatedManager["Examination"], examinations)
+        expected_interventions = cast(models.manager.RelatedManager["FindingIntervention"], expected_interventions)
+
+        @property
+        def related_requirements(self) -> "models.manager.RelatedManager[Requirement]": ...
 
     @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()),
@@ -96,9 +101,9 @@ class ExaminationIndication(models.Model):
     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.
         """
@@ -111,7 +116,7 @@ class ExaminationIndication(models.Model):
     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.
         """
@@ -120,13 +125,11 @@ class ExaminationIndication(models.Model):
     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 +140,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.
         """
@@ -192,7 +195,7 @@ class ExaminationIndicationClassification(models.Model):
     def get_choices(self) -> List["ExaminationIndicationClassificationChoice"]:
         """
         Retrieves all classification choices associated with this classification.
-        
+
         Returns:
             List[ExaminationIndicationClassificationChoice]: A list of classification choice instances.
         """
@@ -201,7 +204,7 @@ class ExaminationIndicationClassification(models.Model):
     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.
         """
@@ -210,7 +213,7 @@ class ExaminationIndicationClassification(models.Model):
     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.
         """
@@ -222,15 +225,13 @@ 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.
         """

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
+
 
 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,16 @@ 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)
+    time_types = models.ManyToManyField("ExaminationTimeType", blank=True)
     end_time = models.TimeField(blank=True, null=True)
     objects = ExaminationTimeManager()
 
+    if TYPE_CHECKING:
+        time_types = cast(models.manager.RelatedManager["ExaminationTimeType"], time_types)
+
     def __str__(self) -> str:
         """
         String representation of the examination time.
@@ -43,7 +54,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,85 @@
 # 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
+    examinations = models.ManyToManyField("Examination", blank=True, related_name="findings")
+    finding_types = models.ManyToManyField("FindingType", blank=True, related_name="findings")
+
+    finding_interventions = models.ManyToManyField("FindingIntervention", 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,
+            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)
+        examinations = cast(models.manager.RelatedManager["Examination"], examinations)
+        finding_interventions = cast(models.manager.RelatedManager["FindingIntervention"], finding_interventions)
+
+        @property
+        def finding_classifications(self) -> "models.manager.RelatedManager[FindingClassification]": ...
+
+        # finding_classifications: models.QuerySet["FindingClassification"]
+        # examinations: models.QuerySet[Examination]
+        # finding_types: models.QuerySet[FindingType]
+        # finding_interventions: models.QuerySet[FindingIntervention]
+
     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 +88,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,30 +1,31 @@
+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()
-        ]
+        required_classification_types = [_ for _ in finding.required_morphology_classification_types.all()]
         return required_classification_types
 
 
@@ -37,31 +38,25 @@ class FindingClassification(models.Model):
     name = models.CharField(max_length=255, unique=True)
     description = models.TextField(blank=True)
     classification_types = models.ManyToManyField(
-        to=FindingClassificationType, 
+        to=FindingClassificationType,
         # on_delete=models.CASCADE
     )
-    choices = models.ManyToManyField(
-        'FindingClassificationChoice', 
-        related_name='classifications', 
-        blank=True
-    )
+    choices = models.ManyToManyField("FindingClassificationChoice", related_name="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')
+    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")
 
     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, PatientFindingClassification
+
+        classification_types = cast(models.manager.RelatedManager["FindingClassificationType"], classification_types)
+        choices = cast(models.manager.RelatedManager["FindingClassificationChoice"], choices)
+        examinations = cast(models.manager.RelatedManager["Examination"], examinations)
+        findings = cast(models.manager.RelatedManager["Finding"], findings)
+        finding_types = cast(models.manager.RelatedManager["FindingType"], finding_types)
 
     def natural_key(self):
         return (self.name,)
@@ -72,9 +67,9 @@ 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()
 
@@ -97,46 +92,40 @@ 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", 
+    #     "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
-

endoreg_db/models/medical/finding/finding_intervention.py

@@ -1,52 +1,57 @@
+from typing import TYPE_CHECKING, cast
+
 from django.db import models
 
+
 class FindingInterventionManager(models.Manager):
     def get_by_natural_key(self, name):
         return self.get(name=name)
-    
+
+
 class FindingIntervention(models.Model):
     name = models.CharField(max_length=100, unique=True)
     description = models.TextField(blank=True, null=True)
 
-    intervention_types = models.ManyToManyField(
-        'FindingInterventionType',
-        blank=True,
-        related_name='interventions'
-    )
+    intervention_types = models.ManyToManyField("FindingInterventionType", blank=True, related_name="interventions")
 
-    required_lab_values = models.ManyToManyField(
-        'LabValue',
-        blank=True,
-        related_name='required_by_finding_interventions'
-    )
+    required_lab_values = models.ManyToManyField("LabValue", blank=True, related_name="required_by_finding_interventions")
 
-    contraindications = models.ManyToManyField(
-        'Contraindication',
-        blank=True,
-        related_name='contraindicating_finding_interventions'
-    )
+    contraindications = models.ManyToManyField("Contraindication", blank=True, related_name="contraindicating_finding_interventions")
 
     objects = FindingInterventionManager()
-    
+
+    if TYPE_CHECKING:
+        from endoreg_db.models import Contraindication, FindingInterventionType, LabValue
+
+        intervention_types = cast(models.manager.RelatedManager["FindingInterventionType"], intervention_types)
+        required_lab_values = cast(models.manager.RelatedManager["LabValue"], required_lab_values)
+        contraindications = cast(models.manager.RelatedManager["Contraindication"], contraindications)
+
     def natural_key(self):
         return (self.name,)
-    
+
     def __str__(self):
         return str(self.name)
-    
+
 
 class FindingInterventionTypeManager(models.Manager):
     def get_by_natural_key(self, name):
         return self.get(name=name)
-    
+
+
 class FindingInterventionType(models.Model):
     name = models.CharField(max_length=100, unique=True)
     description = models.TextField(blank=True, null=True)
 
     objects = FindingInterventionTypeManager()
-    
+
+    if TYPE_CHECKING:
+
+        @property
+        def interventions(self) -> "models.manager.RelatedManager[FindingIntervention]": ...
+
     def natural_key(self):
         return (self.name,)
-    
+
     def __str__(self):
         return str(self.name)