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

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/case/case.py

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

@@ -0,0 +1,15 @@
+# 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
+
+__all__ = [
+    "CaseTemplateRule",
+    "CaseTemplateRuleType",
+    "CaseTemplateRuleValue",
+    "CaseTemplateRuleValueType",
+    "CaseTemplateType",
+    "CaseTemplate",
+]

endoreg_db/models/case_template/case_template.py

@@ -0,0 +1,125 @@
+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):
+    """
+    Represents a case template.
+
+    Attributes:
+        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")
+    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):
+        """
+        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):
+        """
+        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):
+        """
+        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'."
+            )
+        
+    # 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):
+        """
+        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")
+        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):
+        """
+        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")
+        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]

endoreg_db/models/case_template/case_template_rule.py

@@ -0,0 +1,276 @@
+from django.db import models
+
+class CaseTemplateRuleTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class CaseTemplateRuleType(models.Model):
+    """
+    Represents a type of rule for a case template.
+
+    Attributes:
+        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)
+    name_en = models.CharField(max_length=255, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    objects = CaseTemplateRuleTypeManager()
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+
+class CaseTemplateRuleManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+    def get_default_create_patient_rule(self):
+        """Get the default create patient rule."""
+        return self.get(name="create-patient-default")
+    
+    def get_default_create_patient_lab_sample_rules(self):
+        """Get the default create patient lab sample rules."""
+        return self.get(name="create-patient_lab_sample-default")
+    
+    def get_default_create_patient_medication_schedule_rule(self):
+        """Get the create patient medication schedule rule."""
+        r = self.get(name="create-patient_medication_schedule")
+        assert r, "No create patient medication schedule rule found"
+        return r
+    
+class CaseTemplateRule(models.Model):
+    """
+    A class representing a case template rule.
+
+    Attributes:
+        name (str): The name of the case template rule.
+        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.
+        rule_type (CaseTemplateRuleType): The type of the rule.
+        parent_model (str): The model on which the rule is applied.
+        target_field (str): The field of the parent model on which the rule is applied.
+        target_model (str): The model to which the foreign key points (used for foreign key and many-to-many rules).
+        rule_values (list): A list of string values for the rule.
+        extra_parameters (dict): A dictionary of extra parameters for the rule.
+        value_type (CaseTemplateRuleValueType): The type of the rule value.
+        chained_rules (QuerySet): The chained rules associated with the current rule.
+        single_categorical_value_distribution (SingleCategoricalValueDistribution): The single categorical value distribution for the rule.
+        numerical_value_distribution (NumericValueDistribution): The numerical value distribution for the rule.
+        multiple_categorical_value_distribution (MultipleCategoricalValueDistribution): The multiple categorical value distribution for the rule.
+        date_value_distribution (DateValueDistribution): The date value distribution for the rule.
+        objects (CaseTemplateRuleManager): The manager for the CaseTemplateRule model.
+
+    Methods:
+        natural_key(): Returns the natural key of the rule.
+        __str__(): Returns a string representation of the rule.
+        get_rule_type(): Returns the name of the rule type.
+        get_chained_rules(): Returns all the chained rules associated with the current rule.
+        get_all_downward_chained_rules(): Returns all the chained rules of the current rule, including indirectly chained rules.
+        chained_rules_has_self_reference(): Checks if any directly or indirectly chained rules reference this rule, creating a non-terminating loop.
+        save(*args, **kwargs): Customizes the save method to check for self-references.
+
+    """
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+    description = models.TextField(blank=True, null=True)
+    rule_type = models.ForeignKey(
+        "CaseTemplateRuleType", on_delete=models.CASCADE
+    )
+    parent_model = models.CharField(max_length=255, blank=True, null=True)
+    parent_field = models.CharField(max_length=255, blank=True, null=True)
+    target_field = models.CharField(max_length=255, blank=True, null=True)
+    target_model = models.CharField(max_length=255, blank=True, null=True)
+    rule_values = models.JSONField(blank=True, null=True)
+    extra_parameters = models.JSONField(blank=True, null=True)
+    value_type = models.ForeignKey("CaseTemplateRuleValueType", on_delete=models.SET_NULL, null=True)
+    chained_rules = models.ManyToManyField(
+        "CaseTemplateRule",
+        related_name="calling_rules"
+    )
+    single_categorical_value_distribution = models.ForeignKey(
+        "SingleCategoricalValueDistribution", on_delete=models.SET_NULL, null=True
+    )
+    numerical_value_distribution = models.ForeignKey(
+        "NumericValueDistribution", on_delete=models.SET_NULL, null=True
+    )
+    multiple_categorical_value_distribution = models.ForeignKey(
+        "MultipleCategoricalValueDistribution", on_delete=models.SET_NULL, null=True
+    )
+    date_value_distribution = models.ForeignKey(
+        "DateValueDistribution", on_delete=models.SET_NULL, null=True
+    )
+    objects = CaseTemplateRuleManager()
+
+    def natural_key(self):
+        """
+        Returns the natural key of the rule.
+
+        :return: A tuple representing the natural key of the rule.
+        """
+        return (self.name,)
+
+    def __str__(self):
+        """
+        Returns a string representation of the rule.
+
+        :return: A string representation of the rule.
+        """
+        return self.name
+
+    def get_rule_type(self):
+        """
+        Returns the name of the rule type.
+
+        :return: The name of the rule type.
+        """
+        return self.rule_type.name
+
+    def get_chained_rules(self):
+        """
+        Returns all the chained rules associated with the current rule.
+
+        :return: A queryset of all the chained rules associated with the current rule.
+        """
+        return self.chained_rules.all()
+    
+    def get_distribution(self):
+        """
+        Returns the value distribution of the rule.
+
+        :return: The value distribution of the rule.
+        """
+        DEBUG = True
+        if DEBUG:
+            print("Rule: ", self.name)
+            print(f"single_categorical_value_distribution: {self.single_categorical_value_distribution}")
+            print(f"numerical_value_distribution: {self.numerical_value_distribution}")
+            print(f"multiple_categorical_value_distribution: {self.multiple_categorical_value_distribution}")
+            print(f"date_value_distribution: {self.date_value_distribution}")
+
+
+        if self.single_categorical_value_distribution:
+            return self.single_categorical_value_distribution
+        elif self.numerical_value_distribution:
+            return self.numerical_value_distribution
+        elif self.multiple_categorical_value_distribution:
+            return self.multiple_categorical_value_distribution
+        elif self.date_value_distribution:
+            return self.date_value_distribution
+        return None
+
+    def get_all_downward_chained_rules(self):
+        """
+        Get all chained rules of the current rule, including indirectly chained rules.
+
+        :return: A set of all chained rules of the current rule.
+        """
+        all_chained_rules = set()
+
+        def traverse_chained_rules(rule):
+            """
+            Helper function to recursively traverse chained rules.
+
+            :param rule: The current CaseTemplateRule being checked.
+            :return: None
+            """
+            for chained_rule in rule.chained_rules.all():
+                if chained_rule not in all_chained_rules:
+                    all_chained_rules.add(chained_rule)
+                    traverse_chained_rules(chained_rule)
+
+        # Initialize the traversal starting with the current rule
+        traverse_chained_rules(self)
+        return all_chained_rules
+
+    def chained_rules_has_self_reference(self):
+        """
+        Check if any directly or indirectly chained rules reference this rule, creating a non-terminating loop.
+        Return a list containing a tuple (first_rule, self_referencing_rule) for each self-reference.
+        first_rule is the most upward rule in the chain that references the rule.
+        self_referencing_rule is the rule that references the current rule itself.
+
+        :return: A list of tuples representing the self-referencing rules.
+        """
+        result_list = []
+
+        def traverse_chained_rules(rule, visited_rules):
+            """
+            Helper function to recursively traverse chained rules and check for self-references.
+
+            :param rule: The current CaseTemplateRule being checked.
+            :param visited_rules: A list of tuples representing the path of rules visited so far.
+            :return: None
+            """
+            for chained_rule in rule.chained_rules.all():
+                if chained_rule == self:
+                    # A self-reference is detected
+                    first_rule = visited_rules[0][0]
+                    self_referencing_rule = visited_rules[-1][1]
+                    result_list.append((first_rule, self_referencing_rule))
+                elif chained_rule not in [r[1] for r in visited_rules]:
+                    # Continue to check chained rules of the current chained rule
+                    traverse_chained_rules(chained_rule, visited_rules + [(rule, chained_rule)])
+
+        # Initialize the traversal starting with the current rule
+        traverse_chained_rules(self, [(self, self)])
+        return result_list
+    
+    def get_target_model(self):
+        """
+        Returns the target model of the rule.
+
+        :return: The target model of the rule.
+        """
+        from django.apps import apps
+
+        if not self.target_model:
+            return None
+
+        try:
+            target_model = apps.get_model("endoreg_db", self.target_model)
+        except LookupError:
+            raise ValueError(f"Model {self.target_model} not found.")
+        return target_model
+    
+    def get_target_field(self):
+        """
+        Returns the target field of the rule.
+
+        :return: The target field of the rule.
+        """
+        return self.target_field
+    
+    def get_parent_model(self):
+        """
+        Returns the parent model of the rule.
+
+        :return: The parent model of the rule.
+        """
+        from django.apps import apps
+
+        if not self.parent_model:
+            return None
+
+        try:
+            self.parent_model = apps.get_model("endoreg_db", self.parent_model)
+        except LookupError:
+            raise ValueError(f"Model {self.parent_model} not found.")
+        return self.parent_model
+
+    # customize the save method to check for self-references
+    # def save(self, *args, **kwargs):
+    #     # Check for self-references
+    #     self_referencing_rules = self.chained_rules_has_self_reference()
+    #     if self_referencing_rules:
+    #         raise ValueError(f"Self-references detected: {self_referencing_rules}")
+    #     super().save(*args, **kwargs)
+

endoreg_db/models/case_template/case_template_rule_value.py

@@ -0,0 +1,88 @@
+from django.db import models
+
+class CaseTemplateRuleValueTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class CaseTemplateRuleValueType(models.Model):
+    """
+    A class representing a case template rule value type.
+
+    Attributes:
+        name (str): The name of the case template rule value type.
+        distribution_type: One of "single_categorical", "multiple_categorical", "numeric"
+        description (str): A description of the case template rule value type.
+    """
+    DISTRIBUTION_TYPES = [
+        ("single_categorical", "single_categorical"),
+        ("multiple_categorical", "multiple_categorical"),
+        ("numeric", "numeric")
+    ]
+    objects = CaseTemplateRuleValueTypeManager()
+
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    distribution_type = models.CharField(max_length=255, choices=DISTRIBUTION_TYPES)
+
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+
+class CaseTemplateRuleValueManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class CaseTemplateRuleValue(models.Model):
+    """
+    Represents a case template rule value.
+
+    Attributes:
+        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()
+
+    name = models.CharField(max_length=255)
+    description = models.TextField(blank=True, null=True)
+
+    fk_value = models.CharField(max_length=255, null=True, blank=True)
+    numeric_value = models.FloatField(null=True, blank=True)
+    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:
+            return self.numeric_value
+        elif self.text_value:
+            return self.text_value
+        else:
+            return None

endoreg_db/models/case_template/case_template_type.py

@@ -0,0 +1,28 @@
+from django.db import models
+
+
+class CaseTemplateTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class CaseTemplateType(models.Model):
+    """
+    A class representing a case template type.
+
+    Attributes:
+        name (str): The name of the case template type.
+        description (str): A description of the case template type.
+
+    """
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    objects = CaseTemplateTypeManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name

endoreg_db/models/center/__init__.py

@@ -0,0 +1,11 @@
+from .center import Center
+from .center_product import CenterProduct
+from .center_resource import CenterResource
+from .center_waste import CenterWaste
+
+__all__ = [
+    'Center',
+    'CenterProduct',
+    'CenterResource',
+    'CenterWaste'
+]