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

kailash/__init__.py

@@ -15,7 +15,7 @@ from kailash.workflow.visualization import WorkflowVisualizer
 # For backward compatibility
 WorkflowGraph = Workflow
 
-__version__ = "0.2.0"
+__version__ = "0.3.1"
 
 __all__ = [
     "Workflow",

kailash/access_control.py

@@ -51,10 +51,11 @@ Future Enhancements:
 
 import logging
 import threading
+from collections.abc import Callable
 from dataclasses import dataclass, field
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from enum import Enum
-from typing import Any, Callable, Dict, List, Optional, Set, Union
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -136,11 +137,11 @@ class UserContext:
     user_id: str
     tenant_id: str
     email: str
-    roles: List[str] = field(default_factory=list)
-    permissions: List[str] = field(default_factory=list)
-    attributes: Dict[str, Any] = field(default_factory=dict)  # Custom attributes
-    session_id: Optional[str] = None
-    ip_address: Optional[str] = None
+    roles: list[str] = field(default_factory=list)
+    permissions: list[str] = field(default_factory=list)
+    attributes: dict[str, Any] = field(default_factory=dict)  # Custom attributes
+    session_id: str | None = None
+    ip_address: str | None = None
 
 
 @dataclass
@@ -195,21 +196,21 @@ class PermissionRule:
     id: str
     resource_type: str  # "workflow" or "node"
     resource_id: str  # workflow_id or node_id
-    permission: Union[WorkflowPermission, NodePermission]
+    permission: WorkflowPermission | NodePermission
     effect: PermissionEffect
 
     # Who does this apply to?
-    user_id: Optional[str] = None  # Specific user
-    role: Optional[str] = None  # Any user with role
-    tenant_id: Optional[str] = None  # All users in tenant
+    user_id: str | None = None  # Specific user
+    role: str | None = None  # Any user with role
+    tenant_id: str | None = None  # All users in tenant
 
     # Conditions
-    conditions: Dict[str, Any] = field(default_factory=dict)
+    conditions: dict[str, Any] = field(default_factory=dict)
 
     # Metadata
-    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
-    created_by: Optional[str] = None
-    expires_at: Optional[datetime] = None
+    created_at: datetime = field(default_factory=lambda: datetime.now(UTC))
+    created_by: str | None = None
+    expires_at: datetime | None = None
     priority: int = 0  # Higher priority rules evaluated first
 
 
@@ -262,17 +263,17 @@ class AccessDecision:
 
     allowed: bool
     reason: str
-    applied_rules: List[PermissionRule] = field(default_factory=list)
-    conditions_met: Dict[str, bool] = field(default_factory=dict)
-    masked_fields: List[str] = field(default_factory=list)  # Fields to mask in output
-    redirect_node: Optional[str] = None  # Alternative node to execute
+    applied_rules: list[PermissionRule] = field(default_factory=list)
+    conditions_met: dict[str, bool] = field(default_factory=dict)
+    masked_fields: list[str] = field(default_factory=list)  # Fields to mask in output
+    redirect_node: str | None = None  # Alternative node to execute
 
 
 class ConditionEvaluator:
     """Evaluates conditions for conditional permissions"""
 
     def __init__(self):
-        self.evaluators: Dict[str, Callable] = {
+        self.evaluators: dict[str, Callable] = {
             "time_range": self._eval_time_range,
             "data_contains": self._eval_data_contains,
             "user_attribute": self._eval_user_attribute,
@@ -281,7 +282,7 @@ class ConditionEvaluator:
         }
 
     def evaluate(
-        self, condition_type: str, condition_value: Any, context: Dict[str, Any]
+        self, condition_type: str, condition_value: Any, context: dict[str, Any]
     ) -> bool:
         """Evaluate a condition"""
         evaluator = self.evaluators.get(condition_type)
@@ -295,7 +296,7 @@ class ConditionEvaluator:
             logger.error(f"Error evaluating condition {condition_type}: {e}")
             return False
 
-    def _eval_time_range(self, value: Dict[str, str], context: Dict[str, Any]) -> bool:
+    def _eval_time_range(self, value: dict[str, str], context: dict[str, Any]) -> bool:
         """Check if current time is within range"""
         from datetime import datetime, time
 
@@ -305,7 +306,7 @@ class ConditionEvaluator:
         return start <= now <= end
 
     def _eval_data_contains(
-        self, value: Dict[str, Any], context: Dict[str, Any]
+        self, value: dict[str, Any], context: dict[str, Any]
     ) -> bool:
         """Check if data contains specific values"""
         data = context.get("data", {})
@@ -317,7 +318,7 @@ class ConditionEvaluator:
         return False
 
     def _eval_user_attribute(
-        self, value: Dict[str, Any], context: Dict[str, Any]
+        self, value: dict[str, Any], context: dict[str, Any]
     ) -> bool:
         """Check user attributes"""
         user = context.get("user")
@@ -329,7 +330,7 @@ class ConditionEvaluator:
 
         return user.attributes.get(attr_name) == expected
 
-    def _eval_ip_range(self, value: Dict[str, Any], context: Dict[str, Any]) -> bool:
+    def _eval_ip_range(self, value: dict[str, Any], context: dict[str, Any]) -> bool:
         """Check if IP is in allowed range"""
         # Simplified IP check - in production use ipaddress module
         allowed_ips = value.get("allowed", [])
@@ -337,7 +338,7 @@ class ConditionEvaluator:
 
         return user_ip in allowed_ips
 
-    def _eval_custom(self, value: Dict[str, Any], context: Dict[str, Any]) -> bool:
+    def _eval_custom(self, value: dict[str, Any], context: dict[str, Any]) -> bool:
         """Evaluate custom condition"""
         # This would call a custom function registered by the user
         return True
@@ -409,7 +410,7 @@ class AccessControlManager:
 
     def __init__(self, enabled: bool = False):
         self.enabled = enabled  # Disabled by default
-        self.rules: List[PermissionRule] = []
+        self.rules: list[PermissionRule] = []
         self.condition_evaluator = ConditionEvaluator()
         self._cache = {}  # Cache access decisions
         self._cache_lock = threading.Lock()
@@ -458,7 +459,7 @@ class AccessControlManager:
         user: UserContext,
         node_id: str,
         permission: NodePermission,
-        runtime_context: Dict[str, Any] = None,
+        runtime_context: dict[str, Any] = None,
     ) -> AccessDecision:
         """Check if user has permission on node"""
         cache_key = f"node:{node_id}:{user.user_id}:{permission.value}"
@@ -494,7 +495,7 @@ class AccessControlManager:
 
     def get_accessible_nodes(
         self, user: UserContext, workflow_id: str, permission: NodePermission
-    ) -> Set[str]:
+    ) -> set[str]:
         """Get all nodes user can access in a workflow"""
         accessible = set()
 
@@ -518,9 +519,9 @@ class AccessControlManager:
         self,
         user: UserContext,
         conditional_node_id: str,
-        true_path_nodes: List[str],
-        false_path_nodes: List[str],
-    ) -> List[str]:
+        true_path_nodes: list[str],
+        false_path_nodes: list[str],
+    ) -> list[str]:
         """Determine which path user should take based on permissions"""
         # Check if user has access to nodes in true path
         true_path_accessible = all(
@@ -544,8 +545,8 @@ class AccessControlManager:
                 return []
 
     def mask_node_output(
-        self, user: UserContext, node_id: str, output: Dict[str, Any]
-    ) -> Dict[str, Any]:
+        self, user: UserContext, node_id: str, output: dict[str, Any]
+    ) -> dict[str, Any]:
         """Mask sensitive fields in node output"""
         decision = self.check_node_access(user, node_id, NodePermission.READ_OUTPUT)
 
@@ -568,8 +569,8 @@ class AccessControlManager:
         user: UserContext,
         resource_type: str,
         resource_id: str,
-        permission: Union[WorkflowPermission, NodePermission],
-        runtime_context: Dict[str, Any],
+        permission: WorkflowPermission | NodePermission,
+        runtime_context: dict[str, Any],
     ) -> AccessDecision:
         """Evaluate all applicable rules"""
         applicable_rules = []
@@ -584,7 +585,7 @@ class AccessControlManager:
             ):
 
                 # Check expiration
-                if rule.expires_at and rule.expires_at < datetime.now(timezone.utc):
+                if rule.expires_at and rule.expires_at < datetime.now(UTC):
                     continue
 
                 applicable_rules.append(rule)
@@ -593,7 +594,7 @@ class AccessControlManager:
         context = {
             "user": user,
             "runtime": runtime_context,
-            "timestamp": datetime.now(timezone.utc),
+            "timestamp": datetime.now(UTC),
         }
 
         final_effect = PermissionEffect.DENY  # Default deny
@@ -660,7 +661,7 @@ class AccessControlManager:
         user: UserContext,
         resource_type: str,
         resource_id: str,
-        permission: Union[WorkflowPermission, NodePermission],
+        permission: WorkflowPermission | NodePermission,
         decision: AccessDecision,
     ):
         """Log access attempt for audit"""

kailash/api/auth.py

@@ -50,8 +50,8 @@ Future Enhancements:
 import os
 import secrets
 import threading
-from datetime import datetime, timedelta, timezone
-from typing import Any, Dict, List, Optional
+from datetime import UTC, datetime, timedelta
+from typing import Any
 
 from fastapi import Depends, HTTPException, Request, status
 from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
@@ -101,14 +101,14 @@ class User(Base):
 
     # User roles and permissions
     roles = Column(JSON, default=lambda: ["user"])
-    permissions = Column(JSON, default=lambda: [])
+    permissions = Column(JSON, default=list)
 
     # Timestamps
-    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    created_at = Column(DateTime, default=lambda: datetime.now(UTC))
     updated_at = Column(
         DateTime,
-        default=lambda: datetime.now(timezone.utc),
-        onupdate=lambda: datetime.now(timezone.utc),
+        default=lambda: datetime.now(UTC),
+        onupdate=lambda: datetime.now(UTC),
     )
     last_login = Column(DateTime)
 
@@ -150,11 +150,11 @@ class Tenant(Base):
     subscription_tier = Column(String(50), default="free")
 
     # Timestamps
-    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    created_at = Column(DateTime, default=lambda: datetime.now(UTC))
     updated_at = Column(
         DateTime,
-        default=lambda: datetime.now(timezone.utc),
-        onupdate=lambda: datetime.now(timezone.utc),
+        default=lambda: datetime.now(UTC),
+        onupdate=lambda: datetime.now(UTC),
     )
 
     # Relationships
@@ -187,7 +187,7 @@ class APIKey(Base):
     usage_count = Column(JSON, default=lambda: {"total": 0, "monthly": 0})
 
     # Timestamps
-    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    created_at = Column(DateTime, default=lambda: datetime.now(UTC))
 
     # Relationships
     user = relationship("User", back_populates="api_keys")
@@ -203,7 +203,7 @@ class UserCreate(BaseModel):
     email: EmailStr
     username: str = Field(..., min_length=3, max_length=100)
     password: str = Field(..., min_length=8)
-    tenant_id: Optional[str] = None  # If None, create new tenant
+    tenant_id: str | None = None  # If None, create new tenant
 
 
 class UserLogin(BaseModel):
@@ -227,9 +227,9 @@ class TokenData(BaseModel):
 
     sub: str
     tenant_id: str
-    roles: List[str] = ["user"]
-    permissions: List[str] = []
-    exp: Optional[datetime] = None
+    roles: list[str] = ["user"]
+    permissions: list[str] = []
+    exp: datetime | None = None
 
 
 class JWTAuth:
@@ -240,33 +240,27 @@ class JWTAuth:
         self.algorithm = ALGORITHM
 
     def create_access_token(
-        self, data: Dict[str, Any], expires_delta: Optional[timedelta] = None
+        self, data: dict[str, Any], expires_delta: timedelta | None = None
     ) -> str:
         """Create a JWT access token"""
         to_encode = data.copy()
 
         if expires_delta:
-            expire = datetime.now(timezone.utc) + expires_delta
+            expire = datetime.now(UTC) + expires_delta
         else:
-            expire = datetime.now(timezone.utc) + timedelta(
-                hours=ACCESS_TOKEN_EXPIRE_HOURS
-            )
+            expire = datetime.now(UTC) + timedelta(hours=ACCESS_TOKEN_EXPIRE_HOURS)
 
-        to_encode.update(
-            {"exp": expire, "iat": datetime.now(timezone.utc), "type": "access"}
-        )
+        to_encode.update({"exp": expire, "iat": datetime.now(UTC), "type": "access"})
 
         encoded_jwt = jwt.encode(to_encode, self.secret_key, algorithm=self.algorithm)
         return encoded_jwt
 
-    def create_refresh_token(self, data: Dict[str, Any]) -> str:
+    def create_refresh_token(self, data: dict[str, Any]) -> str:
         """Create a JWT refresh token"""
         to_encode = data.copy()
-        expire = datetime.now(timezone.utc) + timedelta(days=REFRESH_TOKEN_EXPIRE_DAYS)
+        expire = datetime.now(UTC) + timedelta(days=REFRESH_TOKEN_EXPIRE_DAYS)
 
-        to_encode.update(
-            {"exp": expire, "iat": datetime.now(timezone.utc), "type": "refresh"}
-        )
+        to_encode.update({"exp": expire, "iat": datetime.now(UTC), "type": "refresh"})
 
         encoded_jwt = jwt.encode(to_encode, self.secret_key, algorithm=self.algorithm)
         return encoded_jwt
@@ -421,13 +415,13 @@ async def verify_api_key(
         )
 
     # Check expiration
-    if valid_key.expires_at and valid_key.expires_at < datetime.now(timezone.utc):
+    if valid_key.expires_at and valid_key.expires_at < datetime.now(UTC):
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED, detail="API key expired"
         )
 
     # Update usage
-    valid_key.last_used_at = datetime.now(timezone.utc)
+    valid_key.last_used_at = datetime.now(UTC)
     valid_key.usage_count["total"] += 1
     valid_key.usage_count["monthly"] += 1
     session.commit()
@@ -514,7 +508,7 @@ class TenantContext:
 _tenant_context = threading.local()
 
 
-def get_current_tenant_id() -> Optional[str]:
+def get_current_tenant_id() -> str | None:
     """Get current tenant ID from context"""
     return getattr(_tenant_context, "tenant_id", None)
 
@@ -615,7 +609,7 @@ class AuthService:
             )
 
         # Update last login
-        user.last_login = datetime.now(timezone.utc)
+        user.last_login = datetime.now(UTC)
         self.session.commit()
 
         # Generate tokens
@@ -646,7 +640,7 @@ class AuthService:
         return self.auth.create_tokens(user)
 
     def create_api_key(
-        self, name: str, user: User, scopes: List[str] = None
+        self, name: str, user: User, scopes: list[str] = None
     ) -> tuple[str, APIKey]:
         """Create an API key for a user"""
         key, key_hash = create_api_key()

kailash/api/custom_nodes.py

@@ -9,7 +9,7 @@ This module provides endpoints for users to:
 """
 
 from datetime import datetime
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -19,40 +19,40 @@ class CustomNodeCreate(BaseModel):
 
     name: str = Field(..., min_length=1, max_length=255)
     category: str = Field(default="custom", max_length=100)
-    description: Optional[str] = None
-    icon: Optional[str] = Field(None, max_length=50)
-    color: Optional[str] = Field(None, pattern="^#[0-9A-Fa-f]{6}$")
+    description: str | None = None
+    icon: str | None = Field(None, max_length=50)
+    color: str | None = Field(None, pattern="^#[0-9A-Fa-f]{6}$")
 
     # Node configuration
-    parameters: List[Dict[str, Any]] = Field(default_factory=list)
-    inputs: List[Dict[str, Any]] = Field(default_factory=list)
-    outputs: List[Dict[str, Any]] = Field(default_factory=list)
+    parameters: list[dict[str, Any]] = Field(default_factory=list)
+    inputs: list[dict[str, Any]] = Field(default_factory=list)
+    outputs: list[dict[str, Any]] = Field(default_factory=list)
 
     # Implementation
     implementation_type: str = Field(..., pattern="^(python|workflow|api)$")
-    implementation: Dict[str, Any]
+    implementation: dict[str, Any]
 
 
 class CustomNodeUpdate(BaseModel):
     """Request model for updating a custom node"""
 
-    name: Optional[str] = Field(None, min_length=1, max_length=255)
-    category: Optional[str] = Field(None, max_length=100)
-    description: Optional[str] = None
-    icon: Optional[str] = Field(None, max_length=50)
-    color: Optional[str] = Field(None, pattern="^#[0-9A-Fa-f]{6}$")
+    name: str | None = Field(None, min_length=1, max_length=255)
+    category: str | None = Field(None, max_length=100)
+    description: str | None = None
+    icon: str | None = Field(None, max_length=50)
+    color: str | None = Field(None, pattern="^#[0-9A-Fa-f]{6}$")
 
     # Node configuration
-    parameters: Optional[List[Dict[str, Any]]] = None
-    inputs: Optional[List[Dict[str, Any]]] = None
-    outputs: Optional[List[Dict[str, Any]]] = None
+    parameters: list[dict[str, Any]] | None = None
+    inputs: list[dict[str, Any]] | None = None
+    outputs: list[dict[str, Any]] | None = None
 
     # Implementation
-    implementation_type: Optional[str] = Field(None, pattern="^(python|workflow|api)$")
-    implementation: Optional[Dict[str, Any]] = None
+    implementation_type: str | None = Field(None, pattern="^(python|workflow|api)$")
+    implementation: dict[str, Any] | None = None
 
     # Publishing
-    is_published: Optional[bool] = None
+    is_published: bool | None = None
 
 
 class CustomNodeResponse(BaseModel):
@@ -62,22 +62,22 @@ class CustomNodeResponse(BaseModel):
     tenant_id: str
     name: str
     category: str
-    description: Optional[str]
-    icon: Optional[str]
-    color: Optional[str]
+    description: str | None
+    icon: str | None
+    color: str | None
 
     # Node configuration
-    parameters: List[Dict[str, Any]]
-    inputs: List[Dict[str, Any]]
-    outputs: List[Dict[str, Any]]
+    parameters: list[dict[str, Any]]
+    inputs: list[dict[str, Any]]
+    outputs: list[dict[str, Any]]
 
     # Implementation
     implementation_type: str
-    implementation: Dict[str, Any]
+    implementation: dict[str, Any]
 
     # Metadata
     is_published: bool
-    created_by: Optional[str]
+    created_by: str | None
     created_at: datetime
     updated_at: datetime
 
@@ -88,7 +88,7 @@ def setup_custom_node_routes(app, SessionLocal, tenant_id: str):
 
     from .database import CustomNodeRepository, get_db_session
 
-    @app.get("/api/custom-nodes", response_model=List[CustomNodeResponse])
+    @app.get("/api/custom-nodes", response_model=list[CustomNodeResponse])
     async def list_custom_nodes():
         """List all custom nodes for the tenant"""
         with get_db_session(SessionLocal) as session:
@@ -230,7 +230,7 @@ def setup_custom_node_routes(app, SessionLocal, tenant_id: str):
             return {"message": "Custom node deleted successfully"}
 
     @app.post("/api/custom-nodes/{node_id}/test")
-    async def test_custom_node(node_id: str, test_data: Dict[str, Any]):
+    async def test_custom_node(node_id: str, test_data: dict[str, Any]):
         """Test a custom node with sample data"""
         with get_db_session(SessionLocal) as session:
             repo = CustomNodeRepository(session)

kailash/api/custom_nodes_secure.py

@@ -9,7 +9,7 @@ This module provides secure endpoints for users to:
 """
 
 from datetime import datetime
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from fastapi import Depends, HTTPException
 from pydantic import BaseModel, Field
@@ -24,40 +24,40 @@ class CustomNodeCreate(BaseModel):
 
     name: str = Field(..., min_length=1, max_length=255)
     category: str = Field(default="custom", max_length=100)
-    description: Optional[str] = None
-    icon: Optional[str] = Field(None, max_length=50)
-    color: Optional[str] = Field(None, pattern="^#[0-9A-Fa-f]{6}$")
+    description: str | None = None
+    icon: str | None = Field(None, max_length=50)
+    color: str | None = Field(None, pattern="^#[0-9A-Fa-f]{6}$")
 
     # Node configuration
-    parameters: List[Dict[str, Any]] = Field(default_factory=list)
-    inputs: List[Dict[str, Any]] = Field(default_factory=list)
-    outputs: List[Dict[str, Any]] = Field(default_factory=list)
+    parameters: list[dict[str, Any]] = Field(default_factory=list)
+    inputs: list[dict[str, Any]] = Field(default_factory=list)
+    outputs: list[dict[str, Any]] = Field(default_factory=list)
 
     # Implementation
     implementation_type: str = Field(..., pattern="^(python|workflow|api)$")
-    implementation: Dict[str, Any]
+    implementation: dict[str, Any]
 
 
 class CustomNodeUpdate(BaseModel):
     """Request model for updating a custom node"""
 
-    name: Optional[str] = Field(None, min_length=1, max_length=255)
-    category: Optional[str] = Field(None, max_length=100)
-    description: Optional[str] = None
-    icon: Optional[str] = Field(None, max_length=50)
-    color: Optional[str] = Field(None, pattern="^#[0-9A-Fa-f]{6}$")
+    name: str | None = Field(None, min_length=1, max_length=255)
+    category: str | None = Field(None, max_length=100)
+    description: str | None = None
+    icon: str | None = Field(None, max_length=50)
+    color: str | None = Field(None, pattern="^#[0-9A-Fa-f]{6}$")
 
     # Node configuration
-    parameters: Optional[List[Dict[str, Any]]] = None
-    inputs: Optional[List[Dict[str, Any]]] = None
-    outputs: Optional[List[Dict[str, Any]]] = None
+    parameters: list[dict[str, Any]] | None = None
+    inputs: list[dict[str, Any]] | None = None
+    outputs: list[dict[str, Any]] | None = None
 
     # Implementation
-    implementation_type: Optional[str] = Field(None, pattern="^(python|workflow|api)$")
-    implementation: Optional[Dict[str, Any]] = None
+    implementation_type: str | None = Field(None, pattern="^(python|workflow|api)$")
+    implementation: dict[str, Any] | None = None
 
     # Publishing
-    is_published: Optional[bool] = None
+    is_published: bool | None = None
 
 
 class CustomNodeResponse(BaseModel):
@@ -67,22 +67,22 @@ class CustomNodeResponse(BaseModel):
     tenant_id: str
     name: str
     category: str
-    description: Optional[str]
-    icon: Optional[str]
-    color: Optional[str]
+    description: str | None
+    icon: str | None
+    color: str | None
 
     # Node configuration
-    parameters: List[Dict[str, Any]]
-    inputs: List[Dict[str, Any]]
-    outputs: List[Dict[str, Any]]
+    parameters: list[dict[str, Any]]
+    inputs: list[dict[str, Any]]
+    outputs: list[dict[str, Any]]
 
     # Implementation
     implementation_type: str
-    implementation: Dict[str, Any]
+    implementation: dict[str, Any]
 
     # Metadata
     is_published: bool
-    created_by: Optional[str]
+    created_by: str | None
     created_at: datetime
     updated_at: datetime
 
@@ -90,7 +90,7 @@ class CustomNodeResponse(BaseModel):
 def setup_custom_node_routes(app, SessionLocal):
     """Setup custom node API routes with authentication"""
 
-    @app.get("/api/custom-nodes", response_model=List[CustomNodeResponse])
+    @app.get("/api/custom-nodes", response_model=list[CustomNodeResponse])
     async def list_custom_nodes(
         user: User = Depends(require_permission("read:nodes")),
         tenant: Tenant = Depends(get_current_tenant),
@@ -255,7 +255,7 @@ def setup_custom_node_routes(app, SessionLocal):
     @app.post("/api/custom-nodes/{node_id}/test")
     async def test_custom_node(
         node_id: str,
-        test_data: Dict[str, Any],
+        test_data: dict[str, Any],
         user: User = Depends(require_permission("execute:nodes")),
         tenant: Tenant = Depends(get_current_tenant),
         session: Session = Depends(get_db_session),
@@ -293,8 +293,8 @@ def setup_custom_node_routes(app, SessionLocal):
 
 
 async def _execute_python_node(
-    node: CustomNode, test_data: Dict[str, Any], tenant_id: str
-) -> Dict[str, Any]:
+    node: CustomNode, test_data: dict[str, Any], tenant_id: str
+) -> dict[str, Any]:
     """Execute a Python-based custom node with security sandboxing"""
     from kailash.nodes.code.python import PythonCodeNode
     from kailash.security import SecurityConfig, TenantContext
@@ -323,8 +323,8 @@ async def _execute_python_node(
 
 
 async def _execute_workflow_node(
-    node: CustomNode, test_data: Dict[str, Any], tenant_id: str
-) -> Dict[str, Any]:
+    node: CustomNode, test_data: dict[str, Any], tenant_id: str
+) -> dict[str, Any]:
     """Execute a workflow-based custom node"""
     from kailash.runtime.local import LocalRuntime
     from kailash.security import TenantContext
@@ -346,8 +346,8 @@ async def _execute_workflow_node(
 
 
 async def _execute_api_node(
-    node: CustomNode, test_data: Dict[str, Any], tenant_id: str
-) -> Dict[str, Any]:
+    node: CustomNode, test_data: dict[str, Any], tenant_id: str
+) -> dict[str, Any]:
     """Execute an API-based custom node"""
 
     from kailash.nodes.api.http import HTTPRequestNode