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

endoreg_db/models/requirement/requirement_operator.py

@@ -1,24 +1,89 @@
+from logging import getLogger  # Added logger
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Union
+
 from django.db import models
-from typing import TYPE_CHECKING, List
-from logging import getLogger # Added logger
+from pydantic import BaseModel
+
+from endoreg_db.utils.requirement_operator_logic.new_operator_logic import REQUIREMENT_OPERATORS, model_attribute_set_any
 
 # 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
+    from .requirement import Requirement  # Added Requirement import for type hint
+
+logger = getLogger(__name__)  # Added logger instance
+
+
+class OperatorInstructions(BaseModel):
+    input_targets: List[str] = []
+    requirement_targets: List[str] = []
+    kwargs: Dict[str, Union[str, int, float, bool]] = {}
+    args: List[Union[str, int, float, bool]] = []
+
+
+def _parse_operator_instructions(raw: str):
+    target_attributes_list = [_.strip() for _ in raw.split(";") if _.strip()]
+
+    input_targets = []
+    kwargs: Dict[str, Union[str, int, float, bool]] = {}
+    args: List[Union[str, int, float, bool]] = []
+
+    valid_prefixes = [
+        "!",  # Requirement target
+        "?",  # Input target
+        "$",  # Keyword argument, keyword and value separated by ":"
+        "@",  # Positional argument
+    ]
+
+    for entry in target_attributes_list:
+        _prefix = entry[0]
+
+        if _prefix in valid_prefixes:
+            _attribute = entry[1:].strip()
+            if _prefix == "!":
+                # Requirement target
+                input_targets.append(_attribute)
+            elif _prefix == "?":
+                # Input target
+                input_targets.append(_attribute)
+            elif _prefix == "$":
+                # Keyword argument
+                if ":" in _attribute:
+                    key, value = _attribute.split(":", 1)
+                    kwargs[key.strip()] = value.strip()
+                else:
+                    raise ValueError(f"Invalid keyword argument format in target_attributes: '{entry}'. Expected format is '$key:value'.")
+            elif _prefix == "@":
+                # Positional argument
+                args.append(_attribute)
+        else:
+            raise ValueError(f"Invalid prefix '{_prefix}' in target_attributes entry: '{entry}'. Valid prefixes are {valid_prefixes}.")
+    return OperatorInstructions(
+        input_targets=input_targets,
+        requirement_targets=input_targets,
+        kwargs=kwargs,
+        args=args,
+    )
+
+
+def _validate_operator_instructions(instance: "Requirement") -> bool:
+    """Ensures requirement fixtures declare at least one target attribute."""
+    if not instance.operator_instructions_parsed:
+        raise ValueError(f"Requirement '{instance.name}' must declare at least one target attribute.")
+    return True
+
 
 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.
         """
@@ -36,7 +101,7 @@ class RequirementOperator(models.Model):
 
     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
+    evaluation_function_name = models.CharField(max_length=255, blank=True, null=True)  # Added field
 
     objects = RequirementOperatorManager()
 
@@ -45,30 +110,34 @@ class RequirementOperator(models.Model):
 
         requirements: models.QuerySet[Requirement]
 
-    @property
-    def operator_evaluation_models(self):
+    @classmethod
+    def parse_instructions(cls, raw: str) -> OperatorInstructions:
         """
-        Returns a dictionary of operator evaluation models for this requirement operator.
-        
-        This property dynamically imports and provides access to the available operator evaluation models.
+        Parses the raw target attributes string into structured operator instructions.
+
+        Args:
+            raw: The raw target attributes string.
+
+        Returns:
+            An OperatorInstructions instance containing parsed input targets, requirement targets, kwargs, and args.
         """
-        from .requirement_evaluation.operator_evaluation_models import operator_evaluation_models
-        return operator_evaluation_models
-    
+        return _parse_operator_instructions(raw)
+
     @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,)
@@ -78,99 +147,21 @@ class RequirementOperator(models.Model):
         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
+    def get_operator_function(self) -> Callable[..., bool]:
+        _operator_function = REQUIREMENT_OPERATORS.get(self.name)
+        if not _operator_function:
+            raise ValueError(f"Operator function for '{self.name}' not found in REQUIREMENT_OPERATORS.")
+        return _operator_function
+
+    def evaluate(self, operator_instructions: "OperatorInstructions", requirement: "Requirement", input_obj: Any, **kwargs) -> bool:
+        """ """
+        eval_result: bool = False
+        requirement_links: "RequirementLinks" = requirement.links
+        expected_input_models = requirement.expected_models
+        operator_function = self.get_operator_function()
+
+        input_model = type(input_obj)
+        assert input_model in expected_input_models, f"Input model {input_model} not in expected models {expected_input_models}"
+
+        return eval_result

endoreg_db/models/requirement/requirement_set.py

@@ -1,6 +1,6 @@
-from django.db import models
 from typing import TYPE_CHECKING, List
 
+from django.db import models
 
 REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP = {
     "all": all,
@@ -11,6 +11,7 @@ REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP = {
     "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.
@@ -19,10 +20,10 @@ class RequirementSetTypeManager(models.Manager):
     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.
         """
@@ -50,7 +51,7 @@ class RequirementSetType(models.Model):
     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.
         """
@@ -61,10 +62,10 @@ 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.
         """
@@ -82,53 +83,69 @@ class RequirementSet(models.Model):
 
     name = models.CharField(max_length=100, unique=True)
     description = models.TextField(blank=True, null=True)
-    requirements = models.ManyToManyField(  # type: ignore[assignment]
+    
+    depends_on = models.ManyToManyField(
+        "self",
+        symmetrical=False,
+        related_name="dependents",
+        blank=True,
+        help_text=(
+            "Andere RequirementSets, die zuerst erfüllt sein müssen, "
+            "bevor dieses Set geprüft wird ('after')."
+        ),
+    )
+    
+    requirements = models.ManyToManyField(
         "Requirement",
         blank=True,
         related_name="requirement_sets",
     )
-    links_to_sets = models.ManyToManyField(  # type: ignore[assignment]
+    links_to_sets = models.ManyToManyField(
         "RequirementSet",
         blank=True,
         related_name="links_from_sets",
     )
-    requirement_set_type = models.ForeignKey(  # type: ignore[assignment]
+    requirement_set_type = models.ForeignKey(
         "RequirementSetType",
         on_delete=models.CASCADE,
         related_name="requirement_sets",
         blank=True,
         null=True,
     )
-    information_sources = models.ManyToManyField(  # type: ignore[assignment]
+    information_sources = models.ManyToManyField(
         "InformationSource",
         related_name="requirement_sets",
         blank=True,
     )
-    
-    reqset_exam_links = models.ManyToManyField(  # type: ignore[assignment]
+
+    reqset_exam_links = models.ManyToManyField(
         "ExaminationRequirementSet",
         related_name="requirement_set",
         blank=True,
     )
-    
-    tags = models.ManyToManyField(  # type: ignore[assignment]
+
+    tags = models.ManyToManyField(
         "Tag",
         related_name="requirement_sets",
         blank=True,
     )
-    
+
     objects = RequirementSetManager()
 
     if TYPE_CHECKING:
-        from endoreg_db.models import Tag, Requirement, InformationSource
-        from typing import Optional
+        from typing import Optional, cast
+
+        from endoreg_db.models import ExaminationRequirementSet, InformationSource, Requirement, Tag
+
+        tags = cast(models.manager.RelatedManager["Tag"], tags)
+        requirements = cast(models.manager.RelatedManager["Requirement"], requirements)
+        links_to_sets = cast(models.manager.RelatedManager["RequirementSet"], links_to_sets)
+        reqset_exam_links = cast(models.manager.RelatedManager["ExaminationRequirementSet"], reqset_exam_links)
+        information_sources = cast(models.manager.RelatedManager["InformationSource"], information_sources)
+        requirement_set_type: models.ForeignKey["RequirementSetType | None"]
 
-        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]"
+        @property
+        def links_from_sets(self) -> "models.manager.RelatedManager[RequirementSet]": ...
 
     def natural_key(self):
         """Return the natural key as a tuple containing the instance's name."""
@@ -139,19 +156,19 @@ class RequirementSet(models.Model):
         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, 
+        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.
         """
@@ -162,36 +179,39 @@ class RequirementSet(models.Model):
             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 the requirement expects PatientFinding instances, scope queryset to relevant findings
             if PatientFinding in expected_models:
-                return input_object.patient_findings.all()
+                findings_qs = input_object.patient_findings.all()
+                required_findings = list(requirement.findings.all())
+                if required_findings:
+                    findings_qs = findings_qs.filter(finding__in=required_findings)
+                return findings_qs
 
-        
         # Handle other model conversions as needed in the future
         # For now, return the original input object as fallback
         return input_object
@@ -199,7 +219,7 @@ class RequirementSet(models.Model):
     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.
         """
@@ -211,12 +231,12 @@ class RequirementSet(models.Model):
             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:
@@ -226,12 +246,12 @@ class RequirementSet(models.Model):
     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.
         """
@@ -243,45 +263,42 @@ class RequirementSet(models.Model):
         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"):
+        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
-
-
 
+        return result

endoreg_db/models/state/__init__.py

@@ -1,12 +1,12 @@
-from .sensitive_meta import SensitiveMetaState
-from .video import VideoState, AnonymizationStatus
 from .label_video_segment import LabelVideoSegmentState
 from .raw_pdf import RawPdfState
-
+from .sensitive_meta import SensitiveMetaState
+from .video import VideoState
+from .anonymization import AnonymizationState
 __all__ = [
     "SensitiveMetaState",
     "VideoState",
     "LabelVideoSegmentState",
-    "AnonymizationStatus",
+    "AnonymizationState",
     "RawPdfState",
 ]

endoreg_db/models/state/abstract.py

@@ -1,11 +1,11 @@
 from django.db import models
 
+
 class AbstractState(models.Model):
     """Abstract base class for all states."""
 
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
 
-
     class Meta:
-        abstract = True
+        abstract = True

endoreg_db/models/state/anonymization.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class AnonymizationState(str, Enum):
+    NOT_STARTED = "not_started"
+    EXTRACTING_FRAMES = "extracting_frames"
+    PROCESSING_ANONYMIZING = "processing_anonymization"
+    DONE_PROCESSING_ANONYMIZATION = "done_processing_anonymization"
+    VALIDATED = "validated"
+    FAILED = "failed"
+    STARTED = "started"
+    ANONYMIZED = "anonymized"