endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/models/other/distribution/multiple_categorical_value_distribution.py

@@ -0,0 +1,50 @@
+import numpy as np
+from django.db import models
+
+from .base_value_distribution import BaseValueDistribution
+
+
+class MultipleCategoricalValueDistributionManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+
+class MultipleCategoricalValueDistribution(BaseValueDistribution):
+    """
+    Multiple categorical value distribution model.
+    Assigns a specific number or varying number of values based on probabilities.
+    """
+
+    objects = MultipleCategoricalValueDistributionManager()
+    categories = models.JSONField()  # { "category": "probability", ... }
+    min_count = models.IntegerField()
+    max_count = models.IntegerField()
+    count_distribution_type = models.CharField(
+        max_length=20, choices=[("uniform", "Uniform"), ("normal", "Normal")]
+    )
+    count_mean = models.FloatField(null=True, blank=True)
+    count_std_dev = models.FloatField(null=True, blank=True)
+
+    @property
+    def count_mean_safe(self):
+        if self.count_mean is None:
+            raise ValueError("count_mean is not set")
+        return self.count_mean
+
+    @property
+    def count_std_dev_safe(self):
+        if self.count_std_dev is None:
+            raise ValueError("count_std_dev is not set")
+        return self.count_std_dev
+
+    def generate_value(self):
+        if self.count_distribution_type == "uniform":
+            count = np.random.randint(self.min_count, self.max_count + 1)
+        elif self.count_distribution_type == "normal":
+            count = int(np.random.normal(self.count_mean_safe, self.count_std_dev_safe))
+            count = np.clip(count, self.min_count, self.max_count)
+        else:
+            raise ValueError("Unsupported count distribution type")
+
+        categories, probabilities = zip(*self.categories.items())
+        return list(np.random.choice(categories, size=count, p=probabilities))

endoreg_db/models/other/distribution/numeric_value_distribution.py

@@ -0,0 +1,211 @@
+"""Model for numeric value distribution"""
+
+import numpy as np
+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"""
+
+    def get_by_natural_key(self, name):
+        """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"),
+    ]
+
+    distribution_type = models.CharField(max_length=20, choices=DISTRIBUTION_CHOICES)
+    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":
+            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_val_from_range = default_normal_range_dict.get(min_key_needed)
+            max_val_from_range = default_normal_range_dict.get(max_key_needed)
+
+            if min_val_from_range is None:
+                raise ValueError(
+                    f"Cannot generate value for LabValue '{lab_value.name}' using distribution "
+                    f"'{getattr(self, 'name', self.pk)}'. "
+                    f"Required normal range component '{min_key_needed}' derived from min_descriptor "
+                    f"'{self.min_descriptor}' is None. "
+                    f"Patient context: age={patient.age()}, gender='{patient.gender.name if patient.gender else None}'. "
+                    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 "
+                    f"'{getattr(self, 'name', self.pk)}'. "
+                    f"Required normal range component '{max_key_needed}' derived from max_descriptor "
+                    f"'{self.max_descriptor}' is None. "
+                    f"Patient context: age={patient.age()}, gender='{patient.gender.name if patient.gender else None}'. "
+                    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":
+            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 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 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."""
+        # strings of shape f"{value_key}_{operator}_{value}"
+        # extract value_key, operator, value
+        value_key, operator, value = value_descriptor.split("_")
+        value = float(value)
+
+        operator_functions = {
+            "+": lambda x: x + value,
+            "-": lambda x: x - value,
+            "x": lambda x: x * value,
+            "/": lambda x: x / value,
+        }
+
+        return {value_key: operator_functions[operator]}
+
+        # 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)
+        value_function_dict.update(self.parse_value_descriptor(self.max_descriptor))
+
+        result_dict = {
+            key: value_function(default_normal_range_dict[key])
+            for key, value_function in value_function_dict.items()
+        }
+
+        # generate value
+        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

@@ -0,0 +1,23 @@
+import numpy as np
+from django.db import models
+
+from .base_value_distribution import BaseValueDistribution
+
+
+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/__init__.py

@@ -0,0 +1,5 @@
+from .emission_factor import EmissionFactor
+
+__all__ = [
+    "EmissionFactor",
+]

endoreg_db/models/other/emission/emission_factor.py

@@ -0,0 +1,110 @@
+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.
+
+    Attributes:
+        name (str): The name of the emission factor.
+        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)
+    unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
+    value = models.FloatField()
+
+    if TYPE_CHECKING:
+        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.
+
+        Returns:
+            tuple: The natural key consisting of the name.
+        """
+        return (self.name,)
+
+    def __str__(self, verbose: bool = False) -> str:
+        """
+        String representation of the emission factor.
+
+        Args:
+            verbose (bool): If True, includes additional details.
+
+        Returns:
+            str: The string representation of the emission factor.
+        """
+        result = f"{self.name}:	{self.value} per {self.unit}"
+        if verbose:
+            result += "\n\tSources:"
+            for source in self.sources():
+                result += f"\n\t\t{source}"
+
+        return result
+
+    def get_reference_products(self) -> List["ReferenceProduct"]:
+        """
+        Retrieves all reference products associated with the emission factor.
+
+        Returns:
+            list: A list of ReferenceProduct instances associated with this emission factor.
+        """
+        from ...administration.product import ReferenceProduct
+
+        reference_products = []
+        reference_products += ReferenceProduct.objects.filter(
+            emission_factor_total=self
+        )
+        reference_products += ReferenceProduct.objects.filter(
+            emission_factor_package=self
+        )
+        reference_products += ReferenceProduct.objects.filter(
+            emission_factor_product=self
+        )
+
+        return reference_products
+
+    def sources(self) -> List:
+        """
+        Retrieves all sources related to the emission factor.
+
+        Returns:
+            list: A list of sources related to the emission factor.
+        """
+        sources = []
+        sources.extend(self.get_reference_products())
+        return sources

endoreg_db/models/other/gender.py

@@ -0,0 +1,32 @@
+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)
+    abbreviation = models.CharField(max_length=255, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    if TYPE_CHECKING:
+
+        @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

@@ -0,0 +1,190 @@
+from typing import TYPE_CHECKING
+
+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.
+    """
+    _source = InformationSource.objects.get(name="prediction")
+
+    # make sure to return only one object
+    assert _source, "No prediction information source found"
+    return _source
+
+
+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.
+        """
+        return self.get(name=name)
+
+
+class InformationSource(models.Model):
+    objects = InformationSourceManager()
+
+    name = models.CharField(max_length=100)
+
+    url = models.URLField(blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+    date = models.DateField(blank=True, null=True)
+    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:
+        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"
+
+        # add name and abbreviation as index
+        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
+        serialization and natural key lookup.
+        """
+        return (self.name,)
+
+    def __str__(self):
+        """
+        Return the name of the InformationSource as its string representation.
+        """
+        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()
+
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True, null=True)
+
+    information_sources = models.ManyToManyField(
+        InformationSource,
+        related_name="information_source_types",
+        blank=True,
+    )
+
+    class Meta:
+        verbose_name = "Information Source Type"
+        verbose_name_plural = "Information Source Types"
+
+    # information_sources: models.QuerySet["InformationSource"]
+
+    @classmethod
+    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.
+
+        """
+        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
+
+    @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.
+
+        """
+        try:
+            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."
+            ) from e
+
+    def natural_key(self):
+        """
+        Return a tuple containing the name of the information source type for natural key serialization.
+        """
+        return (self.name,)
+
+    def __str__(self):
+        """
+        Return the name of the InformationSourceType as its string representation.
+        """
+        return str(self.name)

endoreg_db/models/other/material.py

@@ -0,0 +1,34 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+if TYPE_CHECKING:
+    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()
+
+    name = models.CharField(max_length=255)
+    emission_factor = models.ForeignKey(
+        "EmissionFactor", on_delete=models.SET_NULL, null=True
+    )
+
+    if TYPE_CHECKING:
+        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

@@ -0,0 +1,24 @@
+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()
+
+    name = models.CharField(max_length=255)
+
+    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