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

kailash/nodes/data/directory.py

@@ -3,7 +3,7 @@
 import mimetypes
 import os
 from datetime import datetime
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from kailash.nodes.base import Node, NodeParameter, register_node
 from kailash.security import validate_file_path
@@ -46,7 +46,7 @@ class DirectoryReaderNode(Node):
         - Directory structure information
     """
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define input parameters for directory scanning."""
         return {
             "directory_path": NodeParameter(
@@ -85,7 +85,7 @@ class DirectoryReaderNode(Node):
             ),
         }
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """Execute directory scanning operation.
 
         Returns:
@@ -179,9 +179,9 @@ class DirectoryReaderNode(Node):
         file_path: str,
         filename: str,
         include_hidden: bool,
-        file_patterns: List[str],
-        exclude_patterns: List[str],
-    ) -> Optional[Dict[str, Any]]:
+        file_patterns: list[str],
+        exclude_patterns: list[str],
+    ) -> dict[str, Any] | None:
         """Extract metadata from a single file.
 
         Args:

kailash/nodes/data/event_generation.py

@@ -2,8 +2,8 @@
 
 import random
 import uuid
-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, NodeParameter, register_node
 
@@ -84,7 +84,7 @@ class EventGeneratorNode(Node):
         >>> assert result['metadata']['total_events'] == 5
     """
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         return {
             "event_types": NodeParameter(
                 name="event_types",
@@ -135,7 +135,7 @@ class EventGeneratorNode(Node):
             ),
         }
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         event_types = kwargs["event_types"]
         event_count = kwargs.get("event_count", 10)
         aggregate_prefix = kwargs.get("aggregate_prefix", "AGG")
@@ -149,7 +149,7 @@ class EventGeneratorNode(Node):
 
         # Generate events
         events = []
-        now = datetime.now(timezone.utc)
+        now = datetime.now(UTC)
 
         # Create a set of aggregate IDs for realistic event grouping
         num_aggregates = max(1, event_count // 3)  # Roughly 3 events per aggregate
@@ -165,7 +165,7 @@ class EventGeneratorNode(Node):
             # Generate timestamp within range
             hours_offset = random.uniform(-time_range_hours, 0)
             event_timestamp = now.timestamp() + hours_offset * 3600
-            event_time = datetime.fromtimestamp(event_timestamp, tz=timezone.utc)
+            event_time = datetime.fromtimestamp(event_timestamp, tz=UTC)
 
             # Generate event data
             event_data = self._generate_event_data(
@@ -213,8 +213,8 @@ class EventGeneratorNode(Node):
         }
 
     def _generate_event_data(
-        self, event_type: str, aggregate_id: str, template: Dict[str, Any]
-    ) -> Dict[str, Any]:
+        self, event_type: str, aggregate_id: str, template: dict[str, Any]
+    ) -> dict[str, Any]:
         """Generate event-specific data based on type and template."""
 
         # Default data generators by event type
@@ -239,7 +239,7 @@ class EventGeneratorNode(Node):
                 "tracking_number": f"TRACK-{random.randint(100000, 999999)}",
                 "carrier": random.choice(["UPS", "FedEx", "DHL", "USPS"]),
                 "status": "shipped",
-                "estimated_delivery": datetime.now(timezone.utc)
+                "estimated_delivery": datetime.now(UTC)
                 .replace(day=datetime.now().day + random.randint(1, 7))
                 .isoformat()
                 + "Z",
@@ -293,5 +293,5 @@ class EventGeneratorNode(Node):
             return {
                 "event_data": f"Generated data for {event_type}",
                 "aggregate_id": aggregate_id,
-                "timestamp": datetime.now(timezone.utc).isoformat() + "Z",
+                "timestamp": datetime.now(UTC).isoformat() + "Z",
             }

kailash/nodes/data/file_discovery.py

@@ -4,9 +4,9 @@ import hashlib
 import mimetypes
 import os
 import time
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any
 
 from kailash.nodes.base import Node, NodeParameter, register_node
 
@@ -89,7 +89,7 @@ class FileDiscoveryNode(Node):
         >>> large_files = result['discovered_files']
     """
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         return {
             "search_paths": NodeParameter(
                 name="search_paths",
@@ -165,7 +165,7 @@ class FileDiscoveryNode(Node):
             ),
         }
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         search_paths = kwargs["search_paths"]
         file_patterns = kwargs.get("file_patterns", ["*"])
         exclude_patterns = kwargs.get("exclude_patterns", [])
@@ -218,7 +218,7 @@ class FileDiscoveryNode(Node):
                         "type": "discovery_error",
                         "path": search_path,
                         "error": str(e),
-                        "timestamp": datetime.now(timezone.utc).isoformat() + "Z",
+                        "timestamp": datetime.now(UTC).isoformat() + "Z",
                     }
                 )
 
@@ -237,23 +237,23 @@ class FileDiscoveryNode(Node):
                 [f for f in discovered_files if f.get("type") != "discovery_error"]
             ),
             "execution_time": execution_time,
-            "timestamp": datetime.now(timezone.utc).isoformat() + "Z",
+            "timestamp": datetime.now(UTC).isoformat() + "Z",
         }
 
     def _discover_files_in_path(
         self,
         search_path: str,
-        file_patterns: List[str],
-        exclude_patterns: List[str],
+        file_patterns: list[str],
+        exclude_patterns: list[str],
         max_depth: int,
         include_metadata: bool,
         include_checksums: bool,
-        min_size_mb: Optional[float],
-        max_size_mb: Optional[float],
-        older_than_days: Optional[int],
-        newer_than_days: Optional[int],
+        min_size_mb: float | None,
+        max_size_mb: float | None,
+        older_than_days: int | None,
+        newer_than_days: int | None,
         follow_symlinks: bool,
-    ) -> Tuple[List[Dict[str, Any]], Dict[str, int]]:
+    ) -> tuple[list[dict[str, Any]], dict[str, int]]:
         """Discover files in a specific path."""
 
         discovered_files = []
@@ -326,8 +326,7 @@ class FileDiscoveryNode(Node):
                                 "path": file_path,
                                 "name": file_name,
                                 "error": str(e),
-                                "timestamp": datetime.now(timezone.utc).isoformat()
-                                + "Z",
+                                "timestamp": datetime.now(UTC).isoformat() + "Z",
                             }
                         )
 
@@ -338,7 +337,7 @@ class FileDiscoveryNode(Node):
         return discovered_files, stats
 
     def _matches_patterns(
-        self, file_name: str, include_patterns: List[str], exclude_patterns: List[str]
+        self, file_name: str, include_patterns: list[str], exclude_patterns: list[str]
     ) -> bool:
         """Check if filename matches include patterns and doesn't match exclude patterns."""
         import fnmatch
@@ -360,7 +359,7 @@ class FileDiscoveryNode(Node):
 
     def _analyze_file(
         self, file_path: str, include_metadata: bool, include_checksums: bool
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Analyze a single file and return its information."""
 
         file_path_obj = Path(file_path)
@@ -383,15 +382,15 @@ class FileDiscoveryNode(Node):
                     "modified_timestamp": stat_info.st_mtime,
                     "accessed_timestamp": stat_info.st_atime,
                     "created_date": datetime.fromtimestamp(
-                        stat_info.st_ctime, timezone.utc
+                        stat_info.st_ctime, UTC
                     ).isoformat()
                     + "Z",
                     "modified_date": datetime.fromtimestamp(
-                        stat_info.st_mtime, timezone.utc
+                        stat_info.st_mtime, UTC
                     ).isoformat()
                     + "Z",
                     "accessed_date": datetime.fromtimestamp(
-                        stat_info.st_atime, timezone.utc
+                        stat_info.st_atime, UTC
                     ).isoformat()
                     + "Z",
                 }
@@ -445,9 +444,7 @@ class FileDiscoveryNode(Node):
                 # Content analysis for text files
                 if mime_type and mime_type.startswith("text/"):
                     try:
-                        with open(
-                            file_path, "r", encoding="utf-8", errors="ignore"
-                        ) as f:
+                        with open(file_path, encoding="utf-8", errors="ignore") as f:
                             content_sample = f.read(1024)  # Read first 1KB
                             file_info.update(
                                 {
@@ -475,10 +472,10 @@ class FileDiscoveryNode(Node):
                 }
             )
 
-        file_info["timestamp"] = datetime.now(timezone.utc).isoformat() + "Z"
+        file_info["timestamp"] = datetime.now(UTC).isoformat() + "Z"
         return file_info
 
-    def _calculate_checksums(self, file_path: str) -> Dict[str, str]:
+    def _calculate_checksums(self, file_path: str) -> dict[str, str]:
         """Calculate MD5 and SHA256 checksums for a file."""
         checksums = {}
 
@@ -509,9 +506,9 @@ class FileDiscoveryNode(Node):
 
     def _matches_date_criteria(
         self,
-        file_info: Dict[str, Any],
-        older_than_days: Optional[int],
-        newer_than_days: Optional[int],
+        file_info: dict[str, Any],
+        older_than_days: int | None,
+        newer_than_days: int | None,
     ) -> bool:
         """Check if file matches date criteria."""
 
@@ -532,10 +529,10 @@ class FileDiscoveryNode(Node):
 
     def _generate_discovery_summary(
         self,
-        discovered_files: List[Dict],
-        discovery_stats: Dict[str, int],
+        discovered_files: list[dict],
+        discovery_stats: dict[str, int],
         execution_time: float,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Generate summary of file discovery results."""
 
         # Count files by type/extension

kailash/nodes/data/readers.py

@@ -30,7 +30,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
@@ -146,7 +146,7 @@ class CSVReaderNode(Node):
         ... )
     """
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define input parameters for CSV reading.
 
         This method specifies the configuration options for reading CSV files,
@@ -197,7 +197,7 @@ class CSVReaderNode(Node):
             ),
         }
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """Execute CSV reading operation.
 
         This method performs the actual file reading, handling both headerless
@@ -272,7 +272,7 @@ class CSVReaderNode(Node):
                 index_pos = header_row.index(index_column) if index_column else None
 
                 for row in reader:
-                    row_dict = dict(zip(header_row, row))
+                    row_dict = dict(zip(header_row, row, strict=False))
                     data.append(row_dict)
 
                     # If index column specified, add to indexed dictionary
@@ -345,7 +345,7 @@ class JSONReaderNode(Node):
         # }
     """
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define input parameters for JSON reading.
 
         Simple parameter definition reflecting JSON's self-describing nature.
@@ -368,7 +368,7 @@ class JSONReaderNode(Node):
             )
         }
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """Execute JSON reading operation.
 
         Reads and parses JSON file, preserving the original structure
@@ -472,7 +472,7 @@ class TextReaderNode(Node):
         >>> # result['text'] = "2024-01-01 INFO: Application started\\n..."
     """
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define input parameters for text reading.
 
         Provides essential parameters for text file reading with
@@ -507,7 +507,7 @@ class TextReaderNode(Node):
             ),
         }
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """Execute text reading operation.
 
         Reads entire text file into memory as a single string,

kailash/nodes/data/retrieval.py

@@ -1,6 +1,6 @@
 """Document retrieval nodes for finding relevant content using various similarity methods."""
 
-from typing import Any, Dict, List
+from typing import Any
 
 from kailash.nodes.base import Node, NodeParameter, register_node
 
@@ -9,7 +9,7 @@ from kailash.nodes.base import Node, NodeParameter, register_node
 class RelevanceScorerNode(Node):
     """Scores chunk relevance using various similarity methods including embeddings similarity."""
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         return {
             "chunks": NodeParameter(
                 name="chunks",
@@ -45,7 +45,7 @@ class RelevanceScorerNode(Node):
             ),
         }
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         chunks = kwargs.get("chunks", [])
         query_embeddings = kwargs.get("query_embedding", [])
         chunk_embeddings = kwargs.get("chunk_embeddings", [])
@@ -98,8 +98,8 @@ class RelevanceScorerNode(Node):
         return {"relevant_chunks": top_chunks}
 
     def _cosine_similarity_scoring(
-        self, chunks: List[Dict], query_embeddings: List, chunk_embeddings: List
-    ) -> List[Dict]:
+        self, chunks: list[dict], query_embeddings: list, chunk_embeddings: list
+    ) -> list[dict]:
         """Score chunks using cosine similarity."""
         # Extract actual embedding vectors from the embedding objects
         # EmbeddingGeneratorNode returns embeddings in format: {"embedding": [...], "text": "...", "dimensions": X}
@@ -131,7 +131,7 @@ class RelevanceScorerNode(Node):
                 return 0.5
 
             try:
-                dot_product = sum(x * y for x, y in zip(a, b))
+                dot_product = sum(x * y for x, y in zip(a, b, strict=False))
                 norm_a = sum(x * x for x in a) ** 0.5
                 norm_b = sum(x * x for x in b) ** 0.5
                 return dot_product / (norm_a * norm_b) if norm_a * norm_b > 0 else 0
@@ -162,16 +162,16 @@ class RelevanceScorerNode(Node):
         return scored_chunks
 
     def _bm25_scoring(
-        self, chunks: List[Dict], query_embeddings: List, chunk_embeddings: List
-    ) -> List[Dict]:
+        self, chunks: list[dict], query_embeddings: list, chunk_embeddings: list
+    ) -> list[dict]:
         """Score chunks using BM25 algorithm (future implementation)."""
         # TODO: Implement BM25 scoring
         # For now, return chunks with default scores
         return [{**chunk, "relevance_score": 0.5} for chunk in chunks]
 
     def _tfidf_scoring(
-        self, chunks: List[Dict], query_embeddings: List, chunk_embeddings: List
-    ) -> List[Dict]:
+        self, chunks: list[dict], query_embeddings: list, chunk_embeddings: list
+    ) -> list[dict]:
         """Score chunks using TF-IDF similarity (future implementation)."""
         # TODO: Implement TF-IDF scoring
         # For now, return chunks with default scores

kailash/nodes/data/sharepoint_graph.py

@@ -23,7 +23,7 @@ Downstream consumers:
 
 import os
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 import requests
 
@@ -79,7 +79,7 @@ class SharePointGraphReader(Node):
             author="Kailash SDK",
         )
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define input parameters for SharePoint Graph operations."""
         return {
             "tenant_id": NodeParameter(
@@ -149,7 +149,7 @@ class SharePointGraphReader(Node):
 
     def _authenticate(
         self, tenant_id: str, client_id: str, client_secret: str
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Authenticate with Microsoft Graph API using MSAL.
 
         Returns dict with token and headers for stateless operation.
@@ -184,7 +184,7 @@ class SharePointGraphReader(Node):
             },
         }
 
-    def _get_site_data(self, site_url: str, headers: Dict[str, str]) -> Dict[str, Any]:
+    def _get_site_data(self, site_url: str, headers: dict[str, str]) -> dict[str, Any]:
         """Get SharePoint site data from Graph API."""
         # Convert SharePoint URL to Graph API site ID format
         site_id = site_url.replace("https://", "").replace(
@@ -201,8 +201,8 @@ class SharePointGraphReader(Node):
             )
 
     def _list_libraries(
-        self, site_id: str, headers: Dict[str, str]
-    ) -> List[Dict[str, Any]]:
+        self, site_id: str, headers: dict[str, str]
+    ) -> list[dict[str, Any]]:
         """List all document libraries in the site."""
         drives_url = f"https://graph.microsoft.com/v1.0/sites/{site_id}/drives"
         response = requests.get(drives_url, headers=headers)
@@ -215,8 +215,8 @@ class SharePointGraphReader(Node):
             )
 
     def _get_drive_id(
-        self, site_id: str, library_name: str, headers: Dict[str, str]
-    ) -> Optional[str]:
+        self, site_id: str, library_name: str, headers: dict[str, str]
+    ) -> str | None:
         """Get the drive ID for a specific library."""
         libraries = self._list_libraries(site_id, headers)
         for lib in libraries:
@@ -225,8 +225,8 @@ class SharePointGraphReader(Node):
         return None
 
     def _list_files(
-        self, site_id: str, library_name: str, folder_path: str, headers: Dict[str, str]
-    ) -> Dict[str, Any]:
+        self, site_id: str, library_name: str, folder_path: str, headers: dict[str, str]
+    ) -> dict[str, Any]:
         """List files in a specific library and folder."""
         drive_id = self._get_drive_id(site_id, library_name, headers)
         if not drive_id:
@@ -289,8 +289,8 @@ class SharePointGraphReader(Node):
         file_name: str,
         folder_path: str,
         local_path: str,
-        headers: Dict[str, str],
-    ) -> Dict[str, Any]:
+        headers: dict[str, str],
+    ) -> dict[str, Any]:
         """Download a file from SharePoint."""
         drive_id = self._get_drive_id(site_id, library_name, headers)
         if not drive_id:
@@ -344,8 +344,8 @@ class SharePointGraphReader(Node):
             )
 
     def _search_files(
-        self, site_id: str, library_name: str, query: str, headers: Dict[str, str]
-    ) -> Dict[str, Any]:
+        self, site_id: str, library_name: str, query: str, headers: dict[str, str]
+    ) -> dict[str, Any]:
         """Search for files in a library."""
         drive_id = self._get_drive_id(site_id, library_name, headers)
         if not drive_id:
@@ -383,7 +383,7 @@ class SharePointGraphReader(Node):
                 f"Search failed: {response.status_code} - {response.text}"
             )
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """Execute SharePoint Graph operation.
 
         This method is stateless and returns JSON-serializable results
@@ -494,7 +494,7 @@ class SharePointGraphWriter(Node):
             author="Kailash SDK",
         )
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define input parameters for SharePoint upload operations."""
         return {
             "tenant_id": NodeParameter(
@@ -549,7 +549,7 @@ class SharePointGraphWriter(Node):
             ),
         }
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """Execute SharePoint upload operation."""
         # Validate required parameters
         tenant_id = kwargs.get("tenant_id")

kailash/nodes/data/sources.py

@@ -1,6 +1,6 @@
 """Data source nodes for providing input data to workflows."""
 
-from typing import Any, Dict
+from typing import Any
 
 from kailash.nodes.base import Node, NodeParameter, register_node
 
@@ -9,7 +9,7 @@ from kailash.nodes.base import Node, NodeParameter, register_node
 class DocumentSourceNode(Node):
     """Provides sample documents for hierarchical RAG processing."""
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         return {
             "sample_documents": NodeParameter(
                 name="sample_documents",
@@ -20,7 +20,7 @@ class DocumentSourceNode(Node):
             )
         }
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         # Sample documents for demonstration
         documents = [
             {
@@ -48,7 +48,7 @@ class DocumentSourceNode(Node):
 class QuerySourceNode(Node):
     """Provides sample queries for RAG processing."""
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         return {
             "query": NodeParameter(
                 name="query",
@@ -59,7 +59,7 @@ class QuerySourceNode(Node):
             )
         }
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         query = kwargs.get("query", "What are the main types of machine learning?")
         print(f"Debug QuerySource: providing query='{query}'")
         return {"query": query}

kailash/nodes/data/sql.py

@@ -16,7 +16,7 @@ import os
 import threading
 import time
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Optional
 
 import yaml
 from sqlalchemy import create_engine, text
@@ -38,7 +38,7 @@ class SQLDatabaseNode(Node):
             self.config_path = project_config_path
             self.config = self._load_project_config()
 
-        def _load_project_config(self) -> Dict[str, Any]:
+        def _load_project_config(self) -> dict[str, Any]:
             """Load project configuration from YAML file."""
             if not os.path.exists(self.config_path):
                 raise NodeExecutionError(
@@ -46,7 +46,7 @@ class SQLDatabaseNode(Node):
                 )
 
             try:
-                with open(self.config_path, "r") as f:
+                with open(self.config_path) as f:
                     config = yaml.safe_load(f)
                     return config or {}
             except yaml.YAMLError as e:
@@ -56,7 +56,7 @@ class SQLDatabaseNode(Node):
 
         def get_database_config(
             self, connection_name: str
-        ) -> Tuple[str, Dict[str, Any]]:
+        ) -> tuple[str, dict[str, Any]]:
             """Get database configuration by connection name.
 
             Args:
@@ -185,8 +185,8 @@ class SQLDatabaseNode(Node):
     """
 
     # Class-level shared resources for connection pooling
-    _shared_pools: Dict[Tuple[str, frozenset], Any] = {}
-    _pool_metrics: Dict[Tuple[str, frozenset], Dict[str, Any]] = {}
+    _shared_pools: dict[tuple[str, frozenset], Any] = {}
+    _pool_metrics: dict[tuple[str, frozenset], dict[str, Any]] = {}
     _pool_lock = threading.Lock()
     _config_manager: Optional["SQLDatabaseNode._DatabaseConfigManager"] = None
 
@@ -252,7 +252,7 @@ class SQLDatabaseNode(Node):
         # Call parent constructor
         super().__init__(**kwargs)
 
-    def get_parameters(self) -> Dict[str, NodeParameter]:
+    def get_parameters(self) -> dict[str, NodeParameter]:
         """Define input parameters for SQL execution.
 
         Configuration parameters (provided to constructor):
@@ -334,7 +334,7 @@ class SQLDatabaseNode(Node):
 
             return self._shared_pools[cache_key]
 
-    def run(self, **kwargs) -> Dict[str, Any]:
+    def run(self, **kwargs) -> dict[str, Any]:
         """Execute SQL query using shared connection pool.
 
         Args:
@@ -458,7 +458,7 @@ class SQLDatabaseNode(Node):
         }
 
     @classmethod
-    def get_pool_status(cls) -> Dict[str, Any]:
+    def get_pool_status(cls) -> dict[str, Any]:
         """Get status of all shared connection pools."""
         with cls._pool_lock:
             status = {}
@@ -736,7 +736,7 @@ class SQLDatabaseNode(Node):
 
         return sanitized
 
-    def _convert_to_named_parameters(self, query: str, parameters: List) -> tuple:
+    def _convert_to_named_parameters(self, query: str, parameters: list) -> tuple:
         """Convert positional parameters to named parameters for SQLAlchemy 2.0.
 
         Args:
@@ -790,8 +790,8 @@ class SQLDatabaseNode(Node):
         return modified_query, param_dict
 
     def _format_results(
-        self, rows: List, columns: List[str], result_format: str
-    ) -> List[Any]:
+        self, rows: list, columns: list[str], result_format: str
+    ) -> list[Any]:
         """Format query results according to specified format.
 
         Args:
@@ -820,4 +820,4 @@ class SQLDatabaseNode(Node):
             self.logger.warning(
                 f"Unknown result_format '{result_format}', defaulting to 'dict'"
             )
-            return [dict(zip(columns, row)) for row in rows]
+            return [dict(zip(columns, row, strict=False)) for row in rows]