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

endoreg_db/models/requirement/requirement.py

@@ -1,67 +1,46 @@
 from django.db import models
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Dict, List, Union
+from endoreg_db.utils.links.requirement_link import RequirementLinks
+import logging
+from subprocess import run
+
+logger = logging.getLogger(__name__)
 
-from pydantic import BaseModel
 
 QuerySet = models.QuerySet
 
 if TYPE_CHECKING:
     from endoreg_db.models import (
-        RequirementOperator,
-        RequirementSet,
-        Examination,
-        ExaminationIndication,
-        LabValue,
         Disease,
         DiseaseClassificationChoice,
         Event,
+        EventClassification,
+        EventClassificationChoice,
+        Examination,
+        ExaminationIndication,
         Finding,
-        FindingMorphologyClassificationChoice,
-        FindingLocationClassificationChoice,
         FindingIntervention,
+        FindingClassification,
+        FindingClassificationChoice,
+        FindingClassificationType,
+        LabValue,
+        Medication,
+        MedicationIndication,
+        MedicationIntakeTime, # Added MedicationIntakeTime
+        MedicationSchedule,
+        PatientDisease,
+        PatientEvent,
+        PatientExamination,
+        PatientFinding,
+        PatientFindingIntervention,
+        PatientFindingClassification,
+        PatientLabValue,
+        PatientMedicationSchedule, # Added PatientMedicationSchedule
+        RequirementOperator,
+        RequirementSet, 
+        Gender
     )
-
-
-class RequirementsModelDict(BaseModel):
-    """
-    A class representing a dictionary of models related to a requirement.
-
-    Attributes:
-        requirement_types (QuerySet[RequirementType]): A queryset of requirement types.
-        operators (QuerySet[RequirementOperator]): A queryset of operators.
-        requirement_sets (QuerySet[RequirementSet]): A queryset of requirement sets.
-        examinations (QuerySet[Examination]): A queryset of examinations.
-        examination_indications (QuerySet[ExaminationIndication]): A queryset of examination indications.
-        lab_values (QuerySet[LabValue]): A queryset of lab values.
-        diseases (QuerySet[Disease]): A queryset of diseases.
-        disease_classification_choices (QuerySet[DiseaseClassificationChoice]): A queryset of disease classification choices.
-        events (QuerySet[Event]): A queryset of events.
-        findings (QuerySet[Finding]): A queryset of findings.
-        finding_morphology_classification_choices (QuerySet[FindingMorphologyClassificationChoice]): A queryset of finding morphology classification choices.
-        finding_location_classification_choices (QuerySet[FindingLocationClassificationChoice]): A queryset of finding location classification choices.
-        finding_interventions (QuerySet[FindingIntervention]): A queryset of finding interventions.
-    """
-
-    model_config = {"arbitrary_types_allowed": True}
-    requirement_types: Optional[QuerySet["RequirementType"]] = None
-    operators: Optional[QuerySet["RequirementOperator"]] = None
-    requirement_sets: Optional[QuerySet["RequirementSet"]] = None
-    examinations: Optional[QuerySet["Examination"]] = None
-    examination_indications: Optional[QuerySet["ExaminationIndication"]] = None
-    lab_values: Optional[QuerySet["LabValue"]] = None
-    diseases: Optional[QuerySet["Disease"]] = None
-    disease_classification_choices: Optional[
-        QuerySet["DiseaseClassificationChoice"]
-    ] = None
-    events: Optional[QuerySet["Event"]] = None
-    findings: Optional[QuerySet["Finding"]] = None
-    finding_morphology_classification_choices: Optional[
-        QuerySet["FindingMorphologyClassificationChoice"]
-    ] = None
-    finding_location_classification_choices: Optional[
-        QuerySet["FindingLocationClassificationChoice"]
-    ] = None
-    finding_interventions: Optional[QuerySet["FindingIntervention"]] = None
+    # from endoreg_db.utils.links.requirement_link import RequirementLinks # Already imported above
 
 
 class RequirementTypeManager(models.Manager):
@@ -86,13 +65,9 @@ class RequirementType(models.Model):
 
     Attributes:
         name (str): The name of the requirement type.
-        name_de (str): The German name of the requirement type.
-        name_en (str): The English name of the requirement type.
     """
 
     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)
 
     objects = RequirementTypeManager()
@@ -134,15 +109,12 @@ class Requirement(models.Model):
 
     Attributes:
         name (str): The name of the requirement.
-        name_de (str): The German name of the requirement.
-        name_en (str): The English name of the requirement.
         description (str): A description of the requirement.
     """
 
     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)
+    
     numeric_value = models.FloatField(
         blank=True,
         null=True,
@@ -175,13 +147,13 @@ class Requirement(models.Model):
 
     objects = RequirementManager()
 
-    requirement_types = models.ManyToManyField(
+    requirement_types = models.ManyToManyField( # type: ignore[assignment]
         "RequirementType",
         blank=True,
         related_name="linked_requirements",
     )
 
-    operators = models.ManyToManyField(
+    operators = models.ManyToManyField( # type: ignore[assignment]
         "RequirementOperator",
         blank=True,
         related_name="required_in",
@@ -195,66 +167,96 @@ class Requirement(models.Model):
         null=True,
     )
 
-    examinations = models.ManyToManyField(
+    examinations = models.ManyToManyField( # type: ignore[assignment]
         "Examination",
         blank=True,
         related_name="required_in",
     )
 
-    examination_indications = models.ManyToManyField(
+    examination_indications = models.ManyToManyField( # type: ignore[assignment]
         "ExaminationIndication",
         blank=True,
         related_name="required_in",
     )
 
-    diseases = models.ManyToManyField(
+    diseases = models.ManyToManyField( # type: ignore[assignment]
         "Disease",
         blank=True,
         related_name="required_in",
     )
 
-    disease_classification_choices = models.ManyToManyField(
+    disease_classification_choices = models.ManyToManyField( # type: ignore[assignment]
         "DiseaseClassificationChoice",
         blank=True,
         related_name="required_in",
     )
 
-    events = models.ManyToManyField(
+    events = models.ManyToManyField( # type: ignore[assignment]
         "Event",
         blank=True,
         related_name="required_in",
     )
 
-    lab_values = models.ManyToManyField(
+    lab_values = models.ManyToManyField( # type: ignore[assignment]
         "LabValue",
         blank=True,
         related_name="required_in",
     )
 
-    findings = models.ManyToManyField(
+    findings = models.ManyToManyField( # type: ignore[assignment]
         "Finding",
         blank=True,
         related_name="required_in",
     )
 
-    finding_morphology_classification_choices = models.ManyToManyField(
-        "FindingMorphologyClassificationChoice",
+    finding_classifications = models.ManyToManyField( # type: ignore[assignment]
+        "FindingClassification",
         blank=True,
         related_name="required_in",
     )
 
-    finding_location_classification_choices = models.ManyToManyField(
-        "FindingLocationClassificationChoice",
+    finding_classification_choices = models.ManyToManyField( # type: ignore[assignment]
+        "FindingClassificationChoice",
         blank=True,
         related_name="required_in",
     )
 
-    finding_interventions = models.ManyToManyField(
+    finding_interventions = models.ManyToManyField( # type: ignore[assignment]
         "FindingIntervention",
         blank=True,
         related_name="required_in",
     )
 
+    medications = models.ManyToManyField( # type: ignore[assignment]
+        "Medication",
+        blank=True,
+        related_name="required_in",
+    )
+
+    medication_indications = models.ManyToManyField( # type: ignore[assignment]
+        "MedicationIndication",
+        blank=True,
+        related_name="required_in",
+    )
+
+    medication_intake_times = models.ManyToManyField( # type: ignore[assignment]
+        "MedicationIntakeTime",
+        blank=True,
+        related_name="required_in",
+    )
+
+    medication_schedules = models.ManyToManyField( # type: ignore[assignment]
+        "MedicationSchedule",
+        blank=True,
+        related_name="required_in",
+    )
+
+    genders = models.ManyToManyField( # type: ignore[assignment]
+        "Gender",
+        blank=True,
+        related_name="required_in",
+    )
+
     if TYPE_CHECKING:
         requirement_types: models.QuerySet[RequirementType]
         operators: models.QuerySet[RequirementOperator]
@@ -266,60 +268,500 @@ class Requirement(models.Model):
         disease_classification_choices: models.QuerySet[DiseaseClassificationChoice]
         events: models.QuerySet[Event]
         findings: models.QuerySet[Finding]
-        finding_morphology_classification_choices: models.QuerySet[
-            FindingMorphologyClassificationChoice
-        ]
-        finding_location_classification_choices: models.QuerySet[
-            FindingLocationClassificationChoice
-        ]
+        finding_classifications: models.QuerySet[FindingClassification]
+        finding_classification_choices: models.QuerySet[FindingClassificationChoice]
         finding_interventions: models.QuerySet[FindingIntervention]
+        medications: models.QuerySet[Medication]
+        medication_indications: models.QuerySet[MedicationIndication]
+        medication_intake_times: models.QuerySet[MedicationIntakeTime] # Added type hint
+        medication_schedules: models.QuerySet[MedicationSchedule]
+        genders: models.QuerySet[Gender]
 
     def natural_key(self):
         """
-        Return a tuple containing the natural key of the instance.
-
-        The tuple, comprised solely of the instance's name, serves as an alternative unique identifier for serialization.
+        Returns a tuple containing the instance's name as its natural key.
+        
+        This tuple provides a unique identifier for serialization purposes.
         """
         return (self.name,)
 
     def __str__(self):
-        """Return the string representation of the requirement's name.
+        """Returns the name of the requirement as its string representation."""
+        return str(self.name)
 
-        Returns:
-            str: The name of the requirement.
+    @property
+    def expected_models(self) -> List[Union[
+        "Disease",
+        "DiseaseClassificationChoice",
+        "Event",
+        "EventClassification",
+        "EventClassificationChoice",
+        "Examination",
+        "ExaminationIndication",
+        "Finding",
+        "FindingIntervention",
+        "FindingClassification",
+        "FindingClassificationChoice",
+        "FindingClassificationType",
+        "LabValue",
+        "Medication",
+        "MedicationIndication",
+        "MedicationIntakeTime", # Added MedicationIntakeTime
+        "PatientDisease",
+        "PatientEvent",
+        "PatientExamination",
+        "PatientFinding",
+        "PatientFindingIntervention",
+        "PatientFindingClassification",
+        "PatientLabValue",
+        "PatientMedicationSchedule", # Added PatientMedicationSchedule
+    ]]:
         """
-        return str(self.name)
+        Return the list of model classes that are expected as input for evaluating this requirement.
+        
+        The returned models correspond to the requirement types linked to this requirement, mapped via the internal data model dictionary.
+        """
+        req_types = self.requirement_types.all()
+        req_type_names = [_.name for _ in req_types]
+
+        expected_models = [self.data_model_dict[_] for _ in req_type_names]
+        # e.g. [PatientExamination, PatientFinding]
+        return expected_models
 
-    def get_models_dict(self) -> RequirementsModelDict:
+    @property
+    def links(self) -> "RequirementLinks":
         """
-        Returns a RequirementsModelDict with querysets of all associated models.
-
-        This method aggregates related models by invoking .all() on each
-        many-to-many field of the requirement. The resulting RequirementsModelDict
-        includes querysets for requirement types, operators, requirement sets,
-        examinations, examination indications, lab values, diseases, disease
-        classification choices, events, findings, finding morphology classification
-        choices, finding location classification choices, and finding interventions.
+        Return a RequirementLinks object containing all non-null related model instances for this requirement.
+        
+        The returned object provides structured access to all associated entities, such as examinations, diseases, findings, classifications, interventions, medications, and related choices, aggregated from the requirement's many-to-many fields.
         """
-        models_dict = RequirementsModelDict(
-            requirement_types=self.requirement_types.all(),
-            operators=self.operators.all(),
-            requirement_sets=self.requirement_sets.all(),
-            examinations=self.examinations.all(),
-            examination_indications=self.examination_indications.all(),
-            lab_values=self.lab_values.all(),
-            diseases=self.diseases.all(),
-            disease_classification_choices=self.disease_classification_choices.all(),
-            events=self.events.all(),
-            findings=self.findings.all(),
-            finding_morphology_classification_choices=self.finding_morphology_classification_choices.all(),
-            finding_location_classification_choices=self.finding_location_classification_choices.all(),
-            finding_interventions=self.finding_interventions.all(),
+        # requirement_sets is not part of RequirementLinks (avoids circular import); collect other related models
+        models_dict = RequirementLinks(
+            examinations=[_ for _ in self.examinations.all() if _ is not None],
+            examination_indications=[_ for _ in self.examination_indications.all() if _ is not None],
+            lab_values=[_ for _ in self.lab_values.all() if _ is not None],
+            diseases=[_ for _ in self.diseases.all() if _ is not None],
+            disease_classification_choices=[_ for _ in self.disease_classification_choices.all() if _ is not None],
+            events=[_ for _ in self.events.all() if _ is not None],
+            findings=[_ for _ in self.findings.all() if _ is not None],
+            finding_classifications=[_ for _ in self.finding_classifications.all() if _ is not None],
+            finding_classification_choices=[_ for _ in self.finding_classification_choices.all() if _ is not None],
+            finding_interventions=[_ for _ in self.finding_interventions.all() if _ is not None],
+            medications=[_ for _ in self.medications.all() if _ is not None],
+            medication_indications=[_ for _ in self.medication_indications.all() if _ is not None],
+            medication_intake_times=[_ for _ in self.medication_intake_times.all() if _ is not None],
         )
         return models_dict
     
-    def evaluate(self, **kwargs):
-        #TODO refactor after prototyping
-        # from .requirement_evaluation.requirement_type_parser import get_input_data
-
-        return_value = True
+    @property
+    def data_model_dict(self) -> dict:
+        """
+        Provides a mapping from requirement type names to their corresponding model classes.
+        
+        Returns:
+            A dictionary where keys are requirement type names and values are model classes used for requirement evaluation.
+        """
+        from .requirement_evaluation.requirement_type_parser import data_model_dict
+        return data_model_dict
+    
+    @property
+    def active_links(self) -> Dict[str, List]:
+        """Returns a dictionary of linked models containing only non-empty entries.
+        
+        The returned dictionary includes only those related model lists that have at least one linked instance.
+        """
+        return self.links.active()
+    
+    
+    def evaluate(self, *args, mode:str, **kwargs):
+        """
+        Evaluates whether the requirement is satisfied for the given input models using linked operators and gender constraints.
+        
+        Args:
+            *args: Instances or QuerySets of expected model classes to be evaluated. Each must have a `.links` property returning a `RequirementLinks` object.
+            mode: Evaluation mode; "strict" requires all operators to pass, "loose" requires any operator to pass.
+            **kwargs: Additional keyword arguments passed to operator evaluations.
+        
+        Returns:
+            True if the requirement is satisfied according to the specified mode, linked operators, and gender restrictions; otherwise, False.
+        
+        Raises:
+            ValueError: If an invalid mode is provided.
+            TypeError: If an input is not an instance or QuerySet of expected models, or lacks a valid `.links` attribute.
+        
+        If the requirement specifies genders, only input containing a patient with a matching gender will be considered valid for evaluation.
+        """
+        #TODO Review, Optimize or remove
+        if mode not in ["strict", "loose"]:
+            raise ValueError(f"Invalid mode: {mode}. Use 'strict' or 'loose'.")
+
+        evaluate_result_list_func = all if mode == "strict" else any
+
+        requirement_req_links = self.links
+        expected_models = self.expected_models
+
+        # helpers to avoid passing a complex tuple to isinstance/issubclass which confuses type checkers
+        def _is_expected_instance(obj) -> bool:
+            for cls in expected_models:
+                if isinstance(cls, type):
+                    try:
+                        if isinstance(obj, cls):
+                            return True
+                    except Exception:
+                        # cls might not be a runtime type
+                        continue
+            return False
+
+        def _is_queryset_of_expected(qs) -> bool:
+            if not isinstance(qs, models.QuerySet) or not hasattr(qs, 'model'):
+                return False
+            for cls in expected_models:
+                if isinstance(cls, type):
+                    try:
+                        if issubclass(qs.model, cls):
+                            return True
+                    except Exception:
+                        continue
+            return False
+
+        # Aggregate RequirementLinks from all input arguments
+        aggregated_input_links_data = {}
+        processed_inputs_count = 0
+
+        for _input in args:
+            # Check if the input is an instance of any of the expected model types
+            if not _is_expected_instance(_input):
+                # Allow QuerySets of expected models
+                if _is_queryset_of_expected(_input):
+                    # For QuerySets, evaluate each item individually and return True if any matches
+                    if not _input.exists(): # Skip empty querysets
+                        continue
+                    
+                    queryset_results = []
+                    for item in _input:
+                        if not hasattr(item, 'links') or not isinstance(item.links, RequirementLinks):
+                            raise TypeError(
+                                f"Item {item} of type {type(item)} in QuerySet does not have a valid .links attribute of type RequirementLinks."
+                            )
+                        
+                        # Evaluate this single item against the requirement
+                        item_input_links = RequirementLinks(**item.links.active())
+                        
+                        # Evaluate all operators for this single item
+                        item_operator_results = []
+                        for operator in self.operators.all():
+                            try:
+                                operator_result = operator.evaluate(
+                                    requirement_links=requirement_req_links,
+                                    input_links=item_input_links,
+                                    requirement=self,
+                                    original_input_args=args,
+                                    **kwargs
+                                )
+                                item_operator_results.append(operator_result)
+                            except Exception as e:
+                                logger.debug(f"Operator {operator.name} evaluation failed for item {item}: {e}")
+                                item_operator_results.append(False)
+                        
+                        # Apply evaluation mode for this single item
+                        item_result = evaluate_result_list_func(item_operator_results) if item_operator_results else True
+                        queryset_results.append(item_result)
+                        processed_inputs_count += 1
+                    
+                    # If any item in the QuerySet matches, return True for the whole QuerySet evaluation
+                    if any(queryset_results):
+                        return True
+                    continue # Move to the next arg after processing queryset
+                else:
+                    raise TypeError(
+                        f"Input type {type(_input)} is not among expected models: {self.expected_models} "
+                        f"nor a QuerySet of expected models."
+                    )
+
+            # Process single model instance
+            if not hasattr(_input, 'links') or not isinstance(_input.links, RequirementLinks):
+                raise TypeError(
+                    f"Input {_input} of type {type(_input)} does not have a valid .links attribute of type RequirementLinks."
+                )
+            
+            active_input_links = _input.links.active() # Get dict of non-empty lists
+            for link_key, link_list in active_input_links.items():
+                if link_key not in aggregated_input_links_data:
+                    aggregated_input_links_data[link_key] = []
+                aggregated_input_links_data[link_key].extend(link_list)
+            processed_inputs_count += 1
+
+        if not processed_inputs_count and args: # If args were provided but none were processable (e.g. all empty querysets)
+              # This situation implies no relevant data was provided for evaluation against the requirement.
+              # Depending on operator logic (e.g., "requires at least one matching item"), this might lead to False.
+              # For "models_match_any", an empty input_links will likely result in False if requirement_req_links is not empty.
+              pass
+
+
+        # Deduplicate items within each list after aggregation
+        for key in aggregated_input_links_data:
+            try:
+                # Using dict.fromkeys to preserve order and remove duplicates for hashable items
+                aggregated_input_links_data[key] = list(dict.fromkeys(aggregated_input_links_data[key]))
+            except TypeError:
+                # Fallback for non-hashable items (though Django models are hashable)
+                temp_list = []
+                for item in aggregated_input_links_data[key]:
+                    if item not in temp_list:
+                        temp_list.append(item)
+                aggregated_input_links_data[key] = temp_list
+        
+        final_input_links = RequirementLinks(**aggregated_input_links_data)
+        
+        # Gender strict check: if this requirement has genders, only pass if patient.gender is in the set
+        genders_exist = self.genders.exists()
+        if genders_exist:
+            # Import here to avoid circular import
+            from endoreg_db.models.administration.person.patient import Patient
+            patient = None
+            for arg in args:
+                if isinstance(arg, Patient):
+                    patient = arg
+                    break
+            if patient is None or patient.gender is None:
+                return False
+            if not self.genders.filter(pk=patient.gender.pk).exists():
+                return False
+
+        operators = self.operators.all()
+        if not operators.exists(): # If a requirement has no operators, its evaluation is ambiguous.
+            # Consider if this should be True, False, or an error.
+            # For now, if no operators, and mode is strict, it's vacuously true. If loose, vacuously false.
+            # However, typically a requirement implies some condition.
+            # Let's assume if no operators, it cannot be satisfied unless it also has no specific links.
+            # This behavior might need further refinement based on business logic.
+            if not requirement_req_links.active(): # No conditions in requirement
+                 return True # Vacuously true if requirement itself is empty
+            return False # Cannot be satisfied if requirement has conditions but no operators to check them
+
+
+        operator_results = []
+        for operator in operators:
+            # Prepare kwargs for the operator, including the current Requirement instance
+            op_kwargs = kwargs.copy() # Start with kwargs passed to Requirement.evaluate
+            op_kwargs['requirement'] = self # Add the Requirement instance itself
+            op_kwargs['original_input_args'] = args # Add the original input arguments for operators that need them (e.g., age operators)
+            operator_results.append(operator.evaluate(
+                requirement_links=requirement_req_links,
+                input_links=final_input_links,
+                **op_kwargs
+            ))
+
+        is_valid = evaluate_result_list_func(operator_results)
+
+        return is_valid
+
+    def evaluate_with_details(self, *args, mode:str, **kwargs):
+        """
+        Evaluates whether the requirement is satisfied for the given input models using linked operators and gender constraints.
+        
+        Args:
+            *args: Instances or QuerySets of expected model classes to be evaluated. Each must have a `.links` property returning a `RequirementLinks` object.
+            mode: Evaluation mode; "strict" requires all operators to pass, "loose" requires any operator to pass.
+            **kwargs: Additional keyword arguments passed to operator evaluations.
+        
+        Returns:
+            True if the requirement is satisfied according to the specified mode, linked operators, and gender restrictions; otherwise, False.
+        
+        Raises:
+            ValueError: If an invalid mode is provided.
+            TypeError: If an input is not an instance or QuerySet of expected models, or lacks a valid `.links` attribute.
+        
+        If the requirement specifies genders, only input containing a patient with a matching gender will be considered valid for evaluation.
+        """
+        #TODO Review, Optimize or remove
+        if mode not in ["strict", "loose"]:
+            raise ValueError(f"Invalid mode: {mode}. Use 'strict' or 'loose'.")
+
+        evaluate_result_list_func = all if mode == "strict" else any
+
+        requirement_req_links = self.links
+        expected_models = self.expected_models
+
+        # helpers to avoid passing a complex tuple to isinstance/issubclass which confuses type checkers
+        def _is_expected_instance(obj) -> bool:
+            for cls in expected_models:
+                if isinstance(cls, type):
+                    try:
+                        if isinstance(obj, cls):
+                            return True
+                    except Exception:
+                        # cls might not be a runtime type
+                        continue
+            return False
+
+        def _is_queryset_of_expected(qs) -> bool:
+            if not isinstance(qs, models.QuerySet) or not hasattr(qs, 'model'):
+                return False
+            for cls in expected_models:
+                if isinstance(cls, type):
+                    try:
+                        if issubclass(qs.model, cls):
+                            return True
+                    except Exception:
+                        continue
+            return False
+
+        # Aggregate RequirementLinks from all input arguments
+        aggregated_input_links_data = {}
+        processed_inputs_count = 0
+
+        for _input in args:
+            # Check if the input is an instance of any of the expected model types
+            if not _is_expected_instance(_input):
+                # Allow QuerySets of expected models
+                if _is_queryset_of_expected(_input):
+                    # For QuerySets, evaluate each item individually and return True if any matches
+                    if not _input.exists(): # Skip empty querysets
+                        continue
+                    
+                    queryset_results = []
+                    for item in _input:
+                        if not hasattr(item, 'links') or not isinstance(item.links, RequirementLinks):
+                            raise TypeError(
+                                f"Item {item} of type {type(item)} in QuerySet does not have a valid .links attribute of type RequirementLinks."
+                            )
+                        
+                        # Evaluate this single item against the requirement
+                        item_input_links = RequirementLinks(**item.links.active())
+                        
+                        # Evaluate all operators for this single item
+                        item_operator_results = []
+                        for operator in self.operators.all():
+                            try:
+                                operator_result = operator.evaluate(
+                                    requirement_links=requirement_req_links,
+                                    input_links=item_input_links,
+                                    requirement=self,
+                                    original_input_args=args,
+                                    **kwargs
+                                )
+                                item_operator_results.append(operator_result)
+                            except Exception as e:
+                                logger.debug(f"Operator {operator.name} evaluation failed for item {item}: {e}")
+                                item_operator_results.append(False)
+                        
+                        # Apply evaluation mode for this single item
+                        item_result = evaluate_result_list_func(item_operator_results) if item_operator_results else True
+                        queryset_results.append(item_result)
+                        processed_inputs_count += 1
+                    
+                    # If any item in the QuerySet matches, return True for the whole QuerySet evaluation
+                    if any(queryset_results):
+                        return True
+                    continue # Move to the next arg after processing queryset
+                else:
+                    raise TypeError(
+                        f"Input type {type(_input)} is not among expected models: {self.expected_models} "
+                        f"nor a QuerySet of expected models."
+                    )
+
+            # Process single model instance
+            if not hasattr(_input, 'links') or not isinstance(_input.links, RequirementLinks):
+                raise TypeError(
+                    f"Input {_input} of type {type(_input)} does not have a valid .links attribute of type RequirementLinks."
+                )
+            
+            active_input_links = _input.links.active() # Get dict of non-empty lists
+            for link_key, link_list in active_input_links.items():
+                if link_key not in aggregated_input_links_data:
+                    aggregated_input_links_data[link_key] = []
+                aggregated_input_links_data[link_key].extend(link_list)
+            processed_inputs_count += 1
+
+        if not processed_inputs_count and args: # If args were provided but none were processable (e.g. all empty querysets)
+             # This situation implies no relevant data was provided for evaluation against the requirement.
+             # Depending on operator logic (e.g., "requires at least one matching item"), this might lead to False.
+             # For "models_match_any", an empty input_links will likely result in False if requirement_req_links is not empty.
+             pass
+
+
+        # Deduplicate items within each list after aggregation
+        for key in aggregated_input_links_data:
+            try:
+                # Using dict.fromkeys to preserve order and remove duplicates for hashable items
+                aggregated_input_links_data[key] = list(dict.fromkeys(aggregated_input_links_data[key]))
+            except TypeError:
+                # Fallback for non-hashable items (though Django models are hashable)
+                temp_list = []
+                for item in aggregated_input_links_data[key]:
+                    if item not in temp_list:
+                        temp_list.append(item)
+                aggregated_input_links_data[key] = temp_list
+        
+        final_input_links = RequirementLinks(**aggregated_input_links_data)
+        
+        # Gender strict check: if this requirement has genders, only pass if patient.gender is in the set
+        genders_exist = self.genders.exists()
+        if genders_exist:
+            # Import here to avoid circular import
+            from endoreg_db.models.administration.person.patient import Patient
+            patient = None
+            for arg in args:
+                if isinstance(arg, Patient):
+                    patient = arg
+                    break
+            if patient is None or patient.gender is None:
+                return False
+            if not self.genders.filter(pk=patient.gender.pk).exists():
+                return False
+
+        operators = self.operators.all()
+        if not operators.exists(): # If a requirement has no operators, its evaluation is ambiguous.
+            # Consider if this should be True, False, or an error.
+            # For now, if no operators, and mode is strict, it's vacuously true. If loose, vacuously false.
+            # However, typically a requirement implies some condition.
+            # Let's assume if no operators, it cannot be satisfied unless it also has no specific links.
+            # This behavior might need further refinement based on business logic.
+            if not requirement_req_links.active(): # No conditions in requirement
+                 return True # Vacuously true if requirement itself is empty
+            return False # Cannot be satisfied if requirement has conditions but no operators to check them
+
+
+        operator_results = []
+        operator_details = []
+        for operator in operators:
+            # Prepare kwargs for the operator, including the current Requirement instance
+            op_kwargs = kwargs.copy() # Start with kwargs passed to Requirement.evaluate
+            op_kwargs['requirement'] = self # Add the Requirement instance itself
+            op_kwargs['original_input_args'] = args # Add the original input arguments for operators that need them (e.g., age operators)
+            try:
+                operator_result = operator.evaluate(
+                    requirement_links=requirement_req_links,
+                    input_links=final_input_links,
+                    **op_kwargs
+                )
+                operator_results.append(operator_result)
+                operator_details.append(f"{operator.name}: {'Passed' if operator_result else 'Failed'}")
+            except Exception as e:
+                operator_results.append(False)
+                operator_details.append(f"{operator.name}: {str(e)}")
+
+        is_valid = evaluate_result_list_func(operator_results)
+
+        # Create detailed feedback
+        if not operator_results:
+            details = "Keine Operatoren für die Bewertung verfügbar"
+        elif len(operator_results) == 1:
+            details = operator_details[0]
+        else:
+            failed_details = [detail for detail, result in zip(operator_details, operator_results) if not result]
+            if failed_details:
+                details = "; ".join(failed_details)
+            else:
+                details = "Alle Operatoren erfolgreich"
+
+        # Append working directory for debugging convenience
+        try:
+            cwd = run("pwd", capture_output=True, text=True).stdout.strip()
+            details = f"{details}\ncwd: {cwd}"
+        except Exception:
+            # non-fatal: ignore if subprocess fails
+            pass
+
+        return is_valid, details