ethyca-fides 2.68.1b0__py2.py3-none-any.whl → 2.68.1b2__py2.py3-none-any.whl

fides/api/task/conditional_dependencies/logging_utils.py

@@ -0,0 +1,196 @@
+from typing import Optional, cast
+
+from fides.api.task.conditional_dependencies.schemas import (
+    ConditionEvaluationResult,
+    EvaluationResult,
+    GroupEvaluationResult,
+)
+
+MAX_DEPTH = 100
+
+
+def format_evaluation_success_message(
+    evaluation_result: Optional[EvaluationResult],
+) -> str:
+    """Format a detailed message about which conditions succeeded
+
+    Args:
+        evaluation_result: The evaluation result to create a string from
+
+    Returns:
+        A string describing the evaluation result
+
+    """
+    if not evaluation_result:
+        return "No conditional dependencies to evaluate."
+
+    return _format_evaluation_message(evaluation_result, success=True, depth=0)
+
+
+def format_evaluation_failure_message(
+    evaluation_result: Optional[EvaluationResult],
+) -> str:
+    """Format a detailed message about which conditions failed
+
+    Args:
+        evaluation_result: The evaluation result to create a string from
+
+    Returns:
+        A string describing the evaluation result
+    """
+    if not evaluation_result:
+        return "No conditional dependencies to evaluate."
+
+    return _format_evaluation_message(evaluation_result, success=False, depth=0)
+
+
+def _format_leaf_condition(evaluation_result: ConditionEvaluationResult) -> str:
+    """Format a single leaf condition into a readable string
+
+    Args:
+        evaluation_result: The conditionevaluation result to create a string from
+
+    Returns:
+        A string describing the evaluation result
+    """
+    condition_desc = f"{evaluation_result.field_address} {evaluation_result.operator}"
+    if evaluation_result.expected_value is not None:
+        condition_desc += f" {evaluation_result.expected_value}"
+    return condition_desc
+
+
+def _format_condition_list(
+    results: list[EvaluationResult], success: bool, depth: int
+) -> list[str]:
+    """Format a list of conditions (either leaf or group) into readable strings
+
+    Args:
+        results: The list of conditions to format
+        success: Whether the conditions were successful
+        depth: The depth of the conditions
+
+    Returns:
+        A list of strings describing the conditions
+    """
+    condition_descriptions = []
+    for sub_result in results:
+        if _is_leaf_condition(sub_result):
+            # Cast to the specific type after verification
+            leaf_result = cast(ConditionEvaluationResult, sub_result)
+            condition_descriptions.append(_format_leaf_condition(leaf_result))
+        elif _is_group_condition(sub_result):
+            # Cast to the specific type after verification
+            group_result = cast(GroupEvaluationResult, sub_result)
+            condition_descriptions.append(
+                _format_evaluation_message(group_result, success, depth + 1)
+            )
+    return condition_descriptions
+
+
+def _format_evaluation_message(
+    evaluation_result: EvaluationResult, success: bool, depth: int = 0
+) -> str:
+    """Format evaluation results into a readable message
+
+    Args:
+        evaluation_result: The evaluation result to format
+        success: Whether the conditions were successful
+        depth: The depth of the conditions
+
+    Returns:
+        A string describing the evaluation result
+    """
+    # Prevent infinite recursion
+    if depth > MAX_DEPTH:
+        return "Condition evaluation too deeply nested"
+
+    # Try to format as group condition first
+    if _is_group_condition(evaluation_result):
+        # Cast to the specific type after verification
+        group_result = cast(GroupEvaluationResult, evaluation_result)
+        return _format_group_condition(group_result, success, depth)
+
+    # Try to format as leaf condition
+    if _is_leaf_condition(evaluation_result):
+        # Cast to the specific type after verification
+        leaf_result = cast(ConditionEvaluationResult, evaluation_result)
+        return _format_leaf_condition_message(leaf_result, success)
+
+    # Unknown condition type
+    return "Evaluation result details unavailable"
+
+
+def _is_group_condition(evaluation_result: EvaluationResult) -> bool:
+    """Check if evaluation_result is a group condition by checking for group-specific attributes
+
+    Args:
+        evaluation_result: The evaluation result to check
+
+    Returns:
+        True if the evaluation result is a group condition, False otherwise
+    """
+    # Check for attributes that are unique to GroupEvaluationResult
+    return hasattr(evaluation_result, "logical_operator") and hasattr(
+        evaluation_result, "condition_results"
+    )
+
+
+def _is_leaf_condition(evaluation_result: EvaluationResult) -> bool:
+    """Check if evaluation_result is a leaf condition by checking for leaf-specific attributes
+
+    Args:
+        evaluation_result: The evaluation result to check
+
+    Returns:
+        True if the evaluation result is a leaf condition, False otherwise
+    """
+    # Check for attributes that are unique to ConditionEvaluationResult
+    return hasattr(evaluation_result, "field_address") and hasattr(
+        evaluation_result, "operator"
+    )
+
+
+def _format_group_condition(
+    evaluation_result: GroupEvaluationResult, success: bool, depth: int
+) -> str:
+    """Format a group condition evaluation result
+
+    Args:
+        evaluation_result: The group evaluation result to format
+        success: Whether the conditions were successful
+        depth: The depth of the conditions
+
+    Returns:
+        A string describing the evaluation result
+    """
+    logical_operator = evaluation_result.logical_operator
+    results = evaluation_result.condition_results
+    condition_descriptions = _format_condition_list(results, success, depth)
+
+    if success:
+        return f"All conditions in {logical_operator.upper()} group were met: {'; '.join(condition_descriptions)}"
+
+    if condition_descriptions:
+        return f"Failed conditions in {logical_operator.upper()} group: {'; '.join(condition_descriptions)}"
+
+    return f"Group condition with {logical_operator.upper()} operator failed"
+
+
+def _format_leaf_condition_message(
+    evaluation_result: ConditionEvaluationResult, success: bool
+) -> str:
+    """Format a leaf condition evaluation result
+
+    Args:
+        evaluation_result: The leaf evaluation result to format
+        success: Whether the conditions were successful
+
+    Returns:
+        A string describing the evaluation result
+    """
+    condition_desc = _format_leaf_condition(evaluation_result)
+
+    if success:
+        return f"Condition '{condition_desc}' was met"
+
+    return f"Condition '{condition_desc}' was not met"

fides/api/task/conditional_dependencies/operators.py

@@ -1,7 +1,7 @@
 import numbers
 import operator as py_operator
 
-from fides.api.task.conditional_dependencies.schemas import Operator
+from fides.api.task.conditional_dependencies.schemas import GroupOperator, Operator
 
 # Define operator methods for validation
 #
@@ -17,7 +17,7 @@ from fides.api.task.conditional_dependencies.schemas import Operator
 #   * None in [] returns False
 #   * None not in [] returns True
 #   * This allows None to be a valid list element for membership testing
-operator_methods = {
+OPERATOR_METHODS = {
     # Basic operators - handle None naturally using Python's built-in behavior
     Operator.exists: lambda a, _: a is not None,
     Operator.not_exists: lambda a, _: a is None,
@@ -103,6 +103,12 @@ operator_methods = {
     ),
 }
 
+# Define logical operators for group conditions
+LOGICAL_OPERATORS = {
+    GroupOperator.and_: all,
+    GroupOperator.or_: any,
+}
+
 # Common operators that work with most data types
 COMMON_OPERATORS = {
     Operator.eq,

fides/api/task/conditional_dependencies/schemas.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import List, Optional, Union
+from typing import Any, List, Optional, Union
 
 from pydantic import BaseModel, Field, model_validator
 
@@ -100,6 +100,30 @@ class ConditionGroup(BaseModel):
         return self
 
 
+# Evaluation result for a single condition
+class ConditionEvaluationResult(BaseModel):
+    field_address: str
+    operator: Operator
+    expected_value: Optional[
+        Union[str, int, float, bool, List[Union[str, int, float, bool]]]
+    ]
+    actual_value: Any
+    result: bool
+    message: str
+
+
+# Evaluation result for a group of conditions
+class GroupEvaluationResult(BaseModel):
+    logical_operator: GroupOperator
+    condition_results: list["EvaluationResult"]
+    result: bool
+
+
+# Union type for evaluation results
+EvaluationResult = Union[ConditionEvaluationResult, GroupEvaluationResult]
+
+
 # Use model_rebuild to allow recursive nesting
 Condition = Union[ConditionLeaf, ConditionGroup]
 ConditionGroup.model_rebuild()
+GroupEvaluationResult.model_rebuild()

fides/api/task/graph_task.py

@@ -437,13 +437,20 @@ class GraphTask(ABC):  # pylint: disable=too-many-instance-attributes
         self.update_status("retrying", [], action_type, ExecutionLogStatus.retrying)
 
     def log_awaiting_processing(
-        self, action_type: ActionType, ex: Optional[BaseException]
+        self,
+        action_type: ActionType,
+        ex: Optional[BaseException],
+        extra_message: Optional[str] = None,
     ) -> None:
         """On paused activities"""
         logger.info("Pausing node {}", self.key)
 
+        message = str(ex)
+        if extra_message:
+            message = f"{message}. {extra_message}"
+
         self.update_status(
-            str(ex), [], action_type, ExecutionLogStatus.awaiting_processing
+            message, [], action_type, ExecutionLogStatus.awaiting_processing
         )
 
     def log_skipped(self, action_type: ActionType, ex: str) -> None:

fides/api/task/manual/manual_task_conditional_evaluation.py

@@ -0,0 +1,193 @@
+from typing import Any, Optional
+
+from pydantic.v1.utils import deep_update
+from sqlalchemy.orm import Session
+
+from fides.api.graph.config import CollectionAddress, FieldAddress
+from fides.api.models.manual_task import ManualTask
+from fides.api.models.manual_task.conditional_dependency import (
+    ManualTaskConditionalDependency,
+)
+from fides.api.task.conditional_dependencies.evaluator import ConditionEvaluator
+from fides.api.task.conditional_dependencies.schemas import EvaluationResult
+from fides.api.util.collection_util import Row
+
+
+def extract_conditional_dependency_data_from_inputs(
+    *inputs: list[Row], manual_task: ManualTask, input_keys: list[CollectionAddress]
+) -> dict[str, Any]:
+    """
+    Extract data for conditional dependency field addresses from input data.
+
+    This method processes data from upstream regular tasks that provide fields
+    referenced in manual task conditional dependencies. It extracts the relevant
+    field values and makes them available for conditional dependency evaluation.
+
+    Args:
+        *inputs: Input data from upstream nodes (regular tasks)
+        manual_task: Manual task to extract conditional dependencies from
+
+    Returns:
+        Dictionary mapping field addresses to their values from input data
+    """
+
+    conditional_data: dict[str, Any] = {}
+
+    # Get all conditional dependencies field addresses
+    field_addresses = [
+        dependency.field_address
+        for dependency in manual_task.conditional_dependencies
+        if dependency.field_address
+    ]
+
+    # if no field addresses, return empty conditional data
+    # This will allow the manual task to be executed if there are no conditional dependencies
+    if not field_addresses:
+        return conditional_data
+
+    # For manual tasks, we need to preserve the original field names from conditional dependencies
+    # Instead of using pre_process_input_data which consolidates fields, we'll extract directly
+    # from the raw input data based on the execution node's input_keys
+
+    # Create a mapping between collections and their input data
+    # Convert CollectionAddress objects to strings for consistent key types
+    collection_data_map = {
+        str(collection_key): input_data
+        for collection_key, input_data in zip(input_keys, inputs)
+    }
+
+    # Extract data for each conditional dependency field address
+    for field_address in field_addresses:
+        source_collection_key, field_path = parse_field_address(field_address)
+
+        # Find the input data for this collection
+        field_value = None
+        input_data = collection_data_map.get(source_collection_key)
+        if input_data:
+
+            # Look for the field in the input data
+            for row in input_data:
+
+                # Traverse the nested field path to get the actual value
+                field_value = extract_nested_field_value(row, field_path)
+
+                if field_value is not None:
+                    break
+            # Found the field value, break out of the inner loop (over rows)
+            # but continue with the outer loop to process this field
+
+        # Always include the field in conditional_data, even if value is None
+        # This allows conditional dependencies to evaluate existence, non-existence, and falsy values
+        nested_data = set_nested_value(field_address, field_value)
+        conditional_data = deep_update(conditional_data, nested_data)
+
+    return conditional_data
+
+
+def parse_field_address(field_address: str) -> tuple[str, list[str]]:
+    """
+    Parse a field address into dataset, collection, and field path.
+
+    For complex addresses with > 2 colons, uses manual string parsing.
+    For simple addresses with ≤ 2 colons, uses FieldAddress.from_string().
+    """
+    if field_address.count(":") > 2:
+        # Parse manually: dataset:collection:field:subfield -> dataset, collection, [field, subfield]
+        dataset, collection, *field_path = field_address.split(":")
+        source_collection_key = f"{dataset}:{collection}"
+    else:
+        # Use standard FieldAddress parsing for simple cases
+        field_address_obj = FieldAddress.from_string(field_address)
+        source_collection_key = str(field_address_obj.collection_address())
+        field_path = list(field_address_obj.field_path.levels)
+    return source_collection_key, field_path
+
+
+def extract_nested_field_value(data: Any, field_path: list[str]) -> Any:
+    """
+    Extract a nested field value by traversing the field path.
+
+    Args:
+        data: The data to extract from (usually a dict)
+        field_path: List of field names to traverse (e.g., ["profile", "preferences", "theme"])
+
+    Returns:
+        The value at the end of the field path, or None if not found
+    """
+    if not field_path:
+        return data
+
+    current = data
+    for field_name in field_path:
+        if isinstance(current, dict) and field_name in current:
+            current = current[field_name]
+        else:
+            return None
+
+    return current
+
+
+def set_nested_value(field_address: str, value: Any) -> dict[str, Any]:
+    """
+    Set a field value in the conditional data structure.
+
+    Args:
+        field_address: Colon-separated field address (e.g., "dataset:collection:field" or "dataset:collection:nested:field")
+        value: The value to set
+
+    Returns:
+        Dictionary with the field value set at the specified path
+    """
+    # For conditional dependencies, we want to set the field value directly
+    # The field_address format is "dataset:collection:field" or "dataset:collection:nested:field"
+    # We want to create: {dataset: {collection: {field: value}}} or {dataset: {collection: {nested: {field: value}}}}
+    parts = field_address.split(":")
+
+    if len(parts) >= 3:
+        dataset, collection = parts[0], parts[1]
+        # Handle nested field paths beyond the first 3 parts
+        if len(parts) == 3:
+            # Simple case: dataset:collection:field
+            field = parts[2]
+            return {dataset: {collection: {field: value}}}
+
+        # Nested case: dataset:collection:nested:field
+        # Build the nested structure from the remaining parts
+        nested_structure = value
+        for part in reversed(parts[2:]):
+            nested_structure = {part: nested_structure}
+        return {dataset: {collection: nested_structure}}
+
+    # Fallback for unexpected formats
+    return {field_address: value}
+
+
+def evaluate_conditional_dependencies(
+    db: Session, manual_task: ManualTask, conditional_data: dict[str, Any]
+) -> Optional[EvaluationResult]:
+    """
+    Evaluate conditional dependencies for a manual task using data from regular tasks.
+
+    This method evaluates whether a manual task should be executed based on its
+    conditional dependencies and the data received from upstream regular tasks.
+
+    Args:
+        manual_task: The manual task to evaluate
+        conditional_data: Data from regular tasks for conditional dependency fields
+
+    Returns:
+        EvaluationResult object containing detailed information about which conditions
+        were met or not met, or None if no conditional dependencies exist
+    """
+    # Get the root condition for this manual task
+    root_condition = ManualTaskConditionalDependency.get_root_condition(
+        db, manual_task.id
+    )
+
+    if not root_condition:
+        # No conditional dependencies - always execute
+        return None
+
+    # Evaluate the condition using the data from regular tasks
+    evaluator = ConditionEvaluator(db)
+    return evaluator.evaluate_rule(root_condition, conditional_data)