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

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/__init__.py

@@ -0,0 +1,2 @@
+from .endoscopy_processor import EndoscopyProcessor
+from .endoscope import Endoscope, EndoscopeType

endoreg_db/models/hardware/endoscope.py

@@ -0,0 +1,60 @@
+from django.db import models
+
+class EndoscopeManager(models.Manager):
+    def get_by_natural_key(self, name, sn):
+        return self.get(name=name, sn=sn)
+    
+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)
+    
+    def __str__(self):
+        return self.name
+    
+    class Meta:
+        ordering = ['name']
+        verbose_name = 'Endoscope'
+        verbose_name_plural = 'Endoscopes'
+
+class EndoscopeTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class EndoscopeType(models.Model):
+    objects = EndoscopeTypeManager()
+    
+    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)
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    
+    class Meta:
+        ordering = ['name']
+        verbose_name = 'Endoscope Type'
+        verbose_name_plural = 'Endoscope Types'

endoreg_db/models/hardware/endoscopy_processor.py

@@ -0,0 +1,155 @@
+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()
+    # image_fps = models.IntegerField()
+
+    # Roi for endoscope image
+    endoscope_image_x = models.IntegerField()
+    endoscope_image_y = models.IntegerField()
+    endoscope_image_width = models.IntegerField()
+    endoscope_image_height = models.IntegerField()
+
+    # Roi for examination date
+    examination_date_x = models.IntegerField()
+    examination_date_y = models.IntegerField()
+    examination_date_width = models.IntegerField()
+    examination_date_height = models.IntegerField()
+
+    # Roi for examination time
+    examination_time_x = models.IntegerField(blank=True, null=True)
+    examination_time_y = models.IntegerField(blank=True, null=True)
+    examination_time_width = models.IntegerField(blank=True, null=True)
+    examination_time_height = models.IntegerField(blank=True, null=True)
+
+    # Roi for patient first name
+    patient_first_name_x = models.IntegerField()
+    patient_first_name_y = models.IntegerField()
+    patient_first_name_width = models.IntegerField()
+    patient_first_name_height = models.IntegerField()
+
+    # Roi for patient name
+    patient_last_name_x = models.IntegerField()
+    patient_last_name_y = models.IntegerField()
+    patient_last_name_width = models.IntegerField()
+    patient_last_name_height = models.IntegerField()
+
+    # Roi for patient dob
+    patient_dob_x = models.IntegerField()
+    patient_dob_y = models.IntegerField()
+    patient_dob_width = models.IntegerField()
+    patient_dob_height = models.IntegerField()
+
+    # Roi for endoscope type
+    endoscope_type_x = models.IntegerField(blank=True, null=True)
+    endoscope_type_y = models.IntegerField(blank=True, null=True)
+    endoscope_type_width = models.IntegerField(blank=True, null=True)
+    endoscope_type_height = models.IntegerField(blank=True, null=True)
+
+    # Roi for endoscopy sn
+    endoscope_sn_x = models.IntegerField(blank=True, null=True)
+    endoscope_sn_y = models.IntegerField(blank=True, null=True)
+    endoscope_sn_width = models.IntegerField(blank=True, null=True)
+    endoscope_sn_height = models.IntegerField(blank=True, null=True)
+
+    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,
+        }
+
+    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,
+        }
+
+    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,
+        }
+
+    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,
+        }
+
+    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,
+        }
+
+    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,
+        }
+
+    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,
+        }
+
+    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,
+        }
+
+    def get_rois(self):
+        return {
+            "endoscope_image": self.get_roi_endoscope_image(),
+            "examination_date": self.get_roi_examination_date(),
+            "examination_time": self.get_roi_examination_time(),
+            "patient_first_name": self.get_roi_patient_first_name(),
+            "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(),
+        }

endoreg_db/models/information_source.py

@@ -0,0 +1,29 @@
+from django.db import models
+
+def get_prediction_information_source():
+    _source = InformationSource.objects.get(name="prediction")
+
+    # make sure to return only one object
+    assert _source, "No prediction information source found"
+    return _source
+
+class InformationSourceManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class InformationSource(models.Model):
+    objects = InformationSourceManager()
+
+    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)
+
+    url = models.URLField(blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+    date = models.DateField(blank=True, null=True)
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name

endoreg_db/models/label/__init__.py

@@ -0,0 +1 @@
+from .label import Label, LabelType, LabelSet

endoreg_db/models/label/label.py

@@ -0,0 +1,112 @@
+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.
+
+    Attributes:
+        name (str): The name of the label type.
+        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 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.
+
+    Attributes:
+        name (str): The name of the label.
+        label_type (LabelType): The type of the label.
+        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"
+    )
+    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 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.
+
+    Attributes:
+        name (str): The name of the label set.
+        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 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).
+        """
+        labels = list(self.labels.all())
+        labels.sort(key=lambda x: x.name)
+        return labels

endoreg_db/models/laboratory/__init__.py

@@ -0,0 +1 @@
+from .lab_value import LabValue

endoreg_db/models/laboratory/lab_value.py

@@ -0,0 +1,111 @@
+from django.db import models
+import warnings
+
+LANG = "de"
+
+class LabValueManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class LabValue(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)
+    abbreviation = models.CharField(max_length=10, blank=True, null=True)
+    default_unit = models.ForeignKey('Unit', on_delete=models.CASCADE, blank=True, null=True)
+    numeric_precision = models.IntegerField(default=3)
+    default_single_categorical_value_distribution = models.ForeignKey(
+        'SingleCategoricalValueDistribution',
+        on_delete=models.CASCADE,
+        blank=True, null=True,
+        related_name='default_single_categorical_value_distribution'
+    )
+    default_numerical_value_distribution = models.ForeignKey(
+        'NumericValueDistribution',
+        on_delete=models.CASCADE,
+        blank=True, null=True,
+        related_name='default_numerical_value_distribution'
+    )
+    default_multiple_categorical_value_distribution = models.ForeignKey(
+        'MultipleCategoricalValueDistribution',
+        on_delete=models.CASCADE,
+        blank=True, null=True,
+        related_name='default_multiple_categorical_value_distribution'
+    )
+    default_date_value_distribution = models.ForeignKey(
+        'DateValueDistribution',
+        on_delete=models.CASCADE,
+        blank=True, null=True,
+        related_name='default_date_value_distribution'
+    )
+    default_normal_range = models.JSONField(blank=True, null=True)
+    normal_range_age_dependent = models.BooleanField(default=False)
+    normal_range_gender_dependent = models.BooleanField(default=False)
+    normal_range_special_case = models.BooleanField(default=False)
+    objects = LabValueManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+    
+    def get_default_default_distribution(self):
+        if self.default_single_categorical_value_distribution:
+            return self.default_single_categorical_value_distribution
+        elif self.default_numerical_value_distribution:
+            return self.default_numerical_value_distribution
+        elif self.default_multiple_categorical_value_distribution:
+            return self.default_multiple_categorical_value_distribution
+        elif self.default_date_value_distribution:
+            return self.default_date_value_distribution
+        else:
+            warnings.warn("No default distribution set for lab value")
+            return 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
+
+        min_value = None
+        max_value = None
+
+        if not age_dependent and \
+        not gender_dependent and \
+        not special_case:
+            min_value = self.default_normal_range.get('min', None)
+            max_value = self.default_normal_range.get('max', None)
+
+        if age_dependent: 
+            # get normal range for age)
+            warnings.warn("Age dependent normal range not implemented yet")
+            pass
+        
+        if gender_dependent:
+            if not gender:
+                warnings.warn("Calling get_normal_range with gender_dependent=True requires gender to be set, choosing by random")
+                # set gender to either "male" or "female"
+                from random import choice
+                choices = ["male", "female"]
+                gender = choice(choices)
+
+            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)
+
+        if special_case:
+            # get normal range for special case
+            warnings.warn("Special case normal range not implemented yet")
+
+        normal_range_dict = {
+            "min": min_value,
+            "max": max_value
+        }
+
+        return normal_range_dict
+

endoreg_db/models/logging/__init__.py

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

endoreg_db/models/logging/agl_service.py

@@ -0,0 +1,19 @@
+from django.db import models
+from .base import AbstractLogEntry
+
+class AglServiceLogEntry(AbstractLogEntry):
+    """
+    Model for log entries related to AGL services.
+    """
+    service = models.ForeignKey("AglService", on_delete=models.CASCADE)
+    device = models.ForeignKey(
+        "NetworkDevice", on_delete=models.CASCADE, null=True, blank=True
+    )
+    log_type = models.ForeignKey("LogType", on_delete=models.CASCADE, null=True, blank=True)
+
+    class Meta:
+        verbose_name = "AGL Service Log Entry"
+        verbose_name_plural = "AGL Service Log Entries"
+
+    def __str__(self):
+        return f"{self.timestamp} - {self.user} - {self.ip_address} - {self.service} - {self.message}"

endoreg_db/models/logging/base.py

@@ -0,0 +1,22 @@
+# django model for logging, first define an abstract base model
+from django.db import models
+from django.conf import settings
+
+class AbstractLogEntry(models.Model):
+    """
+    Abstract base model for log entries.
+    """
+
+    class Meta:
+        abstract = True
+
+    timestamp = models.DateTimeField(auto_now_add=True)
+    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.SET_NULL, null=True, blank=True)
+    ip_address = models.GenericIPAddressField(null=True, blank=True)
+    user_agent = models.CharField(max_length=256, null=True, blank=True)
+    message = models.TextField()
+    json_content = models.JSONField(null=True, blank=True)
+    
+
+    def __str__(self):
+        return f"{self.timestamp} - {self.user} - {self.ip_address} - {self.message}"

endoreg_db/models/logging/log_type.py

@@ -0,0 +1,23 @@
+from django.db import models
+
+class LogTypeManager(models.Manager):
+    # Custom manager for LogType; defines name as natural key
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+
+class LogType(models.Model):
+    name = models.CharField(max_length=255)
+    description = models.CharField(max_length=255)
+    created = models.DateTimeField(auto_now_add=True)
+    updated = models.DateTimeField(auto_now=True)
+    objects = LogTypeManager()
+    
+    def __str__(self):
+        return self.name
+    
+    class Meta:
+        ordering = ['name']
+        
+    def natural_key(self):
+        return (self.name,)