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

endoreg_db/models/medication/medication.py

@@ -1,10 +1,15 @@
+'''Model for the medication.'''
 from django.db import models
 
+
 class MedicationManager(models.Manager):
+    '''Manager for the medication model.'''
     def get_by_natural_key(self, name):
+        '''Retrieve a medication by its natural key.'''
         return self.get(name=name)
 
 class Medication(models.Model):
+    '''Model representing a medication.'''
     name = models.CharField(max_length=255, unique=True)
     name_de = models.CharField(max_length=255, blank=True, null=True)
     name_en = models.CharField(max_length=255, blank=True, null=True)
@@ -20,129 +25,9 @@ class Medication(models.Model):
     objects = MedicationManager()
 
     def natural_key(self):
+        '''Return the natural key for the medication.'''
         return (self.name,)
 
     def __str__(self):
-        return self.name
-    
-class MedicationScheduleManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-class MedicationSchedule(models.Model):
-    name = models.CharField(max_length=255)
-    name_de = models.CharField(max_length=255, blank=True, null=True)
-    name_en = models.CharField(max_length=255, blank=True, null=True)
-    description = models.TextField(blank=True, null=True)
-    medication = models.ForeignKey("Medication", on_delete=models.CASCADE)
-    unit = models.ForeignKey("Unit", on_delete=models.CASCADE)
-    therapy_duration_d = models.FloatField(blank=True, null=True)
-    dose = models.FloatField()
-    intake_times = models.ManyToManyField(
-        "MedicationIntakeTime", 
-    )
-
-    objects = MedicationScheduleManager()
-
-    def natural_key(self):
-        return (self.name,)
-    
-    def __str__(self):
-        return self.name
-    
-    
-class MedicationIntakeTimeManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-class MedicationIntakeTime(models.Model):
-    name = models.CharField(max_length=255)
-    name_de = models.CharField(max_length=255, blank=True, null=True)
-    name_en = models.CharField(max_length=255, blank=True, null=True)
-    repeats = models.CharField(max_length=20, default = "daily")
-    time = models.TimeField()
-
-    objects = MedicationIntakeTimeManager()
-
-    def natural_key(self):
-        return (self.name,)
-    
-    def __str__(self):
-        return self.name
-
-# IMPLEMENT MEDICATION INDICATION TYPE
-class MedicationIndicationTypeManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-
-class MedicationIndicationType(models.Model):
-    name = models.CharField(max_length=255, unique=True)
-    name_de = models.CharField(max_length=255, blank=True, null=True)
-    name_en = models.CharField(max_length=255, blank=True, null=True)
-
-    objects = MedicationIndicationTypeManager()
-
-    def natural_key(self):
-        return (self.name,)
-
-    def __str__(self):
-        return self.name
-    
-    @classmethod
-    def get_random_indication_by_type(cls, name) -> "MedicationIndication":
-        return cls.objects.get(name=name).medication_indications.order_by('?').first()
-    
-
-    def get_random_medication_indication(self):
-        from endoreg_db.models import MedicationIndication
-        return MedicationIndication.objects.filter(indication_type=self).order_by('?').first()
-
-
-class MedicationIndicationManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-
-class MedicationIndication(models.Model):
-    name = models.CharField(max_length=255, unique=True)
-    indication_type = models.ForeignKey(
-        "MedicationIndicationType", on_delete=models.CASCADE, related_name="medication_indications"
-    )
-    medication_schedules = models.ManyToManyField(
-        "MedicationSchedule"
-    )
-    diseases = models.ManyToManyField(
-        "Disease"
-    )
-    events = models.ManyToManyField(
-        "Event"
-    )
-    classification_choices = models.ManyToManyField(
-        "DiseaseClassificationChoice"
-    )
-    sources = models.ManyToManyField(
-        "InformationSource"
-    )
-
-    def get_indication_links(self):
-        links = {
-            "medication_schedules": self.medication_schedules,
-            "diseases": self.diseases,
-            "events": self.events,
-            "classification_choices": self.classification_choices
-        }
-
-    objects = MedicationIndicationManager()
-
-    def natural_key(self):
-        return (self.name,)
-    
-    def __str__(self):
-        return self.name
+        return str(self.name)
     
-    def create_patient_medication_schedules(self, patient):
-        from endoreg_db.models import PatientMedicationSchedule
-        for medication_schedule in self.medication_schedules.all():
-            PatientMedicationSchedule.objects.create(
-                patient=patient,
-                medication_schedule=medication_schedule
-            )

endoreg_db/models/medication/medication_indication.py

@@ -0,0 +1,50 @@
+"""Model for medication indication."""
+
+from django.db import models
+
+
+class MedicationIndicationManager(models.Manager):
+    """Manager for the medication indication model."""
+
+    def get_by_natural_key(self, name):
+        """Retrieve a medication indication by its natural key."""
+        return self.get(name=name)
+
+
+class MedicationIndication(models.Model):
+    """Model representing a medication indication."""
+
+    name = models.CharField(max_length=255, unique=True)
+    indication_type = models.ForeignKey(
+        "MedicationIndicationType",
+        on_delete=models.CASCADE,
+        related_name="medication_indications",
+    )
+    medication_schedules = models.ManyToManyField(
+        "MedicationSchedule",
+    )
+    diseases = models.ManyToManyField("Disease")
+    events = models.ManyToManyField("Event")
+    disease_classification_choices = models.ManyToManyField(
+        "DiseaseClassificationChoice"
+    )
+    sources = models.ManyToManyField("InformationSource")
+
+    def get_indication_links(self) -> dict:
+        """Return a dictionary of all linked objects for this medication indication."""
+        links = {
+            "medication_schedules": self.medication_schedules,
+            "diseases": self.diseases,
+            "events": self.events,
+            "disease_classification_choices": self.disease_classification_choices,
+        }
+        return links
+
+    objects = MedicationIndicationManager()
+
+    def natural_key(self):
+        """Return the natural key for the medication indication."""
+        return (self.name,)
+
+    def __str__(self):
+        return str(self.name)

endoreg_db/models/medication/medication_indication_type.py

@@ -0,0 +1,34 @@
+'''Model for medication indication type.'''
+from django.db import models
+
+class MedicationIndicationTypeManager(models.Manager):
+    '''Manager for the medication indication type model.'''
+    def get_by_natural_key(self, name):
+        '''Retrieve a medication indication type by its natural key.'''
+        return self.get(name=name)
+
+class MedicationIndicationType(models.Model):
+    '''Model representing a medication indication type.'''
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+
+    objects = MedicationIndicationTypeManager()
+
+    def natural_key(self):
+        '''Return the natural key for the medication indication type.'''
+        return (self.name,)
+
+    def __str__(self):
+        return str(self.name)
+    
+    @classmethod
+    def get_random_indication_by_type(cls, name) -> "MedicationIndication":
+        '''Return a random medication indication of the given type.'''
+        return cls.objects.get(name=name).medication_indications.order_by('?').first()
+    
+
+    def get_random_medication_indication(self):
+        '''Return a random medication indication of this type.'''
+        from endoreg_db.models import MedicationIndication
+        return MedicationIndication.objects.filter(indication_type=self).order_by('?').first()

endoreg_db/models/medication/medication_intake_time.py

@@ -0,0 +1,26 @@
+'''Model for medication intake time'''
+from django.db import models
+
+
+class MedicationIntakeTimeManager(models.Manager):
+    '''Manager for the medication intake time model.'''
+    def get_by_natural_key(self, name):
+        '''Retrieve a medication intake time by its natural key.'''
+        return self.get(name=name)
+    
+class MedicationIntakeTime(models.Model):
+    '''Model representing a medication intake time.'''
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+    repeats = models.CharField(max_length=20, default = "daily")
+    time = models.TimeField()
+
+    objects = MedicationIntakeTimeManager()
+
+    def natural_key(self):
+        '''Return the natural key for the medication intake time.'''
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name + " at " + str(self.time) + " (" + self.repeats + ")"

endoreg_db/models/medication/medication_schedule.py

@@ -0,0 +1,37 @@
+'''Model for the medication schedule.'''
+from typing import List
+from django.db import models
+
+class MedicationScheduleManager(models.Manager):
+    '''Manager for the medication schedule model.'''
+    def get_by_natural_key(self, name):
+        '''Retrieve a medication schedule by its natural key.'''
+        return self.get(name=name)
+    
+class MedicationSchedule(models.Model):
+    '''Model representing a medication schedule.'''
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+    medication = models.ForeignKey("Medication", on_delete=models.CASCADE)
+    unit = models.ForeignKey("Unit", on_delete=models.CASCADE)
+    therapy_duration_d = models.FloatField(blank=True, null=True)
+    dose = models.FloatField()
+    intake_times = models.ManyToManyField(
+        "MedicationIntakeTime", 
+    )
+
+    objects = MedicationScheduleManager()
+
+    def natural_key(self):
+        '''Return the natural key for the medication schedule.'''
+        return (self.name,)
+    
+    def __str__(self):
+        return str(self.name)
+    
+    def get_intake_times(self) -> List["MedicationIntakeTime"]:
+        '''Return a list of all intake times for this medication schedule.'''
+        return [_ for _ in self.intake_times.all()] # type: ignore # pylint: disable=E1101
+    

endoreg_db/models/network/__init__.py

@@ -1,3 +1,9 @@
 from .network_device import NetworkDevice
 from .network_device_type import NetworkDeviceType
-from .agl_service import AglService
+from .agl_service import AglService
+
+__all__ = [
+    "NetworkDevice",
+    "NetworkDeviceType",
+    "AglService",
+]

endoreg_db/models/network/network_device.py

@@ -1,13 +1,16 @@
-# Django db class to store network devices (e.g., servers, clients, switches, etc.)
-
+import subprocess
 from django.db import models
 
+# Django db class to store network devices (e.g., servers, clients, switches, etc.)
+
 class NetworkDeviceManager(models.Manager):
-    # Custom manager for NetworkDevice; defines name as natural key
+    """Custom manager for NetworkDevice that defines name as natural key."""
     def get_by_natural_key(self, name):
+        """Return the network device with the given name as its natural key."""
         return self.get(name=name)
     
 class NetworkDevice(models.Model):
+    """Django model representing a network device."""
     name = models.CharField(max_length=255)
     ip = models.GenericIPAddressField(blank=True, null=True)
     description = models.CharField(max_length=255)
@@ -18,21 +21,23 @@ class NetworkDevice(models.Model):
     objects = NetworkDeviceManager()
 
     def __str__(self):
-        return self.name
+        """Return the device name."""
+        return str(self.name)
 
+    # pylint: disable=too-few-public-methods
     class Meta:
+        """Meta options for the NetworkDevice model."""
         db_table = 'network_devices'
         ordering = ['name']
         
     def natural_key(self):
+        """Return a tuple representing the natural key for this network device."""
         return (self.name,)
     
     def ping(self):
+        """Check device availability by sending one ping request."""
         target_ip = self.ip
 
-        # Import the required module
-        import subprocess
-
         # Define the command
         command = ['ping', '-c', '1', target_ip]
 
@@ -49,5 +54,5 @@ class NetworkDevice(models.Model):
         self.online = return_code == 0
         self.save()
         return self.online
-    
+
 

endoreg_db/models/organ/__init__.py

@@ -0,0 +1,38 @@
+"""Module for Organ models."""
+from django.db import models
+
+class OrganManager(models.Manager):
+    """Manager for Organ model."""
+
+    def get_by_natural_key(self, name):
+        """Retrieve an Organ by its natural key."""
+        return self.get(name=name)
+    
+    def all_names(self):
+        """Return a list of all organ names."""
+        return list(self.all().values_list('name', flat=True))
+    
+class Organ(models.Model):
+    """Model representing an organ."""
+    
+    name = models.CharField(max_length=100, unique=True)
+    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)
+    description_de = models.TextField(blank=True, null=True)
+    description_en = models.TextField(blank=True, null=True)
+
+    location_choices = models.ManyToManyField(
+        'FindingLocationClassificationChoice', 
+        blank=True, related_name='organs'
+    )
+
+    objects = OrganManager()
+    
+    def natural_key(self):
+        """Return the natural key for the organ."""
+        return (self.name,)
+    
+    def __str__(self):
+        """Return string representation of the organ."""
+        return str(self.name)

endoreg_db/models/other/__init__.py

@@ -2,4 +2,22 @@ from .material import Material
 from .resource import Resource
 from .transport_route import TransportRoute
 from .waste import Waste
-from .distribution import *
+from .distribution import (
+    BaseValueDistribution,
+    NumericValueDistribution,
+    SingleCategoricalValueDistribution,
+    MultipleCategoricalValueDistribution,
+    DateValueDistribution,
+)
+
+__all__ = [
+    'Material',
+    'Resource',
+    'TransportRoute',
+    'Waste',
+    'BaseValueDistribution',
+    'NumericValueDistribution',
+    'SingleCategoricalValueDistribution',
+    'MultipleCategoricalValueDistribution',
+    'DateValueDistribution',
+]

endoreg_db/models/other/distribution/__init__.py

@@ -0,0 +1,44 @@
+'''Module for distribution models.'''
+
+from .base_value_distribution import BaseValueDistribution
+from .numeric_value_distribution import NumericValueDistribution
+from .single_categorical_value_distribution import SingleCategoricalValueDistribution
+from .multiple_categorical_value_distribution import MultipleCategoricalValueDistribution
+from .date_value_distribution import DateValueDistribution
+
+
+__all__ = [
+    'BaseValueDistribution',
+    'NumericValueDistribution',
+    'SingleCategoricalValueDistribution',
+    'MultipleCategoricalValueDistribution',
+    'DateValueDistribution',
+]
+
+# Example Usage
+# Numeric distribution for age
+# age_distribution = NumericValueDistribution.objects.create(
+#     name='Age Distribution',
+#     distribution_type='normal',
+#     min_value=0,
+#     max_value=100,
+#     mean=50,
+#     std_dev=15
+# )
+
+# # Single categorical distribution for gender
+# gender_distribution = SingleCategoricalValueDistribution.objects.create(
+#     name='Gender Distribution',
+#     categories={'male': 0.5, 'female': 0.5}
+# )
+
+# # Multiple categorical distribution for symptoms
+# symptoms_distribution = MultipleCategoricalValueDistribution.objects.create(
+#     name='Symptoms Distribution',
+#     categories={'fever': 0.3, 'cough': 0.4, 'fatigue': 0.2, 'nausea': 0.1},
+#     min_count=1,
+#     max_count=3,
+#     count_distribution_type='normal',
+#     count_mean=2,
+#     count_std_dev=0.5
+# )

endoreg_db/models/other/distribution/base_value_distribution.py

@@ -0,0 +1,20 @@
+from django.db import models
+
+class BaseValueDistribution(models.Model):
+    """
+    Abstract base class for value distributions.
+    """
+    name = models.CharField(max_length=100)
+
+    class Meta:
+        abstract = True
+
+    def generate_value(self):
+        """
+        Generate a value based on the distribution rules.
+        Must be implemented by subclasses.
+        """
+        raise NotImplementedError("Subclasses must implement this method")
+    
+    def natural_key(self):
+        return (self.name,)

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