endoreg-db 0.8.6.4__py3-none-any.whl

endoreg_db/models/administration/ai/ai_model.py

@@ -0,0 +1,156 @@
+"""
+Django model for AI models.
+"""
+from importlib import metadata
+from django.db import models
+from icecream import ic
+from typing import TYPE_CHECKING, Optional, Union
+
+if TYPE_CHECKING:
+    from .model_type import ModelType
+    from ...metadata import ModelMeta 
+    from ...label import VideoSegmentationLabelSet
+    # Forward reference AiModel for use in type hints within the class itself
+    from typing import ForwardRef
+    AiModelRef = ForwardRef("'AiModel'")
+
+     
+class AiModelManager(models.Manager):
+    """
+    Manager for AI models with custom query methods.
+    """
+
+    def get_by_natural_key(self, name: str):
+        """
+        Retrieves the AiModel instance with the specified unique name.
+        
+        Args:
+            name: The unique identifier of the AiModel to retrieve.
+        
+        Returns:
+            The AiModel instance matching the given name.
+        
+        Raises:
+            AiModel.DoesNotExist: If no AiModel with the specified name exists.
+        """
+        return self.get(name=name)
+
+
+class AiModel(models.Model):
+    """
+    Represents a generic AI model that encapsulates high-level metadata about the model,
+    including names (default, German, and English), a description, categorization details,
+    and associated label sets and meta information.
+
+        name (str): Unique name of the AI model.
+        description (str): Optional detailed description of the AI model.
+        model_type (str): Optional type/category of the AI model.
+        model_subtype (str): Optional subtype within the broader model type.
+        video_segmentation_labelset (VideoSegmentationLabelSet): Optional associated label set for video segmentation tasks.
+        active_meta (ModelMeta): Optional reference to the currently active ModelMeta instance associated with the model.
+    """
+    objects = AiModelManager()
+
+    name = models.CharField(max_length=255, unique=True)
+
+    description = models.TextField(blank=True, null=True)
+    model_type:Optional[models.ForeignKey[Union["ModelType", None]]] = models.ForeignKey(
+        "ModelType",
+        on_delete=models.CASCADE,
+        related_name="ai_models",
+        blank=True,
+        null=True,
+    )
+    model_subtype = models.CharField(max_length=255, blank=True, null=True)
+    video_segmentation_labelset:Optional[models.ForeignKey[Union["VideoSegmentationLabelSet", None]]] = models.ForeignKey(
+        "VideoSegmentationLabelSet",
+        on_delete=models.CASCADE,
+        related_name="ai_models",
+        blank=True,
+        null=True,
+    )
+    active_meta:Optional[models.ForeignKey[Union["ModelMeta", None]]] = models.ForeignKey(
+        "ModelMeta",
+        on_delete=models.SET_NULL,
+        related_name="active_model", 
+        blank=True,
+        null=True,
+    )
+
+    if TYPE_CHECKING:
+        metadata_versions: models.QuerySet["ModelMeta"]
+
+
+    def get_version(self, version: int) -> "ModelMeta":
+        """
+        Retrieves the ModelMeta instance for the specified version.
+        
+        If the active_meta matches the requested version, it is returned. Otherwise, searches related metadata_versions for a matching version. Raises ValueError if no matching metadata is found.
+        
+        Args:
+            version: The version number of the desired ModelMeta.
+        
+        Returns:
+            The ModelMeta instance corresponding to the specified version.
+        
+        Raises:
+            ValueError: If no ModelMeta with the given version exists.
+        """
+        if self.active_meta is not None and self.active_meta.version == version:
+            return self.active_meta
+
+        # Get the model metadata with the given version
+        model_meta = self.metadata_versions.filter(version=version).first()
+        if model_meta is not None:
+            return model_meta
+
+        raise ValueError(f"No model metadata found for version {version}.")
+
+    def get_latest_version(self) -> "ModelMeta":
+        """
+        Get the model_metadata object from metadata_versions with the highest version number.
+        """
+        if self.active_meta is not None:
+            return self.active_meta
+
+        # Get the latest version of the model metadata
+        latest_version = self.metadata_versions.order_by("-version").first()
+        if latest_version is not None:
+            return latest_version
+
+        raise ValueError("No model metadata found for this model.")
+
+    @classmethod
+    def set_active_model_meta(cls, model_name: str, meta_name: str, meta_version: int):
+        """
+        Sets the active metadata version for the specified AI model.
+        
+        Updates the `active_meta` field of the AiModel identified by `model_name` to the ModelMeta instance matching `meta_name` and `meta_version`.
+        """
+        from ...metadata import ModelMeta
+
+        model = cls.objects.get(name=model_name)
+        assert model is not None, "Model not found"
+
+        ic(f"Getting model meta for {model_name} {meta_name} {meta_version}")
+
+        model_meta = ModelMeta.objects.get(
+            name=meta_name, model=model, version=meta_version
+        )
+        assert model_meta is not None, "ModelMeta not found"
+
+        model.active_meta = model_meta
+        model.save()
+
+        ic(
+            f"Set active model meta for {model_name} to {meta_name} version {meta_version}"
+        )
+
+    def natural_key(self):
+        """
+        Return the natural key for this model.
+        """
+        return (self.name,)
+
+    def __str__(self):
+        return str(self.name)

endoreg_db/models/administration/ai/model_type.py

@@ -0,0 +1,41 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .ai_model import AiModel
+
+class ModelTypeManager(models.Manager):
+    """
+    Custom manager for ModelType with additional query methods.
+    """
+
+    def get_by_natural_key(self, name: str) -> "ModelType":
+        """Get the model type by its natural key"""
+        return self.get(name=name)
+
+
+class ModelType(models.Model):
+    """
+    A class representing a model type.
+
+    Attributes:
+        name (str): The name of the model type.
+        description (str): A description of the model type.
+
+    """
+
+    name = models.CharField(max_length=255)
+    description = models.TextField(blank=True, null=True)
+
+    objects = ModelTypeManager()
+
+    if TYPE_CHECKING:
+        ai_models: models.QuerySet["AiModel"]
+
+    def natural_key(self):
+        """Return the natural key for this model type"""
+        return (self.name,)
+
+    def __str__(self):
+        """Return the name of the model type"""
+        return str(self.name)

endoreg_db/models/administration/case/__init__.py

@@ -0,0 +1,19 @@
+from .case import Case
+from .case_template import (
+    CaseTemplate,
+    CaseTemplateRule,
+    CaseTemplateRuleType,
+    CaseTemplateRuleValue,
+    CaseTemplateRuleValueType,
+    CaseTemplateType,
+)
+
+__all__ = [
+    "Case",
+    "CaseTemplate",
+    "CaseTemplateRule",
+    "CaseTemplateRuleType",
+    "CaseTemplateRuleValue",
+    "CaseTemplateRuleValueType",
+    "CaseTemplateType",
+]

endoreg_db/models/administration/case/case.py

@@ -0,0 +1,114 @@
+from django.db import models
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from ..person import Patient
+    from ...medical.patient.patient_examination import PatientExamination
+from django.utils import timezone
+
+class Case(models.Model):
+    """
+    Represents a clinical case, linking a patient to one or more examinations over a specific period.
+
+    Attributes:
+        patient (Patient): The patient associated with this case.
+        patient_examinations (QuerySet[PatientExamination]): Examinations included in this case.
+        hash (str): An optional hash value for the case.
+        start_date (datetime): The start date and time of the case.
+        end_date (datetime): The end date and time of the case (optional).
+        is_active (bool): Indicates if the case is currently active.
+        is_closed (bool): Indicates if the case has been closed.
+        is_deleted (bool): Indicates if the case is marked as deleted.
+        created_at (datetime): Timestamp of case creation.
+        updated_at (datetime): Timestamp of last case update.
+    """
+    patient = models.ForeignKey(
+        'Patient',
+        on_delete=models.CASCADE,
+        related_name='cases',
+        help_text="The patient associated with this case.",
+        db_index=True
+    )
+    patient_examinations = models.ManyToManyField(
+        'PatientExamination',
+        related_name='cases',
+        help_text="The examinations included in this case."
+    )
+    hash = models.CharField(
+        max_length=255,
+        blank=True,
+        null=True,
+        help_text="An optional hash value associated with the case."
+    )
+
+    start_date = models.DateTimeField(
+        help_text="The start date and time of the case.",
+        db_index=True
+    )
+    end_date = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="The end date and time of the case (optional)."
+    )
+    is_active = models.BooleanField(
+        default=True,
+        help_text="Flag indicating if the case is currently active.",
+        db_index=True
+    )
+    is_closed = models.BooleanField(
+        default=False,
+        help_text="Flag indicating if the case has been closed.",
+        db_index=True
+    )
+    is_deleted = models.BooleanField(
+        default=False,
+        help_text="Flag indicating if the case is marked as deleted.",
+        db_index=True
+    )
+    created_at = models.DateTimeField(
+        auto_now_add=True,
+        help_text="The date and time the case was created."
+    )
+    updated_at = models.DateTimeField(
+        auto_now=True,
+        help_text="The date and time the case was last updated."
+    )
+
+    if TYPE_CHECKING:
+        patient: "Patient"
+        patient_examinations: models.QuerySet["PatientExamination"]
+
+    class Meta:
+        ordering = ['-start_date', 'patient']
+        verbose_name = "Case"
+        verbose_name_plural = "Cases"
+
+    def __str__(self):
+        string_representation = f"Case {self.pk} ({self.patient})"
+        if self.start_date:
+            string_representation += f" - {self.start_date.strftime('%Y-%m-%d')}"
+        if self.end_date:
+            string_representation += f" - {self.end_date.strftime('%Y-%m-%d')}"
+        return string_representation
+
+    def close(self, end_date=None):
+        """Close this case with optional end date."""
+        self.is_closed = True
+        self.is_active = False
+        if end_date:
+            self.end_date = end_date
+        elif not self.end_date:
+            self.end_date = timezone.now()
+        self.save()
+
+    def reopen(self):
+        """Reopen this case if it was closed."""
+        self.is_closed = False
+        self.is_active = True
+        self.save()
+
+    def mark_as_deleted(self):
+        """Mark this case as deleted."""
+        self.is_deleted = True
+        self.is_active = False
+        self.save()

endoreg_db/models/administration/case/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/administration/case/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 str(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 .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 .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]