endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/models/medical/examination/examination_indication.py

@@ -0,0 +1,229 @@
+from typing import TYPE_CHECKING, cast
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from endoreg_db.models import (
+        Examination,
+        FindingIntervention,
+        InformationSource,
+        Requirement,
+    )
+    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,
+    )
+
+    expected_interventions = models.ManyToManyField(
+        "FindingIntervention",
+        related_name="indications",
+        blank=True,
+    )
+
+    information_sources = models.ManyToManyField(
+        "InformationSource",
+        related_name="examination_indications",
+        blank=True,
+    )
+
+    objects = ExaminationIndicationManager()
+
+    if TYPE_CHECKING:
+        classifications = cast(
+            models.manager.RelatedManager["ExaminationIndicationClassification"],
+            classifications,
+        )
+        expected_interventions = cast(
+            models.manager.RelatedManager["FindingIntervention"], expected_interventions
+        )
+        information_sources = cast(
+            models.manager.RelatedManager["InformationSource"], information_sources
+        )
+
+        @property
+        def related_requirements(
+            self,
+        ) -> "models.manager.RelatedManager[Requirement]": ...
+
+        @property
+        def examinations(self) -> "models.manager.RelatedManager[Examination]": ...
+
+    @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)
+
+
+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)
+    choices = models.ManyToManyField(
+        "ExaminationIndicationClassificationChoice",
+        related_name="classifications",
+        blank=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 str(self.name)
+
+
+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)
+
+    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,68 @@
+from typing import TYPE_CHECKING, cast
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from endoreg_db.models import ExaminationTimeType, InformationSource
+
+
+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)
+    time_types = models.ManyToManyField("ExaminationTimeType", blank=True)
+    objects = ExaminationTimeManager()
+
+    information_sources = models.ManyToManyField(
+        "InformationSource",
+        related_name="examination_times",
+        blank=True,
+    )
+
+    if TYPE_CHECKING:
+        time_types = cast(
+            models.manager.RelatedManager["ExaminationTimeType"], time_types
+        )
+        information_sources = cast(
+            models.manager.RelatedManager["InformationSource"], information_sources
+        )
+
+    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,44 @@
+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,47 @@
+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 = str(self.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,20 @@
+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,113 @@
+# Class to represent findings of examinations
+from typing import TYPE_CHECKING, Optional, cast
+
+from django.db import models
+
+
+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)
+    finding_types = models.ManyToManyField(
+        "FindingType", blank=True, related_name="findings"
+    )
+    finding_interventions = models.ManyToManyField(
+        "FindingIntervention", blank=True, related_name="findings"
+    )
+    caused_by_interventions = models.ManyToManyField(
+        "FindingIntervention", blank=True, related_name="causes_findings"
+    )
+    finding_classifications = models.ManyToManyField(
+        "FindingClassification", blank=True, related_name="findings"
+    )
+    information_sources = models.ManyToManyField(
+        "InformationSource", blank=True, related_name="findings"
+    )
+    objects = FindingManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models import (
+            Examination,
+            FindingClassification,
+            FindingClassificationType,
+            FindingIntervention,
+            FindingType,
+            InformationSource,
+            PatientFindingClassification,
+        )
+
+        finding_types = cast(
+            models.manager.RelatedManager["FindingType"], finding_types
+        )
+        finding_interventions = cast(
+            models.manager.RelatedManager["FindingIntervention"], finding_interventions
+        )
+        finding_classifications = cast(
+            models.manager.RelatedManager["FindingClassification"],
+            finding_classifications,
+        )
+
+    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: Optional[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,131 @@
+from typing import TYPE_CHECKING, cast
+
+from django.db import models
+
+
+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)
+
+
+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)
+    finding_types = models.ManyToManyField(
+        "FindingType", blank=True, related_name="finding_classifications"
+    )
+    choices = models.ManyToManyField(
+        "FindingClassificationChoice", related_name="classifications", blank=True
+    )
+
+    classification_types = models.ManyToManyField(
+        to=FindingClassificationType,
+        # on_delete=models.CASCADE
+    )
+    information_sources = models.ManyToManyField(
+        "InformationSource",
+        related_name="finding_classifications",
+        blank=True,
+    )
+
+    @property
+    def examinations(self):
+        from endoreg_db.models import Examination
+
+        return Examination.objects.filter(findings__finding_classifications=self)
+
+    objects = FindingClassificationManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models import (
+            Examination,
+            Finding,
+            FindingType,
+            InformationSource,
+            PatientFindingClassification,
+        )
+
+        classification_types = cast(
+            models.manager.RelatedManager["FindingClassificationType"],
+            classification_types,
+        )
+        choices = cast(
+            models.manager.RelatedManager["FindingClassificationChoice"], choices
+        )
+        finding_types = cast(
+            models.manager.RelatedManager["FindingType"], finding_types
+        )
+        information_sources = cast(
+            models.manager.RelatedManager["InformationSource"], information_sources
+        )
+
+        @property
+        def findings(self) -> "models.manager.RelatedManager[Finding]": ...
+
+    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()
+
+
+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)
+    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