endoreg-db 0.4.5__py3-none-any.whl → 0.8.6.3__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/{ai_model → administration/ai}/model_type.py

@@ -1,10 +1,19 @@
 from django.db import models
-from django.core import serializers
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .ai_model import AiModel
 
 class ModelTypeManager(models.Manager):
-    def get_by_natural_key(self, name):
+    """
+    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.
@@ -14,13 +23,19 @@ class ModelType(models.Model):
         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 self.name
+        """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/{case_template → administration/case/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 → administration/case/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,35 +31,72 @@ 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):
-        return self.name
+        """
+        String representation of the case template.
+
+        Returns:
+            str: The name of the case template.
+        """
+        return str(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.
         """
-        from endoreg_db.models.case_template.case_template_rule import CaseTemplateRule
+        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'.")
@@ -67,10 +105,16 @@ 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.
         """
-        from endoreg_db.models.case_template.case_template_rule import CaseTemplateRule
+        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'.")

endoreg_db/models/{case_template → administration/case/case_template}/case_template_rule.py

@@ -6,16 +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.
+        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()
@@ -24,7 +21,7 @@ class CaseTemplateRuleType(models.Model):
         return (self.name,)
     
     def __str__(self):
-        return self.name
+        return str(self.name)
 
 class CaseTemplateRuleManager(models.Manager):
     def get_by_natural_key(self, name):
@@ -50,10 +47,7 @@ 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.
         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.
@@ -79,8 +73,6 @@ class CaseTemplateRule(models.Model):
 
     """
     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
@@ -124,7 +116,7 @@ class CaseTemplateRule(models.Model):
 
         :return: A string representation of the rule.
         """
-        return self.name
+        return str(self.name)
 
     def get_rule_type(self):
         """
@@ -193,6 +185,7 @@ class CaseTemplateRule(models.Model):
 
     def chained_rules_has_self_reference(self):
         """
+        :noindex:
         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.

endoreg_db/models/{case_template → administration/case/case_template}/case_template_rule_value.py

@@ -21,8 +21,6 @@ class CaseTemplateRuleValueType(models.Model):
     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)
@@ -32,7 +30,7 @@ class CaseTemplateRuleValueType(models.Model):
         return (self.name,)
 
     def __str__(self):
-        return self.name
+        return str(self.name)
 
 class CaseTemplateRuleValueManager(models.Manager):
     def get_by_natural_key(self, name):
@@ -40,12 +38,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 +57,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):
-        return self.name
+        """
+        String representation of the object.
+        """
+        return str(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/{case_template → administration/case/case_template}/case_template_type.py

@@ -15,8 +15,6 @@ class CaseTemplateType(models.Model):
 
     """
     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()
@@ -25,4 +23,4 @@ class CaseTemplateType(models.Model):
         return (self.name,)
 
     def __str__(self):
-        return self.name
+        return str(self.name)

endoreg_db/models/{center → administration/center}/__init__.py

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