endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.9__py3-none-any.whl

endoreg_db/models/administration/case/case_template/case_template.py

@@ -1,125 +1,3 @@
-from django.db import models
+"""Deprecated case template models have been removed."""
 
-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]
+__all__: list[str] = []

endoreg_db/models/administration/case/case_template/case_template_rule.py

@@ -1,269 +1,3 @@
-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.
-        description (str): A description of the rule type.
-    """
-    name = models.CharField(max_length=255)
-    description = models.TextField(blank=True, null=True)
-
-    objects = CaseTemplateRuleTypeManager()
-
-    def natural_key(self):
-        return (self.name,)
-    
-    def __str__(self):
-        return str(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.
-        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)
-    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 str(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):
-        """
-        :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.
-        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)
+"""Deprecated case template rule models have been removed."""
 
+__all__: list[str] = []

endoreg_db/models/administration/case/case_template/case_template_rule_value.py

@@ -1,86 +1,3 @@
-from django.db import models
+"""Deprecated case template rule value models have been removed."""
 
-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)
-    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 str(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 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:
-            return self.numeric_value
-        elif self.text_value:
-            return self.text_value
-        else:
-            return None
+__all__: list[str] = []

endoreg_db/models/administration/case/case_template/case_template_type.py

@@ -1,26 +1,3 @@
-from django.db import models
+"""Deprecated case template type model has been removed."""
 
-
-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)
-    description = models.TextField(blank=True, null=True)
-
-    objects = CaseTemplateTypeManager()
-
-    def natural_key(self):
-        return (self.name,)
-
-    def __str__(self):
-        return str(self.name)
+__all__: list[str] = []

endoreg_db/models/administration/center/center.py

@@ -1,13 +1,14 @@
+from typing import TYPE_CHECKING, cast
+
 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 ...administration import CenterProduct, CenterResource, CenterWaste
     from ...media import AnonymExaminationReport, AnonymHistologyReport
+    from ...medical import Endoscope, EndoscopyProcessor
+    from ..person.names.first_name import FirstName
+    from ..person.names.last_name import LastName
+
 
 class CenterManager(models.Manager):
     def get_by_natural_key(self, name) -> "Center":
@@ -16,8 +17,6 @@ class CenterManager(models.Manager):
 
 class Center(models.Model):
     objects = CenterManager()
-
-    # import_id = models.IntegerField(primary_key=True)
     name = models.CharField(max_length=255)
     display_name = models.CharField(max_length=255, blank=True, default="")
 
@@ -28,16 +27,31 @@ class Center(models.Model):
     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"]
-        
+        from django.db.models.manager import RelatedManager
+
+        first_names = cast(RelatedManager[FirstName], first_names)
+        last_names = cast(RelatedManager[LastName], last_names)
+
+        @property
+        def center_products(self) -> RelatedManager[CenterProduct]: ...
+
+        @property
+        def center_resources(self) -> RelatedManager[CenterResource]: ...
+
+        @property
+        def center_wastes(self) -> RelatedManager[CenterWaste]: ...
+
+        @property
+        def endoscopy_processors(self) -> RelatedManager[EndoscopyProcessor]: ...
+
+        @property
+        def endoscopes(self) -> RelatedManager[Endoscope]: ...
+
+        @property
+        def anonymexaminationreport_set(self) -> RelatedManager[AnonymExaminationReport]: ...
+
+        @property
+        def anonymhistologyreport_set(self) -> RelatedManager[AnonymHistologyReport]: ...
 
     @classmethod
     def get_by_name(cls, name):
@@ -52,7 +66,7 @@ class Center(models.Model):
         super().save(*args, **kwargs)
 
     def __str__(self) -> str:
-        return str(object=self.display_name or self.name)
+        return str(self.display_name or self.name)
 
     def get_first_names(self):
         return self.first_names.all()

endoreg_db/models/administration/center/center_product.py

@@ -1,8 +1,9 @@
-from django.db import models
 from typing import TYPE_CHECKING
 
+from django.db import models
+
 if TYPE_CHECKING:
-    from ..product import Product, ProductGroup
+    from ..product import Product
     from .center import Center
 
 
@@ -15,10 +16,11 @@ class CenterProduct(models.Model):
         date_used (date): The date the product was used.
         center (Center): The center where the product was used.
     """
+
     product = models.ForeignKey(
         "Product",
         on_delete=models.CASCADE,
-        related_name="center_products" # Changed related_name for clarity
+        related_name="center_products",  # Changed related_name for clarity
     )
     date_used = models.DateField()
     center = models.ForeignKey(
@@ -28,25 +30,26 @@ class CenterProduct(models.Model):
     )
 
     if TYPE_CHECKING:
-        product: "Product"
-        center: "Center"
+        product: models.ForeignKey["Product"]
+        center: models.ForeignKey["Center"]
 
     class Meta:
-        ordering = ['center', '-date_used', 'product']
+        ordering = ["center", "-date_used", "product"]
         verbose_name = "Center Product Usage"
         verbose_name_plural = "Center Product Usages"
 
     def __str__(self) -> str:
         return f"{self.product} - {self.center} - {self.date_used}"
+
     def get_product_name(self) -> str:
         """Returns the name of the product."""
         return self.product.name
 
-    def get_product_group(self) -> "ProductGroup | None":
+    def get_product_group(self):
         """Returns the ProductGroup associated with this product."""
         return self.product.product_group
 
-    def get_reference_product(self) -> "Product | None":
+    def get_reference_product(self):
         """Returns the reference Product for this product's group."""
         product_group = self.get_product_group()
         if product_group:
@@ -55,7 +58,7 @@ class CenterProduct(models.Model):
 
     def get_product_weight(self):
         product = self.product
-        
+
         return product.get_product_weight()
 
     def get_package_weight(self):