endoreg-db 0.6.4__py3-none-any.whl → 0.8.1__py3-none-any.whl

endoreg_db/models/administration/__init__.py

@@ -0,0 +1,116 @@
+# AI
+from .ai import (
+    AiModel,
+    ActiveModel,
+    ModelType,
+)
+
+# Case
+from .case import (
+    Case,
+    CaseTemplate,
+    CaseTemplateRule,
+    CaseTemplateRuleType,
+    CaseTemplateRuleValue,
+    CaseTemplateRuleValueType,
+    CaseTemplateType,
+)
+
+# Center
+from .center import (
+    Center,
+    CenterProduct,
+    CenterResource,
+    CenterWaste,
+    CenterShift,
+)
+
+
+#TODO Review module
+# from .permissions import () 
+
+# Person
+from .person import (
+    Person,
+    Examiner, 
+    Patient, 
+    PortalUserInfo,     
+    FirstName,
+    LastName,
+    Profession,
+    Employee,
+    EmployeeType,
+    EmployeeQualification,
+)
+
+# Product
+from .product import (
+    Product,
+    ProductMaterial,
+    ProductGroup,
+    ReferenceProduct,
+    ProductWeight,
+)
+
+from .qualification import (
+    Qualification,
+    QualificationType,
+)
+
+from .shift import (
+    Shift,
+    ShiftType,
+    ScheduledDays,
+)
+
+__all__ = [
+    # AI
+    "AiModel",
+    "ActiveModel",
+    "ModelType",
+
+    # Case
+    "Case",
+    "CaseTemplate",
+    "CaseTemplateRule",
+    "CaseTemplateRuleType",
+    "CaseTemplateRuleValue",
+    "CaseTemplateRuleValueType",
+    "CaseTemplateType",
+
+    # Center
+    "Center",
+    "CenterProduct",
+    "CenterResource",
+    "CenterWaste",
+    "CenterShift",
+
+    # Person
+    "Person",
+    "Patient",
+    "Examiner",
+    "PortalUserInfo",
+    "FirstName",
+    "LastName",
+    "Profession",
+    "Employee",
+    "EmployeeType",
+    "EmployeeQualification",
+
+    # Product
+    'Product',
+    'ProductMaterial',
+    'ProductGroup',
+    'ReferenceProduct',
+    'ProductWeight',
+
+    # Qualification
+    "Qualification",
+    "QualificationType",
+
+    # Shift
+    "Shift",
+    "ShiftType",
+    "ScheduledDays",
+]
+

endoreg_db/models/{ai_model → administration/ai}/__init__.py

@@ -1,4 +1,9 @@
-from .model_meta import ModelMeta
 from .model_type import ModelType
 from .active_model import ActiveModel
 from .ai_model import AiModel
+
+__all__ = [
+    "ModelType",
+    "ActiveModel",
+    "AiModel",
+]

endoreg_db/models/administration/ai/active_model.py

@@ -0,0 +1,35 @@
+from django.db import models
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from endoreg_db.models.metadata import ModelMeta
+
+
+class ActiveModelManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class ActiveModel(models.Model):
+    """
+    ActiveModel represents an active instance of a model within the application.
+    Attributes:
+        name (str): A unique identifier for the active model.
+        model_meta (ModelMeta, optional): A reference to the metadata of the model. This field acts as a ForeignKey
+                                            to the ModelMeta model and can be null.
+    Notes:
+        - The model_meta attribute is configured with on_delete=models.SET_NULL, meaning that if the related ModelMeta
+          record is deleted, model_meta will be set to null.
+        - Type hints for model_meta are provided under a TYPE_CHECKING conditional import to avoid circular dependencies,
+          importing ModelMeta only when type checking is performed.
+    Managers:
+        objects (ActiveModelManager): Custom manager providing specialized query capabilities for ActiveModel instances.
+    """
+
+    name = models.CharField(max_length=255, unique=True)
+    
+    model_meta:Optional[models.ForeignKey["ModelMeta"]] = models.ForeignKey(
+        'ModelMeta', on_delete=models.SET_NULL, 
+        blank=True, null=True
+    )
+
+    objects = ActiveModelManager()

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,6 +1,8 @@
 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):
     """
@@ -27,6 +29,9 @@ class ModelType(models.Model):
 
     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,)

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}/case_template.py

@@ -46,7 +46,7 @@ class CaseTemplate(models.Model):
         Returns:
             str: The name of the case template.
         """
-        return self.name
+        return str(self.name)
     
     def get_rules(self):
         """
@@ -96,7 +96,7 @@ class CaseTemplate(models.Model):
         Raises:
             ValueError: If multiple such rules exist.
         """
-        from endoreg_db.models.case_template.case_template_rule import CaseTemplateRule
+        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'.")
@@ -114,7 +114,7 @@ class CaseTemplate(models.Model):
         Raises:
             ValueError: If multiple such rules exist.
         """
-        from endoreg_db.models.case_template.case_template_rule import CaseTemplateRule
+        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

@@ -10,13 +10,9 @@ class CaseTemplateRuleType(models.Model):
 
     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()
@@ -25,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):
@@ -52,8 +48,6 @@ class CaseTemplateRule(models.Model):
     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.
@@ -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):
@@ -68,7 +66,7 @@ class CaseTemplateRuleValue(models.Model):
         """
         String representation of the object.
         """
-        return self.name
+        return str(self.name)
     
     def get_value(self):
         """

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,10 +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'
+    'CenterWaste',
+    'CenterShift',
 ]

endoreg_db/models/administration/center/center.py

@@ -0,0 +1,61 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...medical import Endoscope, EndoscopyProcessor
+    from ...administration import (
+        CenterProduct,
+        CenterWaste, CenterResource
+    )
+    from ...media import AnonymExaminationReport, AnonymHistologyReport
+
+class CenterManager(models.Manager):
+    def get_by_natural_key(self, name) -> "Center":
+        return self.get(name=name)
+
+
+class Center(models.Model):
+    objects = CenterManager()
+
+    # import_id = models.IntegerField(primary_key=True)
+    name = models.CharField(max_length=255)
+
+    first_names = models.ManyToManyField(
+        to="FirstName",
+        related_name="centers",
+    )
+    last_names = models.ManyToManyField("LastName", related_name="centers")
+
+    if TYPE_CHECKING:
+    #     first_names: RelatedManager["FirstName"]
+    #     last_names: RelatedManager["LastName"]
+        center_products: models.QuerySet["CenterProduct"]
+        center_resources: models.QuerySet["CenterResource"]
+        center_wastes: models.QuerySet["CenterWaste"]
+        endoscopy_processors: models.QuerySet["EndoscopyProcessor"]
+        endoscopes: models.QuerySet["Endoscope"]
+        anonymexaminationreport_set: models.QuerySet["AnonymExaminationReport"]
+        anonymhistologyreport_set: models.QuerySet["AnonymHistologyReport"]
+        
+
+    @classmethod
+    def get_by_name(cls, name):
+        return cls.objects.get(name=name)
+
+    def natural_key(self) -> tuple[str]:
+        return (self.name,)
+
+    def __str__(self) -> str:
+        return str(object=self.name)
+
+    def get_first_names(self):
+        return self.first_names.all()
+
+    def get_last_names(self):
+        return self.last_names.all()
+
+    def get_endoscopes(self):
+        """
+        Returns all Endoscope instances associated with this center.
+        """
+        return self.endoscopes.all()