endoreg-db 0.8.8.0__py3-none-any.whl → 0.8.9.2__py3-none-any.whl

endoreg_db/models/medical/examination/examination_indication.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, List, Optional, cast
 from django.db import models
 
 if TYPE_CHECKING:
-    from endoreg_db.models import Examination, FindingIntervention, Requirement
+    from endoreg_db.models import Examination, FindingIntervention, InformationSource, Requirement
     from endoreg_db.utils.links.requirement_link import RequirementLinks
 
 
@@ -45,15 +45,15 @@ class ExaminationIndication(models.Model):
         blank=True,
     )
 
-    examinations = models.ManyToManyField(
-        "Examination",
+    expected_interventions = models.ManyToManyField(
+        "FindingIntervention",
         related_name="indications",
         blank=True,
     )
 
-    expected_interventions = models.ManyToManyField(
-        "FindingIntervention",
-        related_name="indications",
+    information_sources = models.ManyToManyField(
+        "InformationSource",
+        related_name="examination_indications",
         blank=True,
     )
 
@@ -61,12 +61,15 @@ class ExaminationIndication(models.Model):
 
     if TYPE_CHECKING:
         classifications = cast(models.manager.RelatedManager["ExaminationIndicationClassification"], classifications)
-        examinations = cast(models.manager.RelatedManager["Examination"], examinations)
         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":
         """
@@ -98,39 +101,6 @@ class ExaminationIndication(models.Model):
         """
         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):
     """
@@ -162,18 +132,14 @@ class ExaminationIndicationClassification(models.Model):
 
     name = models.CharField(max_length=255, unique=True)
     description = models.TextField(blank=True, null=True)
-    examinations = models.ManyToManyField(
-        "Examination",
-        related_name="indication_classifications",
+    choices = models.ManyToManyField(
+        "ExaminationIndicationClassificationChoice",
+        related_name="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.
@@ -192,33 +158,6 @@ class ExaminationIndicationClassification(models.Model):
         """
         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):
     """
@@ -252,11 +191,6 @@ class ExaminationIndicationClassificationChoice(models.Model):
     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()
 

endoreg_db/models/medical/examination/examination_time.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, cast
 from django.db import models
 
 if TYPE_CHECKING:
-    from endoreg_db.models import ExaminationTimeType
+    from endoreg_db.models import ExaminationTimeType, InformationSource
 
 
 class ExaminationTimeManager(models.Manager):
@@ -27,13 +27,18 @@ class ExaminationTime(models.Model):
     """
 
     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()
 
+    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:
         """

endoreg_db/models/medical/finding/finding.py

@@ -12,11 +12,11 @@ class FindingManager(models.Manager):
 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")
     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:
@@ -26,20 +26,13 @@ class Finding(models.Model):
             FindingClassificationType,
             FindingIntervention,
             FindingType,
+            InformationSource,
             PatientFindingClassification,
         )
 
         finding_types = cast(models.manager.RelatedManager["FindingType"], finding_types)
-        examinations = cast(models.manager.RelatedManager["Examination"], examinations)
         finding_interventions = cast(models.manager.RelatedManager["FindingIntervention"], finding_interventions)
-
-        @property
-        def finding_classifications(self) -> "models.manager.RelatedManager[FindingClassification]": ...
-
-        # finding_classifications: models.QuerySet["FindingClassification"]
-        # examinations: models.QuerySet[Examination]
-        # finding_types: models.QuerySet[FindingType]
-        # finding_interventions: models.QuerySet[FindingIntervention]
+        finding_classifications = cast(models.manager.RelatedManager["FindingClassification"], finding_classifications)
 
     def natural_key(self):
         """

endoreg_db/models/medical/finding/finding_classification.py

@@ -11,7 +11,6 @@ class FindingClassificationTypeManager(models.Manager):
 class FindingClassificationType(models.Model):
     name = models.CharField(max_length=255, unique=True)
     description = models.TextField(blank=True)
-
     objects = FindingClassificationTypeManager()
 
     def natural_key(self):
@@ -20,14 +19,6 @@ class FindingClassificationType(models.Model):
     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):
@@ -37,26 +28,37 @@ class FindingClassificationManager(models.Manager):
 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
     )
-    choices = models.ManyToManyField("FindingClassificationChoice", related_name="classifications", blank=True)
+    information_sources = models.ManyToManyField(
+        "InformationSource",
+        related_name="finding_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")
+    @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, PatientFindingClassification
+        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)
-        examinations = cast(models.manager.RelatedManager["Examination"], examinations)
-        findings = cast(models.manager.RelatedManager["Finding"], findings)
         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,)
@@ -73,20 +75,6 @@ class FindingClassification(models.Model):
         """
         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):
@@ -105,15 +93,8 @@ class FindingClassificationChoiceManager(models.Manager):
 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:

endoreg_db/models/medical/finding/finding_intervention.py

@@ -11,21 +11,19 @@ class FindingInterventionManager(models.Manager):
 class FindingIntervention(models.Model):
     name = models.CharField(max_length=100, unique=True)
     description = 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")
-
+    information_sources = models.ManyToManyField(
+        "InformationSource",
+        related_name="finding_interventions",
+        blank=True,
+    )
     objects = FindingInterventionManager()
 
     if TYPE_CHECKING:
-        from endoreg_db.models import Contraindication, FindingInterventionType, LabValue
+        from endoreg_db.models import Contraindication, FindingInterventionType, InformationSource, LabValue
 
         intervention_types = cast(models.manager.RelatedManager["FindingInterventionType"], intervention_types)
-        required_lab_values = cast(models.manager.RelatedManager["LabValue"], required_lab_values)
-        contraindications = cast(models.manager.RelatedManager["Contraindication"], contraindications)
+        information_sources = cast(models.manager.RelatedManager["InformationSource"], information_sources)
 
     def natural_key(self):
         return (self.name,)

endoreg_db/models/medical/hardware/endoscope.py

@@ -33,6 +33,12 @@ class Endoscope(models.Model):
         verbose_name = "Endoscope"
         verbose_name_plural = "Endoscopes"
 
+    @property
+    def center_safe(self) -> "Center":
+        if self.center is None:
+            raise ValueError("Endoscope has no associated center.")
+        return self.center
+
 
 class EndoscopeTypeManager(models.Manager):
     def get_by_natural_key(self, name):

endoreg_db/models/medical/patient/medication_examples.py

@@ -28,7 +28,11 @@ daily_night = MedicationIntakeTime.dn()
 mi = MedicationIndication.objects.order_by('?').first()
 
 # Alternatively, we can use a specific indication type
-medication_indication_type = MedicationIndicationType.objects.filter(indication_type='thromboembolism-prevention-non_valvular_af').order_by('?').first()
+
+# FIXME MedicationIndicationType does not have a field named indication_type
+# It does have: id, medication_indications, name
+
+# medication_indication_type = MedicationIndicationType.objects.filter(indication_type='thromboembolism-prevention-non_valvular_af').order_by('?').first()
 
 patient = generate_patient()
 

endoreg_db/models/medical/patient/patient_finding.py

@@ -54,7 +54,7 @@ class PatientFinding(models.Model):
                 fields=["patient_examination", "finding"], condition=models.Q(is_active=True), name="unique_active_finding_per_examination"
             ),
             models.CheckConstraint(
-                check=models.Q(  # called .check in future?
+                condition=models.Q(  # called .check in future?
                     deactivated_at__isnull=True, deactivated_by__isnull=True
                 )
                 | models.Q(deactivated_at__isnull=False, deactivated_by__isnull=False, is_active=False),

endoreg_db/models/metadata/pdf_meta.py

@@ -9,20 +9,28 @@ if TYPE_CHECKING:
 
 class PdfType(models.Model):
     """
-    Defines a specific type or format of PDF report, linking to flags used for parsing.
+    Defines a specific type or format of report report, linking to flags used for parsing.
 
-    Used to configure how different PDF report layouts are processed.
+    Used to configure how different report report layouts are processed.
     """
 
     name = models.CharField(max_length=255)
 
-    patient_info_line = models.ForeignKey("ReportReaderFlag", related_name="pdf_type_patient_info_line", on_delete=models.CASCADE)
+    patient_info_line = models.ForeignKey(
+        "ReportReaderFlag",
+        related_name="pdf_type_patient_info_line",
+        on_delete=models.CASCADE,
+    )
     endoscope_info_line = models.ForeignKey(
         "ReportReaderFlag",
         related_name="pdf_type_endoscopy_info_line",
         on_delete=models.CASCADE,
     )
-    examiner_info_line = models.ForeignKey("ReportReaderFlag", related_name="pdf_type_examiner_info_line", on_delete=models.CASCADE)
+    examiner_info_line = models.ForeignKey(
+        "ReportReaderFlag",
+        related_name="pdf_type_examiner_info_line",
+        on_delete=models.CASCADE,
+    )
     cut_off_above_lines = models.ManyToManyField(
         "ReportReaderFlag",
         related_name="pdf_type_cut_off_above_lines",
@@ -37,11 +45,15 @@ class PdfType(models.Model):
         endoscope_info_line: models.ForeignKey["ReportReaderFlag"]
         examiner_info_line: models.ForeignKey["ReportReaderFlag"]
 
-        cut_off_above_lines = cast(models.manager.RelatedManager["ReportReaderFlag"], cut_off_above_lines)
-        cut_off_below_lines = cast(models.manager.RelatedManager["ReportReaderFlag"], cut_off_below_lines)
+        cut_off_above_lines = cast(
+            models.manager.RelatedManager["ReportReaderFlag"], cut_off_above_lines
+        )
+        cut_off_below_lines = cast(
+            models.manager.RelatedManager["ReportReaderFlag"], cut_off_below_lines
+        )
 
     def __str__(self):
-        """Returns a string summary of the PDF type and its associated flags."""
+        """Returns a string summary of the report type and its associated flags."""
         summary = f"{self.name}"
         # add lines to summary
         summary += f"\nPatient Info Line: {self.patient_info_line.value}"
@@ -60,7 +72,7 @@ class PdfType(models.Model):
 
 class PdfMeta(models.Model):
     """
-    Stores metadata associated with a specific PDF document file.
+    Stores metadata associated with a specific report document file.
     """
 
     pdf_type = models.ForeignKey(PdfType, on_delete=models.CASCADE)
@@ -69,13 +81,13 @@ class PdfMeta(models.Model):
     pdf_hash = models.CharField(max_length=255, unique=True)
 
     def __str__(self):
-        """Returns the PDF hash as its string representation."""
+        """Returns the report hash as its string representation."""
         return str(self.pdf_hash)
 
     @classmethod
     def create_from_file(cls, pdf_file):
         """
-        Creates a PdfMeta instance from a PDF file object.
+        Creates a PdfMeta instance from a report file object.
         Note: This implementation seems incomplete; it doesn't extract hash, date, time, or type.
         """
         pdf_file = File(pdf_file)

endoreg_db/models/metadata/sensitive_meta.py

@@ -303,3 +303,6 @@ class SensitiveMeta(models.Model):
         This method delegates the update operation to the external logic module responsible for managing name data.
         """
         logic.update_name_db(first_name, last_name)
+        
+        
+