endoreg-db 0.8.4.4__py3-none-any.whl → 0.8.8.0__py3-none-any.whl

endoreg_db/models/requirement/requirement_operator.py

@@ -1,24 +1,27 @@
+from logging import getLogger  # Added logger
+from typing import TYPE_CHECKING
+
 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
+    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.
         """
@@ -36,7 +39,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()
 
@@ -49,26 +52,28 @@ class RequirementOperator(models.Model):
     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,)
@@ -78,12 +83,11 @@ 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
-        
+
+    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.
@@ -93,7 +97,7 @@ class RequirementOperator(models.Model):
 
         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.
         """
@@ -101,36 +105,36 @@ class RequirementOperator(models.Model):
         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)
+                result = eval_func(requirement_links=requirement_links, input_links=input_links, **kwargs)
+                assert isinstance(result, bool), (
+                    f"Evaluation function '{self.evaluation_function_name}' for operator '{self.name}' must return a boolean value."
+                )
+                return result
             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}'."
+                    f"Evaluation function '{self.evaluation_function_name}' not found or not callable on {self.__class__.__name__} for operator '{self.name}'."
                 )
+                raise NotImplementedError(f"Evaluation function '{self.evaluation_function_name}' 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 
+                **kwargs,
             )
-    
-    from ..medical.patient.patient_medication import PatientMedication # Added
-    from ..medical.medication import MedicationSchedule as MedicationScheduleTemplate # Added with alias
+
+    from ..medical.medication import MedicationSchedule as MedicationScheduleTemplate  # Added with alias
+    from ..medical.patient.patient_medication import PatientMedication  # Added
 
     def _evaluate_patient_medication_schedule_matches_template(
         self,
         requirement_links: "RequirementLinks",
         input_links: "RequirementLinks",
-        requirement: "Requirement", # Added requirement
+        requirement: "Requirement",  # Added requirement
         **kwargs,
     ) -> bool:
         """
@@ -158,10 +162,10 @@ class RequirementOperator(models.Model):
 
                 # Check for profile match
                 medication_match = pm_instance.medication == schedule_template.medication
-                dose_match = pm_instance.dosage == schedule_template.dose 
+                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}")
@@ -169,8 +173,7 @@ class RequirementOperator(models.Model):
                 # 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
+        return False  # No PatientMedication matched any template

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"