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

endoreg_db/models/{examination → medical/examination}/examination_indication.py

@@ -1,9 +1,9 @@
 from django.db import models
-from typing import List, TYPE_CHECKING
+from typing import List, TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
     from endoreg_db.models import Examination, Requirement, FindingIntervention
-
+    from endoreg_db.utils.links.requirement_link import RequirementLinks
 
 class ExaminationIndicationManager(models.Manager):
     """
@@ -29,16 +29,12 @@ class ExaminationIndication(models.Model):
 
     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.
+        classifications (ManyToManyField): The classifications associated with the indication.
+        examinations (ManyToManyField): The examinations associated with the indication.
         expected_interventions (ManyToManyField): Expected interventions for this 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)
     description = models.TextField(blank=True, null=True)
 
     classifications = models.ManyToManyField(
@@ -47,10 +43,10 @@ class ExaminationIndication(models.Model):
         blank=True,
     )
 
-    examination = models.ForeignKey(
+    examinations = models.ManyToManyField(
         "Examination",
-        on_delete=models.CASCADE,
         related_name="indications",
+        blank=True,
     )
 
     expected_interventions = models.ManyToManyField(
@@ -62,17 +58,29 @@ class ExaminationIndication(models.Model):
     objects = ExaminationIndicationManager()
 
     if TYPE_CHECKING:
-        classifications: "models.ManyToManyField[ExaminationIndicationClassification]"
-        examination: "Examination"
+        classifications: "models.ManyToManyField[ExaminationIndicationClassification, ExaminationIndicationClassification]"
+        examinations: "models.ManyToManyField[Examination, Examination]"
         related_requirements: "models.QuerySet[Requirement]"
-        expected_interventions: "models.ManyToManyField[FindingIntervention]"
+        expected_interventions: "models.ManyToManyField[FindingIntervention, FindingIntervention]"
 
-    def natural_key(self) -> tuple:
+    @property
+    def links(self) -> "RequirementLinks":
         """
-        Returns the natural key for the indication.
-
+        Aggregates related requirements, classifications, examination, and interventions into a RequirementLinks object.
+        
         Returns:
-            tuple: The natural key consisting of the name.
+            A RequirementLinks instance representing all entities linked to this examination indication.
+        """
+        from endoreg_db.utils.links.requirement_link import RequirementLinks
+        return RequirementLinks(
+            examination_indications=[self],
+            examinations=list(self.examinations.all()),
+            finding_interventions=list(self.expected_interventions.all()),
+        )
+
+    def natural_key(self) -> tuple:
+        """
+        Returns a tuple containing the unique name of the indication as its natural key.
         """
         return (self.name,)
 
@@ -100,14 +108,25 @@ class ExaminationIndication(models.Model):
             choices.extend(classification.choices.all())
         return choices
 
-    def get_examination(self) -> "Examination":
+    def get_examination(self) -> Optional["Examination"]:
         """
-        Retrieves the associated examination.
+        Returns the first examination associated with this indication, or None if no examinations exist.
+        
+        Note: Since this is now a many-to-many relationship, this method returns the first examination.
+        Consider using get_examinations() for accessing all related examinations.
+        """
+        return self.examinations.first()
 
+    def get_examinations(self) -> List["Examination"]:
+        """
+        Returns all examinations associated with this indication.
+        
         Returns:
-            Examination: The associated examination.
+            List[Examination]: A list of all examinations linked to this indication.
         """
-        return self.examination
+        return list(self.examinations.all())
+    
+
 
 
 class ExaminationIndicationClassificationManager(models.Manager):
@@ -134,28 +153,24 @@ class ExaminationIndicationClassification(models.Model):
 
     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.
+        description (str): Optional description of the classification.
+        examinations (ManyToManyField): The examinations associated with this 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)
     description = models.TextField(blank=True, null=True)
-    examination = models.ForeignKey(
+    examinations = models.ManyToManyField(
         "Examination",
-        on_delete=models.CASCADE,
         related_name="indication_classifications",
         blank=True,
-        null=True,
     )
 
+    objects = ExaminationIndicationClassificationManager()
+
     if TYPE_CHECKING:
-        examination: "Examination"
+        examinations: "models.ManyToManyField[Examination, Examination]"
         choices: "models.QuerySet[ExaminationIndicationClassificationChoice]"
 
-    objects = ExaminationIndicationClassificationManager()
-
     def natural_key(self) -> tuple:
         """
         Returns the natural key for the classification.
@@ -183,6 +198,24 @@ class ExaminationIndicationClassification(models.Model):
         """
         return list(self.choices.all())
 
+    def get_examination(self) -> Optional["Examination"]:
+        """
+        Returns the first examination associated with this classification, or None if no examinations exist.
+        
+        Note: Since this is now a many-to-many relationship, this method returns the first examination.
+        Consider using get_examinations() for accessing all related examinations.
+        """
+        return self.examinations.first()
+
+    def get_examinations(self) -> List["Examination"]:
+        """
+        Returns all examinations associated with this classification.
+        
+        Returns:
+            List[Examination]: A list of all examinations linked to this classification.
+        """
+        return list(self.examinations.all())
+
 
 class ExaminationIndicationClassificationChoiceManager(models.Manager):
     """
@@ -210,16 +243,12 @@ class ExaminationIndicationClassificationChoice(models.Model):
 
     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(

endoreg_db/models/{examination → medical/examination}/examination_time.py

@@ -14,15 +14,11 @@ class ExaminationTime(models.Model):
 
     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)

endoreg_db/models/{examination → medical/examination}/examination_time_type.py

@@ -13,22 +13,15 @@ class ExaminationTimeType(models.Model):
 
     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 the name of the examination time type as its string representation.
         """
         return self.name
 

endoreg_db/models/{examination → medical/examination}/examination_type.py

@@ -25,20 +25,14 @@ class ExaminationType(models.Model):
 
     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:
         """
-        Return the string representation of the examination type.
-        
-        If an English name is provided, it is returned; otherwise, the default name is used.
+        Return the string representation of the examination type using its name.
         """
         name = self.name_en or self.name
         name = str(name)

endoreg_db/models/medical/finding/__init__.py

@@ -0,0 +1,18 @@
+from .finding import Finding
+from .finding_type import FindingType
+
+from .finding_classification import (
+    FindingClassificationType, FindingClassification, FindingClassificationChoice,
+)
+
+from .finding_intervention import FindingIntervention, FindingInterventionType
+
+__all__ = [
+    "Finding",
+    "FindingClassificationType",
+    "FindingClassification",
+    "FindingClassificationChoice",
+    "FindingType",
+    "FindingIntervention",
+    "FindingInterventionType",
+]

endoreg_db/models/medical/finding/finding.py

@@ -0,0 +1,96 @@
+# Class to represent findings of examinations
+from django.db import models
+from typing import List
+
+from typing import TYPE_CHECKING
+
+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)
+    description = models.TextField(blank=True, null=True)
+    examinations = models.ManyToManyField(
+        'Examination', 
+        blank=True, 
+        related_name='findings'
+    ) # type: ignore
+    finding_types = models.ManyToManyField(
+        'FindingType', 
+        blank=True, 
+        related_name='findings'
+    ) # type: ignore
+
+    finding_interventions = models.ManyToManyField(
+        'FindingIntervention',
+        blank=True,
+        related_name='findings'
+    ) # type: ignore
+
+    objects = FindingManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models import (
+            Examination, FindingType, FindingIntervention, FindingClassificationType,
+            FindingClassification,
+            PatientFindingClassification
+        )
+    
+        finding_classifications: models.QuerySet['FindingClassification']
+        examinations: models.QuerySet[Examination]
+        finding_types: models.QuerySet[FindingType]
+        finding_interventions: models.QuerySet[FindingIntervention]
+        
+    def natural_key(self):
+        """
+        Return a tuple containing the unique natural key for this Finding instance.
+        
+        Returns:
+            tuple: A single-element tuple with the Finding's name.
+        """
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    
+    def get_finding_types(self):
+        """
+        Return all finding types associated with this finding.
+        
+        Returns:
+            QuerySet: All related FindingType instances.
+        """
+        return self.finding_types.all()
+    
+    def get_classifications(self, classification_type: str = None) -> models.QuerySet['FindingClassification']:
+        """
+        Retrieve all classifications associated with this finding, optionally filtered by classification type.
+        
+        Parameters:
+        	classification_type (str, optional): If provided, only classifications with a matching type name are returned.
+        
+        Returns:
+        	List[FindingClassification]: List of related classification objects, filtered by type if specified.
+        """
+        if classification_type:
+            return self.finding_classifications.filter(classification_types__name=classification_type)
+        return self.finding_classifications.all()
+    
+    def get_location_classifications(self):
+        """
+        Retrieve all related FindingClassification objects with classification type 'location'.
+        
+        Returns:
+            QuerySet: All FindingClassification instances linked to this finding where the classification type name is 'location' (case-insensitive).
+        """
+        return self.finding_classifications.filter(classification_types__name__iexact="location")
+
+    def get_morphology_classifications(self):
+        """
+        Retrieve all related FindingClassification objects with classification type 'morphology'.
+        
+        Returns:
+            QuerySet: A queryset of FindingClassification instances associated with this finding and classified as 'morphology'.
+        """
+        return self.finding_classifications.filter(classification_types__name__iexact="morphology")

endoreg_db/models/medical/finding/finding_classification.py

@@ -0,0 +1,142 @@
+from django.db import models
+from typing import TYPE_CHECKING, List
+
+class FindingClassificationTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class FindingClassificationType(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    description = models.TextField(blank=True)
+    
+    objects = FindingClassificationTypeManager()
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return str(self.name)
+    
+    @classmethod
+    def get_required_classifications_for_finding(cls, finding):
+        """
+        Returns all required finding classification types for a given finding.
+        """
+        required_classification_types = [
+            _ for _ in finding.required_morphology_classification_types.all()
+        ]
+        return required_classification_types
+
+
+class FindingClassificationManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+
+class FindingClassification(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    description = models.TextField(blank=True)
+    classification_types = models.ManyToManyField(
+        to=FindingClassificationType, 
+        # on_delete=models.CASCADE
+    )
+    choices = models.ManyToManyField(
+        'FindingClassificationChoice', 
+        related_name='classifications', 
+        blank=True
+    )
+
+    findings = models.ManyToManyField('Finding', blank=True, related_name='finding_classifications')
+    examinations = models.ManyToManyField('Examination', blank=True, related_name='finding_classifications')
+    finding_types = models.ManyToManyField('FindingType', blank=True, related_name='finding_classifications')
+
+    objects = FindingClassificationManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models import (
+            Finding, Examination, FindingType, PatientFindingClassification
+        )
+        classification_types: models.ManyToManyField[FindingClassificationType]
+        findings: models.QuerySet[Finding]
+        examinations: models.QuerySet[Examination]
+        finding_types: models.QuerySet[FindingType]
+        choices: models.QuerySet['FindingClassificationChoice']
+        patient_finding_classifications: models.QuerySet['PatientFindingClassification']
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return str(self.name)
+
+    def get_choices(self):
+        """
+        Return all choices associated with this classification.
+        
+        Returns:
+        	QuerySet: All related FindingClassificationChoice instances.
+        """
+        return self.choices.all()
+
+    @property
+    def is_morphology(self):
+        """
+        Return True if any related classification type has the name "morphology" (case-insensitive).
+        """
+        return self.classification_types.filter(name__iexact="morphology").exists()
+
+    @property
+    def is_location(self):
+        """
+        Returns True if any related classification type has the name "location" (case-insensitive).
+        """
+        return self.classification_types.filter(name__iexact="location").exists()
+
+
+class FindingClassificationChoiceManager(models.Manager):
+    def get_by_natural_key(self, name):
+        """
+        Retrieve an instance by its unique name using the natural key.
+        
+        Parameters:
+            name (str): The unique name identifying the instance.
+        
+        Returns:
+            The model instance with the specified name.
+        """
+        return self.get(name=name)
+    
+class FindingClassificationChoice(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    description = models.TextField(blank=True)
+    # classifications = models.ManyToManyField(
+    #     "FindingClassification", 
+    #     related_name='choices'
+    # )
+    
+    subcategories = models.JSONField(
+        default = dict
+    )
+
+    numerical_descriptors = models.JSONField(
+        default = dict
+    )
+
+    objects = FindingClassificationChoiceManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models import (
+            PatientFindingClassification
+        )
+        classifications: models.QuerySet['FindingClassification']
+        patient_finding_classifications: models.QuerySet['PatientFindingClassification']
+
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        classifications_names = ", ".join([c.name for c in self.classifications.all()])
+        _str = f"{self.name} ({classifications_names})"
+        return _str
+

endoreg_db/models/{finding → medical/finding}/finding_intervention.py

@@ -6,11 +6,7 @@ class FindingInterventionManager(models.Manager):
     
 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',
@@ -36,7 +32,7 @@ class FindingIntervention(models.Model):
         return (self.name,)
     
     def __str__(self):
-        return self.name
+        return str(self.name)
     
 
 class FindingInterventionTypeManager(models.Manager):
@@ -45,11 +41,7 @@ class FindingInterventionTypeManager(models.Manager):
     
 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()
     
@@ -57,4 +49,4 @@ class FindingInterventionType(models.Model):
         return (self.name,)
     
     def __str__(self):
-        return self.name
+        return str(self.name)

endoreg_db/models/medical/finding/finding_type.py

@@ -0,0 +1,35 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+class FindingTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        """
+        Retrieve a FindingType instance by its unique name for natural key deserialization.
+        
+        Parameters:
+            name (str): The unique name of the FindingType to retrieve.
+        
+        Returns:
+            FindingType: The instance matching the given name.
+        """
+        return self.get(name=name)
+    
+class FindingType(models.Model):
+    name = models.CharField(max_length=100, unique=True) 
+    description = models.TextField(blank=True, null=True)
+
+    objects = FindingTypeManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models import (
+            Finding, Examination, FindingClassification, FindingMorphologyClassification
+        )
+        finding_classifications: models.QuerySet['FindingClassification']
+        morphology_classifications: models.QuerySet['FindingMorphologyClassification']
+        
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name

endoreg_db/models/medical/hardware/__init__.py

@@ -0,0 +1,8 @@
+from .endoscopy_processor import EndoscopyProcessor
+from .endoscope import Endoscope, EndoscopeType
+
+__all__ = [
+    "Endoscope",
+    "EndoscopeType",
+    "EndoscopyProcessor",
+]

endoreg_db/models/{hardware → medical/hardware}/endoscope.py

@@ -1,37 +1,41 @@
-from django.db import models
+from django.db import models#
+from typing import TYPE_CHECKING
 
 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)
+
+    name = models.CharField(max_length=255) 
     sn = models.CharField(max_length=255)
     center = models.ForeignKey(
         'Center',
-        blank=True, 
-        null=True, 
+        blank=True,
+        null=True,
         on_delete=models.CASCADE,
         related_name='endoscopes'
     )
     endoscope_type = models.ForeignKey(
         'EndoscopeType', 
-        blank=True, 
-        null=True, 
+        blank=True,
+        null=True,
         on_delete=models.CASCADE,
         related_name='endoscopes'
     )
-    
+
+    if TYPE_CHECKING:
+        from endoreg_db.models.center.center import Center
+        center: "Center"
+        endoscope_type: "EndoscopeType"
+
     def natural_key(self):
         return (self.name, self.sn)
-    
+
     def __str__(self):
-        return self.name
-    
+        return str(self.name)
+
     class Meta:
         ordering = ['name']
         verbose_name = 'Endoscope'
@@ -40,20 +44,21 @@ class Endoscope(models.Model):
 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):
+
+    name = models.CharField(max_length=255, unique=True)
+
+    if TYPE_CHECKING:
+        endoscopes: models.QuerySet["Endoscope"]
+
+    def natural_key(self) -> tuple[str]:
         return (self.name,)
     
     def __str__(self):
-        return self.name
-    
+        return str(self.name)
+
     class Meta:
         ordering = ['name']
         verbose_name = 'Endoscope Type'