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

endoreg_db/models/annotation/image_classification.py

@@ -1,27 +1,86 @@
 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):
     """
-    A class representing an image classification annotation.
+    Represents an image classification annotation.
 
     Attributes:
-        label (str): The label that was assigned to the image.
-        confidence (float): The confidence that the label is correct.
-        annotator (User): The user that created this annotation.
-        date (datetime.datetime): The date and time when this annotation was created.
-
+        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")
-    legacy_frame = models.ForeignKey("LegacyFrame", on_delete=models.CASCADE, blank=True, null=True, related_name="image_classification_annotations")
-    legacy_image = models.ForeignKey("LegacyImage", on_delete=models.CASCADE, blank=True, null=True, related_name="image_classification_annotations")
+    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")
+    label = models.ForeignKey(
+        "Label",
+        on_delete=models.CASCADE,
+        related_name="image_classification_annotations",
+    )
     value = models.BooleanField()
-    annotator = models.CharField(max_length=255)
+    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 __str__(self):
-        return self.label.name + " - " + str(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

@@ -0,0 +1,52 @@
+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/annotation/video_segmentation_labelset.py

@@ -0,0 +1,20 @@
+from django.db import models
+
+
+class VideoSegmentationLabelSetManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+
+class VideoSegmentationLabelSet(models.Model):
+    name = models.CharField(max_length=255)
+    description = models.TextField(blank=True, null=True)
+    labels = models.ManyToManyField("VideoSegmentationLabel", related_name="labelsets")
+
+    objects = VideoSegmentationLabelSetManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return str(self.name)

endoreg_db/models/case/__init__.py

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

endoreg_db/models/{persons/patient/case → case}/case.py

@@ -18,6 +18,10 @@ class Case(models.Model):
         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)

endoreg_db/models/case_template/__init__.py

@@ -3,4 +3,13 @@
 from .case_template_rule import CaseTemplateRule, CaseTemplateRuleType
 from .case_template_rule_value import CaseTemplateRuleValue, CaseTemplateRuleValueType
 from .case_template_type import CaseTemplateType
-from .case_template import CaseTemplate
+from .case_template import CaseTemplate
+
+__all__ = [
+    "CaseTemplateRule",
+    "CaseTemplateRuleType",
+    "CaseTemplateRuleValue",
+    "CaseTemplateRuleValueType",
+    "CaseTemplateType",
+    "CaseTemplate",
+]

endoreg_db/models/case_template/case_template.py

@@ -6,13 +6,14 @@ class CaseTemplateManager(models.Manager):
     
 class CaseTemplate(models.Model):
     """
-    A class representing a case template.
+    Represents a case template.
 
     Attributes:
-        name (str): The name of the case template. This is the natural key.
-        case_template_type (CaseTemplateType): The type of the case template.
+        name (str): The unique name of the case template.
+        template_type (ForeignKey): The type of the case template.
         description (str): A description of the case template.
-
+        rules: The primary rules associated with the case template.
+        secondary_rules: Secondary rules associated with the case template.
     """
     name = models.CharField(max_length=255, unique=True)
     template_type = models.ForeignKey("CaseTemplateType", on_delete=models.CASCADE, related_name="case_templates")
@@ -30,33 +31,70 @@ class CaseTemplate(models.Model):
     objects = CaseTemplateManager()
 
     def natural_key(self):
+        """
+        Returns the natural key for the case template.
+
+        Returns:
+            tuple: The natural key consisting of the name.
+        """
         return (self.name,)
     
     def __str__(self):
+        """
+        String representation of the case template.
+
+        Returns:
+            str: The name of the case template.
+        """
         return self.name
     
     def get_rules(self):
-        rules = self.rules.all()
-        return rules
+        """
+        Retrieves all primary rules associated with the case template.
+
+        Returns:
+            A queryset of primary rules.
+        """
+        return self.rules.all()
+        
     
     def get_secondary_rules(self):
+        """
+        Retrieves all secondary rules associated with the case template.
+
+        Returns:
+            QuerySet: A queryset of secondary rules.
+        """
         rules = self.secondary_rules.all()
         return rules
     
     def _assert_max_one_create_patient_rule(self):
-        """Asserts that there is at most one rule with the rule_type__name "create-object" and target_model__name "Patient"."""
+        """
+        Ensures that there is at most one rule with rule_type "create-object" and target_model "Patient".
+
+        Raises:
+            ValueError: If more than one rule of the specified type exists.
+        """
         create_patient_rules = self.rules.filter(rule_type__name="create-object", target_model__name="Patient")
         if len(create_patient_rules) > 1:
-            raise ValueError("There can be at most one rule with the rule_type__name 'create-object' and target_model__name 'Patient'.")
-
+            raise ValueError(
+                "There can be at most one rule with the rule_type__name 'create-object' and target_model__name 'Patient'."
+            )
+        
     # custom save method which runs the _assert_max_one_create_patient_rule method and others
     def save(self, *args, **kwargs):
         # self._assert_max_one_create_patient_rule() #TODO Fails on first save since many to many can only be used if object has an id
         super().save(*args, **kwargs)
 
     def get_create_patient_rule(self):
-        """Filter the rules for the rule which has the rule_type__name "create-object" and target_model__name "Patient".
-        Also makes sure, that only 1 is returned. If there is no such rule, get default create patient rule.
+        """
+        Retrieves the "create-patient" rule.
+
+        Returns:
+            CaseTemplateRule: The rule that creates a patient.
+
+        Raises:
+            ValueError: If multiple such rules exist.
         """
         from endoreg_db.models.case_template.case_template_rule import CaseTemplateRule
         create_patient_rules = self.rules.filter(rule_type__name="create-object", target_model="Patient")
@@ -67,8 +105,14 @@ class CaseTemplate(models.Model):
         return create_patient_rules[0]
     
     def get_create_patient_medication_schedule_rule(self):
-        """Filter the rules for the rule which has the rule_type__name "create-object" and target_model__name "PatientMedicationSchedule".
-        Also makes sure, that only 1 is returned. If there is no such rule, get default create patient medication schedule rule.
+        """
+        Retrieves the "create-patient_medication_schedule" rule.
+
+        Returns:
+            CaseTemplateRule: The rule for creating a patient medication schedule.
+
+        Raises:
+            ValueError: If multiple such rules exist.
         """
         from endoreg_db.models.case_template.case_template_rule import CaseTemplateRule
         create_patient_medication_schedule_rules = self.rules.filter(rule_type__name="create-object", target_model="PatientMedicationSchedule")

endoreg_db/models/case_template/case_template_rule.py

@@ -6,12 +6,13 @@ class CaseTemplateRuleTypeManager(models.Manager):
     
 class CaseTemplateRuleType(models.Model):
     """
-    A class representing a case template rule type.
+    Represents a type of rule for a case template.
 
     Attributes:
-        name (str): The name of the case template rule type.
-        description (str): A description of the case template rule type.
-
+        name (str): The name of the rule type.
+        name_de (str): The German name of the rule type.
+        name_en (str): The English name of the rule type.
+        description (str): A description of the rule type.
     """
     name = models.CharField(max_length=255)
     name_de = models.CharField(max_length=255, null=True)
@@ -50,7 +51,6 @@ class CaseTemplateRule(models.Model):
 
     Attributes:
         name (str): The name of the case template rule.
-        case_template (CaseTemplate): The case template to which the rule belongs.
         description (str): A description of the case template rule.
         name_de (str): The name of the case template rule in German.
         name_en (str): The name of the case template rule in English.

endoreg_db/models/case_template/case_template_rule_value.py

@@ -40,12 +40,14 @@ class CaseTemplateRuleValueManager(models.Manager):
     
 class CaseTemplateRuleValue(models.Model):
     """
-    A class representing a case template rule value.
+    Represents a case template rule value.
 
     Attributes:
-        value (str): The value of the case template rule value.
-        case_template_rule (CaseTemplateRule): The case template rule of the case template rule value.
-        case_template (CaseTemplate): The case template of the case template rule value.
+        name (str): The name of the rule value.
+        description (str): A description of the rule value.
+        fk_value (str): Foreign key value stored as a string.
+        numeric_value (float): Numeric value for the rule.
+        text_value (str): Text value for the rule.
     """
     objects = CaseTemplateRuleValueManager()
 
@@ -57,12 +59,25 @@ class CaseTemplateRuleValue(models.Model):
     text_value = models.CharField(max_length=255, null=True, blank=True)
 
     def natural_key(self):
+        """
+        Returns the natural key for the object.
+        """
         return (self.name,)
     
     def __str__(self):
+        """
+        String representation of the object.
+        """
         return self.name
     
     def get_value(self):
+        """
+        Retrieves the value based on priority:
+        - fk_value > numeric_value > text_value > None.
+        
+        Returns:
+            str | float | None: The value based on the type hierarchy.
+        """
         if self.fk_value:
             return self.fk_value
         elif self.numeric_value:

endoreg_db/models/center/__init__.py

@@ -2,3 +2,10 @@ from .center import Center
 from .center_product import CenterProduct
 from .center_resource import CenterResource
 from .center_waste import CenterWaste
+
+__all__ = [
+    'Center',
+    'CenterProduct',
+    'CenterResource',
+    'CenterWaste'
+]

endoreg_db/models/center/center.py

@@ -1,9 +1,11 @@
 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()
 
@@ -13,13 +15,37 @@ class Center(models.Model):
     name_en = models.CharField(max_length=255, blank=True, null=True)
 
     first_names = models.ManyToManyField(
-        'FirstName',
-        related_name='centers',
+        "FirstName",
+        related_name="centers",
     )
-    last_names = models.ManyToManyField('LastName', 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
+        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,4 +1,3 @@
-from itertools import product
 from django.db import models
 
 class CenterProduct(models.Model):

endoreg_db/models/center/center_resource.py

@@ -1,4 +1,3 @@
-from os import name
 from django.db import models
 
 class CenterResource(models.Model):
@@ -16,4 +15,19 @@ class CenterResource(models.Model):
     unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
     
     def __str__(self):
-        return self.center.name + " - " + self.resource.name + " (" + str(self.year) + ")"
+        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

@@ -8,4 +8,9 @@ class CenterWaste(models.Model):
     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

@@ -1,6 +1,39 @@
-from .frame import Frame, LegacyFrame
+from .frame import Frame, RawFrame
 from .report_file import ReportFile
-from .video import Video, LegacyVideo, VideoImportMeta
-from .video_segment import LegacyLabelVideoSegment, LabelVideoSegment
-from .metadata import *
-from .import_classes import *
+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,2 +1,7 @@
 from .abstract_frame import AbstractFrame
-from .abstract_video import AbstractVideo
+from .abstract_video import AbstractVideoFile
+
+__all__ = [
+    "AbstractFrame",
+    "AbstractVideoFile",
+]