kailash 0.8.5__py3-none-any.whl → 0.8.6__py3-none-any.whl

kailash/__init__.py

@@ -3,10 +3,10 @@
 The Kailash SDK provides a comprehensive framework for creating nodes and workflows
 that align with container-node architecture while allowing rapid prototyping.
 
-New in v0.7.0: Complete DataFlow and Nexus application frameworks, infrastructure hardening
-with 100% E2E test pass rate, enhanced AsyncNode event loop handling, 8 new monitoring operations,
-distributed transactions, QueryBuilder/QueryCache with Redis, and real MCP execution by default.
-Previous v0.6.6: AgentUIMiddleware shared workflow fix, execute() method standardization.
+New in v0.8.6: Enhanced parameter validation system with 4 modes (off/warn/strict/debug),
+ParameterDebugger for comprehensive flow tracing (10x faster debugging), production-ready
+performance (<1ms overhead), and complete troubleshooting documentation.
+Previous v0.8.5: Test infrastructure enhancement, application framework improvements.
 """
 
 from kailash.nodes.base import Node, NodeMetadata, NodeParameter
@@ -49,7 +49,7 @@ except ImportError:
 # For backward compatibility
 WorkflowGraph = Workflow
 
-__version__ = "0.8.5"
+__version__ = "0.8.6"
 
 __all__ = [
     # Core workflow components

kailash/channels/__init__.py

@@ -5,7 +5,7 @@ enabling unified management of API, CLI, and MCP interfaces through a common cha
 """
 
 from .api_channel import APIChannel
-from .base import Channel, ChannelConfig
+from .base import Channel, ChannelConfig, ChannelType
 from .cli_channel import CLIChannel
 from .mcp_channel import MCPChannel
 from .session import CrossChannelSession, SessionManager
@@ -13,6 +13,7 @@ from .session import CrossChannelSession, SessionManager
 __all__ = [
     "Channel",
     "ChannelConfig",
+    "ChannelType",
     "APIChannel",
     "CLIChannel",
     "MCPChannel",

kailash/channels/mcp_channel.py

@@ -84,6 +84,7 @@ class MCPChannel(Channel):
         # MCP-specific state
         self._clients: Dict[str, Dict[str, Any]] = {}
         self._server_task: Optional[asyncio.Task] = None
+        self._mcp_server_task: Optional[asyncio.Task] = None
 
         logger.info(f"Initialized MCP channel {self.name}")
 
@@ -202,8 +203,15 @@ class MCPChannel(Channel):
             self.status = ChannelStatus.STARTING
             self._setup_event_queue()
 
-            # Start MCP server
-            await self.mcp_server.start()
+            # Start MCP server (Core SDK uses run() method, not start())
+            # For async operation, we need to run it in a separate task
+            if hasattr(self.mcp_server, "run"):
+                # Core SDK MCPServer uses run() method
+                loop = asyncio.get_event_loop()
+                self._mcp_server_task = loop.run_in_executor(None, self.mcp_server.run)
+            else:
+                # Fallback to start() if available
+                await self.mcp_server.start()
 
             # Start server task for handling connections
             self._server_task = asyncio.create_task(self._server_loop())
@@ -261,9 +269,20 @@ class MCPChannel(Channel):
                 except asyncio.CancelledError:
                     pass
 
+            # Stop MCP server task if running
+            if hasattr(self, "_mcp_server_task") and self._mcp_server_task:
+                self._mcp_server_task.cancel()
+                try:
+                    await self._mcp_server_task
+                except asyncio.CancelledError:
+                    pass
+
             # Stop MCP server
-            if self.mcp_server:
-                await self.mcp_server.stop()
+            if self.mcp_server and hasattr(self.mcp_server, "stop"):
+                try:
+                    await self.mcp_server.stop()
+                except Exception as e:
+                    logger.warning(f"Error stopping MCP server: {e}")
 
             await self._cleanup()
             self.status = ChannelStatus.STOPPED

kailash/cli/validate_imports.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""
+Command-line tool for validating import paths for production deployment.
+
+Usage:
+    python -m kailash.cli.validate_imports [path] [options]
+
+Examples:
+    # Validate current directory
+    python -m kailash.cli.validate_imports
+
+    # Validate specific directory
+    python -m kailash.cli.validate_imports src/myapp
+
+    # Fix imports (dry run)
+    python -m kailash.cli.validate_imports src/myapp --fix
+
+    # Fix imports (apply changes)
+    python -m kailash.cli.validate_imports src/myapp --fix --apply
+"""
+
+import argparse
+import sys
+from pathlib import Path
+from typing import List
+
+from kailash.runtime.validation import ImportIssue, ImportPathValidator
+
+
+def main():
+    """Main entry point for import validation CLI."""
+    parser = argparse.ArgumentParser(
+        description="Validate Python imports for production deployment compatibility",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s                    # Validate current directory
+  %(prog)s src/myapp          # Validate specific directory
+  %(prog)s src/myapp --fix    # Show import fixes (dry run)
+  %(prog)s --file module.py   # Validate single file
+  
+For more info, see: sdk-users/7-gold-standards/absolute-imports-gold-standard.md
+        """,
+    )
+
+    parser.add_argument(
+        "path",
+        nargs="?",
+        default=".",
+        help="Path to validate (directory or file, default: current directory)",
+    )
+
+    parser.add_argument(
+        "--file",
+        "-f",
+        action="store_true",
+        help="Treat path as a single file instead of directory",
+    )
+
+    parser.add_argument(
+        "--fix", action="store_true", help="Show suggested fixes for import issues"
+    )
+
+    parser.add_argument(
+        "--apply",
+        action="store_true",
+        help="Apply fixes (use with --fix, CAUTION: modifies files!)",
+    )
+
+    parser.add_argument(
+        "--no-recursive", "-n", action="store_true", help="Do not scan subdirectories"
+    )
+
+    parser.add_argument(
+        "--include-tests", action="store_true", help="Include test files in validation"
+    )
+
+    parser.add_argument("--json", action="store_true", help="Output results as JSON")
+
+    parser.add_argument(
+        "--quiet",
+        "-q",
+        action="store_true",
+        help="Only show errors, no informational output",
+    )
+
+    parser.add_argument(
+        "--verbose", "-v", action="store_true", help="Show detailed output"
+    )
+
+    args = parser.parse_args()
+
+    # Create validator
+    validator = ImportPathValidator()
+
+    # Validate path
+    path = Path(args.path)
+    if not path.exists():
+        print(f"Error: Path '{path}' does not exist", file=sys.stderr)
+        sys.exit(1)
+
+    # Collect issues
+    issues: List[ImportIssue] = []
+
+    if args.file or path.is_file():
+        # Validate single file
+        if args.verbose:
+            print(f"Validating file: {path}")
+        issues = validator.validate_file(str(path))
+    else:
+        # Validate directory
+        if args.verbose:
+            print(f"Validating directory: {path}")
+            print(f"Recursive: {not args.no_recursive}")
+            print(f"Include tests: {args.include_tests}")
+            print()
+
+        # TODO: Add support for include_tests flag in validator
+        issues = validator.validate_directory(
+            str(path), recursive=not args.no_recursive
+        )
+
+    # Handle results
+    if args.json:
+        import json
+
+        # Convert issues to JSON-serializable format
+        issues_data = [
+            {
+                "file": issue.file_path,
+                "line": issue.line_number,
+                "import": issue.import_statement,
+                "type": issue.issue_type.value,
+                "severity": issue.severity,
+                "message": issue.message,
+                "suggestion": issue.suggestion,
+            }
+            for issue in issues
+        ]
+        print(
+            json.dumps(
+                {
+                    "issues": issues_data,
+                    "total": len(issues),
+                    "critical": len([i for i in issues if i.severity == "critical"]),
+                    "warnings": len([i for i in issues if i.severity == "warning"]),
+                },
+                indent=2,
+            )
+        )
+
+    elif args.fix:
+        # Show fixes
+        if not issues:
+            if not args.quiet:
+                print("✅ No import issues found!")
+            sys.exit(0)
+
+        print(f"Found {len(issues)} import issues\n")
+
+        # Group by file
+        files_with_issues = {}
+        for issue in issues:
+            if issue.file_path not in files_with_issues:
+                files_with_issues[issue.file_path] = []
+            files_with_issues[issue.file_path].append(issue)
+
+        for file_path, file_issues in files_with_issues.items():
+            print(f"\n📄 {file_path}")
+            print("-" * 60)
+
+            if args.apply:
+                # Apply fixes
+                fixes = validator.fix_imports_in_file(file_path, dry_run=False)
+                for original, fixed in fixes:
+                    print(f"  ❌ {original}")
+                    print(f"  ✅ {fixed}")
+                print(f"\n  Applied {len(fixes)} fixes to {file_path}")
+            else:
+                # Show proposed fixes
+                for issue in file_issues:
+                    print(f"  Line {issue.line_number}: {issue.import_statement}")
+                    print(f"  Issue: {issue.message}")
+                    print(f"  Fix: {issue.suggestion}")
+                    print()
+
+        if not args.apply:
+            print("\n💡 To apply these fixes, run with --fix --apply")
+            print("⚠️  CAUTION: This will modify your files!")
+
+    else:
+        # Standard report
+        report = validator.generate_report(issues)
+        print(report)
+
+    # Exit code based on critical issues
+    critical_count = len([i for i in issues if i.severity == "critical"])
+    sys.exit(1 if critical_count > 0 else 0)
+
+
+if __name__ == "__main__":
+    main()

kailash/core/resilience/bulkhead.py

@@ -204,11 +204,21 @@ class BulkheadPartition:
             await self._record_failure(execution_time)
             raise
         finally:
-            # Clean up
-            async with self._lock:
-                if operation_id in self._active_operations:
-                    self._active_operations.remove(operation_id)
-                self.metrics.active_operations = len(self._active_operations)
+            # Clean up - with proper exception handling for event loop issues
+            try:
+                async with self._lock:
+                    if operation_id in self._active_operations:
+                        self._active_operations.remove(operation_id)
+                    self.metrics.active_operations = len(self._active_operations)
+            except (RuntimeError, asyncio.CancelledError):
+                # Handle event loop issues during cleanup - force cleanup without lock
+                try:
+                    if operation_id in self._active_operations:
+                        self._active_operations.remove(operation_id)
+                    self.metrics.active_operations = len(self._active_operations)
+                except:
+                    # Final fallback - ignore cleanup errors during shutdown
+                    pass
 
     async def _execute_isolated(
         self, operation_id: str, func: Callable, args: tuple, kwargs: dict, timeout: int

kailash/core/resilience/circuit_breaker.py

@@ -467,7 +467,10 @@ class CircuitBreakerManager:
         return self._breakers[name]
 
     def create_circuit_breaker(
-        self, name: str, config: Optional[CircuitBreakerConfig] = None, pattern: Optional[str] = None
+        self,
+        name: str,
+        config: Optional[CircuitBreakerConfig] = None,
+        pattern: Optional[str] = None,
     ) -> ConnectionCircuitBreaker:
         """Create a new circuit breaker with optional pattern-based configuration."""
         if pattern and pattern in self._patterns: