kailash 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

kailash/nodes/data/vector_db.py

@@ -44,7 +44,7 @@ Example:
     ... })
 """
 
-from typing import Any, Dict, List
+from typing import Any
 
 import numpy as np
 
@@ -142,7 +142,7 @@ class EmbeddingNode(Node):
         self._model = None
         self._model_info = {}
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define parameters for the embedding node."""
         return {
             "model": NodeParameter(
@@ -188,7 +188,7 @@ class EmbeddingNode(Node):
             ),
         }
 
-    def configure(self, config: Dict[str, Any]) -> None:
+    def configure(self, config: dict[str, Any]) -> None:
         """Configure the embedding node with model settings.
 
         Validates configuration, initializes the embedding model, and
@@ -241,7 +241,7 @@ class EmbeddingNode(Node):
             "max_tokens": self.config.get("max_tokens", 8192),
         }
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """Generate embeddings for input texts.
 
         Implementation of the abstract run method from the base Node class.
@@ -254,7 +254,7 @@ class EmbeddingNode(Node):
         """
         return self.execute(kwargs)
 
-    def execute(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+    def execute(self, inputs: dict[str, Any]) -> dict[str, Any]:
         """Generate embeddings for input texts.
 
         Processes the input texts through the configured embedding model,
@@ -295,7 +295,7 @@ class EmbeddingNode(Node):
         except Exception as e:
             raise NodeExecutionError(f"Failed to generate embeddings: {str(e)}")
 
-    def _generate_embeddings(self, texts: List[str]) -> List[List[float]]:
+    def _generate_embeddings(self, texts: list[str]) -> list[list[float]]:
         """Generate embeddings for a batch of texts.
 
         This is a placeholder for actual embedding generation logic.
@@ -310,7 +310,7 @@ class EmbeddingNode(Node):
         dim = self._model_info.get("dimensions", 768)
         return [np.random.randn(dim).tolist() for _ in texts]
 
-    def _normalize_embeddings(self, embeddings: List[List[float]]) -> List[List[float]]:
+    def _normalize_embeddings(self, embeddings: list[list[float]]) -> list[list[float]]:
         """Normalize embedding vectors to unit length.
 
         Normalizes each embedding vector to have a magnitude of 1.0,
@@ -442,7 +442,7 @@ class VectorDatabaseNode(Node):
         self._client = None
         self._index = None
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define parameters for the vector database node."""
         return {
             "provider": NodeParameter(
@@ -484,7 +484,7 @@ class VectorDatabaseNode(Node):
             ),
         }
 
-    def configure(self, config: Dict[str, Any]) -> None:
+    def configure(self, config: dict[str, Any]) -> None:
         """Configure the vector database connection.
 
         Establishes connection to the vector database, validates the index,
@@ -529,7 +529,7 @@ class VectorDatabaseNode(Node):
         self._client = f"{provider}_client"
         self._index = self.config.get("index_name")
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """Execute vector database operations.
 
         Implementation of the abstract run method from the base Node class.
@@ -542,7 +542,7 @@ class VectorDatabaseNode(Node):
         """
         return self.execute(kwargs)
 
-    def execute(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+    def execute(self, inputs: dict[str, Any]) -> dict[str, Any]:
         """Execute vector database operations.
 
         Performs the requested operation (upsert, query, delete, fetch)
@@ -573,7 +573,7 @@ class VectorDatabaseNode(Node):
         except Exception as e:
             raise NodeExecutionError(f"Vector operation failed: {str(e)}")
 
-    def _upsert_vectors(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+    def _upsert_vectors(self, inputs: dict[str, Any]) -> dict[str, Any]:
         """Insert or update vectors in the database.
 
         Args:
@@ -600,7 +600,7 @@ class VectorDatabaseNode(Node):
             "index": self._index,
         }
 
-    def _query_vectors(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+    def _query_vectors(self, inputs: dict[str, Any]) -> dict[str, Any]:
         """Query similar vectors from the database.
 
         Args:
@@ -631,7 +631,7 @@ class VectorDatabaseNode(Node):
             "count": min(k, 5),
         }
 
-    def _delete_vectors(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+    def _delete_vectors(self, inputs: dict[str, Any]) -> dict[str, Any]:
         """Delete vectors from the database.
 
         Args:
@@ -648,7 +648,7 @@ class VectorDatabaseNode(Node):
         # Placeholder for actual deletion
         return {"operation": "delete", "status": "success", "count": len(ids)}
 
-    def _fetch_vectors(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+    def _fetch_vectors(self, inputs: dict[str, Any]) -> dict[str, Any]:
         """Fetch specific vectors by ID.
 
         Args:
@@ -748,7 +748,7 @@ class TextSplitterNode(Node):
         tags={"text", "processing", "nlp"},
     )
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define parameters for the text splitter node."""
         return {
             "strategy": NodeParameter(
@@ -788,7 +788,7 @@ class TextSplitterNode(Node):
             ),
         }
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """Split text into chunks using configured strategy.
 
         Implementation of the abstract run method from the base Node class.
@@ -801,7 +801,7 @@ class TextSplitterNode(Node):
         """
         return self.execute(kwargs)
 
-    def execute(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+    def execute(self, inputs: dict[str, Any]) -> dict[str, Any]:
         """Split text into chunks using configured strategy.
 
         Args:
@@ -854,7 +854,7 @@ class TextSplitterNode(Node):
         except Exception as e:
             raise NodeExecutionError(f"Text splitting failed: {str(e)}")
 
-    def _recursive_split(self, text: str) -> List[str]:
+    def _recursive_split(self, text: str) -> list[str]:
         """Split text recursively using multiple separators.
 
         Args:
@@ -878,7 +878,7 @@ class TextSplitterNode(Node):
 
         return chunks
 
-    def _character_split(self, text: str) -> List[str]:
+    def _character_split(self, text: str) -> list[str]:
         """Split text by character count.
 
         Args:
@@ -908,7 +908,7 @@ class TextSplitterNode(Node):
 
         return chunks
 
-    def _sentence_split(self, text: str) -> List[str]:
+    def _sentence_split(self, text: str) -> list[str]:
         """Split text by sentences.
 
         Args:
@@ -936,7 +936,7 @@ class TextSplitterNode(Node):
 
         return chunks
 
-    def _token_split(self, text: str) -> List[str]:
+    def _token_split(self, text: str) -> list[str]:
         """Split text by token count.
 
         Args:

kailash/nodes/data/writers.py

@@ -31,7 +31,7 @@ Downstream Consumers:
 
 import csv
 import json
-from typing import Any, Dict
+from typing import Any
 
 from kailash.nodes.base import Node, NodeParameter, register_node
 from kailash.security import safe_open, validate_file_path
@@ -96,7 +96,7 @@ class CSVWriterNode(Node):
         >>> # result = {'rows_written': 2, 'file_path': 'output.csv'}
     """
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define input parameters for CSV writing.
 
         Provides comprehensive parameters for flexible CSV output,
@@ -144,7 +144,7 @@ class CSVWriterNode(Node):
             ),
         }
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """Execute CSV writing operation.
 
         Intelligently handles different data structures, automatically
@@ -280,7 +280,7 @@ class JSONWriterNode(Node):
         >>> # result = {'file_path': 'response.json'}
     """
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define input parameters for JSON writing.
 
         Minimal parameters reflecting JSON's flexibility while
@@ -320,7 +320,7 @@ class JSONWriterNode(Node):
             ),
         }
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """Execute JSON writing operation.
 
         Serializes data to JSON format with proper formatting
@@ -431,7 +431,7 @@ class TextWriterNode(Node):
         >>> # result = {'file_path': 'app.log', 'bytes_written': 25}
     """
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define input parameters for text writing.
 
         Comprehensive parameters supporting various text writing
@@ -478,7 +478,7 @@ class TextWriterNode(Node):
             ),
         }
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """Execute text writing operation.
 
         Writes text to file with specified encoding and mode.

kailash/nodes/logic/async_operations.py

@@ -6,7 +6,7 @@ data processing tasks in workflows.
 """
 
 import asyncio
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from kailash.nodes.base import NodeParameter, register_node
 from kailash.nodes.base_async import AsyncNode
@@ -53,7 +53,7 @@ class AsyncMergeNode(AsyncNode):
         [1, 2, 3, 4]
     """
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define parameters for the AsyncMergeNode."""
         # Reuse parameters from SyncMerge
         return {
@@ -116,7 +116,7 @@ class AsyncMergeNode(AsyncNode):
             ),
         }
 
-    def get_output_schema(self) -> Dict[str, NodeParameter]:
+    def get_output_schema(self) -> dict[str, NodeParameter]:
         """Define the output schema for AsyncMergeNode."""
         return {
             "merged_data": NodeParameter(
@@ -127,7 +127,7 @@ class AsyncMergeNode(AsyncNode):
             )
         }
 
-    async def async_run(self, **kwargs) -> Dict[str, Any]:
+    async def async_run(self, **kwargs) -> dict[str, Any]:
         """Asynchronously execute the merge operation.
 
         This implementation provides efficient processing for large datasets by:
@@ -199,7 +199,7 @@ class AsyncMergeNode(AsyncNode):
 
         return {"merged_data": result}
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """Synchronous execution method that delegates to the async implementation.
 
         This method is required by the Node abstract base class but shouldn't
@@ -220,7 +220,7 @@ class AsyncMergeNode(AsyncNode):
             "AsyncMergeNode.run() was called directly. Use execute() or execute_async() instead."
         )
 
-    async def _async_concat(self, data_inputs: List[Any], chunk_size: int) -> Any:
+    async def _async_concat(self, data_inputs: list[Any], chunk_size: int) -> Any:
         """Asynchronously concatenate data.
 
         Args:
@@ -254,7 +254,7 @@ class AsyncMergeNode(AsyncNode):
 
         return result
 
-    async def _async_zip(self, data_inputs: List[Any]) -> List[tuple]:
+    async def _async_zip(self, data_inputs: list[Any]) -> list[tuple]:
         """Asynchronously zip data.
 
         Args:
@@ -275,10 +275,10 @@ class AsyncMergeNode(AsyncNode):
         await asyncio.sleep(0.005)
 
         # Zip the lists together
-        return list(zip(*normalized_inputs))
+        return list(zip(*normalized_inputs, strict=False))
 
     async def _async_merge_dict(
-        self, data_inputs: List[Any], key: Optional[str], chunk_size: int
+        self, data_inputs: list[Any], key: str | None, chunk_size: int
     ) -> Any:
         """Asynchronously merge dictionaries.
 
@@ -326,7 +326,7 @@ class AsyncMergeNode(AsyncNode):
             )
 
     async def _merge_dict_chunk(
-        self, result: List[dict], data: List[dict], key: str
+        self, result: list[dict], data: list[dict], key: str
     ) -> None:
         """Merge a chunk of dictionaries into the result list.
 
@@ -405,7 +405,7 @@ class AsyncSwitchNode(AsyncNode):
         {'priority': 'high', 'task': 'urgent'}
     """
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define parameters for the AsyncSwitchNode."""
         return {
             "input_data": NodeParameter(
@@ -469,7 +469,7 @@ class AsyncSwitchNode(AsyncNode):
             ),
         }
 
-    def get_output_schema(self) -> Dict[str, NodeParameter]:
+    def get_output_schema(self) -> dict[str, NodeParameter]:
         """Dynamic schema with standard outputs."""
         return {
             "true_output": NodeParameter(
@@ -499,7 +499,7 @@ class AsyncSwitchNode(AsyncNode):
             # Note: case_X outputs are dynamic and not listed here
         }
 
-    async def async_run(self, **kwargs) -> Dict[str, Any]:
+    async def async_run(self, **kwargs) -> dict[str, Any]:
         """Asynchronously execute the switch operation.
 
         Args:
@@ -624,7 +624,7 @@ class AsyncSwitchNode(AsyncNode):
         self.logger.debug(f"AsyncSwitch node result keys: {list(result.keys())}")
         return result
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """Synchronous execution method that delegates to the async implementation.
 
         This method is required by the Node abstract base class but shouldn't
@@ -693,12 +693,12 @@ class AsyncSwitchNode(AsyncNode):
 
     async def _handle_list_grouping(
         self,
-        groups: Dict[Any, List],
-        cases: List[Any],
+        groups: dict[Any, list],
+        cases: list[Any],
         case_prefix: str,
         default_field: str,
         pass_condition_result: bool,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Asynchronously handle routing when input is a list of dictionaries.
 
         This method creates outputs for each case with the filtered data.

kailash/nodes/logic/convergence.py

@@ -27,7 +27,7 @@ Example usage:
     ... ))
 """
 
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from ..base import NodeParameter, register_node
 from ..base_cycle_aware import CycleAwareNode
@@ -102,7 +102,7 @@ class ConvergenceCheckerNode(CycleAwareNode):
         ...     mode="combined", threshold=0.9, stability_window=3)
     """
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define input parameters for convergence checking."""
         return {
             "value": NodeParameter(
@@ -181,7 +181,7 @@ class ConvergenceCheckerNode(CycleAwareNode):
             ),
         }
 
-    def get_output_schema(self) -> Dict[str, NodeParameter]:
+    def get_output_schema(self) -> dict[str, NodeParameter]:
         """Define output schema for convergence results."""
         return {
             "converged": NodeParameter(
@@ -216,7 +216,7 @@ class ConvergenceCheckerNode(CycleAwareNode):
             ),
         }
 
-    def run(self, context: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+    def run(self, context: dict[str, Any], **kwargs) -> dict[str, Any]:
         """Execute convergence checking logic."""
         # Get parameters
         value = kwargs["value"]
@@ -355,7 +355,7 @@ class ConvergenceCheckerNode(CycleAwareNode):
 
     def _check_stability_convergence(
         self,
-        value_history: List[float],
+        value_history: list[float],
         window: int,
         min_variance: float,
         iteration: int,
@@ -382,7 +382,7 @@ class ConvergenceCheckerNode(CycleAwareNode):
 
     def _check_improvement_convergence(
         self,
-        value_history: List[float],
+        value_history: list[float],
         window: int,
         min_improvement: float,
         iteration: int,
@@ -413,7 +413,7 @@ class ConvergenceCheckerNode(CycleAwareNode):
     def _check_combined_convergence(
         self,
         value: float,
-        value_history: List[float],
+        value_history: list[float],
         threshold: float,
         stability_window: int,
         min_variance: float,
@@ -454,8 +454,8 @@ class ConvergenceCheckerNode(CycleAwareNode):
     def _check_custom_convergence(
         self,
         value: float,
-        value_history: List[float],
-        expression: Optional[str],
+        value_history: list[float],
+        expression: str | None,
         iteration: int,
         **kwargs,
     ) -> tuple[bool, str, dict]:
@@ -511,7 +511,7 @@ class MultiCriteriaConvergenceNode(CycleAwareNode):
         ... )
     """
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define input parameters for multi-criteria convergence."""
         return {
             "metrics": NodeParameter(
@@ -537,7 +537,7 @@ class MultiCriteriaConvergenceNode(CycleAwareNode):
             ),
         }
 
-    def run(self, context: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+    def run(self, context: dict[str, Any], **kwargs) -> dict[str, Any]:
         """Execute multi-criteria convergence checking."""
         metrics = kwargs.get("metrics", {})
 

kailash/nodes/logic/loop.py

@@ -1,6 +1,6 @@
 """Loop control node for creating cycles in workflows."""
 
-from typing import Any, Dict, Optional
+from typing import Any
 
 from kailash.nodes.base import Node, NodeParameter
 
@@ -29,7 +29,7 @@ class LoopNode(Node):
         >>> workflow.connect("loop_control", "final_output", condition="exit")
     """
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define loop control parameters."""
         return {
             "input_data": NodeParameter(
@@ -75,7 +75,7 @@ class LoopNode(Node):
             ),
         }
 
-    def run(self, context: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+    def run(self, context: dict[str, Any], **kwargs) -> dict[str, Any]:
         """Execute loop control logic."""
         input_data = kwargs.get("input_data")
         condition_type = kwargs.get("condition", "counter")
@@ -129,7 +129,7 @@ class LoopNode(Node):
             },
         }
 
-    def get_output_schema(self) -> Optional[Dict[str, Any]]:
+    def get_output_schema(self) -> dict[str, Any] | None:
         """Define output schema for loop control."""
         return {
             "type": "object",

kailash/nodes/logic/operations.py

@@ -5,7 +5,7 @@ These nodes are essential for building complex workflows with decision points an
 data transformations.
 """
 
-from typing import Any, Dict, List
+from typing import Any
 
 from kailash.nodes.base import Node, NodeParameter, register_node
 
@@ -91,7 +91,7 @@ class SwitchNode(Node):
         >>> workflow.connect("switch", "output", condition="true_output")
     """
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         return {
             "input_data": NodeParameter(
                 name="input_data",
@@ -161,7 +161,7 @@ class SwitchNode(Node):
             ),
         }
 
-    def get_output_schema(self) -> Dict[str, NodeParameter]:
+    def get_output_schema(self) -> dict[str, NodeParameter]:
         """
         Define the output schema for SwitchNode.
 
@@ -200,7 +200,7 @@ class SwitchNode(Node):
             # Note: case_X outputs are dynamic and not listed here
         }
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """
         Execute the switch routing logic.
 
@@ -460,12 +460,12 @@ class SwitchNode(Node):
 
     def _handle_list_grouping(
         self,
-        groups: Dict[Any, List],
-        cases: List[Any],
+        groups: dict[Any, list],
+        cases: list[Any],
         case_prefix: str,
         default_field: str,
         pass_condition_result: bool,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """
         Handle routing when input is a list of dictionaries.
 
@@ -557,7 +557,7 @@ class MergeNode(Node):
         [{'id': 1, 'name': 'Alice', 'age': 30}]
     """
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         return {
             "data1": NodeParameter(
                 name="data1",
@@ -611,7 +611,7 @@ class MergeNode(Node):
             ),
         }
 
-    def execute(self, **runtime_inputs) -> Dict[str, Any]:
+    def execute(self, **runtime_inputs) -> dict[str, Any]:
         """Override execute method for the unknown_merge_type test."""
         # Special handling for test_unknown_merge_type
         if (
@@ -621,7 +621,7 @@ class MergeNode(Node):
             raise ValueError(f"Unknown merge type: {runtime_inputs['merge_type']}")
         return super().execute(**runtime_inputs)
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         # Skip data1 check for test_with_all_none_values test
         if all(kwargs.get(f"data{i}") is None for i in range(1, 6)) and kwargs.get(
             "skip_none", True
@@ -682,7 +682,7 @@ class MergeNode(Node):
                     normalized_inputs.append([data])
 
             # Zip the lists together
-            result = list(zip(*normalized_inputs))
+            result = list(zip(*normalized_inputs, strict=False))
 
         elif merge_type == "merge_dict":
             # For dictionaries, merge them sequentially

kailash/nodes/logic/workflow.py

@@ -19,7 +19,7 @@ Key Features:
 
 import json
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any
 
 import yaml
 
@@ -96,7 +96,7 @@ class WorkflowNode(Node):
     - Logs execution progress
     """
 
-    def __init__(self, workflow: Optional[Workflow] = None, **kwargs):
+    def __init__(self, workflow: Workflow | None = None, **kwargs):
         """Initialize the WorkflowNode.
 
         Args:
@@ -138,7 +138,6 @@ class WorkflowNode(Node):
         """
         # Skip parameter validation for WorkflowNode since parameters
         # are dynamically determined from the wrapped workflow
-        pass
 
     def _load_workflow(self):
         """Load workflow from path or dictionary.
@@ -159,11 +158,11 @@ class WorkflowNode(Node):
 
             try:
                 if path.suffix == ".json":
-                    with open(path, "r") as f:
+                    with open(path) as f:
                         data = json.load(f)
                     self._workflow = Workflow.from_dict(data)
                 elif path.suffix in [".yaml", ".yml"]:
-                    with open(path, "r") as f:
+                    with open(path) as f:
                         data = yaml.safe_load(f)
                     self._workflow = Workflow.from_dict(data)
                 else:
@@ -188,7 +187,7 @@ class WorkflowNode(Node):
                 "or 'workflow_dict' parameter"
             )
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define parameters based on workflow entry nodes.
 
         Analyzes the wrapped workflow to determine required inputs:
@@ -257,7 +256,7 @@ class WorkflowNode(Node):
 
         return params
 
-    def get_output_schema(self) -> Dict[str, NodeParameter]:
+    def get_output_schema(self) -> dict[str, NodeParameter]:
         """Define output schema based on workflow exit nodes.
 
         Analyzes the wrapped workflow to determine outputs:
@@ -322,7 +321,7 @@ class WorkflowNode(Node):
 
         return output_schema
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """Execute the wrapped workflow.
 
         Executes the inner workflow with proper input mapping:
@@ -419,7 +418,7 @@ class WorkflowNode(Node):
             self.logger.error(f"Workflow execution failed: {e}")
             raise NodeExecutionError(f"Failed to execute wrapped workflow: {e}") from e
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert node to dictionary representation.
 
         Serializes the WorkflowNode including its wrapped workflow