endoreg-db 0.8.6.4__py3-none-any.whl

endoreg_db/models/metadata/pdf_meta.py

@@ -0,0 +1,89 @@
+from django.db import models
+from django.core.files import File
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..media.pdf.report_reader.report_reader_flag import ReportReaderFlag
+
+class PdfType(models.Model):
+    """
+    Defines a specific type or format of PDF report, linking to flags used for parsing.
+
+    Used to configure how different PDF 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
+    )
+    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
+    )
+    cut_off_above_lines = models.ManyToManyField(
+        "ReportReaderFlag",
+        related_name="pdf_type_cut_off_above_lines", 
+    )
+    cut_off_below_lines = models.ManyToManyField(
+        "ReportReaderFlag",
+        related_name="pdf_type_cut_off_below_lines", 
+    )
+
+    if TYPE_CHECKING:
+        patient_info_line: "ReportReaderFlag"
+        endoscope_info_line: "ReportReaderFlag"
+        examiner_info_line: "ReportReaderFlag"
+        cut_off_above_lines: models.QuerySet["ReportReaderFlag"]
+        cut_off_below_lines: models.QuerySet["ReportReaderFlag"]
+
+    def __str__(self):
+        """Returns a string summary of the PDF type and its associated flags."""
+        summary = f"{self.name}"
+        # add lines to summary
+        summary += f"\nPatient Info Line: {self.patient_info_line.value}"
+        summary += f"\nEndoscope Info Line: {self.endoscope_info_line.value}"
+        summary += f"\nExaminer Info Line: {self.examiner_info_line.value}"
+        summary += f"\nCut Off Above Lines: {[_.value for _ in self.cut_off_above_lines.all()]}"
+        summary += f"\nCut Off Below Lines: {[_.value for _ in self.cut_off_below_lines.all()]}"
+    
+        return summary
+
+    @classmethod
+    def default_pdf_type(cls):
+        """Returns a default PdfType instance, typically used as a fallback."""
+        return PdfType.objects.get(name="ukw-endoscopy-examination-report-generic")
+
+class PdfMeta(models.Model):
+    """
+    Stores metadata associated with a specific PDF document file.
+    """
+    pdf_type = models.ForeignKey(PdfType, on_delete=models.CASCADE)
+    date = models.DateField()
+    time = models.TimeField()
+    pdf_hash = models.CharField(max_length=255, unique=True)
+
+    if TYPE_CHECKING:
+        pdf_type: "PdfType"
+
+    def __str__(self):
+        """Returns the PDF 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.
+        Note: This implementation seems incomplete; it doesn't extract hash, date, time, or type.
+        """
+        pdf_file = File(pdf_file)
+        pdf_meta = cls(file=pdf_file)
+        pdf_meta.save()
+        return pdf_meta

endoreg_db/models/metadata/sensitive_meta.py

@@ -0,0 +1,288 @@
+from django.db import models
+# Removed hash utils, datetime, random, os, timezone, sha256 imports
+# Removed icecream import (was used in old save logic)
+from typing import TYPE_CHECKING, Dict, Any, Type, Self
+import logging # Add logging import
+
+# Import logic functions
+from . import sensitive_meta_logic as logic
+# Import models needed for type hints and FKs
+from ..state import SensitiveMetaState # Needed for post-save state check
+
+if TYPE_CHECKING:
+    from ..administration import (
+        Center,
+        Examiner,
+        Patient,
+        FirstName, # Keep for type hinting if needed
+        LastName   # Keep for type hinting if needed
+    )
+    from ..other import Gender
+    from ..medical import PatientExamination
+    # from ..state import SensitiveMetaState # Already imported above
+
+logger = logging.getLogger(__name__) # Add logger instance
+
+# SECRET_SALT moved to logic
+
+class SensitiveMeta(models.Model):
+    """
+    Stores potentially sensitive information extracted from media.
+    Logic for creation, hashing, pseudo-anonymization, and saving is in sensitive_meta_logic.py.
+    """
+    examination_date = models.DateField(blank=True, null=True)
+    pseudo_patient = models.ForeignKey(
+        "Patient",
+        on_delete=models.CASCADE,
+        blank=True,
+        null=True,
+        help_text="FK to the pseudo-anonymized Patient record."
+    ) # type: ignore
+    patient_first_name = models.CharField(max_length=255, blank=True, null=True)
+    patient_last_name = models.CharField(max_length=255, blank=True, null=True)
+    patient_dob = models.DateTimeField(
+        blank=True,
+        null=True,
+        help_text="Date of birth (can be auto-generated if missing)."
+    )
+    pseudo_examination = models.ForeignKey(
+        "PatientExamination",
+        on_delete=models.CASCADE,
+        blank=True,
+        null=True,
+        help_text="FK to the pseudo-anonymized PatientExamination record."
+    ) # type: ignore
+    patient_gender = models.ForeignKey(
+        "Gender",
+        on_delete=models.CASCADE,
+        blank=True,
+        null=True,
+    ) # type: ignore
+    examiners = models.ManyToManyField(
+        "Examiner",
+        blank=True,
+        help_text="Pseudo-anonymized examiner(s) associated with the examination."
+    ) # type: ignore
+    center = models.ForeignKey(
+        "Center",
+        on_delete=models.CASCADE,
+        blank=True, # Should ideally be False if always required before save
+        null=True,  # Should ideally be False
+    ) # type: ignore
+
+    # Raw examiner names stored temporarily until pseudo-examiner is created/linked
+    examiner_first_name = models.CharField(max_length=255, blank=True, null=True, editable=False)
+    examiner_last_name = models.CharField(max_length=255, blank=True, null=True, editable=False)
+
+    # Hashes calculated and stored by save logic
+    examination_hash = models.CharField(max_length=64, blank=True, null=True, editable=False, db_index=True) # Use 64 for sha256 hex
+    patient_hash = models.CharField(max_length=64, blank=True, null=True, editable=False, db_index=True) # Use 64 for sha256 hex
+
+    endoscope_type = models.CharField(max_length=255, blank=True, null=True)
+    endoscope_sn = models.CharField(max_length=255, blank=True, null=True)
+
+    # Removed state_verified property, assuming state is handled via the related SensitiveMetaState model
+
+    if TYPE_CHECKING:
+        examiners: models.QuerySet["Examiner"]
+        pseudo_patient: "Patient"
+        patient_gender: "Gender"
+        pseudo_examination: "PatientExamination"
+        state: "SensitiveMetaState" # Assuming related_name='state' is defined on SensitiveMetaState.origin
+        center: "Center"
+
+    @staticmethod
+    def _generate_random_dob():
+        # Delegate to logic
+        return logic.generate_random_dob()
+
+    @staticmethod
+    def _generate_random_examination_date():
+        # Delegate to logic
+        return logic.generate_random_examination_date()
+
+    @classmethod
+    def create_from_dict(cls: Type["SensitiveMeta"], data: Dict[str, Any]):
+        """Creates a SensitiveMeta instance from a dictionary using external logic."""
+        # Delegate to logic function
+        return logic.create_sensitive_meta_from_dict(cls, data)
+
+    # --- Methods related to pseudo-entities are now primarily handled within save logic ---
+
+    def get_pseudo_examiner(self) -> "Examiner | None":
+        """Returns the linked pseudo examiner, if one exists."""
+        if self.pk:
+            return self.examiners.first()
+        return None # Cannot determine before saving and linking
+
+    # --- Update method delegates to logic ---
+    def update_from_dict(self, data: Dict[str, Any]) -> Self:
+        """Updates the instance from a dictionary using external logic."""
+        # Delegate to logic function
+        return logic.update_sensitive_meta_from_dict(self, data)
+
+    # --- String representation ---
+    def __str__(self):
+        # Keep this method for basic representation, ensure fields are accessed safely
+        center_name = self.center.name if self.center else "None"
+        gender_str = str(self.patient_gender) if self.patient_gender else "None"
+        dob_str = str(self.patient_dob.date()) if self.patient_dob else "None" # Show only date part
+        exam_date_str = str(self.examination_date) if self.examination_date else "None"
+
+        examiners_str = "[Not saved yet]"
+        if self.pk:
+            try:
+                # Use prefetch_related in queries accessing this for efficiency
+                examiners_str = ", ".join([str(e) for e in self.examiners.all()]) or "[None]"
+            except Exception as e:
+                examiners_str = f"[Error: {e}]"
+
+        state_verified = "Unknown"
+        if self.pk:
+                # Access state verification through the related state object
+                state_verified = str(self.is_verified)
+        else:
+            state_verified = "[Not saved yet]"
+
+
+        return (
+            f"SensitiveMeta(pk={self.pk}): "
+            f"Patient={self.patient_last_name}, {self.patient_first_name} (*{dob_str}, {gender_str}), "
+            f"ExamDate={exam_date_str}, Center={center_name}, "
+            f"Examiners={examiners_str}, StateVerified={state_verified}, "
+            f"PatientHash={str(self.patient_hash)[-8:] if self.patient_hash else 'None'}, " # Show last 8 chars
+            f"ExamHash={str(self.examination_hash)[-8:] if self.examination_hash else 'None'}" # Show last 8 chars
+        )
+
+    @property
+    def is_verified(self):
+        """
+        Checks if the instance is verified based on the related state object.
+        """
+        # Use try-except for robustness, especially if state might not exist yet
+        try:
+            # Access the related state object directly via the 'state' attribute
+            # This assumes the related_name on SensitiveMetaState.origin is 'state'
+            return self.state.is_verified
+        except SensitiveMetaState.DoesNotExist:
+            # If the state object doesn't exist, it's not verified
+            return False
+        except AttributeError:
+            # If the 'state' attribute doesn't exist (e.g., before first save), it's not verified
+            return False
+
+    def get_or_create_state(self) -> "SensitiveMetaState":
+        """
+        Gets the related SensitiveMetaState instance, creating one if it doesn't exist.
+        Does not save the SensitiveMeta instance itself.
+        """
+        try:
+            # Try accessing the state via the related name 'state'
+            # This assumes the OneToOneField on SensitiveMetaState pointing to SensitiveMeta
+            # has related_name='state'
+            if self.state:
+                return self.state
+        except SensitiveMetaState.DoesNotExist:
+            # If it doesn't exist, create it
+            logger.info("Creating new SensitiveMetaState for SensitiveMeta %s", self.pk)
+            # Create the state, linking it back to this instance
+            # The 'origin' field on SensitiveMetaState points back to this SensitiveMeta instance
+            new_state = SensitiveMetaState.objects.create(origin=self)
+            # Assign the newly created state to the instance's 'state' attribute
+            # This avoids needing to query again immediately
+            self.state = new_state
+            return new_state
+        except AttributeError:
+            # Fallback if related_name is not 'state' or instance not saved yet (no PK)
+            if self.pk:
+                state, created = SensitiveMetaState.objects.get_or_create(origin=self)
+                if created:
+                    logger.info("Created new SensitiveMetaState for SensitiveMeta %s (via get_or_create)", self.pk)
+                # Link the state back to the instance in memory
+                self.state = state
+                return state
+            else:
+                # Cannot create state if the main instance has no PK
+                raise ValueError("Cannot get or create state for an unsaved SensitiveMeta instance.")
+
+        # If self.state existed initially, return it
+        return self.state
+
+    def __repr__(self):
+        return self.__str__()
+
+    # --- Hashing methods delegate to logic ---
+    def get_patient_hash(self, salt=None):
+        """Calculates the patient hash using external logic."""
+        # Use default salt from logic if None is passed
+        salt_to_use = salt if salt is not None else logic.SECRET_SALT
+        # Delegate to logic function
+        return logic.calculate_patient_hash(self, salt=salt_to_use)
+
+    def get_patient_examination_hash(self, salt=None):
+        """Calculates the examination hash using external logic."""
+        salt_to_use = salt if salt is not None else logic.SECRET_SALT
+        # Delegate to logic function
+        return logic.calculate_examination_hash(self, salt=salt_to_use)
+
+    # --- Save method orchestrates calls to logic ---
+    def save(self, *args, **kwargs):
+        """
+        Saves the SensitiveMeta instance, ensuring data integrity, hash calculation, pseudo-entity linking, and related state management using external logic.
+        
+        This method performs pre-save operations via external logic, persists the instance, ensures the related SensitiveMetaState exists, and links the appropriate examiner to the instance.
+        """
+        # 1. Call the main logic function to perform pre-save checks, data generation,
+        #    and creation/linking of pseudo patient/examination FKs.
+        #    This function modifies the instance fields (hashes, FKs, dates).
+        #    It returns the examiner instance to be linked *after* saving.
+        examiner_to_link = logic.perform_save_logic(self) # Pass only self
+
+        # 2. Call the original Django save method to save the instance itself
+        #    (including updated FKs, hashes, dates).
+        super().save(*args, **kwargs) # Pass original args/kwargs
+
+        # 3. Ensure SensitiveMetaState exists *after* saving the main instance
+        #    Use related name 'state' if defined, otherwise access via manager.
+        if self.pk: # Ensure we have a PK
+            try:
+                # Check if the related state object already exists using the related manager
+                _ = self.state
+            except SensitiveMetaState.DoesNotExist:
+                # If not, create a new one, linking it to the saved instance
+                SensitiveMetaState.objects.create(origin=self)
+            except AttributeError:
+                 # Fallback check if 'state' related_name is missing
+                 if not SensitiveMetaState.objects.filter(origin=self).exists():
+                    SensitiveMetaState.objects.create(origin=self)
+
+        # 4. Handle ManyToMany linking (examiners) *after* the instance has a PK.
+        if examiner_to_link and self.pk and not self.examiners.filter(pk=examiner_to_link.pk).exists():
+            self.examiners.add(examiner_to_link) # type: ignore
+            # Adding to M2M handles its own DB interaction, no second super().save() needed.
+
+    def mark_dob_verified(self):
+        """
+        Mark the associated date of birth as verified in the related SensitiveMetaState.
+        """
+        state = self.get_or_create_state()
+        state.mark_dob_verified()
+
+    def mark_names_verified(self):
+        """
+        Mark the patient's names as verified in the associated verification state.
+        
+        This method ensures the related SensitiveMetaState exists and updates its status to indicate that the patient's names have been verified.
+        """
+        state = self.get_or_create_state()
+        state.mark_names_verified()
+
+    @classmethod
+    def _update_name_db(cls, first_name, last_name):
+        # Delegate to logic
+        """
+        Update the name database with the provided first and last names using external logic.
+        
+        This method delegates the update operation to the external logic module responsible for managing name data.
+        """
+        logic.update_name_db(first_name, last_name)