kailash 0.9.14__tar.gz → 0.9.15__tar.gz

{kailash-0.9.14/src/kailash.egg-info → kailash-0.9.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kailash
-Version: 0.9.14
+Version: 0.9.15
 Summary: Python SDK for the Kailash container-node architecture
 Home-page: https://github.com/integrum/kailash-python-sdk
 Author: Integrum

{kailash-0.9.14 → kailash-0.9.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kailash"
-version = "0.9.14"
+version = "0.9.15"
 description = "Python SDK for the Kailash container-node architecture"
 authors = [
     {name = "Integrum", email = "info@integrum.com"}

{kailash-0.9.14 → kailash-0.9.15}/src/kailash/__init__.py

@@ -6,6 +6,7 @@ that align with container-node architecture while allowing rapid prototyping.
 New in v0.9.14: Code quality improvements and updated dependencies for DataFlow v0.4.6 compatibility.
 Applied black formatting fixes and ensured CI stability. Updated dependency references to latest framework versions.
 Previous v0.9.13: Fixed WorkflowBuilder parameter validation false positives (Bug 010).
+Enhanced validation.py to recognize auto_map_from parameters, eliminating spurious warnings.
 Previous v0.9.12: SQLite Compatibility & Code Quality improvements.
 Previous v0.9.2: WebSocket Transport Support with Enterprise Connection Pooling.
 Fixed "Unsupported transport: websocket" error. Added 73% performance improvement with connection pooling.

{kailash-0.9.14 → kailash-0.9.15}/src/kailash/cli/validate_imports.py

@@ -38,7 +38,7 @@ Examples:
   %(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
         """,
     )

{kailash-0.9.14 → kailash-0.9.15}/src/kailash/core/ml/query_patterns.py

@@ -59,8 +59,8 @@ class QueryPatternTracker:
     """Tracks and analyzes query execution patterns."""
 
     def __init__(
-        self, retention_hours: int = 168, min_pattern_frequency: int = 5  # 7 days
-    ):
+        self, retention_hours: int = 168, min_pattern_frequency: int = 5
+    ):  # 7 days
         self.retention_hours = retention_hours
         self.min_pattern_frequency = min_pattern_frequency
 

{kailash-0.9.14 → kailash-0.9.15}/src/kailash/edge/resource/platform_integration.py

@@ -14,10 +14,7 @@ from .cloud_integration import (
     InstanceState,
 )
 from .cost_optimizer import CloudProvider as CostCloudProvider
-from .cost_optimizer import (
-    CostOptimizer,
-    OptimizationStrategy,
-)
+from .cost_optimizer import CostOptimizer, OptimizationStrategy
 from .docker_integration import (
     ContainerSpec,
     ContainerState,

{kailash-0.9.14 → kailash-0.9.15}/src/kailash/integrations/dataflow_edge.py

@@ -227,7 +227,7 @@ class SensitiveData:
     user_id: int
     personal_info: dict
     location: str
-    
+
     __dataflow__ = {
         'multi_tenant': True,
         'soft_delete': True,
@@ -247,7 +247,7 @@ class SensitiveData:
 
 # When using generated nodes in workflows:
 workflow = WorkflowBuilder(edge_config=DataFlowEdgeIntegration.create_edge_workflow_config(
-    'SensitiveData', 
+    'SensitiveData',
     SensitiveData.__dataflow__['edge_config']
 ))
 

{kailash-0.9.14 → kailash-0.9.15}/src/kailash/middleware/database/base_models.py

@@ -8,13 +8,7 @@ import uuid
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
-from sqlalchemy import (
-    JSON,
-    Boolean,
-    CheckConstraint,
-    Column,
-    DateTime,
-)
+from sqlalchemy import JSON, Boolean, CheckConstraint, Column, DateTime
 from sqlalchemy import Enum as SQLEnum
 from sqlalchemy import (
     Float,

{kailash-0.9.14 → kailash-0.9.15}/src/kailash/monitoring/alerts.py

@@ -260,12 +260,12 @@ class EmailNotificationChannel(NotificationChannel):
         <p><strong>Status:</strong> {alert.status.value}</p>
         <p><strong>Description:</strong> {alert.description}</p>
         <p><strong>Created:</strong> {alert.created_at.isoformat()}</p>
-        
+
         <h3>Labels:</h3>
         <ul>
         {"".join(f"<li><strong>{k}:</strong> {v}</li>" for k, v in alert.labels.items())}
         </ul>
-        
+
         <h3>Context:</h3>
         <ul>
         {"".join(f"<li><strong>{k}:</strong> {v}</li>" for k, v in context.items())}

kailash-0.9.15/src/kailash/nodes/__init__.py

@@ -0,0 +1,229 @@
+"""
+Kailash SDK Nodes Module - Safe Lazy Loading Implementation
+
+This implementation provides lazy loading with circular dependency protection
+and maintains full backward compatibility.
+"""
+
+import importlib
+import sys
+import warnings
+from typing import Any, Dict, Optional, Set
+
+# Core imports that are always needed
+from .base import Node, NodeParameter, NodeRegistry
+
+# Track loading state to detect circular dependencies
+_LOADING_STACK: Set[str] = set()
+_LOADED_MODULES: Dict[str, Optional[Any]] = {}
+
+# Define available node categories for lazy loading
+_NODE_CATEGORIES = [
+    "ai",
+    "alerts",
+    "api",
+    "auth",
+    "cache",
+    "code",
+    "compliance",
+    "data",
+    "edge",
+    "enterprise",
+    "logic",
+    "mixins",
+    "monitoring",
+    "rag",
+    "security",
+    "testing",
+    "transaction",
+    "transform",
+]
+
+# Initialize lazy module cache
+_LAZY_MODULES: Dict[str, Optional[Any]] = {
+    category: None for category in _NODE_CATEGORIES
+}
+
+
+def _safe_lazy_import(name: str) -> Any:
+    """
+    Safely import a module with circular dependency detection.
+
+    Args:
+        name: The module name to import
+
+    Returns:
+        The imported module
+
+    Raises:
+        ImportError: If a circular dependency is detected
+    """
+    full_module_name = f"kailash.nodes.{name}"
+
+    # Check if already loaded
+    if name in _LOADED_MODULES:
+        return _LOADED_MODULES[name]
+
+    # Check for circular dependency
+    if full_module_name in _LOADING_STACK:
+        cycle_modules = list(_LOADING_STACK) + [full_module_name]
+        warnings.warn(
+            f"Circular dependency detected: {' -> '.join(cycle_modules)}. "
+            f"Using partial import to break the cycle.",
+            ImportWarning,
+            stacklevel=3,
+        )
+        # Return a placeholder that will be populated after loading
+        module = sys.modules.get(full_module_name)
+        if module:
+            return module
+        # Create empty module as placeholder
+        module = type(sys)("placeholder")
+        sys.modules[full_module_name] = module
+        return module
+
+    # Add to loading stack
+    _LOADING_STACK.add(full_module_name)
+
+    try:
+        # Perform the actual import
+        module = importlib.import_module(f".{name}", package="kailash.nodes")
+        _LOADED_MODULES[name] = module
+        return module
+    finally:
+        # Remove from loading stack
+        _LOADING_STACK.discard(full_module_name)
+
+
+def __getattr__(name: str) -> Any:
+    """
+    Lazy loading of node category modules with circular dependency protection.
+
+    This function is called when accessing an attribute that doesn't exist
+    in the module's namespace. It enables lazy loading of node categories
+    while detecting and handling circular dependencies.
+
+    Args:
+        name: The attribute name being accessed
+
+    Returns:
+        The requested module or attribute
+
+    Raises:
+        AttributeError: If the attribute doesn't exist
+    """
+    # Check if it's a known node category
+    if name in _LAZY_MODULES:
+        if _LAZY_MODULES[name] is None:
+            try:
+                # Use safe import with circular dependency detection
+                _LAZY_MODULES[name] = _safe_lazy_import(name)
+            except ImportError as e:
+                # Log the error and re-raise
+                import logging
+
+                logging.error(f"Failed to import kailash.nodes.{name}: {e}")
+                raise
+        return _LAZY_MODULES[name]
+
+    # Handle special attributes
+    if name == "__all__":
+        return ["Node", "NodeParameter", "NodeRegistry"] + _NODE_CATEGORIES
+
+    # Attribute not found
+    raise AttributeError(f"module 'kailash.nodes' has no attribute '{name}'")
+
+
+def __dir__():
+    """Return the list of available attributes for tab completion."""
+    return ["Node", "NodeParameter", "NodeRegistry"] + _NODE_CATEGORIES
+
+
+def check_circular_dependencies() -> Dict[str, Any]:
+    """
+    Check for circular dependencies in the nodes module.
+
+    Returns:
+        A dictionary containing:
+        - has_circular_deps: Boolean indicating if circular deps exist
+        - circular_chains: List of circular dependency chains found
+        - warnings: List of warning messages
+    """
+    from pathlib import Path
+
+    from ..utils.circular_dependency_detector import CircularDependencyDetector
+
+    # Get the SDK root directory
+    sdk_root = Path(__file__).parent.parent.parent
+
+    detector = CircularDependencyDetector(sdk_root)
+    detector.build_import_graph("src/kailash/nodes")
+    cycles = detector.detect_cycles()
+
+    result = {
+        "has_circular_deps": bool(cycles),
+        "circular_chains": cycles,
+        "warnings": [],
+    }
+
+    if cycles:
+        for cycle in cycles:
+            result["warnings"].append(
+                f"Circular dependency detected: {' -> '.join(cycle)} -> {cycle[0]}"
+            )
+
+    return result
+
+
+def preload_all_categories():
+    """
+    Preload all node categories (useful for testing or warming up).
+
+    This function loads all node categories immediately rather than lazily.
+    It's useful for:
+    - Testing that all imports work correctly
+    - Warming up the import cache
+    - Detecting circular dependencies early
+    """
+    failed_imports = []
+
+    for category in _NODE_CATEGORIES:
+        try:
+            _safe_lazy_import(category)
+        except ImportError as e:
+            failed_imports.append((category, str(e)))
+
+    if failed_imports:
+        warnings.warn(
+            f"Failed to import some categories: {failed_imports}", ImportWarning
+        )
+
+    return {
+        "loaded": [cat for cat in _NODE_CATEGORIES if cat in _LOADED_MODULES],
+        "failed": failed_imports,
+    }
+
+
+# Performance monitoring
+def get_import_stats() -> Dict[str, Any]:
+    """
+    Get statistics about module imports.
+
+    Returns:
+        Dictionary containing import statistics
+    """
+    return {
+        "loaded_modules": list(_LOADED_MODULES.keys()),
+        "pending_modules": [
+            cat for cat in _NODE_CATEGORIES if cat not in _LOADED_MODULES
+        ],
+        "total_categories": len(_NODE_CATEGORIES),
+        "loaded_count": len(_LOADED_MODULES),
+        "currently_loading": list(_LOADING_STACK),
+    }
+
+
+# Backward compatibility - ensure all existing imports work
+__all__ = ["Node", "NodeParameter", "NodeRegistry"] + _NODE_CATEGORIES
+
+# Export core components directly

{kailash-0.9.14 → kailash-0.9.15}/src/kailash/nodes/ai/iterative_llm_agent.py

@@ -1666,7 +1666,7 @@ class IterativeLLMAgentNode(LLMAgentNode):
         synthesis_messages = [
             {
                 "role": "system",
-                "content": """You are an AI assistant synthesizing results from an iterative analysis process. 
+                "content": """You are an AI assistant synthesizing results from an iterative analysis process.
                 Create a comprehensive, helpful response based on the findings from multiple iterations of analysis.""",
             },
             {
@@ -1679,7 +1679,7 @@ Results from {len(iterations)} iterations:
 Insights achieved:
 {chr(10).join(all_insights[:5]) if all_insights else "No specific insights achieved"}
 
-Please provide a comprehensive response to the original query based on these findings. If the findings are limited, 
+Please provide a comprehensive response to the original query based on these findings. If the findings are limited,
 provide your best analysis of the query directly.""",
             },
         ]

kailash-0.9.15/src/kailash/utils/circular_dependency_detector.py

@@ -0,0 +1,319 @@
+"""
+Circular Dependency Detector for Kailash SDK
+
+This module provides tools to detect and report circular dependencies in the codebase,
+ensuring that lazy loading doesn't mask architectural issues.
+"""
+
+import ast
+import importlib
+import os
+import sys
+from collections import defaultdict, deque
+from pathlib import Path
+from typing import Dict, List, Optional, Set, Tuple
+
+
+class CircularDependencyDetector:
+    """Detects circular dependencies in Python modules."""
+
+    def __init__(self, root_path: str):
+        """Initialize the detector with the root path of the codebase."""
+        self.root_path = Path(root_path)
+        self.import_graph: Dict[str, Set[str]] = defaultdict(set)
+        self.visited_files: Set[str] = set()
+        self.circular_deps: List[List[str]] = []
+
+    def analyze_file(self, file_path: Path) -> Set[str]:
+        """Extract all imports from a Python file."""
+        imports = set()
+
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                tree = ast.parse(f.read(), str(file_path))
+
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for alias in node.names:
+                        imports.add(alias.name)
+                elif isinstance(node, ast.ImportFrom):
+                    if node.module:
+                        # Handle relative imports
+                        if node.level > 0:
+                            # Relative import
+                            module_parts = (
+                                str(file_path.relative_to(self.root_path))
+                                .replace(".py", "")
+                                .split("/")
+                            )
+                            parent_parts = (
+                                module_parts[: -node.level]
+                                if node.level < len(module_parts)
+                                else []
+                            )
+                            if node.module:
+                                full_module = ".".join(
+                                    parent_parts + node.module.split(".")
+                                )
+                            else:
+                                full_module = ".".join(parent_parts)
+                            imports.add(full_module.replace("/", "."))
+                        else:
+                            imports.add(node.module)
+
+        except (SyntaxError, FileNotFoundError) as e:
+            print(f"Error analyzing {file_path}: {e}")
+
+        return imports
+
+    def build_import_graph(self, start_dir: str = "src/kailash"):
+        """Build the complete import dependency graph."""
+        start_path = self.root_path / start_dir
+
+        for py_file in start_path.rglob("*.py"):
+            # Skip test files and __pycache__
+            if "__pycache__" in str(py_file) or "test_" in py_file.name:
+                continue
+
+            module_name = self._path_to_module(py_file)
+            imports = self.analyze_file(py_file)
+
+            # Filter to only internal imports
+            internal_imports = {
+                imp
+                for imp in imports
+                if imp.startswith("kailash") or imp.startswith(".")
+            }
+
+            self.import_graph[module_name].update(internal_imports)
+
+    def _path_to_module(self, file_path: Path) -> str:
+        """Convert file path to module name."""
+        relative = file_path.relative_to(self.root_path / "src")
+        module = str(relative).replace(".py", "").replace("/", ".")
+        return module
+
+    def detect_cycles(self) -> List[List[str]]:
+        """Detect all circular dependencies using DFS."""
+        visited = set()
+        rec_stack = set()
+        path = []
+        cycles = []
+
+        def dfs(module: str) -> bool:
+            visited.add(module)
+            rec_stack.add(module)
+            path.append(module)
+
+            for imported in self.import_graph.get(module, set()):
+                if imported not in visited:
+                    if dfs(imported):
+                        return True
+                elif imported in rec_stack:
+                    # Found a cycle
+                    cycle_start = path.index(imported)
+                    cycle = path[cycle_start:] + [imported]
+                    cycles.append(cycle)
+
+            path.pop()
+            rec_stack.remove(module)
+            return False
+
+        for module in self.import_graph:
+            if module not in visited:
+                dfs(module)
+
+        # Remove duplicate cycles
+        unique_cycles = []
+        seen = set()
+        for cycle in cycles:
+            # Normalize cycle to start with smallest element
+            min_idx = cycle.index(min(cycle))
+            normalized = tuple(cycle[min_idx:] + cycle[:min_idx])
+            if normalized not in seen:
+                seen.add(normalized)
+                unique_cycles.append(
+                    list(normalized)[:-1]
+                )  # Remove duplicate last element
+
+        return unique_cycles
+
+    def check_lazy_loading_safety(self, module_path: str) -> Dict[str, any]:
+        """Check if lazy loading is safe for a given module."""
+        result = {
+            "module": module_path,
+            "has_circular_deps": False,
+            "circular_chains": [],
+            "safe_for_lazy_loading": True,
+            "warnings": [],
+        }
+
+        # Check if module is involved in any circular dependencies
+        for cycle in self.circular_deps:
+            if module_path in cycle:
+                result["has_circular_deps"] = True
+                result["circular_chains"].append(cycle)
+                result["safe_for_lazy_loading"] = False
+                result["warnings"].append(
+                    f"Module is part of circular dependency: {' -> '.join(cycle)}"
+                )
+
+        return result
+
+    def generate_report(self) -> str:
+        """Generate a comprehensive circular dependency report."""
+        self.build_import_graph()
+        self.circular_deps = self.detect_cycles()
+
+        report = []
+        report.append("=" * 80)
+        report.append("CIRCULAR DEPENDENCY ANALYSIS REPORT")
+        report.append("=" * 80)
+        report.append("")
+
+        if not self.circular_deps:
+            report.append("✅ No circular dependencies detected!")
+        else:
+            report.append(
+                f"⚠️  Found {len(self.circular_deps)} circular dependency chains:"
+            )
+            report.append("")
+
+            for i, cycle in enumerate(self.circular_deps, 1):
+                report.append(f"{i}. Circular dependency chain:")
+                report.append(f"   {' -> '.join(cycle)} -> {cycle[0]}")
+                report.append("")
+
+        # Analyze specific high-risk modules
+        high_risk_modules = [
+            "kailash.nodes.ai.a2a",
+            "kailash.nodes.ai.self_organizing",
+            "kailash.nodes.ai.intelligent_agent_orchestrator",
+            "kailash.nodes.__init__",
+        ]
+
+        report.append("-" * 80)
+        report.append("HIGH-RISK MODULE ANALYSIS")
+        report.append("-" * 80)
+
+        for module in high_risk_modules:
+            safety = self.check_lazy_loading_safety(module)
+            if safety["has_circular_deps"]:
+                report.append(f"\n❌ {module}:")
+                for warning in safety["warnings"]:
+                    report.append(f"   - {warning}")
+            else:
+                report.append(f"\n✅ {module}: No circular dependencies")
+
+        report.append("")
+        report.append("=" * 80)
+
+        return "\n".join(report)
+
+
+class CircularImportResolver:
+    """Provides solutions for resolving circular dependencies."""
+
+    @staticmethod
+    def create_lazy_import_wrapper(
+        module_name: str, attribute_name: Optional[str] = None
+    ) -> str:
+        """Generate code for a lazy import wrapper."""
+        if attribute_name:
+            return f"""
+def get_{attribute_name}():
+    \"\"\"Lazy import of {module_name}.{attribute_name}\"\"\"
+    from {module_name} import {attribute_name}
+    return {attribute_name}
+"""
+        else:
+            return f"""
+def get_{module_name.split('.')[-1]}():
+    \"\"\"Lazy import of {module_name}\"\"\"
+    import {module_name}
+    return {module_name}
+"""
+
+    @staticmethod
+    def create_type_checking_import(module_name: str, types: List[str]) -> str:
+        """Generate code for TYPE_CHECKING imports to avoid runtime circular deps."""
+        return f"""
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from {module_name} import {', '.join(types)}
+"""
+
+    @staticmethod
+    def suggest_refactoring(cycles: List[List[str]]) -> List[str]:
+        """Suggest refactoring strategies for circular dependencies."""
+        suggestions = []
+
+        for cycle in cycles:
+            if len(cycle) == 2:
+                suggestions.append(
+                    f"""
+Circular dependency between {cycle[0]} and {cycle[1]}:
+1. Extract shared functionality to a common base module
+2. Use dependency injection instead of direct imports
+3. Consider if one module should be a submodule of the other
+"""
+                )
+            elif "ai" in str(cycle):
+                suggestions.append(
+                    f"""
+AI module circular dependency in {' -> '.join(cycle)}:
+1. Create an ai.base module for shared components
+2. Use factory pattern for agent creation
+3. Move orchestration logic to a separate coordinator module
+"""
+                )
+            else:
+                suggestions.append(
+                    f"""
+Complex circular dependency in {' -> '.join(cycle)}:
+1. Apply Dependency Inversion Principle
+2. Create interfaces/protocols for cross-module communication
+3. Use event-driven architecture to decouple modules
+"""
+                )
+
+        return suggestions
+
+
+def main():
+    """Run circular dependency detection on Kailash SDK."""
+    # Get the SDK root directory
+    sdk_root = Path(__file__).parent.parent.parent.parent
+
+    detector = CircularDependencyDetector(sdk_root)
+    report = detector.generate_report()
+
+    print(report)
+
+    if detector.circular_deps:
+        print("\n" + "=" * 80)
+        print("REFACTORING SUGGESTIONS")
+        print("=" * 80)
+
+        resolver = CircularImportResolver()
+        suggestions = resolver.suggest_refactoring(detector.circular_deps)
+
+        for i, suggestion in enumerate(suggestions, 1):
+            print(f"\n{i}. {suggestion}")
+
+        print("\n" + "=" * 80)
+        print("IMMEDIATE ACTION REQUIRED")
+        print("=" * 80)
+        print(
+            """
+1. Fix AI module circular dependencies (critical)
+2. Clean up duplicate __init__.py files
+3. Implement lazy loading WITH circular dependency checks
+4. Add this detector to CI/CD pipeline
+"""
+        )
+
+
+if __name__ == "__main__":
+    main()

{kailash-0.9.14 → kailash-0.9.15/src/kailash.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kailash
-Version: 0.9.14
+Version: 0.9.15
 Summary: Python SDK for the Kailash container-node architecture
 Home-page: https://github.com/integrum/kailash-python-sdk
 Author: Integrum