endoreg-db 0.6.3__py3-none-any.whl → 0.8.1__py3-none-any.whl

endoreg_db/models/patient/patient_finding_location.py

@@ -1,120 +0,0 @@
-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

@@ -1,166 +0,0 @@
-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/permissions/__init__.py

@@ -1,44 +0,0 @@
-from django.contrib.contenttypes.models import ContentType
-from django.contrib.auth.models import Permission
-from endoreg_db.models import *  # Import your models here
-from django.db import transaction
-
-# Step 1: Define model to category mappings
-# Assuming every model class name is unique across your entire Django project
-model_categories = {
-    'SensitiveModel1': 'sensitive',
-    'SensitiveModel2': 'sensitive',
-    'DevelopmentModel1': 'development',
-    'DevelopmentModel2': 'development',
-    # Add all models you have, mapping them to either 'sensitive', 'development', or 'all'
-}
-
-# Step 2: Define permissions for each category
-category_permissions = {
-    'sensitive': ['view', 'edit', 'delete'],
-    'development': ['view', 'edit'],
-    'all': ['view'],
-}
-
-@transaction.atomic
-def create_permissions_for_all_models():
-    for model_class_name, category in model_categories.items():
-        model_class = globals().get(model_class_name)
-        if model_class is None:
-            print(f"Model {model_class_name} not found.")
-            continue
-        
-        content_type = ContentType.objects.get_for_model(model_class)
-        permissions = category_permissions.get(category, [])
-
-        for permission_codename in permissions:
-            permission_name = f"Can {permission_codename} {model_class_name}"
-            permission, created = Permission.objects.get_or_create(
-                codename=f"{permission_codename}_{model_class_name.lower()}",
-                defaults={'name': permission_name, 'content_type': content_type},
-            )
-            if created:
-                print(f"Created permission: {permission_name}")
-
-# Run the function to create and assign permissions based on categories
-create_permissions_for_all_models()

endoreg_db/models/persons/__init__.py

@@ -1,34 +0,0 @@
-from .gender import Gender
-from .person import Person
-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
-
-
-__all__ = [
-    "Gender",
-    "Person",
-    "Patient", "PatientForm",
-    "PatientEvent",
-    "PatientDisease",
-    "PatientLabSample", "PatientLabSampleType",
-    "PatientLabValue",
-    "PatientMedication",
-    "PatientMedicationSchedule",
-    "PatientExaminationIndication",
-    "Examiner", "ExaminerSerializer",
-    "PortalUserInfo", "Profession",
-    "FirstName",
-    "LastName"
-]

endoreg_db/models/persons/examiner/__init__.py

@@ -1,2 +0,0 @@
-from .examiner import Examiner, ExaminerSerializer
-# from .examiner_type import ExaminerType

endoreg_db/models/persons/examiner/examiner.py

@@ -1,60 +0,0 @@
-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
-    )
-    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__"

endoreg_db/models/persons/examiner/examiner_type.py

@@ -1,2 +0,0 @@
-from .examiner import Examiner
-# from .examiner_type import ExaminerType

endoreg_db/models/persons/patient/__init__.py

@@ -1,8 +0,0 @@
-from .patient import Patient, PatientForm
-from .patient_event import PatientEvent
-from .patient_disease import PatientDisease
-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 .patient_examination_indication import PatientExaminationIndication