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

endoreg_db/models/other/distribution/numeric_value_distribution.py

@@ -1,52 +1,87 @@
-'''Model for numeric value distribution'''
+"""Model for numeric value distribution"""
 
-from django.db import models
 import numpy as np
-from .base_value_distribution import BaseValueDistribution
+from django.db import models
 from scipy.stats import skewnorm
+from typing import TYPE_CHECKING
+
+from .base_value_distribution import BaseValueDistribution
+
+if TYPE_CHECKING:
+    from endoreg_db.models import LabValue, Patient
 
 
 class NumericValueDistributionManager(models.Manager):
-    '''Object manager for NumericValueDistribution'''
+    """Object manager for NumericValueDistribution"""
+
     def get_by_natural_key(self, name):
-        '''Retrieve a NumericValueDistribution by its natural key.'''
+        """Retrieve a NumericValueDistribution by its natural key."""
         return self.get(name=name)
 
+
 class NumericValueDistribution(BaseValueDistribution):
     """
     Numeric value distribution model.
     Supports uniform, normal, and skewed normal distributions with hard limits.
     """
+
     objects = NumericValueDistributionManager()
     DISTRIBUTION_CHOICES = [
-        ('uniform', 'Uniform'),
-        ('normal', 'Normal'),
-        ('skewed_normal', 'Skewed Normal'),
+        ("uniform", "Uniform"),
+        ("normal", "Normal"),
+        ("skewed_normal", "Skewed Normal"),
     ]
 
     distribution_type = models.CharField(max_length=20, choices=DISTRIBUTION_CHOICES)
-    min_descriptor = models.CharField(
-        max_length=20
-    )
-
-    max_descriptor = models.CharField(
-        max_length=20
-    )
-
-    def generate_value(self, lab_value, patient):
-        '''Generate a value based on the distribution rules.'''
-        #FIXME
-        from endoreg_db.models import LabValue, Patient
-        assert isinstance(patient, Patient)
-        assert isinstance(lab_value, LabValue)
-        default_normal_range_dict = lab_value.get_normal_range(patient.age(), patient.gender)
+    min_descriptor = models.CharField(max_length=20)
+    max_descriptor = models.CharField(max_length=20)
+    min_value = models.FloatField(blank=True, null=True, help_text="Lower hard limit for generated values")
+    max_value = models.FloatField(blank=True, null=True, help_text="Upper hard limit for generated values")
+    mean = models.FloatField(blank=True, null=True, help_text="Mean used for normal or skewed normal distributions")
+    std_dev = models.FloatField(blank=True, null=True, help_text="Standard deviation for bell-shaped distributions")
+    skewness = models.FloatField(blank=True, null=True, help_text="Shape parameter for skewed normal distributions")
+
+    @property
+    def min_value_safe(self):
+        if self.min_value is None:
+            raise ValueError("min_value is not set")
+        return self.min_value
+
+    @property
+    def max_value_safe(self):
+        if self.max_value is None:
+            raise ValueError("max_value is not set")
+        return self.max_value
+
+    @property
+    def mean_safe(self):
+        if self.mean is None:
+            raise ValueError("mean is not set")
+        return self.mean
+
+    @property
+    def std_dev_safe(self):
+        if self.std_dev is None:
+            raise ValueError("std_dev is not set")
+        return self.std_dev
+
+    @property
+    def skewness_safe(self):
+        if self.skewness is None:
+            raise ValueError("skewness is not set")
+        return self.skewness
+
+    def generate_value(self, lab_value: "LabValue", patient: "Patient"):
+        """Generate a value based on the distribution rules."""
+
+        default_normal_range_dict = lab_value.get_normal_range(patient.age_safe, patient.gender)
         assert isinstance(default_normal_range_dict, dict)
 
-        if self.distribution_type == 'uniform':
+        if self.distribution_type == "uniform":
             assert self.min_descriptor and self.max_descriptor
-            
-            min_key_needed = self.min_descriptor.split('_')[0]
-            max_key_needed = self.max_descriptor.split('_')[0]
+
+            min_key_needed = self.min_descriptor.split("_")[0]
+            max_key_needed = self.max_descriptor.split("_")[0]
 
             min_val_from_range = default_normal_range_dict.get(min_key_needed)
             max_val_from_range = default_normal_range_dict.get(max_key_needed)
@@ -61,7 +96,7 @@ class NumericValueDistribution(BaseValueDistribution):
                     f"LabValue '{lab_value.name}' is gender-dependent: {lab_value.normal_range_gender_dependent}. "
                     f"Check LabValue's default_normal_range definition for this patient context."
                 )
-            
+
             if max_val_from_range is None:
                 raise ValueError(
                     f"Cannot generate value for LabValue '{lab_value.name}' using distribution "
@@ -72,22 +107,29 @@ class NumericValueDistribution(BaseValueDistribution):
                     f"LabValue '{lab_value.name}' is gender-dependent: {lab_value.normal_range_gender_dependent}. "
                     f"Check LabValue's default_normal_range definition for this patient context."
                 )
-            
+
             value = self._generate_value_uniform(default_normal_range_dict)
-            
+
             return value
-        
-        elif self.distribution_type == 'normal':
+
+        elif self.distribution_type == "normal":
+            self._validate_normal_parameters()
+            assert self.mean is not None
+            assert self.std_dev is not None
             value = np.random.normal(self.mean, self.std_dev)
-            return np.clip(value, self.min_value, self.max_value)
-        elif self.distribution_type == 'skewed_normal':
+            return self._clip_to_bounds(value)
+        elif self.distribution_type == "skewed_normal":
+            self._validate_skewed_normal_parameters()
+            assert self.mean is not None
+            assert self.std_dev is not None
+            assert self.skewness is not None
             value = skewnorm.rvs(a=self.skewness, loc=self.mean, scale=self.std_dev)
-            return np.clip(value, self.min_value, self.max_value)
+            return self._clip_to_bounds(value)
         else:
             raise ValueError("Unsupported distribution type")
 
-    def parse_value_descriptor(self, value_descriptor:str):
-        '''Parse the value descriptor string into a dict with a lambda function.'''
+    def parse_value_descriptor(self, value_descriptor: str):
+        """Parse the value descriptor string into a dict with a lambda function."""
         # strings of shape f"{value_key}_{operator}_{value}"
         # extract value_key, operator, value
         value_key, operator, value = value_descriptor.split("_")
@@ -104,22 +146,41 @@ class NumericValueDistribution(BaseValueDistribution):
 
         # create dict with {value_key: lambda x: x operator value}
 
-    def _generate_value_uniform(self, default_normal_range_dict:dict):
-        value_function_dict = self.parse_value_descriptor(
-            self.min_descriptor
-        )
+    def _generate_value_uniform(self, default_normal_range_dict: dict):
+        value_function_dict = self.parse_value_descriptor(self.min_descriptor)
+        value_function_dict.update(self.parse_value_descriptor(self.max_descriptor))
 
-        _ = self.parse_value_descriptor(
-            self.max_descriptor
-        )
-
-        value_function_dict.update(_)
-
-        result_dict = {
-            key: value_function(default_normal_range_dict[key]) 
-            for key, value_function in value_function_dict.items()
-        }
+        result_dict = {key: value_function(default_normal_range_dict[key]) for key, value_function in value_function_dict.items()}
 
         # generate value
-        return np.random.uniform(result_dict["min"], result_dict["max"])
-
+        return float(np.random.uniform(result_dict["min"], result_dict["max"]))
+
+    @property
+    def stddev(self):
+        """Alias to std_dev for backwards compatibility."""
+        return self.std_dev
+
+    @stddev.setter
+    def stddev(self, value):
+        self.std_dev = value
+
+    def _clip_to_bounds(self, value: float) -> float:
+        """Clip the provided value to the configured hard bounds if available."""
+        lower = self.min_value
+        upper = self.max_value
+
+        if lower is not None and upper is not None:
+            return float(np.clip(value, lower, upper))
+        if lower is not None:
+            return float(max(value, lower))
+        if upper is not None:
+            return float(min(value, upper))
+        return float(value)
+
+    def _validate_normal_parameters(self) -> None:
+        if self.mean is None or self.std_dev is None:
+            raise ValueError(f"Normal distribution '{getattr(self, 'name', self.pk)}' requires both mean and std_dev.")
+
+    def _validate_skewed_normal_parameters(self) -> None:
+        if self.mean is None or self.std_dev is None or self.skewness is None:
+            raise ValueError(f"Skewed normal distribution '{getattr(self, 'name', self.pk)}' requires mean, std_dev, and skewness.")

endoreg_db/models/other/distribution/single_categorical_value_distribution.py

@@ -1,5 +1,6 @@
-from django.db import models
 import numpy as np
+from django.db import models
+
 from .base_value_distribution import BaseValueDistribution
 
 
@@ -7,16 +8,16 @@ class SingleCategoricalValueDistributionManager(models.Manager):
     def get_by_natural_key(self, name):
         return self.get(name=name)
 
+
 class SingleCategoricalValueDistribution(BaseValueDistribution):
     """
     Single categorical value distribution model.
     Assigns a single value based on specified probabilities.
     """
+
     objects = SingleCategoricalValueDistributionManager()
     categories = models.JSONField()  # { "category": "probability", ... }
 
     def generate_value(self):
         categories, probabilities = zip(*self.categories.items())
         return np.random.choice(categories, p=probabilities)
-    
-

endoreg_db/models/other/emission/emission_factor.py

@@ -1,21 +1,26 @@
-from django.db import models
 from typing import TYPE_CHECKING, List
 
+from django.db import models
+
 if TYPE_CHECKING:
     from ...administration import ReferenceProduct
     from ..unit import Unit
 
+
 class EmissionFactorManager(models.Manager):
     """
     Manager for EmissionFactor with custom query methods.
     """
+
     def get_by_natural_key(self, name: str) -> "EmissionFactor":
         return self.get(name=name)
 
+
 # get debug from settings
 # from django.conf import settings
 # DEBUG = settings.DEBUG
 
+
 class EmissionFactor(models.Model):
     """
     Represents an emission factor with associated unit and value.
@@ -25,6 +30,7 @@ class EmissionFactor(models.Model):
         unit (ForeignKey): The unit associated with the emission factor.
         value (float): The value of the emission factor.
     """
+
     objects = EmissionFactorManager()
 
     name = models.CharField(max_length=255)
@@ -32,13 +38,17 @@ class EmissionFactor(models.Model):
     value = models.FloatField()
 
     if TYPE_CHECKING:
-        unit: "Unit"
-        reference_products: models.QuerySet["ReferenceProduct"]
-        reference_product_package: models.QuerySet["ReferenceProduct"]
-        reference_product_product: models.QuerySet["ReferenceProduct"]
+        unit: models.ForeignKey["Unit|None"]
+
+        @property
+        def reference_products(self) -> models.QuerySet["ReferenceProduct"]: ...
+
+        @property
+        def reference_product_package(self) -> models.QuerySet["ReferenceProduct"]: ...
+
+        @property
+        def reference_product_product(self) -> models.QuerySet["ReferenceProduct"]: ...
 
-        
-    
     def natural_key(self) -> tuple:
         """
         Returns the natural key for the emission factor.
@@ -65,7 +75,7 @@ class EmissionFactor(models.Model):
                 result += f"\n\t\t{source}"
 
         return result
-    
+
     def get_reference_products(self) -> List["ReferenceProduct"]:
         """
         Retrieves all reference products associated with the emission factor.

endoreg_db/models/other/gender.py

@@ -1,15 +1,19 @@
-from django.db import models
 from typing import TYPE_CHECKING
 
+from django.db import models
+
 if TYPE_CHECKING:
     from ..administration import Patient
 
+
 class GenderManager(models.Manager):
     def get_by_natural_key(self, name):
         return self.get(name=name)
-    
+
+
 class Gender(models.Model):
     """A class representing gender."""
+
     objects = GenderManager()
 
     name = models.CharField(max_length=255)
@@ -17,11 +21,12 @@ class Gender(models.Model):
     description = models.TextField(blank=True, null=True)
 
     if TYPE_CHECKING:
-        patients: models.QuerySet["Patient"]
+
+        @property
+        def patients(self) -> models.QuerySet["Patient"]: ...
 
     def natural_key(self):
         return (self.name,)
-    
+
     def __str__(self):
         return str(self.name)
-

endoreg_db/models/other/information_source.py

@@ -1,12 +1,12 @@
-from django.db import models
 from typing import TYPE_CHECKING
-if TYPE_CHECKING:
-    from endoreg_db.models import InformationSourceType
+
+from django.db import models
+
 
 def get_prediction_information_source():
     """
     Returns the InformationSource instance with the name "prediction".
-    
+
     Raises:
         AssertionError: If no InformationSource with the name "prediction" exists.
     """
@@ -21,10 +21,10 @@ class InformationSourceManager(models.Manager):
     def get_by_natural_key(self, name):
         """
         Retrieves a model instance using its natural key.
-        
+
         Args:
             name: The natural key value corresponding to the model's 'name' field.
-        
+
         Returns:
             The model instance that matches the provided natural key.
         """
@@ -42,11 +42,36 @@ class InformationSource(models.Model):
     date_created = models.DateField(auto_now_add=True)
     date_modified = models.DateField(auto_now=True)
     abbreviation = models.CharField(max_length=100, blank=True, null=True, unique=True)
-    
+
     if TYPE_CHECKING:
-        #information_source_types: models.QuerySet["InformationSourceType"]
-        # Avoid self-referential import; use forward references instead
-        pass
+        from endoreg_db.models import (
+            Examination,
+            ExaminationIndication,
+            ExaminationTime,
+            Finding,
+            FindingClassification,
+            FindingIntervention,
+            InformationSourceType,
+        )
+
+        @property
+        def examinations(self) -> "models.manager.RelatedManager[Examination]": ...
+
+        @property
+        def examination_indications(self) -> "models.manager.RelatedManager[ExaminationIndication]": ...
+
+        @property
+        def examination_times(self) -> "models.manager.RelatedManager[ExaminationTime]": ...
+
+        @property
+        def findings(self) -> "models.manager.RelatedManager[Finding]": ...
+
+        @property
+        def finding_interventions(self) -> "models.manager.RelatedManager[FindingIntervention]": ...
+
+        @property
+        def finding_classifications(self) -> "models.manager.RelatedManager[FindingClassification]": ...
+
     class Meta:
         verbose_name = "Information Source"
         verbose_name_plural = "Information Sources"
@@ -55,14 +80,13 @@ class InformationSource(models.Model):
         indexes = [
             models.Index(fields=["name"]),
             models.Index(fields=["abbreviation"]),
-        ] 
-
+        ]
 
     def natural_key(self):
         """
         Returns the natural key tuple for the information source.
-        
-        The tuple contains the object's name, which uniquely identifies it for 
+
+        The tuple contains the object's name, which uniquely identifies it for
         serialization and natural key lookup.
         """
         return (self.name,)
@@ -73,19 +97,21 @@ class InformationSource(models.Model):
         """
         return str(self.name)
 
+
 class InformationSourceTypeManager(models.Manager):
     def get_by_natural_key(self, name):
         """
         Retrieve an instance of the model by its natural key, which is the 'name' field.
-        
+
         Parameters:
             name (str): The value of the 'name' field to look up.
-        
+
         Returns:
             The model instance with the specified name.
         """
         return self.get(name=name)
-    
+
+
 class InformationSourceType(models.Model):
     objects = InformationSourceTypeManager()
 
@@ -108,10 +134,10 @@ class InformationSourceType(models.Model):
     def get_prediction_type(cls) -> "InformationSourceType":
         """
         Return the InformationSourceType instance with the name "prediction".
-        
+
         Returns:
             InformationSourceType: The instance representing the "prediction" information source type.
-        
+
         Raises:
             InformationSourceType.DoesNotExist: If no such instance exists.
 
@@ -119,20 +145,17 @@ class InformationSourceType(models.Model):
         try:
             return cls.objects.get(name="prediction")
         except cls.DoesNotExist as e:
-            raise cls.DoesNotExist(
-                "The 'prediction' InformationSourceType was not found. "
-                "Please check your data fixtures or initial data migrations."
-            ) from e
+            raise cls.DoesNotExist("The 'prediction' InformationSourceType was not found. Please check your data fixtures or initial data migrations.") from e
 
     @classmethod
     def get_manual_annotation_type(cls) -> "InformationSourceType":
         """
 
         Return the InformationSourceType instance representing manual annotation.
-        
+
         Returns:
             InformationSourceType: The instance with name "annotation".
-        
+
         Raises:
             AssertionError: If no InformationSourceType with name "annotation" exists.
 
@@ -141,11 +164,9 @@ class InformationSourceType(models.Model):
             return cls.objects.get(name="manual_annotation")
         except cls.DoesNotExist as e:
             raise cls.DoesNotExist(
-                "The 'manual_annotation' InformationSourceType was not found. "
-                "Please check your data fixtures or initial data migrations."
+                "The 'manual_annotation' InformationSourceType was not found. Please check your data fixtures or initial data migrations."
             ) from e
 
-
     def natural_key(self):
         """
         Return a tuple containing the name of the information source type for natural key serialization.
@@ -156,4 +177,4 @@ class InformationSourceType(models.Model):
         """
         Return the name of the InformationSourceType as its string representation.
         """
-        return str(self.name)
+        return str(self.name)

endoreg_db/models/other/material.py

@@ -1,15 +1,17 @@
-from django.db import models
 from typing import TYPE_CHECKING
 
+from django.db import models
 
 if TYPE_CHECKING:
-    from .emission import EmissionFactor
     from ..administration.product.product_material import ProductMaterial
+    from .emission import EmissionFactor
+
 
 class MaterialManager(models.Manager):
     def get_by_natural_key(self, name):
         return self.get(name=name)
 
+
 class Material(models.Model):
     objects = MaterialManager()
 
@@ -17,12 +19,14 @@ class Material(models.Model):
     emission_factor = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True)
 
     if TYPE_CHECKING:
-        emission_factor: "EmissionFactor"
-        material_product_materials: models.QuerySet["ProductMaterial"]
+        emission_factor: models.ForeignKey["EmissionFactor|None"]
+
+        @property
+        def material_product_materials(self) -> models.QuerySet["ProductMaterial"]: ...
 
     def natural_key(self):
         return (self.name,)
-    
+
     def __str__(self):
         result = f"{self.name} - EmissionFactor: {self.emission_factor}"
         return result

endoreg_db/models/other/resource.py

@@ -1,9 +1,11 @@
 from django.db import models
 
+
 class ResourceManager(models.Manager):
     def get_by_natural_key(self, name):
         return self.get(name=name)
-    
+
+
 class Resource(models.Model):
     objects = ResourceManager()
 
@@ -12,11 +14,11 @@ class Resource(models.Model):
     def natural_key(self):
         """
         Return a tuple representing the natural key for this resource instance.
-        
+
         Returns:
             tuple: A one-element tuple containing the resource's name.
         """
         return (self.name,)
-    
+
     def __str__(self):
-        return self.name
+        return self.name

endoreg_db/models/other/tag.py

@@ -1,20 +1,25 @@
-from django.db import models
 from typing import TYPE_CHECKING
 
+from django.db import models
+
 if TYPE_CHECKING:
     from endoreg_db.models import RequirementSet
 
+
 class TagManager(models.Manager):
     def get_by_natural_key(self, name):
         return self.get(name=name)
-    
+
+
 class Tag(models.Model):
     name = models.CharField(max_length=100, unique=True)
 
     objects = TagManager()
-    
+
     if TYPE_CHECKING:
-        requirement_sets: "models.ManyToManyField[RequirementSet]"
+
+        @property
+        def requirement_sets(self) -> "models.QuerySet[RequirementSet]": ...
 
     class Meta:
         verbose_name = "Tag"
@@ -24,4 +29,4 @@ class Tag(models.Model):
         return self.name
 
     def natural_key(self):
-        return (self.name,)
+        return (self.name,)

endoreg_db/models/other/transport_route.py

@@ -1,17 +1,20 @@
-from django.db import models
 from typing import TYPE_CHECKING
 
+from django.db import models
+
 if TYPE_CHECKING:
     from endoreg_db.models import (
-        Product,
         EmissionFactor,
+        Product,
         Unit,
     )
 
+
 class TransportRouteManager(models.Manager):
     def get_by_natural_key(self, name):
         return self.get(name=name)
-    
+
+
 class TransportRoute(models.Model):
     objects = TransportRouteManager()
 
@@ -21,13 +24,15 @@ class TransportRoute(models.Model):
     unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
 
     if TYPE_CHECKING:
-        emission_factor: "EmissionFactor"
-        unit: "Unit"
-        products: models.QuerySet["Product"]
+        emission_factor: models.ForeignKey["EmissionFactor|None"]
+        unit: models.ForeignKey["Unit|None"]
+
+        @property
+        def products(self) -> models.QuerySet["Product"]: ...
 
     def natural_key(self):
         return (self.name,)
-    
+
     def __str__(self):
         result = f"{self.name} ({self.distance} {self.unit}) - {self.emission_factor}"
-        return result
+        return result