endoreg-db 0.3.5__py3-none-any.whl → 0.3.6__py3-none-any.whl

endoreg_db/models/ai_model/utils.py

@@ -1,8 +1,8 @@
-from .model_meta import ModelMeta
-
-# get latest model meta by model name
-
-# TODO MOVE THIS TO A QUERY FILE
-def get_latest_model_meta_by_model_name(model_name):
-    model_meta = ModelMeta.objects.filter(name=model_name).order_by('-version').first()
-    return model_meta
+from .model_meta import ModelMeta
+
+# get latest model meta by model name
+
+# TODO MOVE THIS TO A QUERY FILE
+def get_latest_model_meta_by_model_name(model_name):
+    model_meta = ModelMeta.objects.filter(name=model_name).order_by('-version').first()
+    return model_meta

endoreg_db/models/annotation/__init__.py

@@ -1,2 +1,2 @@
-from .image_classification import ImageClassificationAnnotation
+from .image_classification import ImageClassificationAnnotation
 from .binary_classification_annotation_task import LegacyBinaryClassificationAnnotationTask, BinaryClassificationAnnotationTask

endoreg_db/models/annotation/binary_classification_annotation_task.py

@@ -1,80 +1,80 @@
-from django.db import models
-from rest_framework import serializers
-from ..label import Label
-from ..data_file.video_segment import LegacyLabelVideoSegment
-from .image_classification import ImageClassificationAnnotation
-
-ANNOTATION_PER_S_THRESHOLD = 2
-
-def clear_finished_legacy_tasks():
-    # fetch all BinaryClassificationAnnotationTasks that are finished and delete them
-    tasks = LegacyBinaryClassificationAnnotationTask.objects.filter(finished=True)
-
-    # delete tasks with a bulk operation
-    tasks.delete()
-
-def get_legacy_binary_classification_annotation_tasks_by_label(label:Label, n:int=100, legacy=False):
-    clear_finished_legacy_tasks()
-
-    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):
-    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):
-    frame = models.ForeignKey("Frame", on_delete=models.CASCADE, related_name="binary_classification_annotation_tasks")
-    image_type = models.CharField(max_length=255, default="frame")
-
-    def get_frame(self):
-        return self.video_segment.get_frame_by_id(self.frame_id)
-
-class LegacyBinaryClassificationAnnotationTask(AbstractBinaryClassificationAnnotationTask):
-    frame = models.ForeignKey("LegacyFrame", on_delete=models.CASCADE, related_name="binary_classification_annotation_tasks")
-    image_type = models.CharField(max_length=255, default="legacy")
-
-    def get_frame(self):
-        return self.frame
-
-
-
+from django.db import models
+from rest_framework import serializers
+from ..label import Label
+from ..data_file.video_segment import LegacyLabelVideoSegment
+from .image_classification import ImageClassificationAnnotation
+
+ANNOTATION_PER_S_THRESHOLD = 2
+
+def clear_finished_legacy_tasks():
+    # fetch all BinaryClassificationAnnotationTasks that are finished and delete them
+    tasks = LegacyBinaryClassificationAnnotationTask.objects.filter(finished=True)
+
+    # delete tasks with a bulk operation
+    tasks.delete()
+
+def get_legacy_binary_classification_annotation_tasks_by_label(label:Label, n:int=100, legacy=False):
+    clear_finished_legacy_tasks()
+
+    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):
+    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):
+    frame = models.ForeignKey("Frame", on_delete=models.CASCADE, related_name="binary_classification_annotation_tasks")
+    image_type = models.CharField(max_length=255, default="frame")
+
+    def get_frame(self):
+        return self.video_segment.get_frame_by_id(self.frame_id)
+
+class LegacyBinaryClassificationAnnotationTask(AbstractBinaryClassificationAnnotationTask):
+    frame = models.ForeignKey("LegacyFrame", on_delete=models.CASCADE, related_name="binary_classification_annotation_tasks")
+    image_type = models.CharField(max_length=255, default="legacy")
+
+    def get_frame(self):
+        return self.frame
+
+
+

endoreg_db/models/annotation/image_classification.py

@@ -1,27 +1,27 @@
-from django.db import models
-
-class ImageClassificationAnnotation(models.Model):
-    """
-    A class representing 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.
-
-    """
-    # 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")
-
-    label = models.ForeignKey("Label", on_delete=models.CASCADE, related_name="image_classification_annotations")
-    value = models.BooleanField()
-    annotator = models.CharField(max_length=255)
-    date_created = models.DateTimeField(auto_now_add=True)
-    date_modified = models.DateTimeField(auto_now=True)
-
-    def __str__(self):
-        return self.label.name + " - " + str(self.value)
+from django.db import models
+
+class ImageClassificationAnnotation(models.Model):
+    """
+    A class representing 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.
+
+    """
+    # 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")
+
+    label = models.ForeignKey("Label", on_delete=models.CASCADE, related_name="image_classification_annotations")
+    value = models.BooleanField()
+    annotator = models.CharField(max_length=255)
+    date_created = models.DateTimeField(auto_now_add=True)
+    date_modified = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        return self.label.name + " - " + str(self.value)
     

endoreg_db/models/case_template/__init__.py

@@ -1,6 +1,6 @@
-# Django models to define CaseTemplate and CaseTemplateType models 
-# (each with "name" field which acts as a natural key)
-from .case_template_rule import CaseTemplateRule, CaseTemplateRuleType
-from .case_template_rule_value import CaseTemplateRuleValue, CaseTemplateRuleValueType
-from .case_template_type import CaseTemplateType
+# Django models to define CaseTemplate and CaseTemplateType models 
+# (each with "name" field which acts as a natural key)
+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

endoreg_db/models/case_template/case_template.py

@@ -1,81 +1,81 @@
-from django.db import models
-
-class CaseTemplateManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-class CaseTemplate(models.Model):
-    """
-    A class representing 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.
-        description (str): A description of the case template.
-
-    """
-    name = models.CharField(max_length=255, unique=True)
-    template_type = models.ForeignKey("CaseTemplateType", on_delete=models.CASCADE, related_name="case_templates")
-    description = models.TextField(blank=True, null=True)
-
-    rules = models.ManyToManyField(
-        "CaseTemplateRule",
-    )
-
-    secondary_rules = models.ManyToManyField(
-        "CaseTemplateRule",
-        related_name="secondary_rules"
-    )
-
-    objects = CaseTemplateManager()
-
-    def natural_key(self):
-        return (self.name,)
-    
-    def __str__(self):
-        return self.name
-    
-    def get_rules(self):
-        rules = self.rules.all()
-        return rules
-    
-    def get_secondary_rules(self):
-        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"."""
-        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'.")
-
-    # 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.
-        """
-        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")
-        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'.")
-        elif len(create_patient_rules) == 0:
-            create_patient_rules = CaseTemplateRule.objects.get_default_create_patient_rule()
-        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.
-        """
-        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")
-        if len(create_patient_medication_schedule_rules) > 1:
-            raise ValueError("There can be at most one rule with the rule_type__name 'create-object' and target_model__name 'PatientMedicationSchedule'.")
-        elif len(create_patient_medication_schedule_rules) == 0:
-            from warnings import warn
-            warn("No create patient medication schedule rule found. Using default create patient medication schedule rule.")
-            create_patient_medication_schedule_rules = CaseTemplateRule.objects.get_default_create_patient_medication_schedule_rule()
-        return create_patient_medication_schedule_rules[0]
+from django.db import models
+
+class CaseTemplateManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class CaseTemplate(models.Model):
+    """
+    A class representing 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.
+        description (str): A description of the case template.
+
+    """
+    name = models.CharField(max_length=255, unique=True)
+    template_type = models.ForeignKey("CaseTemplateType", on_delete=models.CASCADE, related_name="case_templates")
+    description = models.TextField(blank=True, null=True)
+
+    rules = models.ManyToManyField(
+        "CaseTemplateRule",
+    )
+
+    secondary_rules = models.ManyToManyField(
+        "CaseTemplateRule",
+        related_name="secondary_rules"
+    )
+
+    objects = CaseTemplateManager()
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    
+    def get_rules(self):
+        rules = self.rules.all()
+        return rules
+    
+    def get_secondary_rules(self):
+        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"."""
+        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'.")
+
+    # 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.
+        """
+        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")
+        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'.")
+        elif len(create_patient_rules) == 0:
+            create_patient_rules = CaseTemplateRule.objects.get_default_create_patient_rule()
+        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.
+        """
+        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")
+        if len(create_patient_medication_schedule_rules) > 1:
+            raise ValueError("There can be at most one rule with the rule_type__name 'create-object' and target_model__name 'PatientMedicationSchedule'.")
+        elif len(create_patient_medication_schedule_rules) == 0:
+            from warnings import warn
+            warn("No create patient medication schedule rule found. Using default create patient medication schedule rule.")
+            create_patient_medication_schedule_rules = CaseTemplateRule.objects.get_default_create_patient_medication_schedule_rule()
+        return create_patient_medication_schedule_rules[0]