endoreg-db 0.8.5.1__py3-none-any.whl

endoreg_db/models/requirement/requirement_evaluation/__init__.py

@@ -0,0 +1,6 @@
+# from .operator_functions import get_operator_function
+
+
+__all__ = [
+    # "get_operator_function"
+]

endoreg_db/models/requirement/requirement_evaluation/get_values.py

@@ -0,0 +1,40 @@
+from typing import TYPE_CHECKING, Optional
+
+
+if TYPE_CHECKING:
+    from endoreg_db.models import (
+        Patient,
+        PatientExamination,
+        Requirement,
+    )
+
+def get_values_from_kwargs(
+    requirement: "Requirement",
+    patient: Optional["Patient"] = None,
+    patient_examination: Optional["PatientExamination"] = None,
+    **kwargs,
+) -> dict:
+    """
+    Aggregates and validates input values required for evaluating a requirement.
+    
+    Checks the requirement's types to ensure that necessary parameters such as `patient` or `patient_examination` are provided when required. Raises a ValueError if a required parameter is missing. Returns a dictionary containing the validated inputs and any additional keyword arguments.
+    
+    Returns:
+        A dictionary with keys for 'patient', 'patient_examination', and any extra keyword arguments.
+    """
+    requirement_types = [_.name for _ in requirement.requirement_types]
+    # operators = [_.name for _ in requirement.operators]  # Uncomment when needed
+
+    if "patient_examination" in requirement_types:
+        if patient_examination is None:
+            raise ValueError(
+                "patient_examination is required for this requirement type"
+            )
+
+    if "patient" in requirement_types:
+        if patient is None:
+            raise ValueError("patient is required for this requirement type")
+
+    # Prepare and return the extracted values
+    return {"patient": patient, "patient_examination": patient_examination, **kwargs}
+

endoreg_db/models/requirement/requirement_evaluation/operator_evaluation_models.py

@@ -0,0 +1,9 @@
+from endoreg_db.models import (
+    PatientExamination
+)
+
+#TODO this should be a list of all models that are used in the requirement evaluation
+#TODO All those models must have a "get_requirement_links" property
+operator_evaluation_models = [
+    PatientExamination,
+]

endoreg_db/models/requirement/requirement_evaluation/requirement_type_parser.py

@@ -0,0 +1,95 @@
+# Currently those strings MUST match the ones
+# in the requirement_type data definitions
+
+from typing import Dict, Union
+from endoreg_db.models import (
+    Disease,
+    DiseaseClassification,
+    DiseaseClassificationChoice,
+    Event,
+    EventClassification,
+    EventClassificationChoice,
+    Examination,
+    ExaminationIndication,
+    Finding,
+    FindingIntervention,
+    FindingClassification,
+    FindingClassificationChoice,
+    LabValue,
+    PatientDisease,
+    PatientEvent,
+    PatientExamination,
+    PatientFinding,
+    PatientFindingClassification,
+    PatientFindingIntervention,
+    PatientLabValue,
+    PatientLabSample,  # Assuming PatientLabSample is defined elsewhere,
+    Patient,
+    PatientMedication,  # Added PatientMedication
+    PatientMedicationSchedule, # Added PatientMedicationSchedule
+)
+from endoreg_db.models.other.gender import Gender
+# if TYPE_CHECKING:
+#     from endoreg_db.models import (
+#         RequirementOperator,
+#         Patient,
+#     )
+
+
+
+data_model_dict: Dict[str, Union[
+    Disease,
+    DiseaseClassification,
+    DiseaseClassificationChoice,
+    Event,
+    EventClassification,
+    EventClassificationChoice,
+    Examination,
+    ExaminationIndication,
+    Finding,
+    FindingIntervention,
+    FindingClassification,
+    FindingClassificationChoice,
+    LabValue,
+    PatientDisease,
+    PatientEvent,
+    PatientExamination,
+    PatientFinding,
+    PatientFindingIntervention,
+    PatientFindingClassification,
+    PatientLabValue,
+    PatientLabSample,
+    Patient,
+    PatientMedication,  # Added PatientMedication
+    PatientMedicationSchedule, # Added PatientMedicationSchedule
+]] = {
+    "disease": Disease,
+    "disease_classification_choice": DiseaseClassificationChoice,
+    "disease_classification": DiseaseClassification,
+    "event": Event,
+    "event_classification": EventClassification,
+    "event_classification_choice": EventClassificationChoice,
+    "examination": Examination,
+    "examination_indication": ExaminationIndication,
+    "finding": Finding,
+    "finding_intervention": FindingIntervention,
+    "finding_classification": FindingClassification,
+    "finding_classification_choice": FindingClassificationChoice,
+    "lab_value": LabValue,
+    "patient_disease": PatientDisease,
+    "patient_event": PatientEvent,
+    "patient_examination": PatientExamination,
+    "patient_finding": PatientFinding,
+    "patient_finding_intervention": PatientFindingIntervention,
+    "patient_finding_classification": PatientFindingClassification,
+    "patient_lab_value": PatientLabValue,
+    "patient_lab_sample": PatientLabSample,  # Changed from string "PatientLabSample" to the class
+    "patient": Patient,
+    "patient_medication": PatientMedication,  # Added PatientMedication mapping
+    "patient_medication_schedule": PatientMedicationSchedule, # Added PatientMedicationSchedule mapping
+    "gender": Gender,
+}
+
+data_model_dict_reverse = {
+    v: k for k, v in data_model_dict.items()
+}

endoreg_db/models/requirement/requirement_operator.py

@@ -0,0 +1,176 @@
+from django.db import models
+from typing import TYPE_CHECKING, List
+from logging import getLogger # Added logger
+
+# see how operator evaluation function is fetched, add to docs #TODO
+# endoreg_db/utils/requirement_operator_logic/model_evaluators.py
+
+if TYPE_CHECKING:
+    from endoreg_db.utils.links.requirement_link import RequirementLinks
+    from .requirement import Requirement # Added Requirement import for type hint
+
+logger = getLogger(__name__) # Added logger instance
+
+class RequirementOperatorManager(models.Manager):
+    def get_by_natural_key(self, name):
+        """
+        Retrieves a RequirementOperator instance by its unique name.
+        
+        Args:
+            name: The unique name of the RequirementOperator.
+        
+        Returns:
+            The RequirementOperator instance with the specified name.
+        """
+        return self.get(name=name)
+
+
+class RequirementOperator(models.Model):
+    """
+    A class representing a requirement operator.
+
+    Attributes:
+        name (str): The name of the requirement operator.
+        description (str): A description of the requirement operator.
+    """
+
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True, null=True)
+    evaluation_function_name = models.CharField(max_length=255, blank=True, null=True) # Added field
+
+    objects = RequirementOperatorManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models.requirement.requirement import Requirement
+
+        requirements: models.QuerySet[Requirement]
+
+    @property
+    def operator_evaluation_models(self):
+        """
+        Returns a dictionary of operator evaluation models for this requirement operator.
+        
+        This property dynamically imports and provides access to the available operator evaluation models.
+        """
+        from .requirement_evaluation.operator_evaluation_models import operator_evaluation_models
+        return operator_evaluation_models
+    
+    @property
+    def data_model_dict(self):
+        """
+        Returns the dictionary of data models used for requirement evaluation.
+        
+        This property dynamically imports and provides access to the data model dictionary relevant to requirement operators.
+        """
+        from .requirement_evaluation.requirement_type_parser import data_model_dict
+        return data_model_dict
+
+    def natural_key(self):
+        """
+        Returns a tuple containing the operator's name as its natural key.
+        
+        The natural key uniquely identifies the requirement operator for serialization and deserialization purposes.
+        """
+        return (self.name,)
+
+    def __str__(self):
+        """
+        Returns the name of the requirement operator as its string representation.
+        """
+        return str(self.name)
+    
+    def evaluate(self, requirement_links: "RequirementLinks", input_links: "RequirementLinks", **kwargs) -> bool: # Changed signature
+        
+        """
+        Evaluates the requirement operator against the provided requirement links and input_links.
+        
+        Args:
+            requirement_links: The RequirementLinks object from the Requirement model.
+            input_links: The aggregated RequirementLinks object from the input arguments.
+            **kwargs: Additional keyword arguments for specific operator logic.
+                        For lab value operators, this includes 'requirement' (the Requirement model instance).
+                        The 'requirement' instance is now passed for all operators.
+
+        Returns:
+            True if the condition defined by the operator is met, False otherwise.
+            
+        Raises:
+            NotImplementedError: If the evaluation logic for the operator's name is not implemented.
+        """
+        # kwargs should contain 'requirement' (the Requirement instance) passed from Requirement.evaluate()
+        if self.evaluation_function_name:
+            eval_func = getattr(self, self.evaluation_function_name, None)
+            if eval_func and callable(eval_func):
+                return eval_func(requirement_links=requirement_links, input_links=input_links, **kwargs)
+            else:
+                logger.error(
+                    f"Evaluation function '{self.evaluation_function_name}' "
+                    f"not found or not callable on {self.__class__.__name__} "
+                    f"for operator '{self.name}'."
+                )
+                raise NotImplementedError(
+                    f"Evaluation function '{self.evaluation_function_name}' "
+                    f"not implemented correctly for operator '{self.name}'."
+                )
+        else:
+            # Fallback to the central dispatcher if no specific function name is provided
+            from endoreg_db.utils.requirement_operator_logic.model_evaluators import dispatch_operator_evaluation
+            return dispatch_operator_evaluation(
+                operator_name=self.name,
+                requirement_links=requirement_links,
+                input_links=input_links,
+                operator_instance=self,  # Pass the operator instance
+                **kwargs 
+            )
+    
+    from ..medical.patient.patient_medication import PatientMedication # Added
+    from ..medical.medication import MedicationSchedule as MedicationScheduleTemplate # Added with alias
+
+    def _evaluate_patient_medication_schedule_matches_template(
+        self,
+        requirement_links: "RequirementLinks",
+        input_links: "RequirementLinks",
+        requirement: "Requirement", # Added requirement
+        **kwargs,
+    ) -> bool:
+        """
+        Checks if any PatientMedication in the input PatientMedicationSchedule
+        matches the profile (medication, dose, unit, intake times)
+        of any MedicationSchedule template linked to the requirement.
+        """
+        # Get MedicationSchedule templates from the requirement
+        req_schedule_templates = requirement_links.medication_schedules
+        if not req_schedule_templates:
+            # If the requirement doesn't specify any templates to match against,
+            # it's ambiguous. Consider this a non-match.
+            return False
+
+        # Get PatientMedication instances from the input (derived from PatientMedicationSchedule.links)
+        input_patient_medications = input_links.patient_medications
+        if not input_patient_medications:
+            # If the input schedule has no medications, it cannot match any template.
+            return False
+
+        for pm_instance in input_patient_medications:
+            pm_intake_times_set = set(pm_instance.intake_times.all())
+            for schedule_template in req_schedule_templates:
+                template_intake_times_set = set(schedule_template.intake_times.all())
+
+                # Check for profile match
+                medication_match = pm_instance.medication == schedule_template.medication
+                dose_match = pm_instance.dosage == schedule_template.dose 
+                unit_match = pm_instance.unit == schedule_template.unit
+                intake_times_match = pm_intake_times_set == template_intake_times_set
+                
+                # Debugging output (optional, can be removed)
+                # print(f"Comparing PM ID {pm_instance.id} with Template {schedule_template.name}:")
+                # print(f"  Medication: {pm_instance.medication} vs {schedule_template.medication} -> {medication_match}")
+                # print(f"  Dose: {pm_instance.dosage} vs {schedule_template.dose} -> {dose_match}")
+                # print(f"  Unit: {pm_instance.unit} vs {schedule_template.unit} -> {unit_match}")
+                # print(f"  Intake Times: {pm_intake_times_set} vs {template_intake_times_set} -> {intake_times_match}")
+
+
+                if medication_match and dose_match and unit_match and intake_times_match:
+                    return True  # Found a match
+
+        return False # No PatientMedication matched any template

endoreg_db/models/requirement/requirement_set.py

@@ -0,0 +1,287 @@
+from django.db import models
+from typing import TYPE_CHECKING, List
+
+
+REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP = {
+    "all": all,
+    "any": any,
+    "none": lambda x: not any(x),  # Custom function for 'none'
+    "exactly_1": lambda x: sum(1 for item in x if item) == 1,
+    "at_least_1": lambda x: sum(1 for item in x if item) >= 1,  # Equivalent to any(x)
+    "at_most_1": lambda x: sum(1 for item in x if item) <= 1,
+}
+
+class RequirementSetTypeManager(models.Manager):
+    """
+    Manager for RequirementSetType with custom query methods.
+    """
+
+    def get_by_natural_key(self, name: str) -> "RequirementSetType":
+        """
+        Retrieves a RequirementSetType instance using its natural key.
+        
+        Args:
+            name (str): The unique name that serves as the natural key.
+        
+        Returns:
+            RequirementSetType: The matching RequirementSetType instance.
+        """
+        return self.get(name=name)
+
+
+class RequirementSetType(models.Model):
+    """
+    A class representing a type of requirement set.
+
+    Attributes:
+        name (str): The name of the requirement set type.
+    """
+
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True, null=True)
+
+    objects = RequirementSetTypeManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models.requirement import RequirementType
+
+        requirement_types: models.QuerySet[RequirementType]
+
+    def natural_key(self):
+        """
+        Return the natural key tuple for the instance.
+        
+        Returns:
+            tuple: A one-element tuple containing the instance's name, used as its natural key.
+        """
+        return (self.name,)
+
+
+class RequirementSetManager(models.Manager):
+    def get_by_natural_key(self, name):
+        """
+        Retrieves a model instance by its natural key.
+        
+        Args:
+            name: The natural key value, typically corresponding to the model's unique name.
+        
+        Returns:
+            The model instance whose name matches the provided natural key.
+        """
+        return self.get(name=name)
+
+
+class RequirementSet(models.Model):
+    """
+    A class representing a set of requirements.
+
+    Attributes:
+        name (str): The name of the requirement set.
+        description (str): A description of the requirement set.
+    """
+
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True, null=True)
+    requirements = models.ManyToManyField(  # type: ignore[assignment]
+        "Requirement",
+        blank=True,
+        related_name="requirement_sets",
+    )
+    links_to_sets = models.ManyToManyField(  # type: ignore[assignment]
+        "RequirementSet",
+        blank=True,
+        related_name="links_from_sets",
+    )
+    requirement_set_type = models.ForeignKey(  # type: ignore[assignment]
+        "RequirementSetType",
+        on_delete=models.CASCADE,
+        related_name="requirement_sets",
+        blank=True,
+        null=True,
+    )
+    information_sources = models.ManyToManyField(  # type: ignore[assignment]
+        "InformationSource",
+        related_name="requirement_sets",
+        blank=True,
+    )
+    
+    reqset_exam_links = models.ManyToManyField(  # type: ignore[assignment]
+        "ExaminationRequirementSet",
+        related_name="requirement_set",
+        blank=True,
+    )
+    
+    tags = models.ManyToManyField(  # type: ignore[assignment]
+        "Tag",
+        related_name="requirement_sets",
+        blank=True,
+    )
+    
+    objects = RequirementSetManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models import Tag, Requirement, InformationSource
+        from typing import Optional
+
+        tags: "models.ManyToManyField[Tag]"
+        requirements: "models.Manager[Requirement]"
+        information_sources: "models.Manager[InformationSource]"
+        requirement_set_type: Optional[RequirementSetType]
+        links_to_sets: "models.Manager[RequirementSet]"
+        links_from_sets: "models.Manager[RequirementSet]"
+
+    def natural_key(self):
+        """Return the natural key as a tuple containing the instance's name."""
+        return (self.name,)
+
+    def __str__(self):
+        """
+        Returns the name of the requirement set as its string representation.
+        """
+        return str(self.name)
+    
+    def evaluate_requirements(self, input_object, mode="loose") -> List[bool]:
+        """
+        Evaluates all requirements in the set against the provided input object.
+        
+        Intelligently selects the appropriate input data for each requirement based on its expected model types.
+        For example, if a requirement expects PatientFinding but receives a PatientExamination, 
+        it will use the examination's patient_findings instead.
+        
+        Args:
+            input_object: The object to be evaluated by each requirement.
+            mode: Optional evaluation mode passed to each requirement (default is "loose").
+        
+        Returns:
+            A list of boolean values indicating whether each requirement is satisfied.
+        """
+        results = []
+        for requirement in self.requirements.all():
+            # Get the appropriate input for this specific requirement
+            evaluation_input = self._get_evaluation_input_for_requirement(requirement, input_object)
+            result = requirement.evaluate(evaluation_input, mode=mode)
+            results.append(result)
+        return results
+    
+    def _get_evaluation_input_for_requirement(self, requirement, input_object):
+        """
+        Determines the appropriate input object for evaluating a specific requirement.
+        
+        Args:
+            requirement: The requirement to be evaluated
+            input_object: The original input object
+            
+        Returns:
+            The most appropriate input object for the requirement evaluation
+        """
+        expected_models = requirement.expected_models
+        
+        # If the input object is already one of the expected models, use it directly
+        for expected_model in expected_models:
+            if isinstance(input_object, expected_model):
+                return input_object
+        
+        # Import here to avoid circular imports
+        from endoreg_db.models.medical.patient.patient_examination import PatientExamination
+        from endoreg_db.models.medical.patient.patient_finding import PatientFinding
+        
+        # Handle PatientExamination -> PatientFinding conversion
+        if isinstance(input_object, PatientExamination):
+            # If requirement expects PatientFinding, return the examination's findings
+            if PatientFinding in expected_models:
+                return input_object.patient_findings.all()
+
+        
+        # Handle other model conversions as needed in the future
+        # For now, return the original input object as fallback
+        return input_object
+
+    def evaluate_requirement_sets(self, input_object) -> List[bool]:
+        """
+        Evaluates all linked requirement sets against the provided input object.
+        
+        Returns:
+            A list of boolean values indicating whether each linked requirement set is satisfied.
+        """
+        results = []
+        linked_sets = self.all_linked_sets
+        if not linked_sets:
+            return results
+        for linked_set in linked_sets:
+            result = linked_set.evaluate(input_object)
+            results.append(result)
+        return results
+    
+    @property
+    def eval_function(self):
+        """
+        Returns the evaluation function associated with this requirement set's type.
+        
+        If the requirement set type is defined and matches a known type, returns the corresponding function from REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP. Returns None if no matching function is found.
+        """
+        if self.requirement_set_type and self.requirement_set_type.name in REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP:
+            return REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP[self.requirement_set_type.name]
+        return None
+
+    def evaluate(self, input_object):
+        """
+        Evaluates whether the input object satisfies this requirement set.
+        
+        Combines the evaluation results of all direct requirements and linked requirement sets, then applies the set's evaluation function (such as all, any, none, etc.) to determine if the input object meets the overall criteria.
+        
+        Args:
+            input_object: The object to be evaluated against the requirements and linked sets.
+        
+        Returns:
+            True if the input object satisfies the requirement set according to its evaluation logic; otherwise, False.
+        """
+        evaluate_r_results = self.evaluate_requirements(input_object)
+        evaluate_rs_results = self.evaluate_requirement_sets(input_object)
+
+        results = evaluate_r_results + evaluate_rs_results
+
+        eval_result = self.eval_function(results) if self.eval_function else all(results)
+
+        return eval_result
+    
+    @property
+    def all_linked_sets(self):
+        """
+        Returns all linked requirement sets, including those linked to the current set and those linked to any of its linked sets.
+        
+        Uses recursive traversal with cycle detection to safely handle circular relationships.
+        Eliminates duplicates by tracking visited sets.
+        
+        Returns:
+            List[RequirementSet]: A list of all linked requirement sets.
+        """
+        visited = set()
+        result:List["RequirementSet"] = []
+        
+        def _collect_linked_sets(requirement_set:"RequirementSet"):
+            """
+            Recursively collect linked sets while avoiding cycles and duplicates.
+            
+            Args:
+                requirement_set: The RequirementSet to process
+            """
+            # Use the primary key to track visited sets (avoids issues with object comparison)
+            if requirement_set.pk in visited:
+                return
+            
+            visited.add(requirement_set.pk)
+            
+            # Process all directly linked sets
+            for linked_set in requirement_set.links_to_sets.all():
+                if linked_set.pk not in visited:
+                    result.append(linked_set)
+                    # Recursively process the linked set's links
+                    _collect_linked_sets(linked_set)
+        
+        # Start the recursive collection from this instance
+        _collect_linked_sets(self)
+        
+        return result
+
+
+

endoreg_db/models/rule/__init__.py

@@ -0,0 +1,13 @@
+from .rule_type import RuleType
+from .rule import Rule
+from .ruleset import Ruleset
+from .rule_attribute_dtype import RuleAttributeDType
+from .rule_applicator import RuleApplicator
+
+__all__ = [
+    "RuleType",
+    "Rule",
+    "Ruleset",
+    "RuleAttributeDType",
+    "RuleApplicator",
+]

endoreg_db/models/rule/rule.py

@@ -0,0 +1,27 @@
+from django.db import models
+
+class RuleManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class Rule(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    description = models.TextField(blank=True, null=True)
+    attribute_key = models.CharField(max_length=255)
+    rule_type = models.ForeignKey("RuleType", on_delete=models.CASCADE)
+    attribute_dtype = models.ForeignKey("RuleAttributeDType", on_delete=models.CASCADE)
+
+    objects = RuleManager()
+
+    class Meta:
+        verbose_name = 'Rule'
+        verbose_name_plural = 'Rules'
+
+    def natural_key(self):
+        """
+        Return a tuple representing the natural key for this Rule instance.
+        
+        Returns:
+            tuple: A one-element tuple containing the Rule's unique name.
+        """
+        return (self.name,)