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

endoreg_db/models/requirement/requirement_evaluation/__init__.py

@@ -1,134 +1,6 @@
-from typing import Optional
-from endoreg_db.models import (
-    Patient,
-    PatientExamination,
-    Finding,
-    FindingIntervention,
-    FindingLocationClassification,
-    Requirement,
-)
+# from .operator_functions import get_operator_function
 
 
-def get_kwargs_by_req_type_and_operator(requirement, **kwargs):
-    """
-    Extract keyword arguments based on the requirement's type and operator.
-    
-    This function inspects the provided requirement to determine which keyword arguments are relevant
-    for its evaluation. It constructs and returns a dictionary of arguments suitable for processing the
-    requirement with its associated operator.
-    
-    Args:
-        requirement: The requirement instance used to identify the applicable parameters.
-        **kwargs: Additional keyword arguments that may include values required for evaluation.
-    
-    Returns:
-        A dictionary mapping relevant parameter names to their corresponding values.
-    """
-    pass
-
-
-def models_match_all(requirement: Requirement, **kwargs):
-    """
-    Match all models for a given requirement.
-    
-    Retrieves the models dictionary from the requirement by calling its get_models_dict() method.
-    Additional keyword arguments are accepted for future extensions. Note that this function
-    currently only extracts the models without performing any matching logic.
-    """
-    models_dict = requirement.get_models_dict()
-
-
-SUPPORTED_REQUIREMENT_TYPES = ["patient_examination", "patient"]
-SUPPORTED_OPERATORS = {
-    "models_match_all": models_match_all,
-}
-
-
-def get_operator_function(operator_name):
-    """
-    Retrieves the operator function for the given operator name.
-    
-    This function looks up the operator name in the supported operators mapping
-    and returns the corresponding operator function used for evaluating requirements.
-    If the operator name is not recognized, the behavior is undefined.
-     
-    Args:
-        operator_name: The name of the operator to retrieve.
-    
-    Returns:
-        The operator function associated with the operator name.
-    """
-    pass
-
-
-def get_values_from_kwargs(
-    requirement: Requirement,
-    patient: Optional[Patient] = None,
-    patient_examination: Optional[PatientExamination] = None,
-    **kwargs,
-) -> dict:
-    """
-    Extracts and validates values for requirement evaluation.
-    
-    This function aggregates values from keyword arguments along with
-    the 'patient' and 'patient_examination' inputs based on the requirement's types.
-    It verifies that all requirement types are supported—currently, only types like
-    'patient_examination' and 'patient' are allowed—and ensures that the corresponding
-    parameters are provided when required. A ValueError is raised if an unsupported
-    requirement type is encountered or if a required parameter is missing.
-    
-    Args:
-        requirement (Requirement): The evaluation criterion containing requirement types.
-        patient (Optional[Patient]): Patient details, required if the requirement includes 'patient'.
-        patient_examination (Optional[PatientExamination]): Examination details, required if the requirement includes 'patient_examination'.
-        **kwargs: Additional keyword arguments for the evaluation.
-    
-    Raises:
-        ValueError: If a requirement type is unsupported or a necessary parameter is missing.
-    
-    Returns:
-        dict: A dictionary combining 'patient', 'patient_examination', and additional keyword arguments.
-    """
-    requirement_types = [_.name for _ in requirement.requirement_types]
-    # operators = [_.name for _ in requirement.operators]  # Uncomment when needed
-
-    for requirement_type in requirement_types:
-        if requirement_type not in SUPPORTED_REQUIREMENT_TYPES:
-            raise ValueError(f"Unsupported requirement type: {requirement_type}")
-
-    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}
-
-
-def evaluate_requirement(
-    requirement: Requirement,
-    **kwargs,
-):
-    """
-    Evaluates the given requirement against provided parameters.
-    
-    This function determines if the requirement is met based on its type and
-    the additional evaluation inputs supplied via keyword arguments. Evaluation
-    may depend on context-specific data, such as patient or examination details,
-    as required by the requirement.
-    
-    Args:
-        requirement (Requirement): The requirement to evaluate.
-        **kwargs: Additional parameters that support the evaluation process.
-    
-    Returns:
-        bool: True if the requirement is met, False otherwise.
-    """
-    # Implement the logic to evaluate the requirement based on its type
-    # and the provided keyword arguments.
-    pass
+__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

@@ -1,102 +1,95 @@
 # Currently those strings MUST match the ones
 # in the requirement_type data definitions
-from collections import namedtuple
+
+from typing import Dict, Union
 from endoreg_db.models import (
-    Requirement,
-    RequirementType,
-    PatientExamination,
-    PatientFindingIntervention,
-    Examination,
-    ExaminationIndication,
     Disease,
+    DiseaseClassification,
     DiseaseClassificationChoice,
+    Event,
+    EventClassification,
+    EventClassificationChoice,
+    Examination,
+    ExaminationIndication,
+    Finding,
+    FindingIntervention,
+    FindingClassification,
+    FindingClassificationChoice,
+    LabValue,
+    PatientDisease,
     PatientEvent,
+    PatientExamination,
     PatientFinding,
-    PatientFindingMorphology,
+    PatientFindingClassification,
+    PatientFindingIntervention,
+    PatientLabValue,
+    PatientLabSample,  # Assuming PatientLabSample is defined elsewhere,
+    Patient,
+    PatientMedication,  # Added PatientMedication
+    PatientMedicationSchedule, # Added PatientMedicationSchedule
 )
-from typing import List
-from icecream import ic
-# Requirement has RequirementTypes
-# Requirement has RequirementOperators
-# For each Operator/Type pair, there must be a custom function
-# for evaluation
+from endoreg_db.models.other.gender import Gender
+# if TYPE_CHECKING:
+#     from endoreg_db.models import (
+#         RequirementOperator,
+#         Patient,
+#     )
 
-OperatorTypeTuple = namedtuple("OperatorTypeTuple", ["operator", "requirement_type"])
 
 
-data_model_dict = {
-    "patient_examination": PatientExamination,
-    "finding_intervention": PatientFindingIntervention,
-    "finding_interventions": List[PatientFindingIntervention],
-    "examination": Examination,
-    "examination_indication": ExaminationIndication,
+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,
-    "event": PatientEvent,
-    "finding": PatientFinding,
-    "finding_morphology": PatientFindingMorphology,
-    # Add more mappings as needed
+    "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,
 }
 
-
-def evaluate_operator_type_tuple(
-    operator_type_tuple: OperatorTypeTuple, data: object, **kwargs
-):
-    """
-    Evaluates the requirement type and operator tuple against the provided data.
-
-    Args:
-        operator_type_tuple (OperatorTypeTuple): Tuple containing requirement type and operator.
-        data (object): The data to evaluate.
-        **kwargs: Additional keyword arguments.
-
-    Returns:
-        bool: True if the evaluation is successful, False otherwise.
-    """
-    # data = kwargs.get(name, None)
-
-    # # make sure data type matches the model for the req_type name
-    # if data is None:
-    #     raise ValueError(f"No data found for requirement type: {name}")
-    # if name not in data_model_dict:
-    #     raise ValueError(f"Unknown requirement type: {name}")
-
-    # model = data_model_dict[name]
-    # if not isinstance(data, model):
-    #     raise TypeError(
-    #         f"Data type mismatch for {name}: expected {model}, got {type(data)}"
-    #     )
-
-    requirement_type = operator_type_tuple.requirement_type
-    operator = operator_type_tuple.operator
-
-    # Call the appropriate function based on the requirement type and operator
-    # This is a placeholder; actual implementation will depend on your logic
-    return True  # Replace with actual evaluation logic
-
-
-def evaluate_requirement(requirement: Requirement, **kwargs):
-    requirement_types = requirement.requirement_types.all()
-    requirement_operators = requirement.operators.all()
-    operator_return_values = {}
-    operator_evaluation_results = {}
-
-    for requirement_operator in requirement_operators:
-        # Create tuples
-        requirement_type_operator_tuples = [
-            OperatorTypeTuple(requirement_operator, rt) for ro in requirement_types
-        ]
-
-        eval_result = [
-            evaluate_operator_type_tuple(t, **kwargs)
-            for t in requirement_type_operator_tuples
-        ]
-
-        operator_evaluation_results[requirement_operator.name] = eval_result
-
-        # TODO FIX
-        operator_return_values[requirement_operator.name] = (
-            requirement_operator.evaluate_return_values()
-        )
-
-    return operator_evaluation_results, operator_return_values
+data_model_dict_reverse = {
+    v: k for k, v in data_model_dict.items()
+}

endoreg_db/models/requirement/requirement_operator.py

@@ -1,17 +1,26 @@
 from django.db import models
-from typing import TYPE_CHECKING
+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):
         """
-        Retrieve a RequirementOperator instance by its natural key.
+        Retrieves a RequirementOperator instance by its unique name.
         
         Args:
-            name (str): The unique name representing the natural key.
+            name: The unique name of the RequirementOperator.
         
         Returns:
-            RequirementOperator: The model instance matching the provided name.
+            The RequirementOperator instance with the specified name.
         """
         return self.get(name=name)
 
@@ -22,15 +31,12 @@ class RequirementOperator(models.Model):
 
     Attributes:
         name (str): The name of the requirement operator.
-        name_de (str): The German name of the requirement operator.
-        name_en (str): The English name of the requirement operator.
         description (str): A description of the requirement operator.
     """
 
     name = models.CharField(max_length=100, unique=True)
-    name_de = models.CharField(max_length=100, blank=True, null=True)
-    name_en = models.CharField(max_length=100, blank=True, null=True)
     description = models.TextField(blank=True, null=True)
+    evaluation_function_name = models.CharField(max_length=255, blank=True, null=True) # Added field
 
     objects = RequirementOperatorManager()
 
@@ -39,20 +45,132 @@ class RequirementOperator(models.Model):
 
         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):
         """
-        Return the natural key for the requirement operator.
+        Returns a tuple containing the operator's name as its natural key.
         
-        This method returns a tuple containing the operator's name, which serves as its
-        natural key for serialization and unique identification within the system.
+        The natural key uniquely identifies the requirement operator for serialization and deserialization purposes.
         """
         return (self.name,)
 
     def __str__(self):
         """
-        Return the string representation of the requirement operator.
+        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:
-            str: The name attribute of the operator.
+            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.
         """
-        return str(self.name)
+        # 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