endoreg-db 0.5.3__py3-none-any.whl → 0.6.1__py3-none-any.whl

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
+    
+    

endoreg_db/models/patient/patient_finding_intervention.py

@@ -0,0 +1,26 @@
+from django.db import models 
+
+class PatientFindingIntervention(models.Model):
+    patient_finding = models.ForeignKey(
+        'PatientFinding', 
+        on_delete=models.CASCADE, 
+        related_name='interventions'
+    )
+    intervention = models.ForeignKey(
+        'FindingIntervention',
+        on_delete=models.CASCADE,
+        related_name='patient_finding_interventions'
+    )
+    state = models.CharField(max_length=100, blank=True, null=True)
+    time_start = models.DateTimeField(blank=True, null=True)
+    time_end = models.DateTimeField(blank=True, null=True)
+    date = models.DateField(blank=True, null=True)
+
+    def __str__(self):
+        return self.intervention.name
+
+    def natural_key(self):
+        return (self.intervention.name,)
+    
+
+    objects = models.Manager()

endoreg_db/models/patient/patient_finding_location.py

@@ -0,0 +1,120 @@
+from django.db import models
+
+class PatientFindingLocation(models.Model):
+    location_classification = models.ForeignKey('FindingLocationClassification', on_delete=models.CASCADE, related_name='patient_finding_locations')
+    location_choice = models.ForeignKey('FindingLocationClassificationChoice', on_delete=models.CASCADE, related_name='patient_finding_locations')
+    subcategories = models.JSONField(blank=True, null=True)
+    numerical_descriptors = models.JSONField(blank=True, null=True)
+
+    class Meta:
+        verbose_name = 'Patient Finding Location'
+        verbose_name_plural = 'Patient Finding Locations'
+        ordering = ['location_classification', 'location_choice']
+
+    def __str__(self):
+        return f"{self.location_classification} - {self.location_choice}"
+    
+    # override save method to do the following:
+    # - check if location_choice is in location_classification.choices
+    # - check if subcategories and numerical_descriptors exist
+    # - if not set, fetch them from location_choice and set them
+
+    def save(self, *args, **kwargs):
+        if self.location_choice not in self.location_classification.choices.all():
+            raise ValueError("location_choice must be in location_classification.choices")
+
+        if not self.subcategories:
+            self.subcategories = self.location_choice.subcategories
+
+        if not self.numerical_descriptors:
+            self.numerical_descriptors = self.location_choice.numerical_descriptors
+
+        super().save(*args, **kwargs)
+
+    def set_subcategory(self, subcategory_name, subcategory_value):
+        """
+        Sets a subcategory for this location.
+        """
+        assert subcategory_name in self.subcategories, "Subcategory must be in subcategories."
+        self.subcategories[subcategory_name]["value"] = subcategory_value
+        self.save()
+
+        return self.subcategories[subcategory_name]
+
+    def set_random_subcategories(self):
+        """
+        Sets random subcategories for this location if they are required.
+        """
+        import random
+        if not self.subcategories or not self.numerical_descriptors:
+            self.save()
+
+        self.refresh_from_db()
+        assert self.subcategories, "Subcategories must be set."
+
+        subcategories = self.subcategories
+        # print("SUBCATS")
+        # print(subcategories)
+
+        # subcategories is dict with keys as subcategory names and values as dict with keys as "choices" (List of str) and "required" (bool)
+        # for each subcategory, set a random choice if it is required
+        for subcategory_name, subcategory_dict in subcategories.items():
+            if subcategory_dict["required"]:
+                subcategory_choice = random.choice(subcategory_dict["choices"])
+                self.subcategories[subcategory_name]["value"] = subcategory_choice
+
+        self.save()
+
+        return self.subcategories
+    
+    def set_random_numerical_descriptor(self, descriptor_name):
+        """
+        Sets a random numerical descriptor for this location.
+        """
+        import random
+        if descriptor_name not in self.numerical_descriptors:
+            raise ValueError("Descriptor name must be in numerical descriptors.")
+
+        numerical_descriptor = self.numerical_descriptors[descriptor_name]
+        min_value = numerical_descriptor["min"]
+        max_value = numerical_descriptor["max"]
+
+        assert min_value <= max_value, "Min value must be less than or equal to max value."
+
+        random_value = random.uniform(min_value, max_value)
+        self.numerical_descriptors[descriptor_name]["value"] = random_value
+        self.save()
+
+        return self.numerical_descriptors[descriptor_name]
+
+
+    def set_random_numerical_descriptors(self):
+        """
+        Sets random numerical descriptors for this location if they are required.
+        """
+        import random
+        from endoreg_db.models import FindingLocationClassificationChoice
+        if not self.subcategories or not self.numerical_descriptors:
+            self.save()
+
+        numerical_descriptors = self.numerical_descriptors
+        numerical_descriptor = {}
+
+        # numerical_descriptors is dict with keys as numerical descriptor names 
+        # and values as dict with keys as "min" (float), "max" (float), required (bool), distribution_name (str)
+        # distribution name can be either "uniform" or "normal"
+        # for each numerical descriptor, set a random value between min and max
+        for numerical_descriptor_name, numerical_descriptor_dict in numerical_descriptors.items():
+            min_value = numerical_descriptor_dict["min"]
+            max_value = numerical_descriptor_dict["max"]
+
+            assert min_value <= max_value, "Min value must be less than or equal to max value."
+
+
+            random_value = random.uniform(min_value, max_value)
+            numerical_descriptor[numerical_descriptor_name] = random_value
+
+        self.numerical_descriptors = numerical_descriptor
+        self.save()
+
+        return numerical_descriptor

endoreg_db/models/patient/patient_finding_morphology.py

@@ -0,0 +1,166 @@
+from django.db import models
+
+class PatientFindingMorphology(models.Model):
+    morphology_classification = models.ForeignKey(
+        'FindingMorphologyClassification', on_delete=models.CASCADE, related_name='patient_finding_morphologies'
+    ) 
+    morphology_choice = models.ForeignKey(
+        'FindingMorphologyClassificationChoice', on_delete=models.CASCADE, related_name='patient_finding_morphologies'
+    )
+    subcategories = models.JSONField(default=dict)
+    numerical_descriptors = models.JSONField(default=dict)
+
+    class Meta:
+        verbose_name = 'Patient Finding Morphology'
+        verbose_name_plural = 'Patient Finding Morphologies'
+        ordering = ['morphology_classification', 'morphology_choice']
+
+    def __str__(self):
+
+        _str = f"{self.morphology_classification} - {self.morphology_choice}"
+        
+        if self.subcategories:
+            for key, _dict in self.subcategories.items():
+                value = _dict.get("value", None)
+                if value:
+                    _str += f" - {key}: {value}"
+
+        if self.numerical_descriptors:
+            for key, _dict in self.numerical_descriptors.items():
+                value = _dict.get("value", None)
+                if value:
+                    _str += f" - {key}: {value}"
+        
+        return _str
+
+    # override save method to do the following:
+    # - check if morphology_choice is in morphology_classification.choices
+    # - check if subcategories and numerical_descriptors exist
+    # - if not set, fetch them from morphology_choice and set them
+
+    def set_subcategory(self, subcategory_name, subcategory_value):
+        """
+        Sets a subcategory for this morphology.
+        """
+        assert subcategory_name in self.subcategories, "Subcategory must be in subcategories."
+        self.subcategories[subcategory_name]["value"] = subcategory_value
+        self.save()
+
+        return self.subcategories[subcategory_name]
+
+    def save(self, *args, **kwargs):
+        if self.morphology_choice not in self.morphology_classification.choices.all():
+            raise ValueError("morphology_choice must be in morphology_classification.choices")
+
+        if not self.subcategories:
+            self.subcategories = self.morphology_choice.subcategories
+            if not self.subcategories:
+                self.subcategories = {}
+
+        if not self.numerical_descriptors:
+            self.numerical_descriptors = self.morphology_choice.numerical_descriptors
+            if not self.numerical_descriptors:
+                self.numerical_descriptors = {}
+                
+
+        super().save(*args, **kwargs)
+
+    def get_subcategories(self):
+        """
+        Returns all subcategories that are associated with this patient finding morphology.
+        """
+        if not self.subcategories:
+            self.save()
+        return self.subcategories
+    
+    def get_numerical_descriptors(self):
+        """
+        Returns all numerical descriptors that are associated with this patient finding morphology.
+        """
+        if not self.numerical_descriptors:
+            self.save()
+        return self.numerical_descriptors
+
+    def get_random_value_for_numerical_descriptor(self, descriptor_name):
+        """
+        Returns a random value for a numerical descriptor.
+        """
+        import numpy as np
+        assert descriptor_name in self.numerical_descriptors, "Descriptor must be in numerical descriptors."
+        descriptor = self.numerical_descriptors[descriptor_name]
+        min_val = descriptor.get("min", 0)
+        max_val = descriptor.get("max", 1)
+        distribution = descriptor.get("distribution", "normal")
+        if distribution == "normal":
+            mean = descriptor.get("mean", 0.5)
+            std = descriptor.get("std", 0.1)
+            value = np.random.normal(mean, std)
+            # clip value to min and max
+            value = np.clip(value, min_val, max_val)
+        elif distribution == "uniform":
+            value = np.random.uniform(min_val, max_val)
+        else:
+            raise ValueError("Distribution not supported")
+        
+        return value
+
+    def set_numerical_descriptor_random(self, descriptor_name):
+        """
+        Sets a numerical descriptor for this patient finding morphology.
+        """
+        assert descriptor_name in self.numerical_descriptors, "Descriptor must be in numerical descriptors."
+        
+        value = self.get_random_value_for_numerical_descriptor(descriptor_name)
+        self.numerical_descriptors[descriptor_name]["value"] = value
+        self.save()
+
+        return self.numerical_descriptors[descriptor_name]
+
+    def set_random_numerical_descriptors(self): #TODO Update
+        """
+        Sets random numerical descriptors for this patient finding morphology.
+        """
+        import numpy as np
+        # get numerical descriptors from morphology_choice
+        try:
+            numerical_descriptors = self.morphology_choice.numerical_descriptors
+            assert numerical_descriptors
+            return numerical_descriptors
+        except:
+            # print(f"Numerical descriptors not found for {self.morphology_choice}")
+            return None
+        # If available, numerical descriptors is a dict like this:
+        # {
+        #     "DESCRIPTOR_NAME": {
+        #         "min": 0.5,
+        #         "max": 1.5,
+        #         "unit": "mm"
+        #         "mean": 1.0
+        #         "std": 0.1
+        #         "required": True
+        #     }
+        #}
+        # Iterate over all numerical descriptors
+        # if required is true, set random values following the constraints and distribution
+        # available distributions are: normal, uniform 
+        
+        for descriptor_name, descriptor in numerical_descriptors.items():
+            required = descriptor.get("required", False)
+            if required:
+                min_val = descriptor.get("min", 0)
+                max_val = descriptor.get("max", 1)
+                distribution = descriptor.get("distribution", "normal")
+                if distribution == "normal":
+                    mean = descriptor.get("mean", 0.5)
+                    std = descriptor.get("std", 0.1)
+                    value = np.random.normal(mean, std)
+                    # clip value to min and max
+                    value = np.clip(value, min_val, max_val)
+                elif distribution == "uniform":
+                    value = np.random.uniform(min_val, max_val)
+                else:
+                    raise ValueError("Distribution not supported")
+                
+                self.numerical_descriptors[descriptor_name]["value"] = value
+
+        self.save()

endoreg_db/models/persons/__init__.py

@@ -1,7 +1,34 @@
 from .gender import Gender
 from .person import Person
-from .patient import *
+from .patient import (
+    Patient, PatientForm,
+    PatientEvent,
+    PatientDisease,
+    PatientLabSample, PatientLabSampleType,
+    PatientLabValue,
+    PatientMedication,
+    PatientMedicationSchedule,
+    PatientExaminationIndication
+)
 from .examiner import Examiner, ExaminerSerializer
 from .portal_user_information import PortalUserInfo, Profession
 from .first_name import FirstName
-from .last_name import LastName
+from .last_name import LastName
+
+
+__all__ = [
+    "Gender",
+    "Person",
+    "Patient", "PatientForm",
+    "PatientEvent",
+    "PatientDisease",
+    "PatientLabSample", "PatientLabSampleType",
+    "PatientLabValue",
+    "PatientMedication",
+    "PatientMedicationSchedule",
+    "PatientExaminationIndication",
+    "Examiner", "ExaminerSerializer",
+    "PortalUserInfo", "Profession",
+    "FirstName",
+    "LastName"
+]

endoreg_db/models/persons/examiner/examiner.py

@@ -1,16 +1,60 @@
 from django.db import models
 from ..person import Person
 from rest_framework import serializers
+from endoreg_db.utils import get_examiner_hash
+
+import os
+# from icecream import ic
+# from datetime import date
+
+# get DJANGO_SALT from environment
+SALT = os.getenv("DJANGO_SALT", "default_salt")
+
 
 class Examiner(Person):
-    center = models.ForeignKey('Center', on_delete=models.CASCADE, blank=True, null=True)
+    center = models.ForeignKey(
+        "Center", on_delete=models.CASCADE, blank=True, null=True
+    )
+    hash = models.CharField(max_length=255, unique=True)
 
     def __str__(self):
         return self.first_name + " " + self.last_name
-    
+
+    @classmethod
+    def custom_get_or_create(cls, first_name: str, last_name: str, center: "Center"):
+        from endoreg_db.models import Center
+        from endoreg_db.utils import create_mock_examiner_name
+
+        assert isinstance(center, Center), (
+            f"center must be an instance of Center, not {type(center)}"
+        )
+        created = False
+
+        hash = get_examiner_hash(
+            first_name=first_name,  #
+            last_name=last_name,
+            center_name=center.name,
+            salt=SALT,
+        )
+
+        examiner_exists = cls.objects.filter(hash=hash).exists()
+        if examiner_exists:
+            examiner = cls.objects.get(hash=hash)
+
+        else:
+            first_name, last_name = create_mock_examiner_name()
+            examiner = cls.objects.create(
+                first_name=first_name,
+                last_name=last_name,
+                center=center,
+                hash=hash,
+            )
+            examiner.save()
+            created = True
+        return examiner, created
+
 
 class ExaminerSerializer(serializers.ModelSerializer):
-    
     class Meta:
         model = Examiner
-        fields = '__all__'
+        fields = "__all__"

endoreg_db/models/persons/patient/__init__.py

@@ -5,4 +5,4 @@ from .patient_lab_sample import PatientLabSample, PatientLabSampleType
 from .patient_lab_value import PatientLabValue
 from .patient_medication import PatientMedication
 from .patient_medication_schedule import PatientMedicationSchedule
-from .case import *
+from .patient_examination_indication import PatientExaminationIndication