endoreg-db 0.8.9.2__py3-none-any.whl → 0.8.9.10__py3-none-any.whl

endoreg_db/models/medical/examination/examination_indication.py

@@ -1,9 +1,14 @@
-from typing import TYPE_CHECKING, List, Optional, cast
+from typing import TYPE_CHECKING, cast
 
 from django.db import models
 
 if TYPE_CHECKING:
-    from endoreg_db.models import Examination, FindingIntervention, InformationSource, Requirement
+    from endoreg_db.models import (
+        Examination,
+        FindingIntervention,
+        InformationSource,
+        Requirement,
+    )
     from endoreg_db.utils.links.requirement_link import RequirementLinks
 
 
@@ -60,12 +65,21 @@ class ExaminationIndication(models.Model):
     objects = ExaminationIndicationManager()
 
     if TYPE_CHECKING:
-        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)
+        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]": ...
+        def related_requirements(
+            self,
+        ) -> "models.manager.RelatedManager[Requirement]": ...
 
         @property
         def examinations(self) -> "models.manager.RelatedManager[Examination]": ...
@@ -164,7 +178,9 @@ 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.
 

endoreg_db/models/medical/examination/examination_time.py

@@ -37,8 +37,12 @@ class ExaminationTime(models.Model):
     )
 
     if TYPE_CHECKING:
-        time_types = cast(models.manager.RelatedManager["ExaminationTimeType"], time_types)
-        information_sources = cast(models.manager.RelatedManager["InformationSource"], information_sources)
+        time_types = cast(
+            models.manager.RelatedManager["ExaminationTimeType"], time_types
+        )
+        information_sources = cast(
+            models.manager.RelatedManager["InformationSource"], information_sources
+        )
 
     def __str__(self) -> str:
         """

endoreg_db/models/medical/finding/__init__.py

@@ -2,7 +2,9 @@ from .finding import Finding
 from .finding_type import FindingType
 
 from .finding_classification import (
-    FindingClassificationType, FindingClassification, FindingClassificationChoice,
+    FindingClassificationType,
+    FindingClassification,
+    FindingClassificationChoice,
 )
 
 from .finding_intervention import FindingIntervention, FindingInterventionType

endoreg_db/models/medical/finding/finding.py

@@ -12,11 +12,21 @@ class FindingManager(models.Manager):
 class Finding(models.Model):
     name = models.CharField(max_length=100, unique=True)
     description = models.TextField(blank=True, null=True)
-    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")
+    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:
@@ -30,9 +40,16 @@ class Finding(models.Model):
             PatientFindingClassification,
         )
 
-        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)
+        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):
         """
@@ -55,7 +72,9 @@ class Finding(models.Model):
         """
         return self.finding_types.all()
 
-    def get_classifications(self, classification_type: Optional[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.
 
@@ -66,7 +85,9 @@ class Finding(models.Model):
                 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.filter(
+                classification_types__name=classification_type
+            )
         return self.finding_classifications.all()
 
     def get_location_classifications(self):
@@ -76,7 +97,9 @@ class Finding(models.Model):
         Returns:
             QuerySet: All FindingClassification instances linked to this finding where the classification type name is 'location' (case-insensitive).
         """
-        return self.finding_classifications.filter(classification_types__name__iexact="location")
+        return self.finding_classifications.filter(
+            classification_types__name__iexact="location"
+        )
 
     def get_morphology_classifications(self):
         """
@@ -85,4 +108,6 @@ class Finding(models.Model):
         Returns:
             QuerySet: A queryset of FindingClassification instances associated with this finding and classified as 'morphology'.
         """
-        return self.finding_classifications.filter(classification_types__name__iexact="morphology")
+        return self.finding_classifications.filter(
+            classification_types__name__iexact="morphology"
+        )

endoreg_db/models/medical/finding/finding_classification.py

@@ -28,8 +28,12 @@ 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)
+    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,
@@ -50,12 +54,27 @@ class FindingClassification(models.Model):
     objects = FindingClassificationManager()
 
     if TYPE_CHECKING:
-        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)
+        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]": ...

endoreg_db/models/medical/finding/finding_intervention.py

@@ -11,7 +11,9 @@ class FindingInterventionManager(models.Manager):
 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"
+    )
     information_sources = models.ManyToManyField(
         "InformationSource",
         related_name="finding_interventions",
@@ -20,10 +22,19 @@ class FindingIntervention(models.Model):
     objects = FindingInterventionManager()
 
     if TYPE_CHECKING:
-        from endoreg_db.models import Contraindication, FindingInterventionType, InformationSource, LabValue
-
-        intervention_types = cast(models.manager.RelatedManager["FindingInterventionType"], intervention_types)
-        information_sources = cast(models.manager.RelatedManager["InformationSource"], information_sources)
+        from endoreg_db.models import (
+            Contraindication,
+            FindingInterventionType,
+            InformationSource,
+            LabValue,
+        )
+
+        intervention_types = cast(
+            models.manager.RelatedManager["FindingInterventionType"], intervention_types
+        )
+        information_sources = cast(
+            models.manager.RelatedManager["InformationSource"], information_sources
+        )
 
     def natural_key(self):
         return (self.name,)
@@ -46,7 +57,9 @@ class FindingInterventionType(models.Model):
     if TYPE_CHECKING:
 
         @property
-        def interventions(self) -> "models.manager.RelatedManager[FindingIntervention]": ...
+        def interventions(
+            self,
+        ) -> "models.manager.RelatedManager[FindingIntervention]": ...
 
     def natural_key(self):
         return (self.name,)

endoreg_db/models/medical/finding/finding_type.py

@@ -27,7 +27,9 @@ class FindingType(models.Model):
         from endoreg_db.models import Examination, Finding, FindingClassification
 
         @property
-        def finding_classifications(self) -> "models.manager.RelatedManager[FindingClassification]": ...
+        def finding_classifications(
+            self,
+        ) -> "models.manager.RelatedManager[FindingClassification]": ...
 
     def natural_key(self):
         return (self.name,)

endoreg_db/models/medical/hardware/__init__.py

@@ -5,4 +5,4 @@ __all__ = [
     "Endoscope",
     "EndoscopeType",
     "EndoscopyProcessor",
-]
+]

endoreg_db/models/medical/hardware/endoscope.py

@@ -13,8 +13,20 @@ class Endoscope(models.Model):
 
     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 import Center

endoreg_db/models/medical/laboratory/__init__.py

@@ -2,4 +2,4 @@ from .lab_value import LabValue
 
 __all__ = [
     "LabValue",
-]
+]

endoreg_db/models/medical/laboratory/lab_value.py

@@ -56,7 +56,9 @@ class LabValueManager(models.Manager):
 class LabValue(models.Model):
     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,15 +93,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: 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_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
@@ -158,7 +167,9 @@ class LabValue(models.Model):
             warnings.warn("No default distribution set for lab value")
             return None
 
-    def get_normal_range(self, age: Optional[int] = None, gender: Optional["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.
 
@@ -183,11 +194,15 @@ class LabValue(models.Model):
                 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}'. 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
@@ -202,17 +217,23 @@ class LabValue(models.Model):
                 )
 
         # Fallback to general min/max if needed
-        if (min_value is None or max_value is None) and isinstance(current_range_source, dict):
+        if (min_value is None or max_value is None) and isinstance(
+            current_range_source, dict
+        ):
             if min_value is None:
                 min_value = current_range_source.get("min")
             if max_value is None:
                 max_value = current_range_source.get("max")
 
         if age_dependent:
-            warnings.warn(f"Age dependent normal range not implemented yet for LabValue '{self.name}'. Age: {age}.")
+            warnings.warn(
+                f"Age dependent normal range not implemented yet for LabValue '{self.name}'. Age: {age}."
+            )
 
         if special_case:
-            warnings.warn(f"Special case normal range not implemented yet for LabValue '{self.name}'.")
+            warnings.warn(
+                f"Special case normal range not implemented yet for LabValue '{self.name}'."
+            )
 
         # Final contextual warning
         if min_value is None and max_value is None:
@@ -221,14 +242,20 @@ 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})"
+                    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:
@@ -238,7 +265,9 @@ class LabValue(models.Model):
 
         return {"min": min_value, "max": max_value}
 
-    def get_increased_value(self, patient: Optional["Patient"] = None):  # -> Any | 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,
@@ -252,8 +281,14 @@ class LabValue(models.Model):
         if self.default_numerical_value_distribution:
             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)
+                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
+                        )
+                    )
                     if upper_bound is not None:
                         if generated_value > upper_bound:
                             return generated_value
@@ -263,28 +298,50 @@ class LabValue(models.Model):
                         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)
+                        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
                 if upper_bound is not None:
-                    return upper_bound + (abs(upper_bound * self.bound_adjustment_factor) if upper_bound != 0 else 1)  # Increase by factor or 1
+                    return upper_bound + (
+                        abs(upper_bound * self.bound_adjustment_factor)
+                        if upper_bound != 0
+                        else 1
+                    )  # Increase by factor or 1
                 # If no upper bound and sampling didn't provide a clear high value, return a generated value as last resort
-                return self.default_numerical_value_distribution.generate_value(lab_value=self, patient=patient)
+                return self.default_numerical_value_distribution.generate_value(
+                    lab_value=self, patient=patient
+                )
             else:  # No patient, cannot use distribution
                 warnings.warn(
                     f"Cannot use numerical distribution for {self.name} without patient context. Falling back to normal range logic for increased value."
                 )
                 if upper_bound is not None:
-                    return upper_bound + (abs(upper_bound * self.bound_adjustment_factor) if upper_bound != 0 else 1)
+                    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)
+            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: Optional["Patient"] = None):
@@ -302,21 +359,33 @@ 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
-                    elif lower_bound is not None and generated_value >= lower_bound:  # No upper bound
+                    elif (
+                        lower_bound is not None and generated_value >= lower_bound
+                    ):  # No upper bound
                         return generated_value
-                    elif upper_bound is not None and generated_value <= upper_bound:  # No lower bound
+                    elif (
+                        upper_bound is not None and generated_value <= upper_bound
+                    ):  # No lower bound
                         return generated_value
-                    elif lower_bound is None and upper_bound is None:  # No range defined
+                    elif (
+                        lower_bound is None and upper_bound is None
+                    ):  # No range defined
                         return generated_value
                 # Fallback if sampling fails to produce a value in range
                 if lower_bound is not None and upper_bound is not None:
                     return (lower_bound + upper_bound) / 2.0
                 # Return any generated value as last resort
-                return self.default_numerical_value_distribution.generate_value(lab_value=self, patient=patient)
+                return self.default_numerical_value_distribution.generate_value(
+                    lab_value=self, patient=patient
+                )
             else:  # No patient, cannot use distribution
                 warnings.warn(
                     f"Cannot use numerical distribution for {self.name} without patient context. Falling back to normal range logic for normal value."
@@ -328,7 +397,10 @@ 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:
@@ -338,7 +410,9 @@ 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: Optional["Patient"] = None):
@@ -355,7 +429,11 @@ 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
@@ -365,26 +443,48 @@ class LabValue(models.Model):
                         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)
+                        and generated_value
+                        < (
+                            self.default_numerical_value_distribution.mean
+                            - self.default_numerical_value_distribution.stddev
+                        )
                     ):
                         return generated_value
                 # Fallback
                 if lower_bound is not None:
-                    return lower_bound - (abs(lower_bound * self.bound_adjustment_factor) if lower_bound != 0 else 1)  # Decrease by factor or 1
+                    return lower_bound - (
+                        abs(lower_bound * self.bound_adjustment_factor)
+                        if lower_bound != 0
+                        else 1
+                    )  # Decrease by factor or 1
                 # Return any generated value as last resort
-                return self.default_numerical_value_distribution.generate_value(lab_value=self, patient=patient)
+                return self.default_numerical_value_distribution.generate_value(
+                    lab_value=self, patient=patient
+                )
             else:  # No patient, cannot use distribution
                 warnings.warn(
                     f"Cannot use numerical distribution for {self.name} without patient context. Falling back to normal range logic for decreased value."
                 )
                 if lower_bound is not None:
-                    return lower_bound - (abs(lower_bound * self.bound_adjustment_factor) if lower_bound != 0 else 1)
+                    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)
+            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