endoreg-db 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

endoreg_db/models/other/distribution/date_value_distribution.py

@@ -0,0 +1,91 @@
+'''Model for date value distribution'''
+
+from datetime import date, timedelta
+from django.db import models
+import numpy as np
+
+from .base_value_distribution import BaseValueDistribution
+
+class DateValueDistributionManager(models.Manager):
+    '''Object manager for DateValueDistribution'''
+    def get_by_natural_key(self, name):
+        '''Retrieve a DateValueDistribution by its natural key.'''
+        return self.get(name=name)
+
+
+class DateValueDistribution(BaseValueDistribution):
+    """
+    Assign date values based on specified distribution.
+    Expects distribution_type (uniform, normal) and mode (date, timedelta) and based on this either
+    date_min, date_max, date_mean, date_std_dev or
+    timedelta_days_min, timedelta_days_max, timedelta_days_mean, timedelta_days_std_dev
+    """
+    objects = DateValueDistributionManager()
+    name = models.CharField(max_length=100)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+    DISTRIBUTION_CHOICES = [
+        ('uniform', 'Uniform'),
+        ('normal', 'Normal'),
+    ]
+    MODE_CHOICES = [
+        ('date', 'Date'),
+        ('timedelta', 'Timedelta'),
+    ]
+
+    distribution_type = models.CharField(max_length=20, choices=DISTRIBUTION_CHOICES)
+    mode = models.CharField(max_length=20, choices=MODE_CHOICES)
+
+    # Date-related fields
+    date_min = models.DateField(blank=True, null=True)
+    date_max = models.DateField(blank=True, null=True)
+    date_mean = models.DateField(blank=True, null=True)
+    date_std_dev = models.IntegerField(blank=True, null=True)  # Standard deviation in days
+
+    # Timedelta-related fields
+    timedelta_days_min = models.IntegerField(blank=True, null=True)
+    timedelta_days_max = models.IntegerField(blank=True, null=True)
+    timedelta_days_mean = models.IntegerField(blank=True, null=True)
+    timedelta_days_std_dev = models.IntegerField(blank=True, null=True)
+
+    def generate_value(self):
+        if self.mode == 'date':
+            return self._generate_date_value()
+        elif self.mode == 'timedelta':
+            return self._generate_timedelta_value()
+        else:
+            raise ValueError("Unsupported mode")
+
+    def _generate_date_value(self):
+        #UNTESTED
+        if self.distribution_type == 'uniform':
+            start_date = self.date_min.toordinal()
+            end_date = self.date_max.toordinal()
+            random_ordinal = np.random.randint(start_date, end_date)
+            return date.fromordinal(random_ordinal)
+        elif self.distribution_type == 'normal':
+            mean_ordinal = self.date_mean.toordinal()
+            std_dev_days = self.date_std_dev
+            random_ordinal = int(np.random.normal(mean_ordinal, std_dev_days))
+            random_ordinal = np.clip(random_ordinal, self.date_min.toordinal(), self.date_max.toordinal())
+            return date.fromordinal(random_ordinal)
+        else:
+            raise ValueError("Unsupported distribution type")
+
+    def _generate_timedelta_value(self):
+        if self.distribution_type == 'uniform':
+            random_days = np.random.randint(self.timedelta_days_min, self.timedelta_days_max + 1)
+            
+            
+        elif self.distribution_type == 'normal':
+            random_days = int(np.random.normal(self.timedelta_days_mean, self.timedelta_days_std_dev))
+            random_days = np.clip(random_days, self.timedelta_days_min, self.timedelta_days_max)
+            
+        else:
+            raise ValueError("Unsupported distribution type")
+        
+        current_date = date.today()
+        generated_date = current_date - timedelta(days=random_days)
+        print(generated_date)
+        return(generated_date)

endoreg_db/models/other/distribution/multiple_categorical_value_distribution.py

@@ -0,0 +1,32 @@
+from django.db import models
+import numpy as np
+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)
+
+    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, self.count_std_dev))
+            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,97 @@
+'''Model for numeric value distribution'''
+
+from django.db import models
+import numpy as np
+from .base_value_distribution import BaseValueDistribution
+from scipy.stats import skewnorm
+
+
+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
+    )
+
+    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)
+        assert isinstance(default_normal_range_dict, dict)
+        if self.distribution_type == 'uniform':
+            assert self.min_descriptor and self.max_descriptor
+            assert "min" in default_normal_range_dict and "max" in default_normal_range_dict
+            value = self._generate_value_uniform(default_normal_range_dict)
+            
+            return value
+        
+        elif self.distribution_type == 'normal':
+            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':
+            value = skewnorm.rvs(a=self.skewness, loc=self.mean, scale=self.std_dev)
+            return np.clip(value, self.min_value, self.max_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
+        )
+
+        _ = 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()
+        }
+
+        # generate value
+        return np.random.uniform(result_dict["min"], result_dict["max"])
+
+    

endoreg_db/models/other/distribution/single_categorical_value_distribution.py

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

@@ -0,0 +1,5 @@
+
+
+
+
+   

endoreg_db/models/other/material.py

@@ -0,0 +1,20 @@
+from django.db import models
+
+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)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+    emission_factor = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True)
+
+    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,18 @@
+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)
+    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/other/transport_route.py

@@ -0,0 +1,22 @@
+from django.db import models
+
+class TransportRouteManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class TransportRoute(models.Model):
+    objects = TransportRouteManager()
+
+    distance = models.FloatField()
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+    emission_factor = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True)
+    unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        result = f"{self.name} ({self.distance} {self.unit}) - {self.emission_factor}"
+        return result

endoreg_db/models/other/waste.py

@@ -0,0 +1,20 @@
+from django.db import models
+
+class WasteManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class Waste(models.Model):
+    objects = WasteManager()
+
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+    # emission_factor = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True)
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    

endoreg_db/models/patient/__init__.py

@@ -0,0 +1,24 @@
+from .patient_examination import PatientExamination
+from .patient_finding import (
+    PatientFinding
+)
+from .patient_finding_location import (
+    PatientFindingLocation
+)
+from .patient_finding_morphology import (
+    PatientFindingMorphology
+)
+
+from .patient_finding_intervention import (
+    PatientFindingIntervention
+)
+
+# TODO Migrate to persons/patient
+
+__all__ = [
+    "PatientExamination",
+    "PatientFinding",
+    "PatientFindingLocation",
+    "PatientFindingMorphology",
+    "PatientFindingIntervention"
+]

endoreg_db/models/patient/patient_examination.py

@@ -0,0 +1,182 @@
+from django.db import models
+from typing import List
+
+# Serializer located in serializers/examination.py
+from typing import Optional
+from datetime import datetime
+
+
+class PatientExamination(models.Model):
+    patient = models.ForeignKey(
+        "Patient", on_delete=models.CASCADE, related_name="patient_examinations"
+    )
+    examination = models.ForeignKey(
+        "Examination", on_delete=models.CASCADE, null=True, blank=True
+    )
+    video = models.OneToOneField(
+        "Video",
+        on_delete=models.CASCADE,
+        null=True,
+        blank=True,
+        related_name="patient_examination",
+    )
+    date_start = models.DateField(null=True, blank=True)
+    date_end = models.DateField(null=True, blank=True)
+    hash = models.CharField(max_length=255, unique=True)
+
+    # report_files
+    class Meta:
+        verbose_name = "Patient Examination"
+        verbose_name_plural = "Patient Examinations"
+        ordering = ["patient", "examination", "date_start"]
+
+    @classmethod
+    def get_or_create_pseudo_patient_examination_by_hash(
+        cls,
+        patient_hash: str,
+        examination_hash: str,
+        examination_name: Optional[str] = None,
+    ):
+        from endoreg_db.models import Patient, Examination
+
+        created = False
+
+        if PatientExamination.objects.filter(
+            patient__patient_hash=patient_hash, hash=examination_hash
+        ).exists():
+            return PatientExamination.objects.get(
+                patient__patient_hash=patient_hash, hash=examination_hash
+            ), created
+
+        patient, created = Patient.get_or_create_pseudo_patient_by_hash(patient_hash)
+        if examination_name is not None:
+            examination = Examination.objects.get(name=examination_name)
+        else:
+            examination = None
+
+        patient_examination = cls.objects.create(
+            patient=patient, examination=examination, hash=examination_hash
+        )
+
+        patient_examination.save()
+
+        created = True
+        return patient_examination, created
+
+    def __str__(self):
+        return f"{self.patient} - {self.examination} - {self.date_start}"
+
+    # override save method to make sure that the hash is always set,
+    # if none is existing generate an unique string
+
+    def generate_default_hash(self):
+        # create random hash
+        import random
+        import string
+
+        _hash = "DEFAULT_HASH_" + "".join(
+            random.choices(string.ascii_uppercase + string.digits, k=10)
+        )
+
+        return _hash
+
+    def save(self, *args, **kwargs):
+        if not self.hash:
+            self.hash = self.generate_default_hash()
+        super().save(*args, **kwargs)
+
+    def get_patient_age_at_examination(self) -> int:
+        """
+        Returns the patient's age at the time of the examination.
+        """
+        from endoreg_db.models import Patient
+        from datetime import datetime
+
+        patient: Patient = self.patient
+        dob = patient.get_dob()
+        date_start = self.date_start
+        return (date_start - dob).days // 365
+
+    def get_available_findings(self):
+        """
+        Returns all findings that are associated with the examination of this patient examination.
+        """
+        from endoreg_db.models import Finding, Examination
+
+        examination: Examination = self.examination
+        findings: List[Finding] = [_ for _ in examination.get_available_findings()]
+        return findings
+
+    def get_findings(self):
+        """
+        Returns all findings that are associated with this patient examination.
+        """
+        from endoreg_db.models import PatientFinding
+
+        patient_findings: List[PatientFinding] = [
+            _ for _ in self.patient_findings.all()
+        ]
+        return patient_findings
+
+    def get_indications(self):
+        """
+        Returns all indications that are associated with this patient examination.
+        """
+        from endoreg_db.models import PatientExaminationIndication
+
+        indications: List[PatientExaminationIndication] = [
+            _ for _ in self.indications.all()
+        ]
+        return indications
+
+    def get_indication_choices(self):
+        """
+        Returns all indication choices that are associated with this patient examination.
+        """
+        from endoreg_db.models import ExaminationIndicationClassificationChoice
+
+        choices: List[ExaminationIndicationClassificationChoice] = [
+            _.indication_choice for _ in self.get_indications()
+        ]
+        return choices
+
+    def create_finding(self, finding):
+        """
+        Adds a finding to this patient examination.
+        """
+        from endoreg_db.models import Finding, Examination, PatientFinding
+
+        examination: Examination = self.examination
+        assert examination
+
+        finding: Finding
+
+        patient_finding = PatientFinding.objects.create(
+            patient_examination=self, finding=finding
+        )
+
+        patient_finding.save()
+
+        return patient_finding
+
+    def find_matching_video_from_patient(self):
+        """
+        Finds a video for this patient examination based on the patient's videos.
+        For this, the videos date must be the same as the report file's date.
+        #TODO add more criteria for matching: Examination type
+        """
+        videos = self.patient.video_set.filter(
+            date=self.report_file.date, patient_examination__isnull=True
+        )
+        if videos:
+            if len(videos) > 1:
+                print(
+                    f"Warning: Found more than one video for patient {self.patient} on date {self.report_file.date}. Choosing the first one."
+                )
+            return videos[0]
+        else:
+            videos = self.patient.video_set.filter(patient_examination__isnull=True)
+            if len(videos) == 1:
+                return videos[0]
+
+        return None

endoreg_db/models/patient/patient_finding.py

@@ -0,0 +1,143 @@
+from django.db import models
+from typing import List
+
+class PatientFinding(models.Model):
+    patient_examination = models.ForeignKey('PatientExamination', on_delete=models.CASCADE, related_name='patient_findings')
+    finding = models.ForeignKey('Finding', on_delete=models.CASCADE, related_name='patient_findings')
+    locations = models.ManyToManyField(
+        'PatientFindingLocation',
+        blank=True,
+        related_name='patient_findings'
+    )
+    morphologies = models.ManyToManyField(
+        'PatientFindingMorphology',
+        blank=True,
+        related_name='patient_findings'
+    )
+    
+
+    class Meta:
+        verbose_name = 'Patient Finding'
+        verbose_name_plural = 'Patient Findings'
+        ordering = ['patient_examination', 'finding']
+
+    def __str__(self):
+        return f"{self.patient_examination} - {self.finding}"
+
+   # functions to get all associated location and morphology choices
+    def get_locations(self):
+        """
+        Returns all location choices that are associated with this patient finding.
+        """
+        from endoreg_db.models import PatientFindingLocation
+        locations:List[PatientFindingLocation] = [_ for _ in self.locations.all()]
+        return locations
+    
+    def get_morphologies(self):
+        """
+        Returns all morphology choices that are associated with this patient finding.
+        """
+        from endoreg_db.models import PatientFindingMorphology
+        morphologies:List[PatientFindingMorphology] = [_ for _ in self.morphologies.all()]
+        return morphologies   
+
+    def add_morphology_choice(self, morphology_choice, morphology_classification):
+        """
+        Adds a morphology choice to this patient finding morphology.
+        """
+        from endoreg_db.models import (
+            FindingMorphologyClassificationChoice,
+            FindingMorphologyClassification,
+            PatientFindingMorphology
+        )
+        morphology_choice: FindingMorphologyClassificationChoice
+        morphology_classification: FindingMorphologyClassification
+        
+        patient_finding_morphology = PatientFindingMorphology.objects.create(
+            morphology_classification=morphology_classification,
+            morphology_choice=morphology_choice
+        )
+        patient_finding_morphology.save()
+
+        self.morphologies.add(patient_finding_morphology)
+        self.save()
+
+        return patient_finding_morphology
+
+    def add_intervention(self, intervention, state="pending", date=None):
+        """
+        Adds an intervention to this patient finding.
+        """
+        from endoreg_db.models import PatientFindingIntervention
+        patient_finding_intervention = PatientFindingIntervention.objects.create(
+            patient_finding=self,
+            intervention=intervention,
+            state = state,
+            date = date
+        )
+        patient_finding_intervention.save()
+
+        return patient_finding_intervention
+
+    def add_location_choice(self, location_choice, location_classification):
+        """
+        Adds a location choice to this patient finding location.
+        """
+        from endoreg_db.models import (
+            FindingLocationClassificationChoice,
+            FindingLocationClassification,
+            PatientFindingLocation
+        )
+        location_choice: FindingLocationClassificationChoice
+        location_classification: FindingLocationClassification
+        
+        patient_finding_location = PatientFindingLocation.objects.create(
+            location_classification=location_classification,
+            location_choice=location_choice
+        )
+        patient_finding_location.save()
+
+        self.locations.add(patient_finding_location)
+        self.save()
+
+        return patient_finding_location
+
+    def get_interventions(self):
+        """
+        Returns all interventions that are associated with this patient finding.
+        """
+        from endoreg_db.models import PatientFindingIntervention
+        interventions:List[PatientFindingIntervention] = [_ for _ in self.interventions.all()]
+        return interventions
+
+    def set_random_location(
+            self, location_classification
+        ):
+        """
+        Sets a random location for this finding based on the location classification.
+        """
+        from endoreg_db.models import (
+            FindingLocationClassificationChoice,
+            FindingLocationClassification, 
+            PatientFindingLocation
+        )
+        import random
+        from typing import List
+        location_classification:FindingLocationClassification
+
+        # assert location_classification in self.finding.location_classifications.all()
+
+        location_choices:List[FindingLocationClassificationChoice] = location_classification.choices.all()
+        location_choice = random.choice(location_choices)
+
+        patient_finding_location = PatientFindingLocation.objects.create(
+            location_classification=location_classification,
+            location_choice=location_choice
+        )
+
+        self.locations.add(patient_finding_location)
+        self.save()
+
+        return patient_finding_location
+    
+