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

endoreg_db/models/finding/finding_location_classification.py

@@ -0,0 +1,94 @@
+from django.db import models
+from typing import List
+# Class to represent the LocationClassifications of a Finding
+
+class FindingLocationClassificationManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class FindingLocationClassification(models.Model):
+    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)
+
+    # Many to many relationships:
+    findings = models.ManyToManyField('Finding', blank=True, related_name='location_classifications')
+    examinations = models.ManyToManyField('Examination', blank=True, related_name='location_classifications')
+    finding_types = models.ManyToManyField('FindingType', blank=True, related_name='location_classifications')
+    choices = models.ManyToManyField('FindingLocationClassificationChoice', blank=True, related_name='location_classifications')
+    
+    objects = FindingLocationClassificationManager()
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    
+    def get_available_findings(self):
+        from endoreg_db.models import Finding
+        available_findings:List[Finding] = [_ for _ in self.findings.all()]
+        return available_findings
+    
+    def remove_unavailable_findings(
+            self,
+            findings
+    ):
+        """
+        Returns a list of findings that are in the input list but not available for this location classification.
+        """
+        from endoreg_db.models import Finding
+        for _ in findings:
+            assert isinstance(_, Finding)
+        available_findings:List['Finding'] = self.get_available_findings()
+        available_finding_names = [
+            finding.name for finding in available_findings
+        ]
+
+        filtered_findings = []
+
+        for finding in findings:
+            if finding.name in available_finding_names:
+                filtered_findings.append(finding)
+
+        return filtered_findings
+
+    def get_choices(self):
+        return self.choices.all()
+
+class FindingLocationClassificationChoiceManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class FindingLocationClassificationChoice(models.Model):
+    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)
+
+    # Foreign key relationships: # migrated to organs
+    # organs = models.ManyToManyField('Organ', blank=True, related_name='location_choices')
+    
+    # Optional Descriptors:
+    # subcategories_str is a List of strings with names of categorical descriptors
+    subcategories = models.JSONField(blank=True, null=True)
+    numerical_descriptors = models.JSONField(blank=True, null=True)
+
+    objects = FindingLocationClassificationChoiceManager()
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    
+    def get_subcategories(self)->dict:
+        return self.subcategories
+    
+    def get_numerical_descriptors(self)->dict:
+        return self.numerical_descriptors

endoreg_db/models/finding/finding_morphology_classification.py

@@ -0,0 +1,89 @@
+from django.db import models
+from typing import List
+
+class FindingMorphologyClassificationTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class FindingMorphologyClassificationType(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True)
+    name_en = models.CharField(max_length=255, blank=True)
+    description = models.TextField(blank=True)
+    
+    objects = FindingMorphologyClassificationTypeManager()
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    
+    @classmethod
+    def get_required_classifications_for_finding(cls, finding):
+        """
+        Returns all required morphology classification types for a given finding.
+        """
+        from endoreg_db.models import FindingMorphologyClassificationType
+        required_classification_types:List[FindingMorphologyClassificationType] = [
+            _ for _ in finding.required_morphology_classification_types.all()
+        ]
+        return required_classification_types
+    
+class FindingMorphologyClassificationManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class FindingMorphologyClassification(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True)
+    name_en = models.CharField(max_length=255, blank=True)
+    description = models.TextField(blank=True)
+    classification_type = models.ForeignKey(FindingMorphologyClassificationType, on_delete=models.CASCADE)
+    
+    objects = FindingMorphologyClassificationManager()
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    
+    def get_choices(self):
+        choices: List[FindingMorphologyClassificationChoice] = [_ for _ in self.choices.all()]
+        return choices
+    
+class FindingMorphologyClassificationChoiceManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class FindingMorphologyClassificationChoice(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True)
+    name_en = models.CharField(max_length=255, blank=True)
+    description = models.TextField(blank=True)
+    classification = models.ForeignKey(
+        FindingMorphologyClassification, 
+        on_delete=models.CASCADE,
+        related_name='choices'
+    )
+    
+    subcategories = models.JSONField(
+        default = dict
+    )
+
+    numerical_descriptors = models.JSONField(
+        default = dict
+    )
+
+    objects = FindingMorphologyClassificationChoiceManager()
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        _str = f"{self.name} ({self.classification})"
+        return _str
+
+    
+        

endoreg_db/models/finding/finding_type.py

@@ -0,0 +1,22 @@
+from django.db import models
+
+
+class FindingTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class FindingType(models.Model):
+    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)
+
+    objects = FindingTypeManager()
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name

endoreg_db/models/hardware/endoscope.py

@@ -8,7 +8,23 @@ class Endoscope(models.Model):
     objects = EndoscopeManager()
     
     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)
     sn = models.CharField(max_length=255)
+    center = models.ForeignKey(
+        'Center',
+        blank=True, 
+        null=True, 
+        on_delete=models.CASCADE,
+        related_name='endoscopes'
+    )
+    endoscope_type = models.ForeignKey(
+        'EndoscopeType', 
+        blank=True, 
+        null=True, 
+        on_delete=models.CASCADE,
+        related_name='endoscopes'
+    )
     
     def natural_key(self):
         return (self.name, self.sn)

endoreg_db/models/hardware/endoscopy_processor.py

@@ -1,12 +1,20 @@
 from django.db import models
 
+
 class EndoscopyProcessorManager(models.Manager):
     def get_by_natural_key(self, name):
         return self.get(name=name)
 
+
 class EndoscopyProcessor(models.Model):
     objects = EndoscopyProcessorManager()
 
+    centers = models.ManyToManyField(
+        "Center",
+        blank=True,
+        related_name="endoscopy_processors",
+    )
+
     name = models.CharField(max_length=255)
     image_width = models.IntegerField()
     image_height = models.IntegerField()
@@ -62,74 +70,78 @@ class EndoscopyProcessor(models.Model):
 
     def natural_key(self):
         return (self.name,)
-    
+
+    @classmethod
+    def get_by_name(self, name):
+        return self.objects.get(name=name)
+
     def __str__(self):
         return self.name
-    
+
     def get_roi_endoscope_image(self):
         return {
             "x": self.endoscope_image_x,
             "y": self.endoscope_image_y,
             "width": self.endoscope_image_width,
-            "height": self.endoscope_image_height
+            "height": self.endoscope_image_height,
         }
-    
+
     def get_roi_examination_date(self):
         return {
             "x": self.examination_date_x,
             "y": self.examination_date_y,
             "width": self.examination_date_width,
-            "height": self.examination_date_height
+            "height": self.examination_date_height,
         }
-    
+
     def get_roi_examination_time(self):
         return {
             "x": self.examination_time_x,
             "y": self.examination_time_y,
             "width": self.examination_time_width,
-            "height": self.examination_time_height
+            "height": self.examination_time_height,
         }
-    
+
     def get_roi_patient_last_name(self):
         return {
             "x": self.patient_last_name_x,
             "y": self.patient_last_name_y,
             "width": self.patient_last_name_width,
-            "height": self.patient_last_name_height
+            "height": self.patient_last_name_height,
         }
-    
+
     def get_roi_patient_first_name(self):
         return {
             "x": self.patient_first_name_x,
             "y": self.patient_first_name_y,
             "width": self.patient_first_name_width,
-            "height": self.patient_first_name_height
+            "height": self.patient_first_name_height,
         }
-    
+
     def get_roi_patient_dob(self):
         return {
             "x": self.patient_dob_x,
             "y": self.patient_dob_y,
             "width": self.patient_dob_width,
-            "height": self.patient_dob_height
+            "height": self.patient_dob_height,
         }
-    
+
     def get_roi_endoscope_type(self):
         return {
             "x": self.endoscope_type_x,
             "y": self.endoscope_type_y,
             "width": self.endoscope_type_width,
-            "height": self.endoscope_type_height
+            "height": self.endoscope_type_height,
         }
-    
+
     def get_roi_endoscopy_sn(self):
         return {
             "x": self.endoscope_sn_x,
             "y": self.endoscope_sn_y,
             "width": self.endoscope_sn_width,
-            "height": self.endoscope_sn_height
+            "height": self.endoscope_sn_height,
         }
-    
+
     def get_rois(self):
         return {
             "endoscope_image": self.get_roi_endoscope_image(),
@@ -139,5 +151,5 @@ class EndoscopyProcessor(models.Model):
             "patient_last_name": self.get_roi_patient_last_name(),
             "patient_dob": self.get_roi_patient_dob(),
             "endoscope_type": self.get_roi_endoscope_type(),
-            "endoscope_sn": self.get_roi_endoscopy_sn()
+            "endoscope_sn": self.get_roi_endoscopy_sn(),
         }

endoreg_db/models/label/label.py

@@ -1,9 +1,11 @@
 from django.db import models
 
+
 class LabelTypeManager(models.Manager):
     def get_by_natural_key(self, name):
         return self.get(name=name)
 
+
 class LabelType(models.Model):
     """
     A class representing a label type.
@@ -13,22 +15,28 @@ class LabelType(models.Model):
         description (str): A description of the label type.
 
     """
+
     name = models.CharField(max_length=255)
     description = models.TextField(blank=True, null=True)
 
     objects = LabelTypeManager()
 
     def natural_key(self):
+        """Return the natural key of this label type"""
         return (self.name,)
 
     def __str__(self):
-        return self.name
+        return str(self.name)
 
 
 class LabelManager(models.Manager):
+    """Manager class for handling Label model operations."""
+
     def get_by_natural_key(self, name):
+        """Retrieves a Label instance by its natural key (name)."""
         return self.get(name=name)
 
+
 class Label(models.Model):
     """
     A class representing a label.
@@ -39,22 +47,37 @@ class Label(models.Model):
         description (str): A description of the label.
 
     """
+
     name = models.CharField(max_length=255)
-    label_type = models.ForeignKey("LabelType", on_delete=models.CASCADE, related_name="labels")
+    label_type = models.ForeignKey(
+        "LabelType", on_delete=models.CASCADE, related_name="labels"
+    )
     description = models.TextField(blank=True, null=True)
 
     objects = LabelManager()
 
     def natural_key(self):
+        """Return the natural key of this label"""
         return (self.name,)
 
     def __str__(self):
-        return self.name
+        return str(self.name)
+
 
 class LabelSetManager(models.Manager):
+    """
+    Manager class for handling LabelSet model operations.
+    Methods
+    -------
+    get_by_natural_key(name)
+
+    """
+
     def get_by_natural_key(self, name):
+        """Retrieves a LabelSet instance by its natural key (name)."""
         return self.get(name=name)
 
+
 class LabelSet(models.Model):
     """
     A class representing a label set.
@@ -64,21 +87,26 @@ class LabelSet(models.Model):
         description (str): A description of the label set.
 
     """
+
     name = models.CharField(max_length=255)
     description = models.TextField(blank=True, null=True)
     version = models.IntegerField()
     labels = models.ManyToManyField("Label", related_name="labels")
-    
+
     objects = LabelSetManager()
 
     def natural_key(self):
+        """Return the natural key of this label set"""
         return (self.name,)
 
     def __str__(self):
-        return self.name
-    
+        return str(self.name)
+
     def get_labels_in_order(self):
         """
         Get all labels in this label set as list in the correct order.
+        Ordered by string representation (a is first).
         """
-        return list(self.labels.all().order_by('id'))
+        labels = list(self.labels.all())
+        labels.sort(key=lambda x: x.name)
+        return labels

endoreg_db/models/laboratory/lab_value.py

@@ -63,7 +63,11 @@ class LabValue(models.Model):
             warnings.warn("No default distribution set for lab value")
             return None
     
-    def get_normal_range(self, age=None, gender=None):
+    def get_normal_range(self, age:int=None, gender=None):
+        from endoreg_db.models import Gender
+        assert isinstance(age, int) or age is None
+        assert isinstance(gender, Gender) or gender is None
+
         age_dependent = self.normal_range_age_dependent
         gender_dependent = self.normal_range_gender_dependent
         special_case = self.normal_range_special_case
@@ -90,7 +94,7 @@ class LabValue(models.Model):
                 choices = ["male", "female"]
                 gender = choice(choices)
 
-            default_range_dict = self.default_normal_range.get(gender, {})
+            default_range_dict = self.default_normal_range.get(gender.name, {})
             min_value = default_range_dict.get('min', None)
             max_value = default_range_dict.get('max', None)
 
@@ -98,5 +102,10 @@ class LabValue(models.Model):
             # get normal range for special case
             warnings.warn("Special case normal range not implemented yet")
 
-        return min_value, max_value
+        normal_range_dict = {
+            "min": min_value,
+            "max": max_value
+        }
+
+        return normal_range_dict
 

endoreg_db/models/logging/__init__.py

@@ -1,4 +1,11 @@
 from .base import AbstractLogEntry
 from .network_device import NetworkDeviceLogEntry
 from .log_type import LogType
-from .agl_service import AglServiceLogEntry
+from .agl_service import AglServiceLogEntry
+
+__all__ = [
+    "AbstractLogEntry",
+    "NetworkDeviceLogEntry",
+    "LogType",
+    "AglServiceLogEntry",
+]

endoreg_db/models/lx/__init__.py

@@ -0,0 +1,4 @@
+from .client import LxClientType, LxClientTag, LxClient
+from .identity import LxIdentity, LxIdentityType
+from .permission import LxPermission
+from .user import LxUser

endoreg_db/models/lx/client.py

@@ -0,0 +1,57 @@
+# Insert models for Client, Client Type, Client Tag
+
+from django.db import models
+
+class LxClientTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+#TODO implement base population for client Type
+
+class LxClientType(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    abbreviation = models.CharField(max_length=10, unique=True)  # New field
+    description = models.TextField(blank=True)
+    objects = LxClientTypeManager()
+    
+    def __str__(self):
+        return self.name
+    
+    def natural_key(self):
+        return (self.name,)
+    
+
+class LxClientTagManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+#TODO implement base population for client Tag
+
+class LxClientTag(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True)
+    objects = LxClientTagManager()
+
+    # M2M relationship with LxPermission
+    permissions = models.ManyToManyField('LxPermission', blank=True, related_name="allowed_client_tags")
+    
+    def __str__(self):
+        return self.name
+    
+    def natural_key(self):
+        return (self.name,)
+
+class LxClientManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+#TODO implement base population for client
+
+class LxClient(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True)
+    client_type = models.ForeignKey(LxClientType, on_delete=models.CASCADE)
+    client_tags = models.ManyToManyField(LxClientTag, blank=True)
+    vpn_ip = models.GenericIPAddressField(blank=True, null=True)
+    objects = LxClientManager()
+

endoreg_db/models/lx/identity.py

@@ -0,0 +1,34 @@
+from django.db import models
+
+class LxIdentityTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+#TODO implement base population for identity Type
+## ed25519, rsa, ecdsa, dsa, etc
+
+class LxIdentityType(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True)
+    objects = LxIdentityTypeManager()
+    
+    def __str__(self):
+        return self.name
+    
+    def natural_key(self):
+        return (self.name,)
+
+class LxIdentity(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True)
+    identity_type = models.ForeignKey(LxIdentityType, on_delete=models.CASCADE)
+    objects = models.Manager()
+
+    # Foreign key to user, nullable
+    user = models.ForeignKey('LxUser', on_delete=models.CASCADE, null=True, blank=True)
+    
+    def __str__(self):
+        return self.name
+    
+    def natural_key(self):
+        return (self.name,)

endoreg_db/models/lx/permission.py

@@ -0,0 +1,18 @@
+from django.db import models
+
+class LxPermissionManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+#TODO implement base population for permission
+
+class LxPermission(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True)
+    objects = LxPermissionManager()
+    
+    def __str__(self):
+        return self.name
+    
+    def natural_key(self):
+        return (self.name,)

endoreg_db/models/lx/user.py

@@ -0,0 +1,16 @@
+from django.db import models
+
+class LxUserManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+
+class LxUser(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True)
+
+    
+
+    # to be extended
+
+

endoreg_db/models/medication/__init__.py

@@ -1 +1,19 @@
-from .medication import *
+"""Medication models initialization module."""
+from .medication import Medication, MedicationManager
+from .medication_schedule import MedicationSchedule, MedicationScheduleManager
+from .medication_intake_time import MedicationIntakeTime, MedicationIntakeTimeManager
+from .medication_indication_type import MedicationIndicationType, MedicationIndicationTypeManager
+from .medication_indication import MedicationIndication, MedicationIndicationManager
+
+__all__ = [
+    "Medication",
+    "MedicationManager",
+    "MedicationSchedule",
+    "MedicationScheduleManager",
+    "MedicationIntakeTime",
+    "MedicationIntakeTimeManager",
+    "MedicationIndicationType",
+    "MedicationIndicationTypeManager",
+    "MedicationIndication",
+    "MedicationIndicationManager"
+]