endoreg-db 0.8.5.1__py3-none-any.whl

endoreg_db/models/medical/examination/examination_indication.py

@@ -0,0 +1,278 @@
+from django.db import models
+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):
+    """
+    Manager for ExaminationIndication with custom query methods.
+    """
+
+    def get_by_natural_key(self, name: str) -> "ExaminationIndication":
+        """
+        Retrieves an ExaminationIndication instance by its natural key.
+        
+        Args:
+            name: The unique name identifying the examination indication.
+        
+        Returns:
+            The ExaminationIndication instance corresponding to the specified name.
+        """
+        return self.get(name=name)
+
+
+class ExaminationIndication(models.Model):
+    """
+    Represents an indication for an examination.
+
+    Attributes:
+        name (str): The unique name of 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)
+    description = models.TextField(blank=True, null=True)
+
+    classifications = models.ManyToManyField(
+        "ExaminationIndicationClassification",
+        related_name="indications",
+        blank=True,
+    )
+
+    examinations = models.ManyToManyField(
+        "Examination",
+        related_name="indications",
+        blank=True,
+    )
+
+    expected_interventions = models.ManyToManyField(
+        "FindingIntervention",
+        related_name="indications",
+        blank=True,
+    )
+
+    objects = ExaminationIndicationManager()
+
+    if TYPE_CHECKING:
+        classifications: "models.ManyToManyField[ExaminationIndicationClassification, ExaminationIndicationClassification]"
+        examinations: "models.ManyToManyField[Examination, Examination]"
+        related_requirements: "models.QuerySet[Requirement]"
+        expected_interventions: "models.ManyToManyField[FindingIntervention, FindingIntervention]"
+
+    @property
+    def links(self) -> "RequirementLinks":
+        """
+        Aggregates related requirements, classifications, examination, and interventions into a RequirementLinks object.
+        
+        Returns:
+            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,)
+
+    def __str__(self) -> str:
+        """
+        String representation of the indication.
+
+        Returns:
+            str: The name of the indication.
+        """
+        return str(self.name)
+
+    def get_choices(self) -> List["ExaminationIndicationClassificationChoice"]:
+        """
+        Retrieves all classification choices for the indication.
+        
+        Aggregates and returns the choices from each classification associated with the indication.
+        
+        Returns:
+            List[ExaminationIndicationClassificationChoice]: A list of classification choices.
+        """
+        classifications = self.classifications.all()
+        choices = []
+        for classification in classifications:
+            choices.extend(classification.choices.all())
+        return choices
+
+    def get_examination(self) -> Optional["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:
+            List[Examination]: A list of all examinations linked to this indication.
+        """
+        return list(self.examinations.all())
+    
+
+
+
+class ExaminationIndicationClassificationManager(models.Manager):
+    """
+    Manager for ExaminationIndicationClassification with custom query methods.
+    """
+
+    def get_by_natural_key(self, name: str) -> "ExaminationIndicationClassification":
+        """
+        Retrieves an ExaminationIndicationClassification by its natural key.
+        
+        Args:
+            name: The unique name identifying the classification.
+        
+        Returns:
+            The ExaminationIndicationClassification instance corresponding to the given name.
+        """
+        return self.get(name=name)
+
+
+class ExaminationIndicationClassification(models.Model):
+    """
+    Represents a classification for examination indications.
+
+    Attributes:
+        name (str): The unique 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)
+    description = models.TextField(blank=True, null=True)
+    examinations = models.ManyToManyField(
+        "Examination",
+        related_name="indication_classifications",
+        blank=True,
+    )
+
+    objects = ExaminationIndicationClassificationManager()
+
+    if TYPE_CHECKING:
+        examinations: "models.ManyToManyField[Examination, Examination]"
+        choices: "models.QuerySet[ExaminationIndicationClassificationChoice]"
+
+    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 str(self.name)
+
+    def get_choices(self) -> List["ExaminationIndicationClassificationChoice"]:
+        """
+        Retrieves all classification choices associated with this classification.
+        
+        Returns:
+            List[ExaminationIndicationClassificationChoice]: A list of classification choice instances.
+        """
+        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):
+    """
+    Manager for ExaminationIndicationClassificationChoice with custom query methods.
+    """
+
+    def get_by_natural_key(
+        self, name: str
+    ) -> "ExaminationIndicationClassificationChoice":
+        """
+        Retrieves an ExaminationIndicationClassificationChoice instance by its natural key.
+        
+        Args:
+            name: The unique name serving as the natural key for the classification choice.
+        
+        Returns:
+            An ExaminationIndicationClassificationChoice instance corresponding to the given name.
+        """
+        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.
+        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)
+    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 str(self.name)

endoreg_db/models/medical/examination/examination_time.py

@@ -0,0 +1,49 @@
+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.
+        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)
+    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/medical/examination/examination_time_type.py

@@ -0,0 +1,41 @@
+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.
+        examinations: The examinations associated with this type.
+    """
+    objects = ExaminationTimeTypeManager()
+    name = models.CharField(max_length=100, unique=True)
+    examinations = models.ManyToManyField('Examination', blank=True)
+
+    def __str__(self) -> str:
+        """
+        Return the name of the examination time type as its string representation.
+        """
+        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/medical/examination/examination_type.py

@@ -0,0 +1,48 @@
+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":
+        """
+        Retrieves an ExaminationType instance using its natural key.
+        
+        Args:
+            name: The natural identifier for the ExaminationType, typically the unique name.
+        
+        Returns:
+            The ExaminationType instance that matches the given name.
+        """
+        return self.get(name=name)
+
+
+class ExaminationType(models.Model):
+    """
+    Represents a type of examination.
+
+    Attributes:
+        name (str): The unique name of the examination type.
+    """
+
+    objects = ExaminationTypeManager()
+    name = models.CharField(max_length=100, unique=True)
+
+    def __str__(self) -> str:
+        """
+        Return the string representation of the examination type using its name.
+        """
+        name = self.name_en or self.name
+        name = str(name)
+        return 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/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
+