endoreg-db 0.6.4__py3-none-any.whl → 0.8.2__py3-none-any.whl

endoreg_db/models/annotation/binary_classification_annotation_task.py

@@ -1,117 +0,0 @@
-from django.db import models
-# from rest_framework import serializers
-# from ..label import Label
-# from .image_classification import ImageClassificationAnnotation
-
-ANNOTATION_PER_S_THRESHOLD = 2
-
-# TODO Migrate
-# def clear_finished_legacy_tasks():
-#     """
-#     Deletes all finished LegacyBinaryClassificationAnnotationTask entries.
-#     """
-#     tasks = LegacyBinaryClassificationAnnotationTask.objects.filter(is_finished=True)
-#     tasks.delete()
-
-# def get_legacy_binary_classification_annotation_tasks_by_label(label:Label, n:int=100, legacy=False):
-#     clear_finished_legacy_tasks()
-#     """
-#     Retrieves legacy binary classification annotation tasks for a specific label.
-
-#     Args:
-#         label (Label): The label to filter tasks by.
-#         n (int): Maximum number of tasks to retrieve. Defaults to 100.
-#         legacy (bool): If True, includes legacy tasks. Defaults to False.
-#     """
-#     if legacy:
-#         # fetch all LegacyLabelVideoSegments with the given label
-#         _segments = LegacyLabelVideoSegment.objects.filter(label=label)
-#         frames_for_tasks = []
-
-#         for segment in _segments:
-#             # check if the segment has already been annotated
-#             annotations = list(ImageClassificationAnnotation.objects.filter(legacy_frame__in=segment.get_frames(), label=label))
-#             segment_len_in_s = segment.get_segment_len_in_s()
-
-#             target_annotation_number = segment_len_in_s * ANNOTATION_PER_S_THRESHOLD
-
-#             if len(annotations) < target_annotation_number:
-#                 get_frame_number = int(target_annotation_number - len(annotations))
-#                 frames = segment.get_frames_without_annotation(get_frame_number)
-#                 frames_for_tasks.extend(frames)
-
-#             if len(frames_for_tasks) >= n:
-#                 break
-
-#         # create tasks
-#         tasks = []
-#         for frame in frames_for_tasks:
-
-#             # get_or_create task
-#             task, created = LegacyBinaryClassificationAnnotationTask.objects.get_or_create(
-#                 label=label,
-#                 image_path=frame.image.path,
-#                 frame_id=frame.pk,
-#             )
-
-
-class AbstractBinaryClassificationAnnotationTask(models.Model):
-    """
-    Abstract base class for binary classification annotation tasks.
-
-    Attributes:
-        label (ForeignKey): The associated label.
-        is_finished (bool): Indicates if the task is completed.
-        date_created (datetime): The creation date of the task.
-        date_finished (datetime): The completion date of the task.
-        image_path (str): Path to the associated image.
-        image_type (str): The type of the image (e.g., "frame" or "legacy").
-        frame_id (int): Identifier of the associated frame.
-        labelstudio_project_id (int): The Label Studio project ID.
-        labelstudio_task_id (int): The Label Studio task ID.
-    """
-
-    label = models.ForeignKey("Label", on_delete=models.CASCADE)
-    is_finished = models.BooleanField(default=False)
-    date_created = models.DateTimeField(auto_now_add=True)
-    date_finished = models.DateTimeField(blank=True, null=True)
-    image_path = models.CharField(max_length=255, blank=True, null=True)
-    image_type = models.CharField(max_length=255, blank=True, null=True)
-    frame_id = models.IntegerField(blank=True, null=True)
-    labelstudio_project_id = models.IntegerField(blank=True, null=True)
-    labelstudio_task_id = models.IntegerField(blank=True, null=True)
-
-    class Meta:
-        abstract = True
-
-
-class BinaryClassificationAnnotationTask(AbstractBinaryClassificationAnnotationTask):
-    """
-    Represents a binary classification task for a frame.
-
-    Attributes:
-       frame (ForeignKey): The associated frame for this task.
-    """
-
-    frame = models.ForeignKey(
-        "Frame",
-        on_delete=models.CASCADE,
-        related_name="binary_classification_annotation_tasks",
-    )
-    image_type = models.CharField(
-        max_length=255, default="frame"
-    )  # Default image type for non-legacy tasks
-
-    def get_frame(self):
-        """
-        Retrieves the frame associated with this task.
-        """
-        from endoreg_db.models.data_file.frame import Frame
-
-        frame = self.frame
-        if not frame:
-            return None
-        else:
-            assert isinstance(frame, Frame)
-
-        return frame

endoreg_db/models/annotation/image_classification.py

@@ -1,86 +0,0 @@
-from django.db import models
-
-from typing import TYPE_CHECKING, Union
-
-if TYPE_CHECKING:
-    from endoreg_db.models import Frame, RawFrame, Label
-
-
-class ImageClassificationAnnotation(models.Model):
-    """
-    Represents an image classification annotation.
-
-    Attributes:
-        frame (ForeignKey): The frame associated with the annotation.
-        legacy_frame (ForeignKey): The legacy frame associated with the annotation.
-        legacy_image (ForeignKey): The legacy image associated with the annotation.
-        label (ForeignKey): The label assigned to the annotation.
-        value (bool): Indicates if the classification is valid.
-        annotator (str): The user who created the annotation.
-        date_created (datetime): The creation date of the annotation.
-        date_modified (datetime): The last modification date of the annotation.
-    """
-
-    # Foreign keys to Frame, LegacyFrame, and LegacyImage (only one of these should be set)
-    frame = models.ForeignKey(
-        "Frame",
-        on_delete=models.CASCADE,
-        blank=True,
-        null=True,
-        related_name="image_classification_annotations",
-    )
-
-    raw_frame = models.ForeignKey(
-        "RawFrame",
-        on_delete=models.CASCADE,
-        blank=True,
-        null=True,
-        related_name="image_classification_annotations",
-    )
-
-    label = models.ForeignKey(
-        "Label",
-        on_delete=models.CASCADE,
-        related_name="image_classification_annotations",
-    )
-    value = models.BooleanField()
-    float_value = models.FloatField(blank=True, null=True)
-    annotator = models.CharField(max_length=255, blank=True, null=True)
-    model_meta = models.ForeignKey(
-        "ModelMeta",
-        on_delete=models.SET_NULL,
-        related_name="image_classification_annotations",
-        default=None,
-        null=True,
-        blank=True,
-    )
-    date_created = models.DateTimeField(auto_now_add=True)
-    date_modified = models.DateTimeField(auto_now=True)
-    information_source = models.ForeignKey(
-        "InformationSource",
-        on_delete=models.SET_NULL,
-        related_name="image_classification_annotations",
-        default=None,
-        null=True,
-        blank=True,
-    )
-
-    if TYPE_CHECKING:
-        frame: "Frame"
-        raw_frame: "RawFrame"
-        label: "Label"
-
-    def __str__(self) -> str:
-        """
-        String representation of the annotation.
-        """
-        return f"{self.label.name} - {self.value}"
-
-    def get_frame(self):
-        """
-        Get the frame associated with the annotation.
-        """
-        if self.frame:
-            return self.frame
-        else:
-            return self.raw_frame

endoreg_db/models/annotation/video_segmentation_annotation.py

@@ -1,52 +0,0 @@
-from django.db import models
-
-class VideoSegmentationLabelManager(models.Manager):
-    """
-    Manager for VideoSegmentationLabel with custom query methods.
-    """
-    def get_by_natural_key(self, name: str) -> "VideoSegmentationLabel":
-        return self.get(name=name)
-
-class VideoSegmentationLabel(models.Model):
-    """
-    Represents a label for video segmentation annotations.
-
-    Attributes:
-        name (str): The name of the label.
-        name_de (str): The German name of the label.
-        name_en (str): The English name of the label.
-        description (str): A description of the label.
-        color (str): The color associated with the label.
-        order_priority (int): The priority for ordering labels.
-    """
-    objects = VideoSegmentationLabelManager()
-
-    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)
-    description = models.TextField(blank=True, null=True)
-    color = models.CharField(max_length=255, blank=True, null=True)
-    order_priority = models.IntegerField(default=0)
-
-    def natural_key(self):
-        return (self.name,)
-
-    def __str__(self):
-        return self.name
-
-class VideoSegmentationAnnotation(models.Model):
-    """
-    Represents a video segmentation annotation.
-
-    Attributes:
-        video (ForeignKey): The associated video file.
-        label (ForeignKey): The label for the annotation.
-        start_time (float): The start time of the annotation in seconds.
-        stop_time (float): The stop time of the annotation in seconds.
-        is_true (bool): Indicates if the annotation is valid.
-    """
-    video = models.ForeignKey("RawVideoFile", on_delete=models.CASCADE)
-    label = models.ForeignKey(VideoSegmentationLabel, on_delete=models.CASCADE)
-    start_time = models.FloatField()  # in seconds
-    stop_time = models.FloatField()  # in seconds
-    is_true = models.BooleanField(default=True)

endoreg_db/models/case/__init__.py

@@ -1 +0,0 @@
-from .case import Case

endoreg_db/models/case/case.py

@@ -1,34 +0,0 @@
-from django.db import models
-
-class Case(models.Model):
-    """
-    A class representing a case.
-
-    Attributes:
-        name (str): The name of the case.
-        description (str): A description of the case.
-        case_template (CaseTemplate): The case template of the case.
-        patient (Patient): The patient of the case.
-        start_date (datetime): The start date of the case.
-        end_date (datetime): The end date of the case.
-        is_active (bool): A flag indicating whether the case is active.
-        is_closed (bool): A flag indicating whether the case is closed.
-        is_deleted (bool): A flag indicating whether the case is deleted.
-        created_at (datetime): The creation date of the case.
-        updated_at (datetime): The last update date of the case.
-
-    """
-    patient = models.ForeignKey('Patient', on_delete=models.CASCADE, related_name='cases')
-    patient_examinations = models.ManyToManyField('PatientExamination', related_name='cases')
-    hash = models.CharField(max_length=255, blank=True, null=True)
-
-    start_date = models.DateTimeField()
-    end_date = models.DateTimeField(null=True)
-    is_active = models.BooleanField(default=True)
-    is_closed = models.BooleanField(default=False)
-    is_deleted = models.BooleanField(default=False)
-    created_at = models.DateTimeField(auto_now_add=True)
-    updated_at = models.DateTimeField(auto_now=True)
-
-    def __str__(self):
-        return self.name

endoreg_db/models/center/center.py

@@ -1,51 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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_waste.py

@@ -1,16 +0,0 @@
-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/data_file/__init__.py

@@ -1,39 +0,0 @@
-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

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

endoreg_db/models/data_file/base_classes/abstract_frame.py

@@ -1,98 +0,0 @@
-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
-
-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

@@ -1,127 +0,0 @@
-# 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
-
-
-if TYPE_CHECKING:
-    from endoreg_db.models import SensitiveMeta
-
-logger = logging.getLogger("pdf_import")
-
-
-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)