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

endoreg_db/models/examination/examination.py

@@ -0,0 +1,67 @@
+from django.db import models
+from typing import List
+
+
+class ExaminationManager(models.Manager):
+    """
+    Manager for Examination with custom query methods.
+    """
+
+    def get_by_natural_key(self, name: str) -> "Examination":
+        return self.get(name=name)
+
+
+class Examination(models.Model):
+    """
+    Represents an examination with associated details.
+
+    Attributes:
+        name (str): The unique name of the examination.
+        name_de (str): The German name of the examination.
+        name_en (str): The English name of the examination.
+        examination_types (ManyToManyField): The types associated with the examination.
+        date (DateField): The date of the examination.
+        time (TimeField): The time of the examination.
+    """
+
+    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)
+    examination_types = models.ManyToManyField("ExaminationType", blank=True)
+
+    objects = ExaminationManager()
+
+    def __str__(self) -> str:
+        """
+        String representation of the examination.
+
+        Returns:
+            str: The name of the examination.
+        """
+        return self.name
+
+    def natural_key(self) -> tuple:
+        """
+        Returns the natural key for the examination.
+
+        Returns:
+            tuple: The natural key consisting of the name.
+        """
+        return (self.name,)
+
+    def get_available_findings(self) -> List["Finding"]:
+        """
+        Retrieves all findings associated with the examination.
+
+        Returns:
+            list: A list of findings related to the examination.
+        """
+        from endoreg_db.models import Finding
+
+        findings: List[Finding] = [_ for _ in self.findings.all()]
+        return findings
+
+    class Meta:
+        verbose_name = "Examination"
+        verbose_name_plural = "Examinations"
+        ordering = ["name"]

endoreg_db/models/examination/examination_indication.py

@@ -0,0 +1,170 @@
+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/examination/examination_time.py

@@ -0,0 +1,53 @@
+from django.db import models
+from rest_framework import serializers
+
+class ExaminationTimeManager(models.Manager):
+    """
+    Manager for ExaminationTime with custom query methods.
+    """
+    def get_by_natural_key(self, name: str) -> "ExaminationTime":
+        return self.get(name=name)
+
+class ExaminationTime(models.Model):
+    """
+    Represents a specific time configuration for examinations.
+
+    Attributes:
+        name (str): The unique name of the examination time.
+        name_de (str): The German name of the examination time.
+        name_en (str): The English name of the examination time.
+        start_time (TimeField): The starting time for the examination.
+        end_time (TimeField): The ending time for the examination.
+        time_types (ManyToManyField): The types associated with this examination time.
+    """
+    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)
+    start_time = models.TimeField(blank=True, null=True)
+    time_types = models.ManyToManyField('ExaminationTimeType', blank=True)
+    end_time = models.TimeField(blank=True, null=True)
+    objects = ExaminationTimeManager()
+
+    def __str__(self) -> str:
+        """
+        String representation of the examination time.
+
+        Returns:
+            str: The name of the examination time.
+        """
+        return self.name
+
+    def natural_key(self) -> tuple:
+        """
+        Returns the natural key for the examination time.
+
+        Returns:
+            tuple: The natural key consisting of the name.
+        """
+        return (self.name,)
+
+    class Meta:
+        verbose_name = 'Examination Time'
+        verbose_name_plural = 'Examination Times'
+        ordering = ['name']
+

endoreg_db/models/examination/examination_time_type.py

@@ -0,0 +1,48 @@
+from django.db import models
+
+class ExaminationTimeTypeManager(models.Manager):
+    """
+    Manager for ExaminationTimeType with custom query methods.
+    """
+    def get_by_natural_key(self, name: str) -> "ExaminationTimeType":
+        return self.get(name=name)
+    
+class ExaminationTimeType(models.Model):
+    """
+    Represents a type of examination time.
+
+    Attributes:
+        name (str): The unique name of the examination time type.
+        name_de (str): The German name of the examination time type.
+        name_en (str): The English name of the examination time type.
+        examinations: The examinations associated with this type.
+    """
+    objects = ExaminationTimeTypeManager()
+    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)
+    examinations = models.ManyToManyField('Examination', blank=True)
+
+    def __str__(self) -> str:
+        """
+        String representation of the examination time type.
+
+        Returns:
+            str: The name of the examination time type.
+        """
+        return self.name
+
+    def natural_key(self) -> tuple:
+        """
+        Returns the natural key for the examination time type.
+
+        Returns:
+            tuple: The natural key consisting of the name.
+        """
+        return (self.name,)
+
+    class Meta:
+        verbose_name = 'Examination Time Type'
+        verbose_name_plural = 'Examination Time Types'
+        ordering = ['name']
+

endoreg_db/models/examination/examination_type.py

@@ -0,0 +1,40 @@
+from django.db import models
+
+class ExaminationTypeManager(models.Manager):
+    """
+    Manager for ExaminationType with custom query methods.
+    """
+    def get_by_natural_key(self, name: str) -> "ExaminationType":
+        return self.get(name=name)
+    
+class ExaminationType(models.Model):
+    """
+    Represents a type of examination.
+
+    Attributes:
+        name (str): The unique name of the examination type.
+        name_de (str): The German name of the examination type.
+        name_en (str): The English name of the examination type.
+    """
+    objects = ExaminationTypeManager()
+    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)
+
+    def __str__(self) -> str:
+        """
+        String representation of the examination type.
+
+        Returns:
+            str: The name of the examination type.
+        """
+        return self.name_en or self.name
+
+    def natural_key(self) -> tuple:
+        """
+        Returns the natural key for the examination type.
+
+        Returns:
+            tuple: The natural key consisting of the name.
+        """
+        return (self.name,)

endoreg_db/models/finding/__init__.py

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

@@ -0,0 +1,75 @@
+# 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_intervention.py

@@ -0,0 +1,60 @@
+from django.db import models
+
+class FindingInterventionManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class FindingIntervention(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)
+
+    intervention_types = models.ManyToManyField(
+        'FindingInterventionType',
+        blank=True,
+        related_name='interventions'
+    )
+
+    required_lab_values = models.ManyToManyField(
+        'LabValue',
+        blank=True,
+        related_name='required_by_finding_interventions'
+    )
+
+    contraindications = models.ManyToManyField(
+        'Contraindication',
+        blank=True,
+        related_name='contraindicating_finding_interventions'
+    )
+
+    objects = FindingInterventionManager()
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    
+
+class FindingInterventionTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class FindingInterventionType(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 = FindingInterventionTypeManager()
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name

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