kailash 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

kailash/nodes/base.py

@@ -21,8 +21,8 @@ Key Components:
 import json
 import logging
 from abc import ABC, abstractmethod
-from datetime import datetime, timezone
-from typing import Any, Dict, Optional, Set, Type
+from datetime import UTC, datetime
+from typing import Any
 
 from pydantic import BaseModel, Field, ValidationError
 
@@ -60,10 +60,10 @@ class NodeMetadata(BaseModel):
     version: str = Field("1.0.0", description="Node version")
     author: str = Field("", description="Node author")
     created_at: datetime = Field(
-        default_factory=lambda: datetime.now(timezone.utc),
+        default_factory=lambda: datetime.now(UTC),
         description="Node creation date",
     )
-    tags: Set[str] = Field(default_factory=set, description="Node tags")
+    tags: set[str] = Field(default_factory=set, description="Node tags")
 
 
 class NodeParameter(BaseModel):
@@ -94,7 +94,7 @@ class NodeParameter(BaseModel):
     """
 
     name: str
-    type: Type
+    type: type
     required: bool = True
     default: Any = None
     description: str = ""
@@ -208,7 +208,7 @@ class Node(ABC):
             ) from e
 
     @abstractmethod
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define the parameters this node accepts.
 
         This abstract method must be implemented by all concrete nodes to
@@ -254,9 +254,8 @@ class Node(ABC):
             - to_dict(): Includes parameters in serialization
             - Workflow.connect(): Validates compatible connections
         """
-        pass
 
-    def get_output_schema(self) -> Dict[str, NodeParameter]:
+    def get_output_schema(self) -> dict[str, NodeParameter]:
         """Define output parameters for this node.
 
         This optional method allows nodes to specify their output schema for
@@ -313,7 +312,7 @@ class Node(ABC):
         return {}
 
     @abstractmethod
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """Execute the node's logic.
 
         This is the core method that implements the node's data processing
@@ -361,7 +360,6 @@ class Node(ABC):
             - LocalRuntime: During workflow execution
             - TestRunner: During unit testing
         """
-        pass
 
     def _validate_config(self):
         """Validate node configuration against defined parameters.
@@ -428,8 +426,8 @@ class Node(ABC):
                             f"Conversion failed: {e}"
                         ) from e
 
-    def validate_inputs(self, **kwargs) -> Dict[str, Any]:
-        """Validate runtime inputs against node requirements.
+    def validate_inputs(self, **kwargs) -> dict[str, Any]:
+        r"""Validate runtime inputs against node requirements.
 
         This method validates inputs provided at execution time against the
         node's parameter schema. It ensures type safety and provides helpful
@@ -521,7 +519,7 @@ class Node(ABC):
 
         return validated
 
-    def validate_outputs(self, outputs: Dict[str, Any]) -> Dict[str, Any]:
+    def validate_outputs(self, outputs: dict[str, Any]) -> dict[str, Any]:
         """Validate outputs against schema and JSON-serializability.
 
         This enhanced method validates outputs in two ways:
@@ -661,7 +659,7 @@ class Node(ABC):
         except (TypeError, ValueError):
             return False
 
-    def execute(self, **runtime_inputs) -> Dict[str, Any]:
+    def execute(self, **runtime_inputs) -> dict[str, Any]:
         """Execute the node with validation and error handling.
 
         This is the main entry point for node execution that orchestrates
@@ -711,7 +709,7 @@ class Node(ABC):
             - Metrics enable performance monitoring
             - Validation ensures data integrity
         """
-        start_time = datetime.now(timezone.utc)
+        start_time = datetime.now(UTC)
         try:
             self.logger.info(f"Executing node {self.id}")
 
@@ -735,7 +733,7 @@ class Node(ABC):
             # Validate outputs
             validated_outputs = self.validate_outputs(outputs)
 
-            execution_time = (datetime.now(timezone.utc) - start_time).total_seconds()
+            execution_time = (datetime.now(UTC) - start_time).total_seconds()
             self.logger.info(
                 f"Node {self.id} executed successfully in {execution_time:.3f}s"
             )
@@ -754,7 +752,7 @@ class Node(ABC):
                 f"Node '{self.id}' execution failed: {type(e).__name__}: {e}"
             ) from e
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert node to dictionary representation.
 
         Serializes the node instance to a dictionary format suitable for:
@@ -866,7 +864,7 @@ class NodeRegistry:
     """
 
     _instance = None
-    _nodes: Dict[str, Type[Node]] = {}
+    _nodes: dict[str, type[Node]] = {}
 
     def __new__(cls):
         """Ensure singleton instance.
@@ -882,7 +880,7 @@ class NodeRegistry:
         return cls._instance
 
     @classmethod
-    def register(cls, node_class: Type[Node], alias: Optional[str] = None):
+    def register(cls, node_class: type[Node], alias: str | None = None):
         """Register a node class.
 
         Adds a node class to the global registry, making it available
@@ -940,7 +938,7 @@ class NodeRegistry:
         logging.info(f"Registered node '{node_name}'")
 
     @classmethod
-    def get(cls, node_name: str) -> Type[Node]:
+    def get(cls, node_name: str) -> type[Node]:
         """Get a registered node class by name.
 
         Retrieves a node class from the registry for instantiation.
@@ -983,7 +981,7 @@ class NodeRegistry:
         return cls._nodes[node_name]
 
     @classmethod
-    def list_nodes(cls) -> Dict[str, Type[Node]]:
+    def list_nodes(cls) -> dict[str, type[Node]]:
         """List all registered nodes.
 
         Returns a copy of the registry for discovery purposes.
@@ -1030,7 +1028,7 @@ class NodeRegistry:
         logging.info("Cleared all registered nodes")
 
 
-def register_node(alias: Optional[str] = None):
+def register_node(alias: str | None = None):
     """Decorator to register a node class.
 
     Provides a convenient decorator pattern for automatic node
@@ -1077,7 +1075,7 @@ def register_node(alias: Optional[str] = None):
         ...         return pd.read_csv(file)
     """
 
-    def decorator(node_class: Type[Node]):
+    def decorator(node_class: type[Node]):
         """Inner decorator that performs registration.
 
         Args:

kailash/nodes/base_async.py

@@ -4,8 +4,8 @@ This module extends the base Node class with asynchronous execution capabilities
 allowing for more efficient handling of I/O-bound operations in workflows.
 """
 
-from datetime import datetime, timezone
-from typing import Any, Dict
+from datetime import UTC, datetime
+from typing import Any
 
 from kailash.nodes.base import Node
 from kailash.sdk_exceptions import NodeExecutionError, NodeValidationError
@@ -45,7 +45,7 @@ class AsyncNode(Node):
     - TaskManager: Tracks node execution status
     """
 
-    def execute(self, **runtime_inputs) -> Dict[str, Any]:
+    def execute(self, **runtime_inputs) -> dict[str, Any]:
         """Execute the node synchronously by running async code in a new event loop.
 
         This override allows AsyncNode to work with synchronous runtimes like LocalRuntime.
@@ -90,7 +90,7 @@ class AsyncNode(Node):
                 asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
             return asyncio.run(self.execute_async(**runtime_inputs))
 
-    async def async_run(self, **kwargs) -> Dict[str, Any]:
+    async def async_run(self, **kwargs) -> dict[str, Any]:
         """Asynchronous execution method for the node.
 
         This method should be overridden by subclasses that require asynchronous
@@ -108,7 +108,7 @@ class AsyncNode(Node):
         # Default implementation calls the synchronous run() method
         return self.run(**kwargs)
 
-    async def execute_async(self, **runtime_inputs) -> Dict[str, Any]:
+    async def execute_async(self, **runtime_inputs) -> dict[str, Any]:
         """Execute the node asynchronously with validation and error handling.
 
         This method follows the same pattern as execute() but supports asynchronous
@@ -129,7 +129,7 @@ class AsyncNode(Node):
             NodeValidationError: If inputs or outputs are invalid
             NodeExecutionError: If execution fails
         """
-        start_time = datetime.now(timezone.utc)
+        start_time = datetime.now(UTC)
         try:
             self.logger.info(f"Executing node {self.id} asynchronously")
 
@@ -153,7 +153,7 @@ class AsyncNode(Node):
             # Validate outputs
             validated_outputs = self.validate_outputs(outputs)
 
-            execution_time = (datetime.now(timezone.utc) - start_time).total_seconds()
+            execution_time = (datetime.now(UTC) - start_time).total_seconds()
             self.logger.info(
                 f"Node {self.id} executed successfully in {execution_time:.3f}s"
             )

kailash/nodes/base_cycle_aware.py

@@ -37,7 +37,7 @@ Example usage:
 """
 
 import time
-from typing import Any, Dict
+from typing import Any
 
 from .base import Node
 
@@ -103,7 +103,7 @@ class CycleAwareNode(Node):
         ...         }
     """
 
-    def get_cycle_info(self, context: Dict[str, Any]) -> Dict[str, Any]:
+    def get_cycle_info(self, context: dict[str, Any]) -> dict[str, Any]:
         """
         Get cycle information with sensible defaults.
 
@@ -138,7 +138,7 @@ class CycleAwareNode(Node):
             **cycle_info,  # Include any additional cycle information
         }
 
-    def get_iteration(self, context: Dict[str, Any]) -> int:
+    def get_iteration(self, context: dict[str, Any]) -> int:
         """
         Get current iteration number.
 
@@ -155,7 +155,7 @@ class CycleAwareNode(Node):
         """
         return self.get_cycle_info(context)["iteration"]
 
-    def is_first_iteration(self, context: Dict[str, Any]) -> bool:
+    def is_first_iteration(self, context: dict[str, Any]) -> bool:
         """
         Check if this is the first iteration of the cycle.
 
@@ -172,7 +172,7 @@ class CycleAwareNode(Node):
         """
         return self.get_iteration(context) == 0
 
-    def is_last_iteration(self, context: Dict[str, Any]) -> bool:
+    def is_last_iteration(self, context: dict[str, Any]) -> bool:
         """
         Check if this is the last iteration of the cycle.
 
@@ -189,7 +189,7 @@ class CycleAwareNode(Node):
         cycle_info = self.get_cycle_info(context)
         return cycle_info["iteration"] >= cycle_info["max_iterations"] - 1
 
-    def get_previous_state(self, context: Dict[str, Any]) -> Dict[str, Any]:
+    def get_previous_state(self, context: dict[str, Any]) -> dict[str, Any]:
         """
         Get previous iteration state safely.
 
@@ -209,7 +209,7 @@ class CycleAwareNode(Node):
         """
         return self.get_cycle_info(context).get("node_state", {})
 
-    def set_cycle_state(self, state: Dict[str, Any]) -> Dict[str, Any]:
+    def set_cycle_state(self, state: dict[str, Any]) -> dict[str, Any]:
         """
         Set state to persist to next iteration.
 
@@ -233,7 +233,7 @@ class CycleAwareNode(Node):
         """
         return {"_cycle_state": state}
 
-    def get_cycle_progress(self, context: Dict[str, Any]) -> float:
+    def get_cycle_progress(self, context: dict[str, Any]) -> float:
         """
         Get cycle progress as a percentage.
 
@@ -256,7 +256,7 @@ class CycleAwareNode(Node):
 
         return min(iteration / max_iterations, 1.0)
 
-    def log_cycle_info(self, context: Dict[str, Any], message: str = "") -> None:
+    def log_cycle_info(self, context: dict[str, Any], message: str = "") -> None:
         """
         Log cycle information for debugging.
 
@@ -284,7 +284,7 @@ class CycleAwareNode(Node):
 
         print(log_msg)
 
-    def should_continue_cycle(self, context: Dict[str, Any], **kwargs) -> bool:
+    def should_continue_cycle(self, context: dict[str, Any], **kwargs) -> bool:
         """
         Helper method to determine if cycle should continue.
 
@@ -307,7 +307,7 @@ class CycleAwareNode(Node):
         return not self.is_last_iteration(context)
 
     def accumulate_values(
-        self, context: Dict[str, Any], key: str, value: Any, max_history: int = 100
+        self, context: dict[str, Any], key: str, value: Any, max_history: int = 100
     ) -> list:
         """
         Accumulate values across iterations with automatic history management.
@@ -340,7 +340,7 @@ class CycleAwareNode(Node):
 
     def detect_convergence_trend(
         self,
-        context: Dict[str, Any],
+        context: dict[str, Any],
         key: str,
         threshold: float = 0.01,
         window: int = 3,

kailash/nodes/base_with_acl.py

@@ -14,7 +14,7 @@ Key Design Principles:
 """
 
 import logging
-from typing import Any, Dict, Optional
+from typing import Any
 
 from kailash.access_control import (
     AccessDecision,
@@ -146,7 +146,7 @@ class NodeWithAccessControl(Node):
         else:
             raise NotImplementedError("Node must implement _execute() method")
 
-    def _should_check_access(self, user_context: Optional[UserContext]) -> bool:
+    def _should_check_access(self, user_context: UserContext | None) -> bool:
         """
         Determine if access control should be checked.
 
@@ -179,7 +179,7 @@ class NodeWithAccessControl(Node):
         # Fall back to class name
         return self.__class__.__name__
 
-    def _mask_fields(self, data: Dict[str, Any], fields: list[str]) -> Dict[str, Any]:
+    def _mask_fields(self, data: dict[str, Any], fields: list[str]) -> dict[str, Any]:
         """Mask specified fields in output data"""
         masked_data = data.copy()
         for field in fields:
@@ -188,7 +188,7 @@ class NodeWithAccessControl(Node):
         return masked_data
 
     def _handle_access_denied(
-        self, decision: AccessDecision, inputs: Dict[str, Any]
+        self, decision: AccessDecision, inputs: dict[str, Any]
     ) -> Any:
         """
         Handle access denied scenarios.
@@ -333,6 +333,6 @@ def add_access_control(node_instance, **acl_config):
         setattr(node_instance, key, value)
 
     # Mark this node as access-controlled
-    setattr(node_instance, "_access_controlled", True)
+    node_instance._access_controlled = True
 
     return node_instance

kailash/nodes/code/python.py

@@ -52,8 +52,9 @@ import inspect
 import logging
 import resource
 import traceback
+from collections.abc import Callable
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Type, Union, get_type_hints
+from typing import Any, get_type_hints
 
 from kailash.nodes.base import Node, NodeMetadata, NodeParameter, register_node
 from kailash.sdk_exceptions import (
@@ -171,8 +172,8 @@ class CodeExecutor:
 
     def __init__(
         self,
-        allowed_modules: Optional[List[str]] = None,
-        security_config: Optional[SecurityConfig] = None,
+        allowed_modules: list[str] | None = None,
+        security_config: SecurityConfig | None = None,
     ):
         """Initialize the code executor.
 
@@ -269,7 +270,7 @@ class CodeExecutor:
         except SyntaxError as e:
             raise NodeExecutionError(f"Invalid Python syntax: {e}")
 
-    def execute_code(self, code: str, inputs: Dict[str, Any]) -> Dict[str, Any]:
+    def execute_code(self, code: str, inputs: dict[str, Any]) -> dict[str, Any]:
         """Execute Python code with given inputs.
 
         Args:
@@ -350,7 +351,7 @@ class CodeExecutor:
             logger.error(error_msg)
             raise NodeExecutionError(error_msg)
 
-    def execute_function(self, func: Callable, inputs: Dict[str, Any]) -> Any:
+    def execute_function(self, func: Callable, inputs: dict[str, Any]) -> Any:
         """Execute a Python function with given inputs.
 
         Args:
@@ -404,7 +405,7 @@ class FunctionWrapper:
         node = wrapper.to_node(name="dropna_processor")
     """
 
-    def __init__(self, func: Callable, executor: Optional[CodeExecutor] = None):
+    def __init__(self, func: Callable, executor: CodeExecutor | None = None):
         """Initialize the function wrapper.
 
         Args:
@@ -422,7 +423,7 @@ class FunctionWrapper:
             # Handle cases where type hints can't be resolved
             self.type_hints = {}
 
-    def get_input_types(self) -> Dict[str, Type]:
+    def get_input_types(self) -> dict[str, type]:
         """Extract input types from function signature.
 
         Returns:
@@ -438,7 +439,7 @@ class FunctionWrapper:
             input_types[param_name] = param_type
         return input_types
 
-    def get_output_type(self) -> Type:
+    def get_output_type(self) -> type:
         """Extract output type from function signature.
 
         Returns:
@@ -446,22 +447,26 @@ class FunctionWrapper:
         """
         return self.type_hints.get("return", Any)
 
-    def execute(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+    def execute(self, inputs: dict[str, Any]) -> dict[str, Any]:
         """Execute the wrapped function."""
         result = self.executor.execute_function(self.func, inputs)
 
-        # Wrap non-dict results in a dict
+        # Always wrap results in "result" key for consistent validation
+        # This ensures both dict and non-dict returns have the same structure
         if not isinstance(result, dict):
             result = {"result": result}
+        else:
+            # For dict results, wrap the entire dict in "result" key
+            result = {"result": result}
 
         return result
 
     def to_node(
         self,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        input_schema: Optional[Dict[str, "NodeParameter"]] = None,
-        output_schema: Optional[Dict[str, "NodeParameter"]] = None,
+        name: str | None = None,
+        description: str | None = None,
+        input_schema: dict[str, "NodeParameter"] | None = None,
+        output_schema: dict[str, "NodeParameter"] | None = None,
     ) -> "PythonCodeNode":
         """Convert function to a PythonCodeNode.
 
@@ -507,9 +512,9 @@ class ClassWrapper:
 
     def __init__(
         self,
-        cls: Type,
-        method_name: Optional[str] = None,
-        executor: Optional[CodeExecutor] = None,
+        cls: type,
+        method_name: str | None = None,
+        executor: CodeExecutor | None = None,
     ):
         """Initialize the class wrapper.
 
@@ -570,7 +575,7 @@ class ClassWrapper:
             # Handle descriptor objects like properties
             self.type_hints = {}
 
-    def get_input_types(self) -> Dict[str, Type]:
+    def get_input_types(self) -> dict[str, type]:
         """Extract input types from method signature."""
         input_types = {}
         for param_name, param in self.signature.parameters.items():
@@ -582,11 +587,11 @@ class ClassWrapper:
             input_types[param_name] = param_type
         return input_types
 
-    def get_output_type(self) -> Type:
+    def get_output_type(self) -> type:
         """Extract output type from method signature."""
         return self.type_hints.get("return", Any)
 
-    def execute(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+    def execute(self, inputs: dict[str, Any]) -> dict[str, Any]:
         """Execute the wrapped method."""
         # Create instance if needed
         if self.instance is None:
@@ -603,18 +608,22 @@ class ClassWrapper:
         # Execute the method
         result = self.executor.execute_function(method, inputs)
 
-        # Wrap non-dict results in a dict
+        # Always wrap results in "result" key for consistent validation
+        # This ensures both dict and non-dict returns have the same structure
         if not isinstance(result, dict):
             result = {"result": result}
+        else:
+            # For dict results, wrap the entire dict in "result" key
+            result = {"result": result}
 
         return result
 
     def to_node(
         self,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        input_schema: Optional[Dict[str, "NodeParameter"]] = None,
-        output_schema: Optional[Dict[str, "NodeParameter"]] = None,
+        name: str | None = None,
+        description: str | None = None,
+        input_schema: dict[str, "NodeParameter"] | None = None,
+        output_schema: dict[str, "NodeParameter"] | None = None,
     ) -> "PythonCodeNode":
         """Convert class to a PythonCodeNode.
 
@@ -707,15 +716,15 @@ class PythonCodeNode(Node):
     def __init__(
         self,
         name: str,
-        code: Optional[str] = None,
-        function: Optional[Callable] = None,
-        class_type: Optional[Type] = None,
-        process_method: Optional[str] = None,
-        input_types: Optional[Dict[str, Type]] = None,
-        output_type: Optional[Type] = None,
-        input_schema: Optional[Dict[str, "NodeParameter"]] = None,
-        output_schema: Optional[Dict[str, "NodeParameter"]] = None,
-        description: Optional[str] = None,
+        code: str | None = None,
+        function: Callable | None = None,
+        class_type: type | None = None,
+        process_method: str | None = None,
+        input_types: dict[str, type] | None = None,
+        output_type: type | None = None,
+        input_schema: dict[str, "NodeParameter"] | None = None,
+        output_schema: dict[str, "NodeParameter"] | None = None,
+        description: str | None = None,
         **kwargs,
     ):
         """Initialize a Python code node.
@@ -784,7 +793,7 @@ class PythonCodeNode(Node):
         if not hasattr(self, "_skip_validation"):
             self._skip_validation = True
 
-    def get_parameters(self) -> Dict[str, "NodeParameter"]:
+    def get_parameters(self) -> dict[str, "NodeParameter"]:
         """Define the parameters this node accepts.
 
         Returns:
@@ -841,7 +850,7 @@ class PythonCodeNode(Node):
 
         return parameters
 
-    def validate_inputs(self, **kwargs) -> Dict[str, Any]:
+    def validate_inputs(self, **kwargs) -> dict[str, Any]:
         """Validate runtime inputs.
 
         For code-based nodes, we accept any inputs since the code
@@ -860,7 +869,7 @@ class PythonCodeNode(Node):
         # Otherwise use standard validation for function/class nodes
         return super().validate_inputs(**kwargs)
 
-    def get_output_schema(self) -> Dict[str, "NodeParameter"]:
+    def get_output_schema(self) -> dict[str, "NodeParameter"]:
         """Define output parameters for this node.
 
         Returns:
@@ -880,7 +889,7 @@ class PythonCodeNode(Node):
             )
         }
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """Execute the node's logic.
 
         Args:
@@ -923,10 +932,10 @@ class PythonCodeNode(Node):
     def from_function(
         cls,
         func: Callable,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        input_schema: Optional[Dict[str, "NodeParameter"]] = None,
-        output_schema: Optional[Dict[str, "NodeParameter"]] = None,
+        name: str | None = None,
+        description: str | None = None,
+        input_schema: dict[str, "NodeParameter"] | None = None,
+        output_schema: dict[str, "NodeParameter"] | None = None,
         **kwargs,
     ) -> "PythonCodeNode":
         """Create a node from a Python function.
@@ -961,12 +970,12 @@ class PythonCodeNode(Node):
     @classmethod
     def from_class(
         cls,
-        class_type: Type,
-        process_method: Optional[str] = None,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        input_schema: Optional[Dict[str, "NodeParameter"]] = None,
-        output_schema: Optional[Dict[str, "NodeParameter"]] = None,
+        class_type: type,
+        process_method: str | None = None,
+        name: str | None = None,
+        description: str | None = None,
+        input_schema: dict[str, "NodeParameter"] | None = None,
+        output_schema: dict[str, "NodeParameter"] | None = None,
         **kwargs,
     ) -> "PythonCodeNode":
         """Create a node from a Python class.
@@ -1003,13 +1012,13 @@ class PythonCodeNode(Node):
     @classmethod
     def from_file(
         cls,
-        file_path: Union[str, Path],
-        function_name: Optional[str] = None,
-        class_name: Optional[str] = None,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        input_schema: Optional[Dict[str, "NodeParameter"]] = None,
-        output_schema: Optional[Dict[str, "NodeParameter"]] = None,
+        file_path: str | Path,
+        function_name: str | None = None,
+        class_name: str | None = None,
+        name: str | None = None,
+        description: str | None = None,
+        input_schema: dict[str, "NodeParameter"] | None = None,
+        output_schema: dict[str, "NodeParameter"] | None = None,
     ) -> "PythonCodeNode":
         """Create a node from a Python file.
 
@@ -1084,7 +1093,7 @@ class PythonCodeNode(Node):
                 f"No suitable function or class found in {file_path}"
             )
 
-    def execute_code(self, inputs: Dict[str, Any]) -> Any:
+    def execute_code(self, inputs: dict[str, Any]) -> Any:
         """Execute the code with given inputs.
 
         This is a convenience method that directly executes the code
@@ -1115,7 +1124,7 @@ class PythonCodeNode(Node):
         else:
             raise NodeExecutionError("No execution method available")
 
-    def get_config(self) -> Dict[str, Any]:
+    def get_config(self) -> dict[str, Any]:
         """Get node configuration for serialization.
 
         Returns: