uipath-core 0.1.3__tar.gz → 0.1.5__tar.gz

{uipath_core-0.1.3 → uipath_core-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-core
-Version: 0.1.3
+Version: 0.1.5
 Summary: UiPath Core abstractions
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-core-python

{uipath_core-0.1.3 → uipath_core-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath-core"
-version = "0.1.3"
+version = "0.1.5"
 description = "UiPath Core abstractions"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"

uipath_core-0.1.5/src/uipath/core/guardrails/_deterministic_guardrails_service.py

@@ -0,0 +1,142 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+from ..tracing.decorators import traced
+from ._evaluators import (
+    evaluate_boolean_rule,
+    evaluate_number_rule,
+    evaluate_universal_rule,
+    evaluate_word_rule,
+)
+from .guardrails import (
+    AllFieldsSelector,
+    ApplyTo,
+    BooleanRule,
+    DeterministicGuardrail,
+    FieldSource,
+    GuardrailValidationResult,
+    NumberRule,
+    SpecificFieldsSelector,
+    UniversalRule,
+    WordRule,
+)
+
+
+class DeterministicGuardrailsService(BaseModel):
+    @traced("evaluate_pre_deterministic_guardrail", run_type="uipath")
+    def evaluate_pre_deterministic_guardrail(
+        self,
+        input_data: dict[str, Any],
+        guardrail: DeterministicGuardrail,
+    ) -> GuardrailValidationResult:
+        """Evaluate deterministic guardrail rules against input data (pre-execution)."""
+        # Check if guardrail contains any output-dependent rules
+        has_output_rule = self._has_output_dependent_rule(guardrail, [ApplyTo.OUTPUT])
+
+        # If guardrail has output-dependent rules, skip evaluation in pre-execution
+        # Output rules will be evaluated during post-execution
+        if has_output_rule:
+            return GuardrailValidationResult(
+                validation_passed=True,
+                reason="Guardrail contains output-dependent rules that will be evaluated during post-execution",
+            )
+        return self._evaluate_deterministic_guardrail(
+            input_data=input_data,
+            output_data={},
+            guardrail=guardrail,
+        )
+
+    @traced("evaluate_post_deterministic_guardrails", run_type="uipath")
+    def evaluate_post_deterministic_guardrail(
+        self,
+        input_data: dict[str, Any],
+        output_data: dict[str, Any],
+        guardrail: DeterministicGuardrail,
+    ) -> GuardrailValidationResult:
+        """Evaluate deterministic guardrail rules against input and output data."""
+        # Check if guardrail contains any output-dependent rules
+        has_output_rule = self._has_output_dependent_rule(
+            guardrail, [ApplyTo.OUTPUT, ApplyTo.INPUT_AND_OUTPUT]
+        )
+
+        # If guardrail has no output-dependent rules, skip post-execution evaluation
+        # Only input rules exist and they should have been evaluated during pre-execution
+        if not has_output_rule:
+            return GuardrailValidationResult(
+                validation_passed=True,
+                reason="Guardrail contains only input-dependent rules that were evaluated during pre-execution",
+            )
+
+        return self._evaluate_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+    @staticmethod
+    def _has_output_dependent_rule(
+        guardrail: DeterministicGuardrail,
+        universal_rules_apply_to_values: list[ApplyTo],
+    ) -> bool:
+        """Check if at least one rule EXCLUSIVELY requires output data.
+
+        Args:
+            guardrail: The guardrail to check
+            universal_rules_apply_to_values: List of ApplyTo values to consider as output-dependent for UniversalRules.
+
+        Returns:
+            True if at least one rule exclusively depends on output data, False otherwise.
+        """
+        for rule in guardrail.rules:
+            # UniversalRule: only return True if it applies to values in universal_rules_apply_to_values
+            if isinstance(rule, UniversalRule):
+                if rule.apply_to in universal_rules_apply_to_values:
+                    return True
+            # Rules with field_selector
+            elif isinstance(rule, (WordRule, NumberRule, BooleanRule)):
+                field_selector = rule.field_selector
+                # AllFieldsSelector applies to both input and output, not exclusively output
+                # SpecificFieldsSelector: only return True if at least one field has OUTPUT source
+                if isinstance(field_selector, SpecificFieldsSelector):
+                    if field_selector.fields and any(
+                        field.source == FieldSource.OUTPUT
+                        for field in field_selector.fields
+                    ):
+                        return True
+                elif isinstance(field_selector, AllFieldsSelector):
+                    if FieldSource.OUTPUT in field_selector.sources:
+                        return True
+
+        return False
+
+    @staticmethod
+    def _evaluate_deterministic_guardrail(
+        input_data: dict[str, Any],
+        output_data: dict[str, Any],
+        guardrail: DeterministicGuardrail,
+    ) -> GuardrailValidationResult:
+        """Evaluate deterministic guardrail rules against input and output data."""
+        for rule in guardrail.rules:
+            if isinstance(rule, WordRule):
+                passed, reason = evaluate_word_rule(rule, input_data, output_data)
+            elif isinstance(rule, NumberRule):
+                passed, reason = evaluate_number_rule(rule, input_data, output_data)
+            elif isinstance(rule, BooleanRule):
+                passed, reason = evaluate_boolean_rule(rule, input_data, output_data)
+            elif isinstance(rule, UniversalRule):
+                passed, reason = evaluate_universal_rule(rule, output_data)
+            else:
+                return GuardrailValidationResult(
+                    validation_passed=False,
+                    reason=f"Unknown rule type: {type(rule)}",
+                )
+
+            if not passed:
+                return GuardrailValidationResult(
+                    validation_passed=False, reason=reason or "Rule validation failed"
+                )
+
+        return GuardrailValidationResult(
+            validation_passed=True, reason="All deterministic guardrail rules passed"
+        )

{uipath_core-0.1.3 → uipath_core-0.1.5}/src/uipath/core/guardrails/_evaluators.py

@@ -4,8 +4,9 @@ This module provides functions for evaluating different types of guardrail rules
 against input and output data.
 """
 
+import inspect
 from enum import IntEnum
-from typing import Any
+from typing import Any, Callable
 
 from .guardrails import (
     AllFieldsSelector,
@@ -119,23 +120,25 @@ def get_fields_from_selector(
     fields: list[tuple[Any, FieldReference]] = []
 
     if isinstance(field_selector, AllFieldsSelector):
-        # For "all" selector, we need to collect all fields from both input and output
+        # For "all" selector, we need to collect all fields from the specified sources
         # This is a simplified implementation - in practice, you might want to
         # recursively collect all nested fields
-        for key, value in input_data.items():
-            fields.append(
-                (
-                    value,
-                    FieldReference(path=key, source=FieldSource.INPUT),
+        if FieldSource.INPUT in field_selector.sources:
+            for key, value in input_data.items():
+                fields.append(
+                    (
+                        value,
+                        FieldReference(path=key, source=FieldSource.INPUT),
+                    )
                 )
-            )
-        for key, value in output_data.items():
-            fields.append(
-                (
-                    value,
-                    FieldReference(path=key, source=FieldSource.OUTPUT),
+        if FieldSource.OUTPUT in field_selector.sources:
+            for key, value in output_data.items():
+                fields.append(
+                    (
+                        value,
+                        FieldReference(path=key, source=FieldSource.OUTPUT),
+                    )
                 )
-            )
     elif isinstance(field_selector, SpecificFieldsSelector):
         # For specific fields, extract values based on field references
         for field_ref in field_selector.fields:
@@ -163,7 +166,7 @@ def format_guardrail_error_message(
 ) -> str:
     """Format a guardrail error message following the standard pattern."""
     source = "Input" if field_ref.source == FieldSource.INPUT else "Output"
-    message = f"{source} data didn't match the guardrail condition: [{field_ref.path}] {operator}"
+    message = f"{source} data didn't match the guardrail condition: [{field_ref.path}] comparing function [{operator}]"
     if expected_value and expected_value.strip():
         message += f" [{expected_value.strip()}]"
     return message
@@ -187,16 +190,18 @@ def evaluate_word_rule(
         field_str = field_value
 
         # Use the custom function to evaluate the rule
+        # If detects_violation returns True, it means the rule was violated (validation fails)
         try:
-            passed = rule.func(field_str)
+            violation_detected = rule.detects_violation(field_str)
         except Exception:
             # If function raises an exception, treat as failure
-            passed = False
+            violation_detected = True
 
-        if not passed:
-            reason = format_guardrail_error_message(
-                field_ref, "comparing function", None
+        if violation_detected:
+            operator = (
+                _humanize_guardrail_func(rule.detects_violation) or "violation check"
             )
+            reason = format_guardrail_error_message(field_ref, operator, None)
             return False, reason
 
     return True, "All word rule validations passed"
@@ -221,16 +226,18 @@ def evaluate_number_rule(
         field_num = float(field_value)
 
         # Use the custom function to evaluate the rule
+        # If detects_violation returns True, it means the rule was violated (validation fails)
         try:
-            passed = rule.func(field_num)
+            violation_detected = rule.detects_violation(field_num)
         except Exception:
             # If function raises an exception, treat as failure
-            passed = False
+            violation_detected = True
 
-        if not passed:
-            reason = format_guardrail_error_message(
-                field_ref, "comparing function", None
+        if violation_detected:
+            operator = (
+                _humanize_guardrail_func(rule.detects_violation) or "violation check"
             )
+            reason = format_guardrail_error_message(field_ref, operator, None)
             return False, reason
 
     return True, "All number rule validations passed"
@@ -256,16 +263,18 @@ def evaluate_boolean_rule(
         field_bool = field_value
 
         # Use the custom function to evaluate the rule
+        # If detects_violation returns True, it means the rule was violated (validation fails)
         try:
-            passed = rule.func(field_bool)
+            violation_detected = rule.detects_violation(field_bool)
         except Exception:
             # If function raises an exception, treat as failure
-            passed = False
+            violation_detected = True
 
-        if not passed:
-            reason = format_guardrail_error_message(
-                field_ref, "comparing function", None
+        if violation_detected:
+            operator = (
+                _humanize_guardrail_func(rule.detects_violation) or "violation check"
             )
+            reason = format_guardrail_error_message(field_ref, operator, None)
             return False, reason
 
     return True, "All boolean rule validations passed"
@@ -307,3 +316,72 @@ def evaluate_universal_rule(
         return False, "Universal rule validation triggered (input and output)"
     else:
         return False, f"Unknown apply_to value: {rule.apply_to}"
+
+
+def _humanize_guardrail_func(func: Callable[..., Any] | str | None) -> str | None:
+    """Build a user-friendly description of a guardrail predicate.
+
+    Deterministic guardrails store Python callables (often lambdas) to evaluate
+    conditions. For diagnostics, it's useful to include a readable hint about the
+    predicate that failed.
+
+    Args:
+        func: A Python callable used as a predicate, or a pre-rendered string
+            description (for example, ``"s:str -> bool: contains 'test'"``).
+
+    Returns:
+        A human-readable description, or ``None`` if one cannot be produced.
+    """
+    if func is None:
+        return None
+
+    if isinstance(func, str):
+        rendered = func.strip()
+        return rendered or None
+
+    name = getattr(func, "__name__", None)
+    if name and name != "<lambda>":
+        return name
+
+    # Best-effort extraction for lambdas / callables.
+    try:
+        sig = str(inspect.signature(func))
+    except (TypeError, ValueError):
+        sig = ""
+
+    try:
+        source_lines = inspect.getsourcelines(func)
+        source = "".join(source_lines[0]).strip()
+        # Collapse whitespace to keep the message compact.
+        source = " ".join(source.split())
+
+        # Remove "detects_violation=lambda" prefix if present
+        # Pattern: "detects_violation=lambda s: condition" -> "condition"
+        if "detects_violation=lambda" in source:
+            # Find the lambda part
+            lambda_start = source.find("detects_violation=lambda")
+            if lambda_start != -1:
+                # Get everything after "detects_violation=lambda"
+                lambda_part = source[
+                    lambda_start + len("detects_violation=lambda") :
+                ].strip()
+                # Find the colon that separates param from body
+                colon_idx = lambda_part.find(":")
+                if colon_idx != -1:
+                    # Extract just the body (condition)
+                    body = lambda_part[colon_idx + 1 :].strip()
+                    # Remove trailing comma if present
+                    body = body.rstrip(",").strip()
+                    source = body
+    except (OSError, TypeError):
+        source = ""
+
+    if source and sig:
+        return f"{sig}: {source}"
+    if source:
+        return source
+    if sig:
+        return sig
+
+    rendered = repr(func).strip()
+    return rendered or None

{uipath_core-0.1.3 → uipath_core-0.1.5}/src/uipath/core/guardrails/guardrails.py

@@ -59,6 +59,7 @@ class AllFieldsSelector(BaseModel):
     """All fields selector."""
 
     selector_type: Literal["all"] = Field(alias="$selectorType")
+    sources: list[FieldSource]
 
     model_config = ConfigDict(populate_by_name=True, extra="allow")
 
@@ -92,7 +93,10 @@ class WordRule(BaseModel):
 
     rule_type: Literal["word"] = Field(alias="$ruleType")
     field_selector: FieldSelector = Field(alias="fieldSelector")
-    func: Callable[[str], bool] = Field(exclude=True)
+    detects_violation: Callable[[str], bool] = Field(
+        exclude=True,
+        description="Function that returns True if the string violates the rule (validation should fail).",
+    )
 
     model_config = ConfigDict(populate_by_name=True, extra="allow")
 
@@ -111,7 +115,10 @@ class NumberRule(BaseModel):
 
     rule_type: Literal["number"] = Field(alias="$ruleType")
     field_selector: FieldSelector = Field(alias="fieldSelector")
-    func: Callable[[float], bool] = Field(exclude=True)
+    detects_violation: Callable[[float], bool] = Field(
+        exclude=True,
+        description="Function that returns True if the number violates the rule (validation should fail).",
+    )
 
     model_config = ConfigDict(populate_by_name=True, extra="allow")
 
@@ -121,7 +128,10 @@ class BooleanRule(BaseModel):
 
     rule_type: Literal["boolean"] = Field(alias="$ruleType")
     field_selector: FieldSelector = Field(alias="fieldSelector")
-    func: Callable[[bool], bool] = Field(exclude=True)
+    detects_violation: Callable[[bool], bool] = Field(
+        exclude=True,
+        description="Function that returns True if the boolean violates the rule (validation should fail).",
+    )
 
     model_config = ConfigDict(populate_by_name=True, extra="allow")
 
@@ -164,7 +174,7 @@ class BaseGuardrail(BaseModel):
 class DeterministicGuardrail(BaseGuardrail):
     """Deterministic guardrail model."""
 
-    guardrail_type: Literal["custom"] = Field(alias="custom")
+    guardrail_type: Literal["custom"] = Field(alias="$guardrailType")
     rules: list[Rule]
 
     model_config = ConfigDict(populate_by_name=True, extra="allow")