kailash 0.6.3__py3-none-any.whl → 0.6.4__py3-none-any.whl

kailash/mcp_server/utils/__init__.py

@@ -10,7 +10,12 @@ This module provides production-ready utilities for MCP servers including:
 
 from .cache import CacheManager, LRUCache, cached_query
 from .config import ConfigManager
-from .formatters import format_response, json_formatter, markdown_formatter, search_formatter
+from .formatters import (
+    format_response,
+    json_formatter,
+    markdown_formatter,
+    search_formatter,
+)
 from .metrics import MetricsCollector
 
 __all__ = [

kailash/mcp_server/utils/cache.py

@@ -7,10 +7,11 @@ Based on patterns from production MCP server implementations.
 
 import asyncio
 import functools
+import json
 import logging
 import threading
 import time
-from typing import Any, Callable, Dict, Optional, Tuple, TypeVar
+from typing import Any, Awaitable, Callable, Dict, Optional, Tuple, TypeVar
 
 logger = logging.getLogger(__name__)
 
@@ -68,8 +69,14 @@ class LRUCache:
             self._hits += 1
             return value
 
-    def set(self, key: str, value: Any) -> None:
-        """Set value in cache, evicting LRU items if necessary."""
+    def set(self, key: str, value: Any, ttl: Optional[int] = None) -> None:
+        """Set value in cache, evicting LRU items if necessary.
+
+        Args:
+            key: Cache key
+            value: Value to cache
+            ttl: Time-to-live in seconds (uses instance default if None)
+        """
         with self._lock:
             current_time = time.time()
 
@@ -120,6 +127,168 @@ class LRUCache:
             }
 
 
+class UnifiedCache:
+    """
+    Unified cache interface that works with both Redis and in-memory LRU cache.
+
+    This provides a consistent interface regardless of the backend.
+    Includes cache stampede prevention using single-flight pattern.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        ttl: int = 300,
+        redis_client=None,
+        redis_prefix: str = "mcp:",
+        lru_cache=None,
+    ):
+        """Initialize unified cache.
+
+        Args:
+            name: Cache name
+            ttl: Default TTL
+            redis_client: Redis client (if using Redis backend)
+            redis_prefix: Redis key prefix
+            lru_cache: LRU cache instance (if using memory backend)
+        """
+        self.name = name
+        self.ttl = ttl
+        self.redis_client = redis_client
+        self.redis_prefix = redis_prefix
+        self.lru_cache = lru_cache
+        self.is_redis = redis_client is not None
+
+        # Single-flight pattern for stampede prevention
+        self._in_flight: Dict[str, asyncio.Future] = {}
+        self._flight_lock = asyncio.Lock()
+
+    def _make_key(self, key: str) -> str:
+        """Make cache key with name prefix."""
+        if self.is_redis:
+            return f"{self.redis_prefix}{self.name}:{key}"
+        return key
+
+    def get(self, key: str):
+        """Get value from cache."""
+        if self.is_redis:
+            # For Redis, we need async operations but this is called synchronously
+            # We'll implement async versions for the server to use
+            return None  # Fallback for now
+        else:
+            return self.lru_cache.get(key)
+
+    def set(self, key: str, value, ttl: Optional[int] = None):
+        """Set value in cache."""
+        if self.is_redis:
+            # For Redis, we need async operations but this is called synchronously
+            # We'll implement async versions for the server to use
+            pass  # Fallback for now
+        else:
+            self.lru_cache.set(key, value, ttl or self.ttl)
+
+    async def aget(self, key: str):
+        """Async get value from cache."""
+        if self.is_redis:
+            try:
+                redis_key = self._make_key(key)
+                value = await self.redis_client.get(redis_key)
+                return json.loads(value) if value else None
+            except Exception as e:
+                logger.error(f"Redis get error: {e}")
+                return None
+        else:
+            return self.lru_cache.get(key)
+
+    async def aset(self, key: str, value, ttl: Optional[int] = None):
+        """Async set value in cache."""
+        if self.is_redis:
+            try:
+                redis_key = self._make_key(key)
+                serialized_value = json.dumps(value)
+                cache_ttl = ttl or self.ttl
+                await self.redis_client.setex(redis_key, cache_ttl, serialized_value)
+                return True
+            except Exception as e:
+                logger.error(f"Redis set error: {e}")
+                return False
+        else:
+            self.lru_cache.set(key, value, ttl or self.ttl)
+            return True
+
+    async def get_or_compute(
+        self,
+        key: str,
+        compute_func: Callable[[], Awaitable[Any]],
+        ttl: Optional[int] = None,
+    ) -> Any:
+        """Get value from cache or compute it if not present (with stampede prevention).
+
+        This method implements single-flight pattern to prevent cache stampede.
+        If multiple requests come in for the same key while it's being computed,
+        only one will actually execute the compute function.
+
+        Args:
+            key: Cache key
+            compute_func: Async function to compute the value if not in cache
+            ttl: TTL for cached value
+
+        Returns:
+            The cached or computed value
+        """
+        # First try to get from cache
+        cached_value = await self.aget(key)
+        if cached_value is not None:
+            return cached_value
+
+        # Check if computation is already in flight
+        async with self._flight_lock:
+            if key in self._in_flight:
+                # Wait for the existing computation
+                logger.debug(f"Cache key {key} already being computed, waiting...")
+                return await self._in_flight[key]
+
+            # Start new computation
+            future = asyncio.Future()
+            self._in_flight[key] = future
+
+        try:
+            # Compute the value
+            logger.debug(f"Computing value for cache key {key}")
+            value = await compute_func()
+
+            # Cache the result
+            await self.aset(key, value, ttl)
+
+            # Notify waiting requests
+            future.set_result(value)
+            return value
+
+        except Exception as e:
+            # Notify waiting requests of the error
+            future.set_exception(e)
+            raise
+        finally:
+            # Clean up in-flight tracking
+            async with self._flight_lock:
+                self._in_flight.pop(key, None)
+
+    def clear(self):
+        """Clear cache."""
+        if self.is_redis:
+            # For async operations, this would need to be implemented separately
+            pass
+        else:
+            self.lru_cache.clear()
+
+    def stats(self):
+        """Get cache statistics."""
+        if self.is_redis:
+            return {"backend": "redis", "name": self.name}
+        else:
+            return self.lru_cache.stats()
+
+
 class CacheManager:
     """
     High-level cache management with multiple caching strategies.
@@ -128,25 +297,52 @@ class CacheManager:
     for different use cases.
     """
 
-    def __init__(self, enabled: bool = True, default_ttl: int = 300):
+    def __init__(
+        self,
+        enabled: bool = True,
+        default_ttl: int = 300,
+        backend: str = "memory",
+        config: Optional[Dict[str, Any]] = None,
+    ):
         """
         Initialize cache manager.
 
         Args:
             enabled: Whether caching is enabled
             default_ttl: Default TTL for cache entries
+            backend: Cache backend ("memory" or "redis")
+            config: Backend-specific configuration
         """
         self.enabled = enabled
         self.default_ttl = default_ttl
-        self._caches: Dict[str, LRUCache] = {}
+        self.backend = backend
+        self.config = config or {}
+        self._caches: Dict[str, UnifiedCache] = {}
+
+        # Initialize Redis if specified
+        self._redis = None
+        if backend == "redis" and enabled:
+            self._init_redis()
 
     def get_cache(
         self, name: str, max_size: int = 128, ttl: Optional[int] = None
-    ) -> LRUCache:
+    ) -> UnifiedCache:
         """Get or create a named cache."""
         if name not in self._caches:
             cache_ttl = ttl if ttl is not None else self.default_ttl
-            self._caches[name] = LRUCache(max_size=max_size, ttl=cache_ttl)
+            if self.backend == "redis" and self._redis:
+                self._caches[name] = UnifiedCache(
+                    name=name,
+                    ttl=cache_ttl,
+                    redis_client=self._redis,
+                    redis_prefix=self.config.get("prefix", "mcp:"),
+                )
+            else:
+                self._caches[name] = UnifiedCache(
+                    name=name,
+                    ttl=cache_ttl,
+                    lru_cache=LRUCache(max_size=max_size, ttl=cache_ttl),
+                )
         return self._caches[name]
 
     def cached(self, cache_name: str = "default", ttl: Optional[int] = None):
@@ -209,6 +405,53 @@ class CacheManager:
 
         return decorator
 
+    def _init_redis(self):
+        """Initialize Redis connection."""
+        try:
+            import redis.asyncio as redis
+
+            redis_url = self.config.get("redis_url", "redis://localhost:6379")
+            self._redis = redis.from_url(redis_url, decode_responses=True)
+            logger.info(f"Initialized Redis cache backend: {redis_url}")
+        except ImportError:
+            logger.warning("Redis not available. Install with: pip install redis")
+            self.enabled = False
+        except Exception as e:
+            logger.error(f"Failed to initialize Redis: {e}")
+            self.enabled = False
+
+    async def get_redis(self, key: str) -> Optional[Any]:
+        """Get value from Redis cache."""
+        if not self._redis:
+            return None
+        try:
+            value = await self._redis.get(self._make_redis_key(key))
+            return json.loads(value) if value else None
+        except Exception as e:
+            logger.error(f"Redis get error: {e}")
+            return None
+
+    async def set_redis(self, key: str, value: Any, ttl: Optional[int] = None) -> bool:
+        """Set value in Redis cache."""
+        if not self._redis:
+            return False
+        try:
+            redis_key = self._make_redis_key(key)
+            serialized_value = json.dumps(value)
+            if ttl:
+                await self._redis.setex(redis_key, ttl, serialized_value)
+            else:
+                await self._redis.set(redis_key, serialized_value)
+            return True
+        except Exception as e:
+            logger.error(f"Redis set error: {e}")
+            return False
+
+    def _make_redis_key(self, key: str) -> str:
+        """Create Redis key with prefix."""
+        prefix = self.config.get("prefix", "mcp:")
+        return f"{prefix}{key}"
+
     def _create_cache_key(self, func_name: str, args: tuple, kwargs: dict) -> str:
         """Create a cache key from function name and arguments."""
         # Convert args and kwargs to string representation

kailash/middleware/auth/auth_manager.py

@@ -229,7 +229,7 @@ class MiddlewareAuthManager:
         api_key = f"sk_{secrets.token_urlsafe(32)}"
 
         # Store API key metadata using credential manager
-        result = self.credential_manager.run(
+        result = self.credential_manager.execute(
             operation="store_credential",
             credential_name=api_key,
             credential_data={
@@ -274,7 +274,7 @@ class MiddlewareAuthManager:
 
         try:
             # Verify using credential manager since rotating credential node doesn't have verify
-            result = self.credential_manager.run(
+            result = self.credential_manager.execute(
                 operation="get_credential", credential_name=api_key
             )
 
@@ -309,7 +309,7 @@ class MiddlewareAuthManager:
         Returns:
             True if permission is granted
         """
-        result = self.permission_checker.run(
+        result = self.permission_checker.execute(
             user_context={"user_id": user_id},
             permission=permission,
             resource=resource or {},

kailash/middleware/communication/api_gateway.py

@@ -15,14 +15,7 @@ from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional, Union
 from urllib.parse import parse_qs
 
-from fastapi import (
-    Depends,
-    FastAPI,
-    HTTPException,
-    Request,
-    WebSocket,
-    WebSocketDisconnect,
-)
+from fastapi import Depends, FastAPI, HTTPException, Request, WebSocket, WebSocketDisconnect
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse, StreamingResponse
 from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
@@ -819,7 +812,7 @@ def create_gateway(
         >>> # Or use default auth
         >>> gateway = create_gateway(title="My App")
         >>>
-        >>> gateway.run(port=8000)
+        >>> gateway.execute(port=8000)
     """
     # Pass auth_manager to APIGateway
     if auth_manager is not None:

kailash/middleware/communication/realtime.py

@@ -378,7 +378,7 @@ class WebhookManager:
 
         try:
             # Use HTTPRequestNode for delivery (it handles retries internally)
-            response = self.http_node.run(
+            response = self.http_node.execute(
                 url=url, method="POST", json_data=payload, headers=headers
             )
 

kailash/middleware/mcp/enhanced_server.py

@@ -24,7 +24,7 @@ from kailash.workflow.builder import WorkflowBuilder
 
 # Import existing Kailash MCP components
 try:
-    from kailash.mcp_server import MCPServer, SimpleMCPServer
+    from kailash.mcp_server import MCPServer
     from kailash.mcp_server.utils import CacheManager, ConfigManager, MetricsCollector
 
     _KAILASH_MCP_AVAILABLE = True

kailash/nodes/__init__.py

@@ -6,6 +6,7 @@ from kailash.nodes import (
     alerts,
     api,
     auth,
+    cache,
     code,
     compliance,
     data,
@@ -37,6 +38,7 @@ __all__ = [
     "alerts",
     "api",
     "auth",
+    "cache",
     "code",
     "compliance",
     "data",

kailash/nodes/admin/audit_log.py

@@ -169,7 +169,7 @@ class EnterpriseAuditLogNode(Node):
         ...         "ip_address": "192.168.1.100"
         ...     }
         ... )
-        >>> result = node.run()
+        >>> result = node.execute()
         >>> event_id = result["event"]["event_id"]
 
         >>> # Query security events
@@ -184,7 +184,7 @@ class EnterpriseAuditLogNode(Node):
         ...     },
         ...     pagination={"page": 1, "size": 50}
         ... )
-        >>> result = node.run()
+        >>> result = node.execute()
         >>> events = result["events"]
 
         >>> # Generate compliance report
@@ -196,7 +196,7 @@ class EnterpriseAuditLogNode(Node):
         ...     },
         ...     export_format="json"
         ... )
-        >>> result = node.run()
+        >>> result = node.execute()
         >>> report = result["report"]
     """
 
@@ -436,7 +436,7 @@ class EnterpriseAuditLogNode(Node):
             }
         )
 
-        db_result = self._db_node.run()
+        db_result = self._db_node.execute()
 
         return {
             "result": {
@@ -571,14 +571,14 @@ class EnterpriseAuditLogNode(Node):
         self._db_node.config.update(
             {"query": count_query, "params": params, "fetch_mode": "one"}
         )
-        count_result = self._db_node.run()
+        count_result = self._db_node.execute()
         total_count = count_result["result"]["data"]["total"]
 
         # Execute data query
         self._db_node.config.update(
             {"query": data_query, "params": params, "fetch_mode": "all"}
         )
-        data_result = self._db_node.run()
+        data_result = self._db_node.execute()
         logs = data_result["result"]["data"]
 
         # Calculate pagination info

kailash/nodes/admin/permission_check.py

@@ -165,7 +165,7 @@ class PermissionCheckNode(Node):
         ...     cache_ttl=300,
         ...     explain=True
         ... )
-        >>> result = node.run()
+        >>> result = node.execute()
         >>> allowed = result["check"]["allowed"]
         >>> explanation = result["explanation"]
 
@@ -177,7 +177,7 @@ class PermissionCheckNode(Node):
         ...     permissions=["read", "write", "delete"],
         ...     cache_level="full"
         ... )
-        >>> result = node.run()
+        >>> result = node.execute()
         >>> results = result["batch_results"]
 
         >>> # Bulk user permission check
@@ -187,7 +187,7 @@ class PermissionCheckNode(Node):
         ...     resource_id="workflow_execute",
         ...     permission="execute"
         ... )
-        >>> result = node.run()
+        >>> result = node.execute()
         >>> access_matrix = result["access_matrix"]
     """
 
@@ -738,7 +738,7 @@ class PermissionCheckNode(Node):
 
         try:
             # Get user data - strict tenant check
-            user_result = self._db_node.run(
+            user_result = self._db_node.execute(
                 query=user_query, parameters=[user_id, tenant_id], result_format="dict"
             )
 
@@ -758,7 +758,7 @@ class PermissionCheckNode(Node):
                 return None
 
             # Get assigned roles - also with strict tenant isolation
-            roles_result = self._db_node.run(
+            roles_result = self._db_node.execute(
                 query=roles_query, parameters=[user_id, tenant_id], result_format="dict"
             )
 
@@ -888,7 +888,7 @@ class PermissionCheckNode(Node):
         """
 
         try:
-            result = self._db_node.run(
+            result = self._db_node.execute(
                 query=query,
                 parameters=[role_id, tenant_id, tenant_id, tenant_id],
                 result_format="dict",
@@ -1246,7 +1246,7 @@ class PermissionCheckNode(Node):
         """
 
         try:
-            result = self._db_node.run(
+            result = self._db_node.execute(
                 query=query, parameters=[role_id, tenant_id], result_format="dict"
             )
             role_rows = result.get("data", [])
@@ -1709,7 +1709,7 @@ class PermissionCheckNode(Node):
             ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
             """
 
-            self._db_node.run(
+            self._db_node.execute(
                 query=audit_query,
                 parameters=[
                     user_id,