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

endoreg_db/models/event.py

@@ -1,4 +1,5 @@
 from django.db import models
+from typing import List
 
 class Event(models.Model):
     """
@@ -14,9 +15,59 @@ class Event(models.Model):
     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)
+    event_classification = models.ForeignKey(
+        'EventClassification', on_delete=models.CASCADE, related_name='events',
+        null=True, blank=True
+    )
 
     def natural_key(self):
         return (self.name,)
 
+    def __str__(self):
+        return self.name
+    
+
+class EventClassificationManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class EventClassification(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+    
+    objects = EventClassificationManager()
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    
+    def get_choices(self)->List['EventClassificationChoice']:
+        choices:List[EventClassificationChoice] = [_ for _ in self.event_classification_choices.all()]
+        return choices
+    
+class EventClassificationChoiceManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class EventClassificationChoice(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)
+    subcategories = models.JSONField(default=dict)
+    numerical_descriptors = models.JSONField(default=dict)
+    
+    event_classification = models.ForeignKey(
+        EventClassification, on_delete=models.CASCADE,
+        related_name='event_classification_choices'
+    )
+    
+    objects = EventClassificationChoiceManager()
+    
+    def natural_key(self):
+        return (self.name,)
+    
     def __str__(self):
         return self.name

endoreg_db/models/examination/__init__.py

@@ -1,4 +1,9 @@
 from .examination import Examination
 from .examination_type import ExaminationType
 from .examination_time import ExaminationTime
-from .examination_time_type import ExaminationTimeType
+from .examination_time_type import ExaminationTimeType
+from .examination_indication import(
+    ExaminationIndication,
+    ExaminationIndicationClassification,
+    ExaminationIndicationClassificationChoice
+)

endoreg_db/models/examination/examination.py

@@ -1,26 +1,67 @@
 from django.db import models
+from typing import List
+
 
 class ExaminationManager(models.Manager):
-    def get_by_natural_key(self, name):
+    """
+    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)
+    examination_types = models.ManyToManyField("ExaminationType", blank=True)
+
     objects = ExaminationManager()
-    date = models.DateField(blank=True, null=True)
-    time = models.TimeField(blank=True, null=True)
 
-    def __str__(self):
+    def __str__(self) -> str:
+        """
+        String representation of the examination.
+
+        Returns:
+            str: The name of the examination.
+        """
         return self.name
-    
-    def natural_key(self):
+
+    def natural_key(self) -> tuple:
+        """
+        Returns the natural key for the examination.
+
+        Returns:
+            tuple: The natural key consisting of the name.
+        """
         return (self.name,)
 
-    class Meta:
-        verbose_name = 'Examination'
-        verbose_name_plural = 'Examinations'
-        ordering = ['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

@@ -2,10 +2,24 @@ from django.db import models
 from rest_framework import serializers
 
 class ExaminationTimeManager(models.Manager):
-    def get_by_natural_key(self, name):
+    """
+    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)
@@ -14,10 +28,22 @@ class ExaminationTime(models.Model):
     end_time = models.TimeField(blank=True, null=True)
     objects = ExaminationTimeManager()
 
-    def __str__(self):
+    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):
+
+    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:

endoreg_db/models/examination/examination_time_type.py

@@ -1,20 +1,44 @@
 from django.db import models
 
 class ExaminationTimeTypeManager(models.Manager):
-    def get_by_natural_key(self, name):
+    """
+    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):
+    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):
+
+    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:

endoreg_db/models/examination/examination_type.py

@@ -1,18 +1,40 @@
 from django.db import models
 
 class ExaminationTypeManager(models.Manager):
-    def get_by_natural_key(self, name):
+    """
+    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):
-        return self.name_en
-    
-    def natural_key(self):
+    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