endoreg-db 0.5.3__py3-none-any.whl → 0.6.1__py3-none-any.whl

endoreg_db/models/data_file/base_classes/abstract_frame.py

@@ -1,51 +1,100 @@
-from endoreg_db.models.annotation.image_classification import ImageClassificationAnnotation
+from typing import Union, TYPE_CHECKING
+from endoreg_db.models.annotation.image_classification import (
+    ImageClassificationAnnotation,
+)
 from endoreg_db.models.label.label import Label
 
 from django.db import models
+from .utils import FRAME_DIR_NAME
+
+if TYPE_CHECKING:
+    from endoreg_db.models import Video, RawVideoFile
 
 
 class AbstractFrame(models.Model):
-    video = None # Placeholder for the video field, to be defined in derived classes
     frame_number = models.IntegerField()
     # Add any other fields you need to store frame-related information
-    image = models.ImageField(upload_to="frames")  # Or some other field type, depending on how you're storing the frame
     suffix = models.CharField(max_length=255)
     # ImageClassificationAnnotation has a foreign key to this model (related name: image_classification_annotations)
+    # image = models.ImageField(blank=True, null=True)
+    is_raw = models.BooleanField(default=False)
+    extracted = models.BooleanField(default=False)
+
+    if TYPE_CHECKING:
+        video: Union["Video", "RawVideoFile"]
+        image_classification_annotations: (
+            "models.QuerySet[ImageClassificationAnnotation]"
+        )
 
     class Meta:
         # Ensure that for each video, the frame_number is unique
         abstract = True
-        unique_together = ('video', 'frame_number')
+        unique_together = ("video", "frame_number")
         # Optimize for retrieval in frame_number order
-        indexes = [models.Index(fields=['video', 'frame_number'])]
-
-
-    def __str__(self):
-        return self.video.file.path + " - " + str(self.frame_number)
+        indexes = [models.Index(fields=["video", "frame_number"])]
 
-    def get_frame_model(self):
-        assert 1 == 2, "This method should be overridden in derived classes"
+    # Override save method to set is_raw based on the type of frame
+    def save(self, *args, **kwargs):
+        self.is_raw = self.is_raw_frame()
+        super().save(*args, **kwargs)
 
     def get_classification_annotations(self):
         """
         Get all image classification annotations for this frame.
         """
+        if self.is_raw_frame():
+            return ImageClassificationAnnotation.objects.filter(raw_frame=self)
         return ImageClassificationAnnotation.objects.filter(frame=self)
 
-    def get_classification_annotations_by_label(self, label:Label):
+    def get_classification_annotations_by_label(self, label: Label):
         """
         Get all image classification annotations for this frame with the given label.
         """
+        if self.is_raw_frame():
+            return ImageClassificationAnnotation.objects.filter(
+                raw_frame=self, label=label
+            )
         return ImageClassificationAnnotation.objects.filter(frame=self, label=label)
 
-    def get_classification_annotations_by_value(self, value:bool):
+    def get_classification_annotations_by_value(self, value: bool):
         """
         Get all image classification annotations for this frame with the given value.
         """
+        if self.is_raw_frame():
+            return ImageClassificationAnnotation.objects.filter(
+                raw_frame=self, value=value
+            )
         return ImageClassificationAnnotation.objects.filter(frame=self, value=value)
 
-    def get_classification_annotations_by_label_and_value(self, label:Label, value:bool):
+    def get_classification_annotations_by_label_and_value(
+        self, label: Label, value: bool
+    ):
         """
         Get all image classification annotations for this frame with the given label and value.
         """
-        return ImageClassificationAnnotation.objects.filter(frame=self, label=label, value=value)
+        if self.is_raw_frame():
+            return ImageClassificationAnnotation.objects.filter(
+                raw_frame=self, label=label, value=value
+            )
+        return ImageClassificationAnnotation.objects.filter(
+            frame=self, label=label, value=value
+        )
+
+    def __str__(self):
+        return self.video.file.path + " - " + str(self.frame_number)
+
+    def is_raw_frame(self):
+        from endoreg_db.models import RawFrame
+
+        if isinstance(self, RawFrame):
+            return True
+        else:
+            return False
+
+    def get_frame_model(self):
+        from endoreg_db.models import Frame, RawFrame
+
+        if self.is_raw_frame():
+            return RawFrame
+        else:
+            return Frame

endoreg_db/models/data_file/base_classes/abstract_pdf.py

@@ -0,0 +1,136 @@
+# models/data_file/import_classes/raw_pdf.py
+# django db model "RawPdf"
+# Class to store raw pdf file using django file field
+# Class contains classmethod to create object from pdf file
+# objects contains methods to extract text, extract metadata from text and anonymize text from pdf file uzing agl_report_reader.ReportReader class
+# ------------------------------------------------------------------------------
+
+from django.db import models
+
+# from django.core.files.storage import FileSystemStorage
+# from django.conf import settings
+from django.core.exceptions import ValidationError
+# from django.core.validators import FileExtensionValidator
+# from endoreg_db.utils.file_operations import get_uuid_filename
+# from icecream import ic
+
+# from agl_report_reader.report_reader import ReportReader
+
+from endoreg_db.utils.hashs import get_pdf_hash
+# from ..metadata import SensitiveMeta
+
+# setup logging to pdf_import.log
+import logging
+
+# import shutil
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from ..base_classes.utils import (
+    STORAGE_LOCATION,
+)
+
+if TYPE_CHECKING:
+    from endoreg_db.models import SensitiveMeta
+
+logger = logging.getLogger("pdf_import")
+
+RAW_PDF_DIR_NAME = "raw_pdf"
+RAW_PDF_DIR = STORAGE_LOCATION / RAW_PDF_DIR_NAME
+
+if not RAW_PDF_DIR.exists():
+    RAW_PDF_DIR.mkdir(parents=True)
+
+
+class AbstractPdfFile(models.Model):
+    pdf_hash = models.CharField(max_length=255, unique=True)
+    pdf_type = models.ForeignKey(
+        "PdfType",
+        on_delete=models.SET_NULL,
+        blank=True,
+        null=True,
+    )
+    sensitive_meta = models.ForeignKey(
+        "SensitiveMeta",
+        on_delete=models.SET_NULL,
+        related_name="report_files",
+        null=True,
+        blank=True,
+    )
+    center = models.ForeignKey(
+        "Center",
+        on_delete=models.SET_NULL,
+        blank=True,
+        null=True,
+    )
+
+    patient = models.ForeignKey(
+        "Patient",
+        on_delete=models.SET_NULL,
+        blank=True,
+        null=True,
+    )
+
+    examination = models.ForeignKey(
+        "PatientExamination",
+        on_delete=models.SET_NULL,
+        blank=True,
+        null=True,
+    )
+
+    examiner = models.ForeignKey(
+        "Examiner",
+        on_delete=models.SET_NULL,
+        blank=True,
+        null=True,
+    )
+
+    text = models.TextField(blank=True, null=True)
+
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    if TYPE_CHECKING:
+        sensitive_meta: "SensitiveMeta"
+
+    class Meta:
+        abstract = True
+
+    def __str__(self):
+        str_repr = f"{self.pdf_hash} ({self.pdf_type}, {self.center})"
+        return str_repr
+
+    def delete_with_file(self):
+        file_path = Path(self.file.path)
+        if file_path.exists():
+            file_path.unlink()
+            logger.info("File removed: %s", file_path)
+
+        r = self.delete()
+        return r
+
+    def update(self, save=True, verbose=True):
+        try:
+            self.text, self.anonymized_text, self.raw_meta = self.process_file(
+                verbose=verbose
+            )
+            self.state_report_processed = True
+            self.state_report_processing_required = False
+
+            if save:
+                self.save()
+
+            return True
+
+        except (IOError, ValueError) as e:
+            logger.error("Error processing file: %s", self.file.path)
+            logger.error(e)
+            return False
+
+    # override save method to get patient and examination from sensitive meta
+    def save(self, *args, **kwargs):
+        if not self.patient and self.sensitive_meta:
+            self.patient = self.sensitive_meta.pseudo_patient
+            self.examination = self.sensitive_meta.pseudo_examination
+            self.center = self.sensitive_meta.center
+
+        super().save(*args, **kwargs)