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

endoreg_db/models/rules/rule_applicator.py

@@ -0,0 +1,224 @@
+from .rule import Rule
+import random
+from django.core.exceptions import ValidationError
+
+class RuleApplicator:
+    """
+    A class to apply different types of rules to a Django model instance based on the Rule configuration.
+    """
+
+    def get_rule_by_name(self, rule_name):
+        """
+        A helper method to fetch a rule by name. This can be further customized.
+        """
+        # get rule by name which is natural key
+        rule = Rule.objects.get_by_natural_key(rule_name)
+        return rule
+
+
+    def apply(self, obj, rule):
+        """
+        Applies a specified rule to an object based on the rule type and attributes.
+
+        Parameters:
+        obj (Django model instance): The object to which the rule is applied.
+        rule (Rule): The rule instance containing the rule_type and attribute details.
+        """
+        rule_type_method = self.get_rule_type_method(rule.rule_type.name)
+        if rule_type_method:
+            rule_type_method(obj, rule)
+
+        else:
+            raise ValueError(f"Unsupported rule type: {rule.rule_type.name}")
+        
+    def apply_rule_by_name(self, obj, rule_name):
+        """
+        A helper method to apply a rule and get a value. This can be further customized.
+        """
+        rule = self.get_rule_by_name(rule_name)
+        self.apply(obj, rule)
+
+    def apply_rules_by_name(self, obj, rule_names):
+        """
+        A helper method to apply multiple rules and get values. This can be further customized.
+        """
+        rules = [self.get_rule_by_name(rule_name) for rule_name in rule_names]
+        for rule in rules:
+            self.apply(obj, rule)
+            
+
+    def get_rule_type_method(self, rule_type_name):
+        """
+        Maps rule type name to the corresponding method.
+        """
+        return getattr(self, f"handle_{rule_type_name}", None)
+
+    def parse_attribute_path(self, obj, attribute_key):
+        """
+        Parses the attribute path and applies the value to the correct attribute of a nested object.
+        """
+        parts = attribute_key.split('.')
+        model_name = parts[0]
+        if model_name.lower() != obj.__class__.__name__.lower():
+            raise ValidationError(f"Model type mismatch: expected {model_name}, got {obj.__class__.__name__}")
+
+        # Navigate through the nested attributes
+        target = obj
+        for part in parts[1:-1]:
+            target = getattr(target, part)
+
+        return target, parts[-1]
+
+    def set_attribute_value(self, obj, rule):
+        """
+        Generic method to set attribute value considering nested paths.
+        """
+        target, attribute = self.parse_attribute_path(obj, rule.attribute_key)
+        setattr(target, attribute, rule.attribute_dict['value'])
+        target.save()
+
+    #####
+
+    def handle_case_attribute_set_value(self, obj, rule):
+        """
+        Sets a specific attribute to a given value.
+        """
+        self.set_attribute_value(obj, rule.attribute_key, rule.attribute_dict["value"])
+
+    def handle_case_attribute_set_value_range_uniform(self, obj, rule):
+        """
+        Sets an attribute to a value within a specified range, selected uniformly.
+        """
+        if not hasattr(rule, 'attribute_dtype') or rule.attribute_dtype.name not in ['numeric', 'ordered_categorical']:
+            raise ValidationError("Attribute dtype must be numeric or ordered_categorical")
+        min_val = rule.attribute_dict["value_min"]
+        max_val = rule.attribute_dict["value_max"]
+        value = random.uniform(min_val, max_val)
+        self.set_attribute_value(obj, rule.attribute_key, value)
+
+    def handle_case_attribute_set_value_range_norm_dist(self, obj, rule):
+        """
+        Sets an attribute to a value within a specified range, based on a normal distribution.
+        """
+        if rule.attribute_dtype.name in ['float', "integer"]:
+            raise ValidationError("Attribute dtype must be float or integer")
+        mean = rule.attribute_dict["value_mean"]
+        std_dev = rule.attribute_dict["value_sd"]
+        value = random.normalvariate(mean, std_dev)
+        self.set_attribute_value(obj, rule.attribute_key, value)
+        
+
+    def handle_case_attribute_set_from_list_uniform(self, obj, rule):
+        """
+        Selects an attribute value uniformly from a list of choices.
+        """
+        choices = rule.attribute_dict["value_choices"]
+        value = random.choice(choices)
+        self.set_attribute_value(obj, rule.attribute_key, value)
+
+    def handle_case_attribute_set_from_prop_tuple_list(self, obj, rule):
+        """
+        Selects an attribute value based on a list of value-probability tuples.
+        """
+        prop_list = rule.attribute_dict["value_prop_tuple_list"]
+        total = sum(prop for _, prop in prop_list)
+        pick = random.uniform(0, total)
+        current = 0
+        for value, prop in prop_list:
+            current += prop
+            if current > pick:
+                self.set_attribute_value(obj, rule.attribute_key, value)
+                break
+
+
+    #####
+
+    def handle_case_add_patient(self, obj, rule):
+        """Function to add a patient to a case. If the patient already exists, raise an error. Requires the following
+        rules in the rule_dict:
+        - gender_rule
+        - dob_rule
+        - event_rules
+        - disease_rules
+        """
+        from endoreg_db.models import Patient, PatientEvent, PatientDisease, Case
+
+        # Check if the 
+        obj:Case = obj
+        if obj.patient:
+            raise ValueError("Patient already exists in the case")
+        
+        patient = Patient()
+        self.apply_rule_by_name(patient, rule.attribute_dict["patient_gender_rule"])
+        self.apply_rule_by_name(patient, rule.attribute_dict["patient_dob_rule"])
+        self.apply_rules_by_name(patient, rule.attribute_dict["patient_event_rules"])
+        self.apply_rules_by_name(patient, rule.attribute_dict["patient_disease_rules"])
+
+    def handle_case_add_polyp(self, obj, rule):
+        """
+        Adds a polyp to the case, processing various polyp characteristics. Requires Rules for each attribute:
+        - polyp_location_organ_rule (single rule)
+        - polyp_location_organ_part_rule (single rule)
+        - polyp_morphology_classification_shape_choices_rule (list of rules)
+        - polyp_morphology_classification_chromo_choices_rule (list of rules)
+        - polyp_intervention_type_rule (single rule)
+        - polyp_intervention_instrument_rule (single rule)
+        - polyp_size_mm_rule (single rule)
+
+        """
+        # Example: create and add a polyp instance based on the rules
+        from endoreg_db.models import Polyp  # Ensure you have a Polyp model and adjust the import
+        from endoreg_db.models import Location
+        from endoreg_db.models import EndoscopicIntervention
+        from endoreg_db.models import PolypMorphology
+
+        assert obj.examination.type != None, "Examination type is required"
+
+        location = Location()
+        location.organ = self.apply_rule_by_name(location, rule.attribute_dict["polyp_location_organ_rule"])
+        location.organ_part = self.apply_rule_by_name(location, rule.attribute_dict["polyp_location_organ_part_rule"])
+        location.save()
+
+        morphology = PolypMorphology()
+        # M2M to ClassificationChoice (linked to Classification which has name as natural key)
+        morphology.shape_classification_choices = self.apply_rules_by_name(morphology, rule.attribute_dict["polyp_morphology_classification_shape_choices_rules"])
+        # M2M to ClassificationChoice (linked to Classification which has name as natural key)
+        morphology.chromo_classification_choices = self.apply_rules_by_name(morphology, rule.attribute_dict["polyp_morphology_classification_chromo_choices_rules"])
+        morphology.save()
+
+        intervention = EndoscopicIntervention()
+        intervention.type = self.apply_rule_by_name(intervention, rule.attribute_dict["polyp_intervention_type_rule"])
+        intervention.instrument = self.apply_rule_by_name(intervention, rule.attribute_dict["polyp_intervention_instrument_rule"])
+        intervention.save()
+
+        polyp = Polyp()
+        polyp.size_mm = self.apply_rule_by_name(polyp, rule.attribute_dict["polyp_size_mm_rule"])
+        polyp.location = location
+        polyp.morphology = morphology
+        polyp.intervention = intervention
+        
+        polyp.save()
+
+        obj.polyps.add(polyp)
+        obj.save()
+
+
+    # def handle_case_add_esophageal_varices(self, obj, rule):
+    #     """
+    #     Handles adding esophageal varices to a case based on the rule.
+    #     """
+    #     # Similar to the polyp case, create and add esophageal varices based on the attributes
+    #     from endoreg_db.models import EsophagealVarices  # Ensure this model exists
+    #     varices = EsophagealVarices()
+    #     varices.origin = self.apply_rule_by_name(obj, rule.attribute_dict["esophageal_varices_origin_rule"])
+    #     varices.classification = self.apply_rule_by_name(obj, rule.attribute_dict["esophageal_varices_classification_rule"])
+    #     varices.location_extent = self.apply_rule_by_name(obj, rule.attribute_dict["esophageal_varices_location_extent_rule"])
+    #     varices.save()
+    #     # Assuming a relationship setup
+    #     obj.esophageal_varices.add(varices)
+    #     obj.save()
+
+
+    
+    
+        

endoreg_db/models/rules/rule_attribute_dtype.py

@@ -0,0 +1,19 @@
+from django.db import models
+
+
+class RuleAttributeDtypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class RuleAttributeDType(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+
+    objects = RuleAttributeDtypeManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name

endoreg_db/models/rules/rule_type.py

@@ -0,0 +1,22 @@
+from django.db import models
+
+class RuleTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class RuleType(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+
+    objects = RuleTypeManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+
+    class Meta:
+        verbose_name = 'Rule Type'
+        verbose_name_plural = 'Rule Types'

endoreg_db/models/rules/ruleset.py

@@ -0,0 +1,19 @@
+from django.db import models
+
+class RulesetManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class Ruleset(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+    rules = models.ManyToManyField('Rule')
+
+    objects = RulesetManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name

endoreg_db/models/unit.py

@@ -1,20 +1,22 @@
-from django.db import models
-
-class UnitManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-
-class Unit(models.Model):
-    objects = UnitManager()
-
-    name = models.CharField(max_length=100) # e.g. "Centimeter"
-    name_de = models.CharField(max_length=100, blank=True, null=True) # e.g. "Zentimeter"
-    name_en = models.CharField(max_length=100, blank=True, null=True) # e.g. "Centimeter"
-    description = models.CharField(max_length=100, blank=True, null=True) # e.g. "centimeters", "millimeters", "inches"
-    abbreviation = models.CharField(max_length=10, blank=True, null=True) # e.g. "cm", "mm", "in"
-
-    def __str__(self):
-        return self.abbreviation
-    
-    def natural_key(self):
+from django.db import models
+
+class UnitManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class Unit(models.Model):
+    objects = UnitManager()
+
+    name = models.CharField(max_length=100) # e.g. "Centimeter"
+    name_de = models.CharField(max_length=100, blank=True, null=True) # e.g. "Zentimeter"
+    name_en = models.CharField(max_length=100, blank=True, null=True) # e.g. "Centimeter"
+    description = models.CharField(max_length=100, blank=True, null=True) # e.g. "centimeters", "milimeters", "inches"
+    abbreviation = models.CharField(max_length=25, blank=True, null=True) # e.g. "cm", "mm", "in"
+    
+    def __str__(self):
+        if self.abbreviation:
+            return self.abbreviation
+        return self.name
+    
+    def natural_key(self):
         return (self.name,)

endoreg_db/queries/__init__.py

@@ -1,5 +1,5 @@
-from .annotations import (
-    generate_legacy_dataset_output
-)
-
+from .annotations import (
+    generate_legacy_dataset_output
+)
+
 from .get import *

endoreg_db/queries/annotations/__init__.py

@@ -1,3 +1,3 @@
-from .legacy import (
-    get_legacy_annotations_for_labelset, generate_legacy_dataset_output
+from .legacy import (
+    get_legacy_annotations_for_labelset, generate_legacy_dataset_output
 )

endoreg_db/queries/annotations/legacy.py

@@ -1,159 +1,159 @@
-from ...models import LabelSet, ImageClassificationAnnotation
-from django.db.models import Q, F
-from django.db import models
-from icecream import ic
-from tqdm import tqdm
-from collections import defaultdict
-
-# def get_legacy_annotations_for_labelset(labelset_name, version=None):
-#     """
-#     Retrieve annotations for a given label set for training.
-
-#     Args:
-#     - labelset_name (str): The name of the label set.
-#     - version (int, optional): The version of the label set. If not specified, the latest version is fetched.
-
-#     Returns:
-#     - list[dict]: A list of dictionaries. Each dictionary represents an image and its annotations.
-#                   Format: [{"frame": <frame_object>, "annotations": [{"label": <label_name>, "value": <value>}, ...]}, ...]
-
-#     Example:
-#         annotations_for_training = get_annotations_for_labelset("YourLabelSetName", version=2)
-
-#     """
-
-#     # Fetch the label set based on the name and optionally the version
-#     if version:
-#         labelset = LabelSet.objects.get(name=labelset_name, version=version)
-#     else:
-#         labelset = LabelSet.objects.filter(name=labelset_name).order_by('-version').first()
-#         if not labelset:
-#             raise ValueError(f"No label set found with the name: {labelset_name}")
-
-#     # Retrieve all labels in the label set
-#     labels_in_set = labelset.labels.all()
-
-#     # Get the most recent annotations for each frame/label combination
-#     annotations = ImageClassificationAnnotation.objects.filter(label__in=labels_in_set)
-#     annotations = annotations.annotate(
-#         latest_annotation=models.Window(
-#             expression=models.functions.RowNumber(),
-#             partition_by=[F('legacy_image'), F('label')],
-#             order_by=F('date_modified').desc()
-#         )
-#     ).filter(latest_annotation=1)
-
-#     # Organize the annotations by image/frame
-#     organized_annotations = []
-
-#     for annotation in tqdm(annotations):
-#         # ic(annotation)
-#         # Check if the frame is already in the organized list
-#         existing_entry = next((entry for entry in organized_annotations if entry['legacy_image'] == annotation.legacy_frame), None)
-
-#         if existing_entry:
-#             # Add this annotation to the existing frame's annotations
-#             existing_entry['annotations'].append({
-#                 "label": annotation.label.name,
-#                 "value": annotation.value
-#             })
-#         else:
-#             # Create a new entry for this frame
-#             organized_annotations.append({
-#                 "legacy_image": annotation.legacy_image,
-#                 "annotations": [{
-#                     "label": annotation.label.name,
-#                     "value": annotation.value
-#                 }]
-#             })
-
-#     return organized_annotations
-
-
-
-def get_legacy_annotations_for_labelset(labelset_name, version=None):
-    """
-    ... [rest of your docstring]
-    """
-
-    # Fetch the label set based on the name and optionally the version
-    if version:
-        labelset = LabelSet.objects.get(name=labelset_name, version=version)
-    else:
-        labelset = LabelSet.objects.filter(name=labelset_name).order_by('-version').first()
-        if not labelset:
-            raise ValueError(f"No label set found with the name: {labelset_name}")
-
-    # Retrieve all labels in the label set
-    labels_in_set = labelset.labels.all()
-
-    # Get the most recent annotations for each frame/label combination
-    annotations = (ImageClassificationAnnotation.objects
-                   .filter(label__in=labels_in_set)
-                   .select_related('legacy_image', 'label')  # Reduce number of queries
-                   .annotate(
-                        latest_annotation=models.Window(
-                            expression=models.functions.RowNumber(),
-                            partition_by=[F('legacy_image'), F('label')],
-                            order_by=F('date_modified').desc()
-                        )
-                    ).filter(latest_annotation=1))
-
-    # Organize the annotations by image/frame using a defaultdict
-    organized_annotations_dict = defaultdict(lambda: {
-        "legacy_image": None,
-        "annotations": []
-    })
-
-    for annotation in tqdm(annotations):
-        organized_entry = organized_annotations_dict[annotation.legacy_image.id]
-        organized_entry["legacy_image"] = annotation.legacy_image
-        organized_entry["annotations"].append({
-            "label": annotation.label.name,
-            "value": annotation.value
-        })
-
-    # Convert organized_annotations_dict to a list
-    organized_annotations = list(organized_annotations_dict.values())
-
-    return organized_annotations
-
-def generate_legacy_dataset_output(labelset_name, version=None):
-    """
-    Generate an output suitable for creating PyTorch datasets.
-
-    Args:
-    - labelset_name (str): The name of the label set.
-    - version (int, optional): The version of the label set. If not specified, the latest version is fetched.
-
-    Returns:
-    - list[dict]: A list of dictionaries, where each dictionary contains the file path and the labels.
-                  Format: [{"path": <file_path>, "labels": [<label_1_value>, <label_2_value>, ...]}, ...]
-    - labelset[LabelSet]: The label set that was used to generate the output.
-    """
-
-    # First, retrieve the organized annotations using the previously defined function
-    organized_annotations = get_legacy_annotations_for_labelset(labelset_name, version)
-
-    # Fetch all labels from the labelset for consistent ordering
-    labelset = LabelSet.objects.get(name=labelset_name, version=version)
-    all_labels = labelset.get_labels_in_order()
-
-    dataset_output = []
-
-    for entry in organized_annotations:
-        # Prepare a dictionary for each frame
-        frame_data = {
-            "path": entry['legacy_image'].image.path,  # Assuming 'image' field stores the file path
-            "labels": [-1] * len(all_labels)  # Initialize with -1 for all labels
-        }
-
-        # Update the labels based on the annotations
-        for annotation in entry['annotations']:
-            index = next((i for i, label in enumerate(all_labels) if label.name == annotation['label']), None)
-            if index is not None:
-                frame_data['labels'][index] = int(annotation['value'])
-
-        dataset_output.append(frame_data)
-
-    return dataset_output, labelset
+from ...models import LabelSet, ImageClassificationAnnotation
+from django.db.models import Q, F
+from django.db import models
+from icecream import ic
+from tqdm import tqdm
+from collections import defaultdict
+
+# def get_legacy_annotations_for_labelset(labelset_name, version=None):
+#     """
+#     Retrieve annotations for a given label set for training.
+
+#     Args:
+#     - labelset_name (str): The name of the label set.
+#     - version (int, optional): The version of the label set. If not specified, the latest version is fetched.
+
+#     Returns:
+#     - list[dict]: A list of dictionaries. Each dictionary represents an image and its annotations.
+#                   Format: [{"frame": <frame_object>, "annotations": [{"label": <label_name>, "value": <value>}, ...]}, ...]
+
+#     Example:
+#         annotations_for_training = get_annotations_for_labelset("YourLabelSetName", version=2)
+
+#     """
+
+#     # Fetch the label set based on the name and optionally the version
+#     if version:
+#         labelset = LabelSet.objects.get(name=labelset_name, version=version)
+#     else:
+#         labelset = LabelSet.objects.filter(name=labelset_name).order_by('-version').first()
+#         if not labelset:
+#             raise ValueError(f"No label set found with the name: {labelset_name}")
+
+#     # Retrieve all labels in the label set
+#     labels_in_set = labelset.labels.all()
+
+#     # Get the most recent annotations for each frame/label combination
+#     annotations = ImageClassificationAnnotation.objects.filter(label__in=labels_in_set)
+#     annotations = annotations.annotate(
+#         latest_annotation=models.Window(
+#             expression=models.functions.RowNumber(),
+#             partition_by=[F('legacy_image'), F('label')],
+#             order_by=F('date_modified').desc()
+#         )
+#     ).filter(latest_annotation=1)
+
+#     # Organize the annotations by image/frame
+#     organized_annotations = []
+
+#     for annotation in tqdm(annotations):
+#         # ic(annotation)
+#         # Check if the frame is already in the organized list
+#         existing_entry = next((entry for entry in organized_annotations if entry['legacy_image'] == annotation.legacy_frame), None)
+
+#         if existing_entry:
+#             # Add this annotation to the existing frame's annotations
+#             existing_entry['annotations'].append({
+#                 "label": annotation.label.name,
+#                 "value": annotation.value
+#             })
+#         else:
+#             # Create a new entry for this frame
+#             organized_annotations.append({
+#                 "legacy_image": annotation.legacy_image,
+#                 "annotations": [{
+#                     "label": annotation.label.name,
+#                     "value": annotation.value
+#                 }]
+#             })
+
+#     return organized_annotations
+
+
+
+def get_legacy_annotations_for_labelset(labelset_name, version=None):
+    """
+    ... [rest of your docstring]
+    """
+
+    # Fetch the label set based on the name and optionally the version
+    if version:
+        labelset = LabelSet.objects.get(name=labelset_name, version=version)
+    else:
+        labelset = LabelSet.objects.filter(name=labelset_name).order_by('-version').first()
+        if not labelset:
+            raise ValueError(f"No label set found with the name: {labelset_name}")
+
+    # Retrieve all labels in the label set
+    labels_in_set = labelset.labels.all()
+
+    # Get the most recent annotations for each frame/label combination
+    annotations = (ImageClassificationAnnotation.objects
+                   .filter(label__in=labels_in_set)
+                   .select_related('legacy_image', 'label')  # Reduce number of queries
+                   .annotate(
+                        latest_annotation=models.Window(
+                            expression=models.functions.RowNumber(),
+                            partition_by=[F('legacy_image'), F('label')],
+                            order_by=F('date_modified').desc()
+                        )
+                    ).filter(latest_annotation=1))
+
+    # Organize the annotations by image/frame using a defaultdict
+    organized_annotations_dict = defaultdict(lambda: {
+        "legacy_image": None,
+        "annotations": []
+    })
+
+    for annotation in tqdm(annotations):
+        organized_entry = organized_annotations_dict[annotation.legacy_image.id]
+        organized_entry["legacy_image"] = annotation.legacy_image
+        organized_entry["annotations"].append({
+            "label": annotation.label.name,
+            "value": annotation.value
+        })
+
+    # Convert organized_annotations_dict to a list
+    organized_annotations = list(organized_annotations_dict.values())
+
+    return organized_annotations
+
+def generate_legacy_dataset_output(labelset_name, version=None):
+    """
+    Generate an output suitable for creating PyTorch datasets.
+
+    Args:
+    - labelset_name (str): The name of the label set.
+    - version (int, optional): The version of the label set. If not specified, the latest version is fetched.
+
+    Returns:
+    - list[dict]: A list of dictionaries, where each dictionary contains the file path and the labels.
+                  Format: [{"path": <file_path>, "labels": [<label_1_value>, <label_2_value>, ...]}, ...]
+    - labelset[LabelSet]: The label set that was used to generate the output.
+    """
+
+    # First, retrieve the organized annotations using the previously defined function
+    organized_annotations = get_legacy_annotations_for_labelset(labelset_name, version)
+
+    # Fetch all labels from the labelset for consistent ordering
+    labelset = LabelSet.objects.get(name=labelset_name, version=version)
+    all_labels = labelset.get_labels_in_order()
+
+    dataset_output = []
+
+    for entry in organized_annotations:
+        # Prepare a dictionary for each frame
+        frame_data = {
+            "path": entry['legacy_image'].image.path,  # Assuming 'image' field stores the file path
+            "labels": [-1] * len(all_labels)  # Initialize with -1 for all labels
+        }
+
+        # Update the labels based on the annotations
+        for annotation in entry['annotations']:
+            index = next((i for i, label in enumerate(all_labels) if label.name == annotation['label']), None)
+            if index is not None:
+                frame_data['labels'][index] = int(annotation['value'])
+
+        dataset_output.append(frame_data)
+
+    return dataset_output, labelset