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

endoreg_db/models/examination/examination_indication.py

@@ -1,170 +0,0 @@
-from django.db import models
-from typing import List
-
-class ExaminationIndicationManager(models.Manager):
-    """
-    Manager for ExaminationIndication with custom query methods.
-    """
-    def get_by_natural_key(self, name: str) -> "ExaminationIndication":
-        return self.get(name=name)
-    
-class ExaminationIndication(models.Model):
-    """
-    Represents an indication for an examination.
-
-    Attributes:
-        name (str): The unique name of the indication.
-        name_de (str): The German name of the indication.
-        name_en (str): The English name of the indication.
-        classification (ForeignKey): The classification associated with the indication.
-        examination (ForeignKey): The examination associated with the indication.
-    """
-    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)
-    classification = models.ForeignKey(
-        'ExaminationIndicationClassification', on_delete=models.CASCADE,
-        related_name='indications',
-        blank=True, null=True
-    )
-    examination = models.ForeignKey(
-        'Examination', on_delete=models.CASCADE,
-        related_name='indications',
-    )
-    
-    objects = ExaminationIndicationManager()
-    
-    def natural_key(self) -> tuple:
-        """
-        Returns the natural key for the indication.
-
-        Returns:
-            tuple: The natural key consisting of the name.
-        """
-        return (self.name,)
-
-    def __str__(self) -> str:
-        """
-        String representation of the indication.
-
-        Returns:
-            str: The name of the indication.
-        """
-        return self.name
-
-    def get_choices(self) -> List['ExaminationIndicationClassificationChoice']:
-        """
-        Retrieves all choices associated with the classification.
-
-        Returns:
-            list: A list of classification choices.
-        """
-        return list(self.classification.choices.all()) if self.classification else []
-
-    def get_examination(self) -> 'Examination':
-        """
-        Retrieves the associated examination.
-
-        Returns:
-            Examination: The associated examination.
-        """
-        return self.examination
-
-class ExaminationIndicationClassificationManager(models.Manager):
-    """
-    Manager for ExaminationIndicationClassification with custom query methods.
-    """
-    def get_by_natural_key(self, name: str) -> "ExaminationIndicationClassification":
-        return self.get(name=name)
-
-class ExaminationIndicationClassification(models.Model):
-    """
-    Represents a classification for examination indications.
-
-    Attributes:
-        name (str): The unique name of the classification.
-        name_de (str): The German name of the classification.
-        name_en (str): The English name of the classification.
-    """
-    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 = ExaminationIndicationClassificationManager()
-    
-    def natural_key(self) -> tuple:
-        """
-        Returns the natural key for the classification.
-
-        Returns:
-            tuple: The natural key consisting of the name.
-        """
-        return (self.name,)
-
-    def __str__(self) -> str:
-        """
-        String representation of the classification.
-
-        Returns:
-            str: The name of the classification.
-        """
-        return self.name
-
-    def get_choices(self) -> List['ExaminationIndicationClassificationChoice']:
-        """
-        Retrieves all choices associated with this classification.
-
-        Returns:
-            list: A list of classification choices.
-        """
-        return list(self.choices.all())
-
-class ExaminationIndicationClassificationChoiceManager(models.Manager):
-    """
-    Manager for ExaminationIndicationClassificationChoice with custom query methods.
-    """
-    def get_by_natural_key(self, name: str) -> "ExaminationIndicationClassificationChoice":
-        return self.get(name=name)
-
-class ExaminationIndicationClassificationChoice(models.Model):
-    """
-    Represents a choice within an examination indication classification.
-
-    Attributes:
-        name (str): The unique name of the choice.
-        name_de (str): The German name of the choice.
-        name_en (str): The English name of the choice.
-        subcategories (JSONField): Subcategories associated with the choice.
-        numerical_descriptors (JSONField): Numerical descriptors for the choice.
-        classification (ForeignKey): The classification to which this choice belongs.
-    """
-    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)
-    subcategories = models.JSONField(default=dict)
-    numerical_descriptors = models.JSONField(default=dict)
-    classification = models.ForeignKey(
-        ExaminationIndicationClassification, on_delete=models.CASCADE,
-        related_name='choices'
-    )
-
-    objects = ExaminationIndicationClassificationChoiceManager()
-
-    def natural_key(self) -> tuple:
-        """
-        Returns the natural key for the classification choice.
-
-        Returns:
-            tuple: The natural key consisting of the name.
-        """
-        return (self.name,)
-
-    def __str__(self) -> str:
-        """
-        String representation of the classification choice.
-
-        Returns:
-            str: The name of the classification choice.
-        """
-        return self.name

endoreg_db/models/finding/__init__.py

@@ -1,11 +0,0 @@
-from .finding import Finding
-from .finding_type import FindingType
-from .finding_location_classification import (
-    FindingLocationClassification, FindingLocationClassificationChoice
-)
-from .finding_morphology_classification import (
-    FindingMorphologyClassificationType, FindingMorphologyClassificationChoice,
-    FindingMorphologyClassification
-)
-
-from .finding_intervention import FindingIntervention, FindingInterventionType

endoreg_db/models/finding/finding.py

@@ -1,75 +0,0 @@
-# Class to represent findings of examinations
-from django.db import models
-from typing import List
-
-class FindingManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-
-class Finding(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)
-    examinations = models.ManyToManyField('Examination', blank=True, related_name='findings')
-    finding_types = models.ManyToManyField('FindingType', blank=True, related_name='findings')
-
-    finding_interventions = models.ManyToManyField(
-        'FindingIntervention',
-        blank=True,
-        related_name='findings'
-    )
-
-    causing_finding_interventions = models.ManyToManyField(
-        'FindingIntervention',
-        blank=True,
-        related_name='causing_findings'
-    )
-
-    opt_causing_finding_interventions = models.ManyToManyField(
-        'FindingIntervention',
-        blank=True,
-        related_name='opt_causing_findings'
-    )
-
-    required_morphology_classification_types = models.ManyToManyField(
-        'FindingMorphologyClassificationType',
-        blank=True,
-        related_name='required_by_findings'
-    )
-
-    optional_morphology_classification_types = models.ManyToManyField(
-        'FindingMorphologyClassificationType',
-        blank=True,
-        related_name='optional_for_findings'
-    )
-
-    objects = FindingManager()
-
-    def natural_key(self):
-        return (self.name,)
-    
-    def __str__(self):
-        return self.name
-    
-    def get_finding_types(self):
-        return self.finding_types.all()
-    
-    def get_location_classifications(self):
-        from endoreg_db.models import FindingLocationClassification
-        # FindingLocationClassification is a class with a many-to-many relationship to Finding
-        # related name is location_classifications
-
-        location_classifications:FindingLocationClassification = self.location_classifications.all()
-        
-        return location_classifications 
-    
-    def get_required_morphology_classification_types(self):
-        from endoreg_db.models import FindingMorphologyClassificationType
-        finding_morphology_classification_types:List[FindingMorphologyClassificationType] = [
-            _ for _ in self.required_morphology_classification_types.all()
-        ]
-        return finding_morphology_classification_types
-    

endoreg_db/models/finding/finding_location_classification.py

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

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

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

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

endoreg_db/models/information_source.py

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

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

endoreg_db/models/laboratory/lab_value.py

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

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

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

@@ -1,22 +0,0 @@
-# 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}"