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

endoreg_db/models/medical/finding/finding_intervention.py

@@ -1,52 +1,55 @@
+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',
+    intervention_types = models.ManyToManyField("FindingInterventionType", blank=True, related_name="interventions")
+    information_sources = models.ManyToManyField(
+        "InformationSource",
+        related_name="finding_interventions",
         blank=True,
-        related_name='interventions'
     )
+    objects = FindingInterventionManager()
 
-    required_lab_values = models.ManyToManyField(
-        'LabValue',
-        blank=True,
-        related_name='required_by_finding_interventions'
-    )
+    if TYPE_CHECKING:
+        from endoreg_db.models import Contraindication, FindingInterventionType, InformationSource, LabValue
 
-    contraindications = models.ManyToManyField(
-        'Contraindication',
-        blank=True,
-        related_name='contraindicating_finding_interventions'
-    )
+        intervention_types = cast(models.manager.RelatedManager["FindingInterventionType"], intervention_types)
+        information_sources = cast(models.manager.RelatedManager["InformationSource"], information_sources)
 
-    objects = FindingInterventionManager()
-    
     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)

endoreg_db/models/medical/finding/finding_type.py

@@ -1,35 +1,36 @@
-from django.db import models
 from typing import TYPE_CHECKING
 
+from django.db import models
+
+
 class FindingTypeManager(models.Manager):
     def get_by_natural_key(self, name):
         """
         Retrieve a FindingType instance by its unique name for natural key deserialization.
-        
+
         Parameters:
             name (str): The unique name of the FindingType to retrieve.
-        
+
         Returns:
             FindingType: The instance matching the given name.
         """
         return self.get(name=name)
-    
+
+
 class FindingType(models.Model):
-    name = models.CharField(max_length=100, unique=True) 
+    name = models.CharField(max_length=100, unique=True)
     description = models.TextField(blank=True, null=True)
 
     objects = FindingTypeManager()
 
     if TYPE_CHECKING:
-        from endoreg_db.models import (
-            Finding, Examination, FindingClassification, FindingMorphologyClassification
-        )
-        finding_classifications: models.QuerySet['FindingClassification']
-        morphology_classifications: models.QuerySet['FindingMorphologyClassification']
-        
+        from endoreg_db.models import Examination, Finding, FindingClassification
+
+        @property
+        def finding_classifications(self) -> "models.manager.RelatedManager[FindingClassification]": ...
 
     def natural_key(self):
         return (self.name,)
-    
+
     def __str__(self):
         return self.name

endoreg_db/models/medical/hardware/endoscope.py

@@ -1,34 +1,26 @@
-from django.db import models#
 from typing import TYPE_CHECKING
 
+from django.db import models  #
+
+
 class EndoscopeManager(models.Manager):
     def get_by_natural_key(self, name, sn):
         return self.get(name=name, sn=sn)
 
+
 class Endoscope(models.Model):
     objects = EndoscopeManager()
 
-    name = models.CharField(max_length=255) 
+    name = models.CharField(max_length=255)
     sn = models.CharField(max_length=255)
-    center = models.ForeignKey(
-        'Center',
-        blank=True,
-        null=True,
-        on_delete=models.CASCADE,
-        related_name='endoscopes'
-    )
-    endoscope_type = models.ForeignKey(
-        'EndoscopeType', 
-        blank=True,
-        null=True,
-        on_delete=models.CASCADE,
-        related_name='endoscopes'
-    )
+    center = models.ForeignKey("Center", blank=True, null=True, on_delete=models.CASCADE, related_name="endoscopes")
+    endoscope_type = models.ForeignKey("EndoscopeType", blank=True, null=True, on_delete=models.CASCADE, related_name="endoscopes")
 
     if TYPE_CHECKING:
-        from endoreg_db.models.center.center import Center
-        center: "Center"
-        endoscope_type: "EndoscopeType"
+        from endoreg_db.models import Center
+
+        center: models.ForeignKey["Center|None"]
+        endoscope_type: models.ForeignKey["EndoscopeType|None"]
 
     def natural_key(self):
         return (self.name, self.sn)
@@ -37,14 +29,22 @@ class Endoscope(models.Model):
         return str(self.name)
 
     class Meta:
-        ordering = ['name']
-        verbose_name = 'Endoscope'
-        verbose_name_plural = 'Endoscopes'
+        ordering = ["name"]
+        verbose_name = "Endoscope"
+        verbose_name_plural = "Endoscopes"
+
+    @property
+    def center_safe(self) -> "Center":
+        if self.center is None:
+            raise ValueError("Endoscope has no associated center.")
+        return self.center
+
 
 class EndoscopeTypeManager(models.Manager):
     def get_by_natural_key(self, name):
         return self.get(name=name)
 
+
 class EndoscopeType(models.Model):
     objects = EndoscopeTypeManager()
 
@@ -55,11 +55,11 @@ class EndoscopeType(models.Model):
 
     def natural_key(self) -> tuple[str]:
         return (self.name,)
-    
+
     def __str__(self):
         return str(self.name)
 
     class Meta:
-        ordering = ['name']
-        verbose_name = 'Endoscope Type'
-        verbose_name_plural = 'Endoscope Types'
+        ordering = ["name"]
+        verbose_name = "Endoscope Type"
+        verbose_name_plural = "Endoscope Types"

endoreg_db/models/medical/hardware/endoscopy_processor.py

@@ -72,8 +72,8 @@ class EndoscopyProcessor(models.Model):
         return (self.name,)
 
     @classmethod
-    def get_by_name(self, name):
-        return self.objects.get(name=name)
+    def get_by_name(cls, name):
+        return cls.objects.get(name=name)
 
     def __str__(self) -> str:
         if self.name is None:

endoreg_db/models/medical/laboratory/lab_value.py

@@ -1,27 +1,31 @@
-from django.db import models
 import warnings
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
+
+from django.db import models
 
 if TYPE_CHECKING:
-    from endoreg_db.models.other.unit import Unit
-    from ...other.distribution import (
-        SingleCategoricalValueDistribution,
-        NumericValueDistribution,
-        MultipleCategoricalValueDistribution,
+    from endoreg_db.models import (
         DateValueDistribution,
+        Gender,
+        MultipleCategoricalValueDistribution,
+        NumericValueDistribution,
+        Patient,
+        SingleCategoricalValueDistribution,
+        Unit,
     )
-    from ...administration.person.patient import Patient  # Added Patient for type hinting
 
 LANG = "de"
 
 from pydantic import BaseModel, ConfigDict
 
+
 class CommonLabValues(BaseModel):
     """
     A Pydantic model representing a lookup for common lab values.
     It is used to provide a structured way to access common lab values like
     hemoglobin, creatinine, and others
     """
+
     hb: "LabValue"
     wbc: "LabValue"
     plt: "LabValue"
@@ -32,31 +36,27 @@ class CommonLabValues(BaseModel):
     inr: "LabValue"
     crp: "LabValue"
 
-    model_config = ConfigDict(
-        from_attributes = True,
-        arbitrary_types_allowed = True
-    )
+    model_config = ConfigDict(from_attributes=True, arbitrary_types_allowed=True)
+
 
 class LabValueManager(models.Manager):
     def get_by_natural_key(self, name):
         """
         Retrieves a LabValue instance by its unique name.
-        
+
         Args:
             name: The unique name of the LabValue.
-        
+
         Returns:
             The LabValue instance with the specified name.
         """
         return self.get(name=name)
-    
+
 
 class LabValue(models.Model):
-    name = models.CharField(max_length=255, unique=True) 
+    name = models.CharField(max_length=255, unique=True)
     abbreviation = models.CharField(max_length=10, blank=True, null=True)
-    default_unit = models.ForeignKey(
-        "Unit", on_delete=models.CASCADE, blank=True, null=True
-    )
+    default_unit = models.ForeignKey("Unit", on_delete=models.CASCADE, blank=True, null=True)
     numeric_precision = models.IntegerField(default=3)
     default_single_categorical_value_distribution = models.ForeignKey(
         "SingleCategoricalValueDistribution",
@@ -91,23 +91,22 @@ class LabValue(models.Model):
     normal_range_gender_dependent = models.BooleanField(default=False)
     normal_range_special_case = models.BooleanField(default=False)
     bound_adjustment_factor = models.FloatField(
-        default=0.1,
-        help_text="Factor for adjusting bounds when generating increased/decreased values, e.g., 0.1 for 10%."
+        default=0.1, help_text="Factor for adjusting bounds when generating increased/decreased values, e.g., 0.1 for 10%."
     )
     objects = LabValueManager()
 
     if TYPE_CHECKING:
-        default_unit: "Unit"
-        default_single_categorical_value_distribution: "SingleCategoricalValueDistribution"
-        default_numerical_value_distribution: "NumericValueDistribution"
-        default_multiple_categorical_value_distribution: "MultipleCategoricalValueDistribution"
-        default_date_value_distribution: "DateValueDistribution"
+        default_unit: models.ForeignKey["Unit|None"]
+        default_single_categorical_value_distribution: models.ForeignKey["SingleCategoricalValueDistribution|None"]
+        default_numerical_value_distribution: models.ForeignKey["NumericValueDistribution|None"]
+        default_multiple_categorical_value_distribution: models.ForeignKey["MultipleCategoricalValueDistribution|None"]
+        default_date_value_distribution: models.ForeignKey["DateValueDistribution|None"]
 
     @classmethod
     def get_common_lab_values(cls):
         """
         Retrieves a structured set of common laboratory values as a CommonLabValues instance.
-        
+
         Returns:
             A CommonLabValues Pydantic model populated with LabValue objects for hemoglobin, white blood cells, platelets, creatinine, sodium, potassium, glucose, international normalized ratio, and C-reactive protein.
         """
@@ -122,10 +121,9 @@ class LabValue(models.Model):
             k=cls.objects.get(name="potassium"),
             glc=cls.objects.get(name="glucose"),
             inr=cls.objects.get(name="international_normalized_ratio"),
-            crp=cls.objects.get(name="c_reactive_protein")
+            crp=cls.objects.get(name="c_reactive_protein"),
         )
 
-
     def natural_key(self):
         """Returns a tuple containing the unique name of this lab value instance."""
         return (self.name,)
@@ -160,13 +158,13 @@ class LabValue(models.Model):
             warnings.warn("No default distribution set for lab value")
             return None
 
-    def get_normal_range(self, age: int = None, gender=None):
+    def get_normal_range(self, age: Optional[int] = None, gender: Optional["Gender"] = None):
         """
         Returns the normal range for this lab value, considering age and gender dependencies.
-        
+
         If the normal range is gender-dependent, attempts to use the provided gender; defaults to "male" if gender is missing or unknown. Falls back to general min/max values if gender-specific data is unavailable. Issues warnings for unimplemented age-dependent or special case ranges, and when min or max values cannot be determined. Returns a dictionary with keys "min" and "max", which may be None if the range is not defined.
         """
-        from ...other.gender import Gender
+        from endoreg_db.models import Gender
 
         assert isinstance(age, int) or age is None
         assert isinstance(gender, Gender) or gender is None
@@ -181,20 +179,15 @@ class LabValue(models.Model):
 
         gender_name_to_use = None
         if gender_dependent:
-            if gender and hasattr(gender, 'name') and gender.name:
+            if gender and hasattr(gender, "name") and gender.name:
                 gender_name_to_use = gender.name
                 if gender_name_to_use not in current_range_source:
                     warnings.warn(
-                        f"Normal range for gender '{gender_name_to_use}' not found for LabValue '{self.name}'. "
-                        f"Defaulting to 'male' range.",
-                        UserWarning
+                        f"Normal range for gender '{gender_name_to_use}' not found for LabValue '{self.name}'. Defaulting to 'male' range.", UserWarning
                     )
                     gender_name_to_use = "male"
             else:
-                warnings.warn(
-                    f"Gender not provided for gender-dependent LabValue '{self.name}'. Defaulting to 'male' range.",
-                    UserWarning
-                )
+                warnings.warn(f"Gender not provided for gender-dependent LabValue '{self.name}'. Defaulting to 'male' range.", UserWarning)
                 gender_name_to_use = "male"
 
             # Attempt gender-specific lookup
@@ -204,9 +197,8 @@ class LabValue(models.Model):
                 max_value = gender_specific_data.get("max")
             else:
                 warnings.warn(
-                    f"No gender-specific data found for '{gender_name_to_use}' in LabValue '{self.name}'. "
-                    f"Falling back to general range if available.",
-                    UserWarning
+                    f"No gender-specific data found for '{gender_name_to_use}' in LabValue '{self.name}'. Falling back to general range if available.",
+                    UserWarning,
                 )
 
         # Fallback to general min/max if needed
@@ -229,16 +221,14 @@ class LabValue(models.Model):
         if min_value is None:
             context_parts = []
             if gender_dependent:
-                gender_repr = (gender.name if gender and hasattr(gender, 'name') else 'None')
+                gender_repr = gender.name if gender and hasattr(gender, "name") else "None"
                 if gender_name_to_use and gender_name_to_use != gender_repr:
                     gender_repr = f"{gender_repr} (lookup attempted for: {gender_name_to_use})"
                 context_parts.append(f"gender: {gender_repr}")
             if age_dependent:
                 context_parts.append(f"age: {age}")
 
-            warning_message = (
-                f"Could not determine a 'min' normal range for LabValue '{self.name}'"
-            )
+            warning_message = f"Could not determine a 'min' normal range for LabValue '{self.name}'"
             if context_parts:
                 warning_message += f" with context ({', '.join(context_parts)})."
             else:
@@ -248,7 +238,7 @@ class LabValue(models.Model):
 
         return {"min": min_value, "max": max_value}
 
-    def get_increased_value(self, patient: "Patient" = None):
+    def get_increased_value(self, patient: Optional["Patient"] = None):  # -> Any | None:
         """
         Returns a value that is considered increased for this lab value.
         It prioritizes sampling from a numerical distribution if available,
@@ -263,19 +253,17 @@ class LabValue(models.Model):
             if patient:
                 # Attempt to sample above the upper bound, or a high value if no bound
                 for _ in range(10):  # Try a few times to get a value if bounds are restrictive
-                    generated_value = self.default_numerical_value_distribution.generate_value(
-                        lab_value=self, patient=patient
-                    )
+                    generated_value = self.default_numerical_value_distribution.generate_value(lab_value=self, patient=patient)
                     if upper_bound is not None:
                         if generated_value > upper_bound:
                             return generated_value
                     # Heuristic for "high" if no upper_bound, compare against mean + stddev
-                    elif hasattr(self.default_numerical_value_distribution, "mean") and \
-                            hasattr(self.default_numerical_value_distribution, "stddev") and \
-                            self.default_numerical_value_distribution.mean is not None and \
-                            self.default_numerical_value_distribution.stddev is not None and \
-                            generated_value > (
-                            self.default_numerical_value_distribution.mean + self.default_numerical_value_distribution.stddev
+                    elif (
+                        hasattr(self.default_numerical_value_distribution, "mean")
+                        and hasattr(self.default_numerical_value_distribution, "stddev")
+                        and self.default_numerical_value_distribution.mean is not None
+                        and self.default_numerical_value_distribution.stddev is not None
+                        and generated_value > (self.default_numerical_value_distribution.mean + self.default_numerical_value_distribution.stddev)
                     ):
                         return generated_value
                 # Fallback if sampling fails to produce a clearly increased value
@@ -290,23 +278,19 @@ class LabValue(models.Model):
                 if upper_bound is not None:
                     return upper_bound + (abs(upper_bound * self.bound_adjustment_factor) if upper_bound != 0 else 1)
                 else:
-                    warnings.warn(
-                        f"Cannot determine an increased value for {self.name} without an upper normal range or patient context for distribution."
-                    )
+                    warnings.warn(f"Cannot determine an increased value for {self.name} without an upper normal range or patient context for distribution.")
                     return None
 
         elif upper_bound is not None:
             return upper_bound + (abs(upper_bound * self.bound_adjustment_factor) if upper_bound != 0 else 1)
         else:
-            warnings.warn(
-                f"Cannot determine an increased value for {self.name} without a numerical distribution or an upper normal range."
-            )
+            warnings.warn(f"Cannot determine an increased value for {self.name} without a numerical distribution or an upper normal range.")
             return None
 
-    def get_normal_value(self, patient: "Patient" = None):
+    def get_normal_value(self, patient: Optional["Patient"] = None):
         """
         Returns a value considered normal for this lab value.
-        
+
         If a numerical distribution and patient context are available, attempts to generate a value within the normal range. Falls back to the midpoint of the normal range or to available bounds if sampling fails or context is insufficient. Returns None if neither a normal range nor a distribution is available.
         """
         _age = patient.age() if patient else None
@@ -318,9 +302,7 @@ class LabValue(models.Model):
         if self.default_numerical_value_distribution:
             if patient:
                 for _ in range(10):  # Try a few times
-                    generated_value = self.default_numerical_value_distribution.generate_value(
-                        lab_value=self, patient=patient
-                    )
+                    generated_value = self.default_numerical_value_distribution.generate_value(lab_value=self, patient=patient)
                     if lower_bound is not None and upper_bound is not None:
                         if lower_bound <= generated_value <= upper_bound:
                             return generated_value
@@ -346,10 +328,7 @@ class LabValue(models.Model):
                 elif upper_bound is not None:
                     return upper_bound
                 else:
-                    warnings.warn(
-                        f"Cannot determine a normal value for {self.name} without a normal range or patient context for distribution.",
-                        UserWarning
-                    )
+                    warnings.warn(f"Cannot determine a normal value for {self.name} without a normal range or patient context for distribution.", UserWarning)
                     return None
 
         elif lower_bound is not None and upper_bound is not None:
@@ -359,12 +338,10 @@ class LabValue(models.Model):
         elif upper_bound is not None:  # Only max is defined
             return upper_bound
         else:
-            warnings.warn(
-                f"Cannot determine a normal value for {self.name} without a numerical distribution or a normal range."
-            )
+            warnings.warn(f"Cannot determine a normal value for {self.name} without a numerical distribution or a normal range.")
             return None
 
-    def get_decreased_value(self, patient: "Patient" = None):
+    def get_decreased_value(self, patient: Optional["Patient"] = None):
         """
         Returns a value that is considered decreased for this lab value.
         It prioritizes sampling from a numerical distribution if available,
@@ -378,19 +355,17 @@ class LabValue(models.Model):
         if self.default_numerical_value_distribution:
             if patient:
                 for _ in range(10):  # Try a few times
-                    generated_value = self.default_numerical_value_distribution.generate_value(
-                        lab_value=self, patient=patient
-                    )
+                    generated_value = self.default_numerical_value_distribution.generate_value(lab_value=self, patient=patient)
                     if lower_bound is not None:
                         if generated_value < lower_bound:
                             return generated_value
                     # Heuristic for "low" if no lower_bound, compare against mean - stddev
-                    elif hasattr(self.default_numerical_value_distribution, "mean") and \
-                            hasattr(self.default_numerical_value_distribution, "stddev") and \
-                            self.default_numerical_value_distribution.mean is not None and \
-                            self.default_numerical_value_distribution.stddev is not None and \
-                            generated_value < (
-                            self.default_numerical_value_distribution.mean - self.default_numerical_value_distribution.stddev
+                    elif (
+                        hasattr(self.default_numerical_value_distribution, "mean")
+                        and hasattr(self.default_numerical_value_distribution, "stddev")
+                        and self.default_numerical_value_distribution.mean is not None
+                        and self.default_numerical_value_distribution.stddev is not None
+                        and generated_value < (self.default_numerical_value_distribution.mean - self.default_numerical_value_distribution.stddev)
                     ):
                         return generated_value
                 # Fallback
@@ -405,15 +380,11 @@ class LabValue(models.Model):
                 if lower_bound is not None:
                     return lower_bound - (abs(lower_bound * self.bound_adjustment_factor) if lower_bound != 0 else 1)
                 else:
-                    warnings.warn(
-                        f"Cannot determine a decreased value for {self.name} without a lower normal range or patient context for distribution."
-                    )
+                    warnings.warn(f"Cannot determine a decreased value for {self.name} without a lower normal range or patient context for distribution.")
                     return None
 
         elif lower_bound is not None:
             return lower_bound - (abs(lower_bound * self.bound_adjustment_factor) if lower_bound != 0 else 1)
         else:
-            warnings.warn(
-                f"Cannot determine a decreased value for {self.name} without a numerical distribution or a lower normal range."
-            )
+            warnings.warn(f"Cannot determine a decreased value for {self.name} without a numerical distribution or a lower normal range.")
             return None

endoreg_db/models/medical/medication/medication.py

@@ -1,31 +1,43 @@
-'''Model for the medication.'''
+"""Model for the medication."""
+
+from typing import TYPE_CHECKING
+
 from django.db import models
 
 
 class MedicationManager(models.Manager):
-    '''Manager for the medication model.'''
+    """Manager for the medication model."""
+
     def get_by_natural_key(self, name):
-        '''Retrieve a medication by its natural key.'''
+        """Retrieve a medication by its natural key."""
         return self.get(name=name)
 
+
 class Medication(models.Model):
-    '''Model representing a medication.'''
-    name = models.CharField(max_length=255, unique=True) 
-    adapt_to_renal_function = models.BooleanField(default = False)
+    """Model representing a medication."""
+
+    name = models.CharField(max_length=255, unique=True)
+    adapt_to_renal_function = models.BooleanField(default=False)
     adapt_to_hepatic_function = models.BooleanField(default=False)
     adapt_to_indication = models.BooleanField(default=False)
     adapt_to_age = models.BooleanField(default=False)
     adapt_to_weight = models.BooleanField(default=False)
     adapt_to_risk = models.BooleanField(default=False)
-    default_unit = models.ForeignKey('Unit', on_delete=models.CASCADE)
-
+    default_unit = models.ForeignKey("Unit", on_delete=models.CASCADE)
 
     objects = MedicationManager()
 
+    if TYPE_CHECKING:
+        from endoreg_db.models import MedicationSchedule, Unit
+
+        default_unit: models.ForeignKey["Unit"]
+
+        @property
+        def medication_schedules(self) -> "models.manager.RelatedManager[MedicationSchedule]": ...
+
     def natural_key(self):
-        '''Return the natural key for the medication.'''
+        """Return the natural key for the medication."""
         return (self.name,)
 
     def __str__(self):
         return str(self.name)
-    

endoreg_db/models/medical/medication/medication_indication.py

@@ -1,5 +1,7 @@
 """Model for medication indication."""
 
+from typing import TYPE_CHECKING, cast
+
 from django.db import models
 
 
@@ -25,11 +27,35 @@ class MedicationIndication(models.Model):
     )
     diseases = models.ManyToManyField("Disease")
     events = models.ManyToManyField("Event")
-    disease_classification_choices = models.ManyToManyField(
-        "DiseaseClassificationChoice"
-    )
+    disease_classification_choices = models.ManyToManyField("DiseaseClassificationChoice")
     sources = models.ManyToManyField("InformationSource")
 
+    if TYPE_CHECKING:
+        from endoreg_db.models import (
+            Disease,
+            DiseaseClassificationChoice,
+            Event,
+            InformationSource,
+            MedicationIndicationType,
+            MedicationSchedule,
+        )
+
+        indication_type: models.ForeignKey["MedicationIndicationType"]
+        medication_schedules = cast(
+            "models.manager.RelatedManager[MedicationSchedule]",
+            medication_schedules,
+        )
+        diseases = cast("models.manager.RelatedManager[Disease]", diseases)
+        events = cast("models.manager.RelatedManager[Event]", events)
+        disease_classification_choices = cast(
+            "models.manager.RelatedManager[DiseaseClassificationChoice]",
+            disease_classification_choices,
+        )
+        sources = cast(
+            "models.manager.RelatedManager[InformationSource]",
+            sources,
+        )
+
     def get_indication_links(self) -> dict:
         """Return a dictionary of all linked objects for this medication indication."""
         links = {