endoreg-db 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

endoreg_db/models/center/center.py

@@ -0,0 +1,51 @@
+from django.db import models
+
+
+class CenterManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+
+class Center(models.Model):
+    objects = CenterManager()
+
+    # import_id = models.IntegerField(primary_key=True)
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+
+    first_names = models.ManyToManyField(
+        "FirstName",
+        related_name="centers",
+    )
+    last_names = models.ManyToManyField("LastName", related_name="centers")
+
+    @classmethod
+    def get_by_name(cls, name):
+        return cls.objects.get(name=name)
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+
+    def get_first_names(self):
+        from endoreg_db.models import FirstName
+
+        names = FirstName.objects.filter(centers=self)
+        return names
+
+    def get_last_names(self):
+        from endoreg_db.models import LastName
+
+        names = LastName.objects.filter(centers=self)
+        return names
+
+    def get_endoscopes(self):
+        from endoreg_db.models import Endoscope
+
+        endoscopes = Endoscope.objects.filter(center=self)
+        return endoscopes
+
+    # def get_endoscopy_processor

endoreg_db/models/center/center_product.py

@@ -0,0 +1,33 @@
+from django.db import models
+
+class CenterProduct(models.Model):
+    product = models.ForeignKey("Product", on_delete=models.CASCADE)
+    date_used = models.DateField()
+    center = models.ForeignKey("Center", on_delete=models.CASCADE)
+
+
+    def get_product_group(self):
+        product = self.product
+        product_group = product.product_group
+
+        return product_group
+    
+    def get_reference_product(self):
+        product_group = self.get_product_group()
+        reference_product = product_group.reference_product
+
+        return reference_product
+    
+    def get_product_weight(self):
+        product = self.product
+        weight, unit = product.get_product_weight()
+
+        return weight, unit
+    
+    def get_package_weight(self):
+        product = self.product
+        weight, unit = product.get_package_weight()
+
+        return weight, unit
+    
+    

endoreg_db/models/center/center_resource.py

@@ -0,0 +1,33 @@
+from django.db import models
+
+class CenterResource(models.Model):
+    name = models.CharField(max_length=255, null=True)
+    center = models.ForeignKey("Center", on_delete=models.CASCADE)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+    quantity = models.FloatField()
+    resource = models.ForeignKey("Resource", on_delete=models.CASCADE)
+    transport_emission_factor = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True,
+                                                  related_name="center_resource_transport_emission_factor")
+    use_emission_factor = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True,
+                                            related_name="center_resource_use_emission_factor")
+    year = models.IntegerField()
+    unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
+    
+    def __str__(self):
+        result_string = ""
+
+        if self.name is not None:
+            result_string += self.name + ":\n"
+
+        result_string += "\tCenter\t-\t" + str(self.center) + "\n"
+        result_string += "\tResource\t-\t" + str(self.resource) + "\n"
+        result_string += "\tQuantity\t-\t" + str(self.quantity) + "\n"
+        result_string += "\tYear\t-\t" + str(self.year) + "\n"
+        result_string += "\tUnit\t-\t" + str(self.unit) + "\n"
+        result_string += "\tTransport Emission Factor\t-\t" + str(self.transport_emission_factor) + "\n"
+        result_string += "\tUse Emission Factor\t-\t" + str(self.use_emission_factor) + "\n"
+
+        result_string += "\n"
+
+        return result_string

endoreg_db/models/center/center_waste.py

@@ -0,0 +1,16 @@
+from django.db import models
+    
+class CenterWaste(models.Model):
+    center = models.ForeignKey("Center", on_delete=models.CASCADE)
+    year = models.IntegerField()
+    waste = models.ForeignKey("Waste", on_delete=models.CASCADE)
+    quantity = models.FloatField()
+    unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
+    emission_factor = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True)
+
+    
+    def __str__(self):
+        result = f"{self.quantity} {self.unit}"
+        result += f" -\t{self.waste}, EmissionFactor: {self.emission_factor}\t\t- {self.center} - {self.year}"
+
+        return result

endoreg_db/models/contraindication/__init__.py

@@ -0,0 +1,21 @@
+from django.db import models
+
+class ContraindicationManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class Contraindication(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+    description_de = models.TextField(blank=True, null=True)
+    description_en = models.TextField(blank=True, null=True)
+
+    objects = ContraindicationManager()
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name

endoreg_db/models/data_file/__init__.py

@@ -0,0 +1,39 @@
+from .frame import Frame, RawFrame
+from .report_file import ReportFile
+from .video import Video, VideoImportMeta
+from .video_segment import (
+    LabelVideoSegment,
+    LabelRawVideoSegment,
+    find_segments_in_prediction_array,
+)
+from .metadata import (
+    SensitiveMeta,
+    PdfMeta,
+    PdfType,
+    VideoMeta,
+    FFMpegMeta,
+)
+
+from .import_classes import (
+    RawPdfFile,
+    RawVideoFile,
+)
+
+
+__all__ = [
+    "Frame",
+    "ReportFile",
+    "Video",
+    "LabelVideoSegment",
+    "LabelRawVideoSegment",
+    "find_segments_in_prediction_array",
+    "SensitiveMeta",
+    "PdfMeta",
+    "PdfType",
+    "RawFrame",
+    "VideoMeta",
+    "FFMpegMeta",
+    "VideoImportMeta",
+    "RawPdfFile",
+    "RawVideoFile",
+]

endoreg_db/models/data_file/base_classes/__init__.py

@@ -0,0 +1,7 @@
+from .abstract_frame import AbstractFrame
+from .abstract_video import AbstractVideoFile
+
+__all__ = [
+    "AbstractFrame",
+    "AbstractVideoFile",
+]

endoreg_db/models/data_file/base_classes/abstract_frame.py

@@ -0,0 +1,100 @@
+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):
+    frame_number = models.IntegerField()
+    # Add any other fields you need to store frame-related information
+    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")
+        # Optimize for retrieval in frame_number order
+        indexes = [models.Index(fields=["video", "frame_number"])]
+
+    # 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):
+        """
+        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):
+        """
+        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
+    ):
+        """
+        Get all image classification annotations for this frame with the given label and 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)