Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Fix rendered expression display for dotted Jinja variables (#SKY-7937) (#4684)
Celal Zamanoglu76411b602265
diff --git a/skyvern/forge/sdk/workflow/models/block.py b/skyvern/forge/sdk/workflow/models/block.pyindex 0d5084e1f..85b619b4f 100644--- a/skyvern/forge/sdk/workflow/models/block.py+++ b/skyvern/forge/sdk/workflow/models/block.py@@ -4957,6 +4957,59 @@ def _is_pure_jinja_expression(expression: str) -> bool:return True+def _resolve_nested_path(value: Any, path: str) -> Any:+ """+ Resolve a dotted/bracket access path on a nested value.++ Examples:+ _resolve_nested_path({"a": {"b": 1}}, ".a.b") -> 1+ _resolve_nested_path([{"x": 2}], "[0].x") -> 2++ Args:+ value: The root value to traverse+ path: The access path (e.g., ".field1.field2[0].field3")++ Returns:+ The resolved leaf value++ Raises:+ LookupError: If the path cannot be resolved+ """+ segments = re.findall(r"\.([a-zA-Z_]\w*)|\[(\d+)\]", path)+ current = value+ for dot_key, bracket_idx in segments:+ if dot_key:+ if isinstance(current, dict):+ if dot_key not in current:+ raise LookupError(f"Key {dot_key!r} not found")+ current = current[dot_key]+ else:+ raise LookupError(f"Cannot access .{dot_key} on {type(current).__name__}")+ elif bracket_idx:+ idx = int(bracket_idx)+ if isinstance(current, (list, tuple)):+ if idx >= len(current):+ raise LookupError(f"Index [{idx}] out of range")+ current = current[idx]+ else:+ raise LookupError(f"Cannot index [{idx}] on {type(current).__name__}")+ return current+++_JINJA_DISPLAY_FILTERS: dict[str, Callable[[Any], Any]] = {+ "lower": lambda v: str(v).lower(),+ "upper": lambda v: str(v).upper(),+ "trim": lambda v: str(v).strip(),+ "title": lambda v: str(v).title(),+ "capitalize": lambda v: str(v).capitalize(),+ "int": lambda v: int(v),+ "float": lambda v: float(v),+ "string": lambda v: str(v),+ "length": lambda v: len(v),+ "abs": lambda v: abs(v),+}++def _render_jinja_expression_for_display(expression: str,context_values: dict[str, Any],@@ -4969,6 +5022,13 @@ def _render_jinja_expression_for_display(without actually evaluating the expression. For example:- Input: "{{ base_date == date_1 }}" with context {"base_date": "01-25-2026", "date_1": "01-25-2026"}- Output: '"01-25-2026" == "01-25-2026"'+ - Input: "{{ output.extracted_information.field != None }}" with nested dict context+ - Output: '"some_value" != None'+ - Input: "{{ output.status|lower == 'active' }}" with context {"output": {"status": "Active"}}+ - Output: '"active" == \'active\''++ Known Jinja filters (lower, upper, trim, etc.) are applied to the resolved value.+ Unknown filters are left as-is in the output.Returns the original expression if it's not a pure Jinja expression or if rendering fails."""@@ -4980,15 +5040,48 @@ def _render_jinja_expression_for_display(inner_expr = expression.strip()[2:-2].strip()display_expr = inner_expr- # Substitute variable names with their values using word boundary regex- # This ensures we only match whole variable names, not substrings- # e.g., "date" won't match inside "validate_date" or "date_1"+ # Substitute variable references (including dotted/bracket access paths and filters)+ # with their values.+ # Match var_name optionally followed by .field or [index] segments,+ # then optionally followed by a |filter_name.+ # Sort by key length (longest first) to avoid partial matches.for var_name in sorted(context_values.keys(), key=len, reverse=True):- pattern = r"\b" + re.escape(var_name) + r"\b"- var_value = context_values[var_name]- # Quote string values for clarity- replacement = f'"{var_value}"' if isinstance(var_value, str) else str(var_value)- display_expr = re.sub(pattern, replacement, display_expr)+ pattern = r"\b" + re.escape(var_name) + r"((?:\.[a-zA-Z_]\w*|\[\d+\])*)(\|[a-zA-Z_]\w*)?"++ def _replacer(match: re.Match, _var_name: str = var_name) -> str:+ access_path = match.group(1) # the dotted/bracket part after var_name+ filter_expr = match.group(2) # e.g., "|lower" or None+ var_value = context_values[_var_name]++ if access_path:+ try:+ var_value = _resolve_nested_path(var_value, access_path)+ except LookupError:+ # Path couldn't be resolved — return original text unchanged+ return match.group(0)++ if filter_expr:+ filter_name = filter_expr[1:] # strip the leading |+ filter_fn = _JINJA_DISPLAY_FILTERS.get(filter_name)+ if filter_fn is not None:+ try:+ var_value = filter_fn(var_value)+ except Exception:+ # Filter application failed — show value with filter text+ if isinstance(var_value, str):+ return f'"{var_value}"{filter_expr}'+ return f"{var_value}{filter_expr}"+ else:+ # Unknown filter — show value with filter text preserved+ if isinstance(var_value, str):+ return f'"{var_value}"{filter_expr}'+ return f"{var_value}{filter_expr}"++ if isinstance(var_value, str):+ return f'"{var_value}"'+ return str(var_value)++ display_expr = re.sub(pattern, _replacer, display_expr)return display_exprexcept Exception as exc: