endoreg-db 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

endoreg_db/models/persons/patient/patient_lab_sample.py

@@ -0,0 +1,106 @@
+from django.db import models
+
+DEFAULT_PATIENT_LAB_SAMPLE_TYPE_NAME = "generic"
+
+class PatientLabSampleTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class PatientLabSampleType(models.Model):
+    """
+    A class representing a patient lab sample type.
+
+    Attributes:
+        name (str): The name of the patient lab sample type.
+        description (str): A description of the patient lab sample type.
+
+    """
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    objects = PatientLabSampleTypeManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+    
+    @classmethod
+    def get_default_sample_type(cls):
+        """
+        Get the default patient lab sample type.
+
+        Returns:
+            PatientLabSampleType: The default patient lab sample type.
+
+        """
+        return cls.objects.get_or_create(name="default")[0]
+    
+from datetime import datetime as dt    
+from datetime import timezone
+class PatientLabSample(models.Model):
+    """
+    A class representing a patient lab sample.
+
+    Attributes:
+        patient (Patient): The patient to which the lab sample belongs.
+        sample_type (PatientLabSampleType): The type of the lab sample.
+        date (datetime): The date of the lab sample.
+        values (PatientLabValue; One2Many): The value of the lab sample.
+        unit (Unit): The unit of the lab sample.
+
+    """
+    patient = models.ForeignKey("Patient", on_delete=models.CASCADE, related_name="lab_samples")
+    sample_type = models.ForeignKey("PatientLabSampleType", on_delete=models.CASCADE)
+    date = models.DateTimeField()
+
+    def __str__(self):
+        return f"{self.patient} - {self.sample_type} - {self.date} ()"
+    
+    def get_values(self):
+        return self.values
+    
+    @classmethod
+    def create_by_patient(cls, patient=None, sample_type=None, date=None, save = True):
+        """
+        Create a new patient lab sample by patient.
+
+        Args:
+            patient (Patient): The patient to which the lab sample belongs.
+            sample_type (PatientLabSampleType): The type of the lab sample.
+            date (datetime): The date of the lab sample.
+
+        Returns:
+            PatientLabSample: The new patient lab sample.
+
+        """
+        from endoreg_db.models.persons.patient import Patient, PatientLabSampleType
+        from warnings import warn
+
+        if not patient:
+            warn("No patient given. Cannot create patient lab sample.")
+            return None
+        if not sample_type:
+            sample_type = PatientLabSampleType.get_default_sample_type()
+        else:
+            sample_type = PatientLabSampleType.objects.get(name=sample_type)
+        if not date:
+            date = dt.now(timezone.utc)
+
+        patient_lab_sample = cls.objects.create(
+            patient=patient,
+            sample_type=sample_type,
+            date=date
+        )
+
+        if save:
+            patient_lab_sample.save()
+
+        return patient_lab_sample
+
+
+    
+    

endoreg_db/models/persons/patient/patient_lab_value.py

@@ -0,0 +1,176 @@
+from django.db import models
+
+class PatientLabValue(models.Model):
+    """
+    A class representing a patient lab value.
+
+    Attributes:
+        patient (Patient): The patient.
+        lab_value (LabValue): The lab value.
+        value (float): The value of the lab value.
+        date (datetime): The date of the lab value.
+    """
+    patient = models.ForeignKey('Patient', on_delete=models.CASCADE,
+                                related_name="lab_values", blank=True, null=True
+    )
+    lab_value = models.ForeignKey('LabValue', on_delete=models.CASCADE)
+    value = models.FloatField(blank=True, null=True)
+    value_str = models.CharField(max_length=255, blank=True, null=True)
+    sample = models.ForeignKey(
+        'PatientLabSample', on_delete=models.CASCADE, 
+        blank=True, null=True,
+        related_name='values'
+    )
+    datetime = models.DateTimeField(# if not set, use now
+        auto_now_add=True        
+    )
+    normal_range = models.JSONField(
+        default = dict
+    )
+    unit = models.ForeignKey('Unit', on_delete=models.CASCADE, blank=True, null=True)
+
+    @classmethod
+    def create_lab_value_by_sample(cls, sample=None, lab_value_name=None, value=None, value_str=None, unit=None):
+        from endoreg_db.models import LabValue
+        patient = sample.patient
+        lab_value = LabValue.objects.get(name=lab_value_name)
+        value = value
+        value_str = value_str
+
+        pat_lab_val = cls.objects.create(
+            patient = patient,
+            lab_value = lab_value,
+            value = value,
+            value_str = value_str,
+            sample = sample,
+            unit = unit,
+        )
+
+        pat_lab_val.save()
+
+        return pat_lab_val
+
+    def __str__(self):
+        _str = f'{self.lab_value} - {self.value} {self.unit} ({self.datetime})'
+        print(_str)
+        return _str
+    
+    def set_min_norm_value(self, value, save = True):
+        self.normal_range["min"] = value
+        if save:
+            self.save()
+
+    def set_max_norm_value(self, value, save = True):
+        self.normal_range["max"] = value
+        if save:
+            self.save()
+
+    def set_norm_values_from_default(self):
+        age = self.patient.age()
+        gender = self.patient.gender
+        min_value, max_value = self.lab_value.get_normal_range(age=age, gender=gender)
+        self.set_min_norm_value(min_value, save = False)
+        self.set_max_norm_value(max_value, save = False)
+        self.save()
+
+
+    def set_unit_from_default(self):
+        self.unit = self.lab_value.default_unit
+        self.save()
+
+    def get_value(self):
+        if self.value:
+            return self.value
+        else:
+            return self.value_str
+        
+    def get_value_field_name(self):
+        if self.value:
+            return "value"
+        else:
+            return "value_str"
+        
+    # customize save method so that if a numeric value exists, we round it to the precision of the lab value
+    def save(self, *args, **kwargs):
+        if self.value:
+            precision = self.lab_value.numeric_precision
+            self.value = round(self.value, precision)
+        super().save(*args, **kwargs)
+
+    def set_value_by_distribution(self, distribution=None, save = True):
+        from endoreg_db.models import (
+            Patient, LabValue, Gender,
+            DateValueDistribution,
+            SingleCategoricalValueDistribution,
+            NumericValueDistribution,
+            MultipleCategoricalValueDistribution,
+        ) 
+        import warnings  
+
+        patient:Patient = self.patient
+
+        dob = patient.dob
+        gender:Gender = patient.gender
+        lab_value:LabValue = self.lab_value
+
+        assert self.lab_value, "Lab value must be set to set value by distribution"
+        self.unit = self.lab_value.default_unit
+
+        if not distribution:
+            distribution = lab_value.get_default_default_distribution()
+
+            if not distribution:
+                warnings.warn(
+                    "No distribution set for lab value, assuming uniform numeric distribution based on normal values"
+                )
+
+                if not self.normal_range.get("min", None) or not self.normal_range.get("max", None):
+                    self.set_norm_values_from_default()
+
+                self.normal_range:dict
+                _min = self.normal_range.get("min", 0.0001)
+                _max = self.normal_range.get("max", 100)
+                _name = "auto-" + self.lab_value.name + "-distribution-default-uniform" 
+                distribution = NumericValueDistribution(
+                    name = _name,
+                    min_value = _min,
+                    max_value = _max,
+                    distribution_type = "uniform"
+                )
+
+                value = distribution.generate_value()
+                self.value = value
+                if save:
+                    self.save()
+                
+                return value
+
+        if isinstance(distribution, SingleCategoricalValueDistribution):
+            value = distribution.generate_value()
+            self.value_str = value
+            if save:
+                self.save()
+            return value
+        
+        elif isinstance(distribution, NumericValueDistribution):
+            value = distribution.generate_value()
+            self.value = value
+            if save:
+                self.save()
+            return value
+        
+        elif isinstance(distribution, MultipleCategoricalValueDistribution):
+            value = distribution.generate_value()
+            self.value_str = value
+            if save:
+                self.save()
+            return value
+
+        elif isinstance(distribution, DateValueDistribution):
+            # raise not implemented error
+            value = distribution.generate_value()
+            self.value = value
+            if save:
+                self.save()
+
+

endoreg_db/models/persons/patient/patient_medication.py

@@ -0,0 +1,44 @@
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+
+class PatientMedication(models.Model):
+    patient = models.ForeignKey("Patient", on_delete= models.CASCADE)
+    medication_indication = models.ForeignKey(
+        "MedicationIndication", on_delete=models.CASCADE,
+        related_name="patient_medications", null=True
+    )
+
+    medication_schedules = models.ManyToManyField(
+        'MedicationSchedule'
+    )
+    unit = models.ForeignKey('Unit', on_delete=models.CASCADE)
+    dosage = models.JSONField()
+    active = models.BooleanField(default=True)
+
+    objects = models.Manager()
+
+    class Meta:
+        verbose_name = _('Patient Medication')
+        verbose_name_plural = _('Patient Medications')
+
+    @classmethod
+    def create_by_patient_and_indication(cls, patient, medication_indication):
+        from endoreg_db.models import MedicationIndication
+        medication_indication: MedicationIndication
+        patient_medication = cls.objects.create(patient=patient, medication_indication=medication_indication)
+        patient_medication.save()
+        patient_medication.set_schedules_from_indication()
+        
+        return patient_medication
+
+    def set_schedules_from_indication(self):
+        schedules = self.medication_indication.medication_schedules.all()
+        self.medication_schedules.set(schedules)
+        self.save()
+
+    def __str__(self):
+        indication = self.medication_indication
+        schedules = self.medication_schedules.all()
+        return f'{indication} - {schedules}'
+    
+    

endoreg_db/models/persons/patient/patient_medication_schedule.py

@@ -0,0 +1,28 @@
+from django.db import models
+
+class PatientMedicationSchedule(models.Model):
+    patient = models.ForeignKey("Patient", on_delete= models.CASCADE)
+    medication = models.ManyToManyField(
+        'PatientMedication', related_name='patient_medication_schedules'
+    )
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        return f'{self.patient} - {self.medication.all()}'
+    
+    @classmethod
+    def create_by_patient_and_indication_type(cls, patient, indication_type):
+        from endoreg_db.models import MedicationIndicationType, PatientMedication
+
+        medication_indication = MedicationIndicationType.get_random_indication_by_type(name=indication_type)
+
+        patient_medication_schedule = cls.objects.create(patient=patient)
+        patient_medication_schedule.save()
+
+        patient_medication = PatientMedication.create_by_patient_and_indication(patient, medication_indication)
+        patient_medication_schedule.medication.add(patient_medication)
+        patient_medication_schedule.save()
+
+        return patient_medication_schedule

endoreg_db/models/persons/person.py

@@ -17,10 +17,7 @@ class Person(models.Model):
     first_name = models.CharField(max_length=255)
     last_name = models.CharField(max_length=255)
     dob = models.DateField("Date of Birth", blank=True, null=True)
-    gender = models.CharField(
-        max_length=10, choices=[('Male', 'Male'), ('Female', 'Female'), ('Other', 'Other')],
-        blank=True, null=True
-    )
+    gender = models.ForeignKey("Gender", on_delete=models.SET_NULL, null=True)
     email = models.EmailField(max_length=255, blank=True, null=True)
     phone = models.CharField(max_length=255, blank=True, null=True)
     is_real_person = models.BooleanField(default=True)

endoreg_db/models/persons/portal_user_information.py

@@ -1,8 +1,6 @@
 from django.db import models
 
 # models.py in your main app
-
-from django.db import models
 from django.contrib.auth.models import User
 
 class ProfessionManager(models.Manager):

endoreg_db/models/product/__init__.py

@@ -0,0 +1,5 @@
+from .product import Product
+from .product_material import ProductMaterial
+from .product_group import ProductGroup
+from .reference_product import ReferenceProduct
+from .product_weight import ProductWeight

endoreg_db/models/product/product.py

@@ -0,0 +1,97 @@
+from django.db import models
+
+class ProductManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+def sum_weights(product_materials):
+    # sum up the weights
+    weight = 0
+    reference_unit = None
+    for product_material in product_materials:
+        if not reference_unit:
+            reference_unit = product_material.unit
+        else:
+            assert reference_unit == product_material.unit, "ProductMaterial units do not match"
+        weight += product_material.quantity
+
+    return weight, reference_unit
+
+def sum_emissions(product_materials):
+    # sum up the emissions
+    emission = 0
+    reference_unit = None
+    for product_material in product_materials:
+        if not reference_unit:
+            reference_unit = product_material.unit
+        else:
+            assert reference_unit == product_material.unit, "ProductMaterial units do not match"
+        emission, emission_unit = product_material.get_emission()
+        assert reference_unit == emission_unit, "ProductMaterial units do not match"
+        emission += emission
+
+    return emission, reference_unit
+
+class Product(models.Model):
+    objects = ProductManager()
+
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+
+    transport_route = models.ForeignKey("TransportRoute", on_delete=models.SET_NULL, null=True)
+    product_group = models.ForeignKey("ProductGroup", on_delete=models.SET_NULL, null=True)
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    
+    def get_product_weight(self):
+        # check if there is a product material weight
+        from .product_material import ProductMaterial
+        product_materials = ProductMaterial.objects.filter(product=self, component="product")
+        if product_materials:
+            return self.get_product_material_weight()
+        
+        # check if there is a product weight
+        #TODO
+
+    def get_package_weight(self):
+        # check if there is a package material weight
+        from .product_material import ProductMaterial
+        product_materials = ProductMaterial.objects.filter(product=self, component="package")
+        if product_materials:
+            return self.get_package_material_weight()
+        
+        # check if there is a package weight
+        #TODO
+
+    def get_product_material_weight(self):
+        # get all materials with component == "product"
+        from .product_material import ProductMaterial
+        product_materials = ProductMaterial.objects.filter(product=self, component="product")
+
+        return sum_weights(product_materials)
+    
+    def get_package_material_weight(self):
+        # get all materials with component == "package"
+        from .product_material import ProductMaterial
+        product_materials = ProductMaterial.objects.filter(product=self, component="package")
+
+        return sum_weights(product_materials)
+
+    def get_product_material_emission(self):
+        # get all materials with component == "product"
+        from .product_material import ProductMaterial
+        product_materials = ProductMaterial.objects.filter(product=self, component="product")
+
+        return sum_emissions(product_materials)
+
+    def get_package_material_emission(self):
+        # get all materials with component == "package"
+        from .product_material import ProductMaterial
+        product_materials = ProductMaterial.objects.filter(product=self, component="package")
+
+        return sum_emissions(product_materials)

endoreg_db/models/product/product_group.py

@@ -0,0 +1,19 @@
+from django.db import models
+
+class ProductGroupManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class ProductGroup(models.Model):
+    objects = ProductGroupManager()
+
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    

endoreg_db/models/product/product_material.py

@@ -0,0 +1,24 @@
+from django.db import models
+
+class ProductMaterial(models.Model):
+    component = models.CharField(max_length=255)
+    material = models.ForeignKey("Material", on_delete=models.CASCADE)
+    product = models.ForeignKey("Product", on_delete=models.CASCADE, related_name="product_materials")
+    unit = models.ForeignKey("Unit", on_delete=models.CASCADE)
+    quantity = models.FloatField()
+
+    def get_emission(self):
+        from ..emission import EmissionFactor
+        emission_factor:EmissionFactor = self.material.emission_factor
+        if emission_factor is None:
+            raise Exception("No emission factor for material " + self.material.name + " found.")
+        
+        # make sure product_material.unit is the same as emission_factor.unit
+        if self.unit != emission_factor.unit:
+            raise Exception("Unit mismatch: " + self.unit.name + " != " + emission_factor.unit.name)
+        
+        emmision_value = emission_factor.value * self.quantity
+        emission_unit = emission_factor.unit
+        return emmision_value, emission_unit
+        
+

endoreg_db/models/product/product_weight.py

@@ -0,0 +1,26 @@
+from django.db import models
+import pandas as pd
+
+class ProductWeightManager(models.Manager):
+    def get_by_natural_key(self, product, product_group, weight):
+        return self.get(product=product, product_group=product_group, weight=weight)
+    
+class ProductWeight(models.Model):
+    objects = ProductWeightManager()
+
+    name = models.CharField(max_length=255, null = True)
+    product = models.ForeignKey("Product", on_delete=models.CASCADE)
+    measured = models.FloatField(null=True)
+    verified = models.FloatField(null=True)
+    manufacturer = models.FloatField(null=True)
+    unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
+
+    def get_weight(self):
+        if not pd.isnull(self.verified):
+            return self.verified
+        elif not pd.isnull(self.measured):
+            return self.measured
+        elif not pd.isnull(self.manufacturer):
+            return self.manufacturer
+        else:
+            return None

endoreg_db/models/product/reference_product.py

@@ -0,0 +1,99 @@
+from django.db import models
+from typing import List
+
+class ReferenceProductManager(models.Manager):
+    def get_by_natural_key(self, product_name:str, product_group_name:str):
+        return self.get(product__name=product_name, product_group__name=product_group_name)
+
+class ReferenceProduct(models.Model):
+    name = models.CharField(max_length=255)
+    product = models.ForeignKey("Product", on_delete=models.CASCADE)
+    product_group = models.OneToOneField("ProductGroup", on_delete=models.CASCADE, related_name="reference_product")
+    emission_factor_total = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True, blank = True)
+    emission_factor_package = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True, related_name="reference_product_package")
+    emission_factor_product = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True, related_name="reference_product_product")
+    
+    objects = ReferenceProductManager()
+
+    def __str__(self):
+        return self.product.name + " (" + self.product_group.name + ")"
+    
+    def set_emission_factors(self):
+        from .product import Product
+        from .product_material import ProductMaterial
+        from ..emission import EmissionFactor
+
+        product:Product = self.product
+        materials = product.product_materials.all()
+        emission_factor_name = f"{self.product_group.name}_{product.name}_total_emission_factor"
+        emission_factor_package_name = f"{self.product_group.name}_{product.name}_package_emission_factor"
+        emission_factor_product_name = f"{self.product_group.name}_{product.name}_product_emission_factor"
+
+        product_emissions = 0
+        package_emissions = 0
+
+        product_weight, product_weight_unit = product.get_product_material_weight()
+        package_weight, package_weight_unit = product.get_package_material_weight()
+        product_emission, product_emission_unit = product.get_product_material_emission()
+        package_emission, package_emission_unit = product.get_package_material_emission()
+
+        total_weight = product_weight + package_weight
+        total_emission = product_emission + package_emission
+
+        reference_unit = product_weight_unit
+        assert reference_unit == package_weight_unit, "Package weight units do not match"
+        assert reference_unit == product_emission_unit, "Product emission units do not match"
+        assert reference_unit == package_emission_unit, "Package emission units do not match"
+
+        product_emission_factor_value = product_emission / product_weight
+        package_emission_factor_value = package_emission / package_weight
+        total_emission_factor_value = total_emission / total_weight
+
+        emission_factor, created = EmissionFactor.objects.get_or_create(
+            name=emission_factor_name,
+            defaults={
+                "name": emission_factor_name,
+                "value": total_emission_factor_value,
+                "unit": reference_unit
+            }
+        )
+        self.emission_factor_total = emission_factor
+
+        emission_factor_package, created = EmissionFactor.objects.get_or_create(
+            name=emission_factor_package_name,
+            defaults={
+                "name": emission_factor_package_name,
+                "value": package_emission_factor_value,
+                "unit": reference_unit
+            }
+        )
+        self.emission_factor_package = emission_factor_package
+
+        emission_factor_product, created = EmissionFactor.objects.get_or_create(
+            name=emission_factor_product_name,
+            defaults={
+                "name": emission_factor_product_name,
+                "value": product_emission_factor_value,
+                "unit": reference_unit
+            }
+        )
+        self.emission_factor_product = emission_factor_product
+
+        self.save()
+
+    def get_emission_factor(self, component:str):
+        # check if emission_factor_total exists:
+        if self.emission_factor_total is None:
+            self.set_emission_factors()
+
+        if component == "total":
+            return self.emission_factor_total
+        elif component == "package":
+            return self.emission_factor_package
+        elif component == "product":
+            return self.emission_factor_product
+        else:
+            raise Exception("Unknown component: " + component)
+        
+
+