kailash 0.9.14__py3-none-any.whl → 0.9.15__py3-none-any.whl

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/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/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/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/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/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/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/nodes/__init__.py

@@ -1,42 +1,24 @@
-"""Node system for the Kailash SDK."""
-
-# Import all node modules to ensure registration - fixed circular import
-from kailash.nodes.base import Node, NodeParameter, NodeRegistry, register_node
-from kailash.nodes.base_cycle_aware import CycleAwareNode
-from kailash.nodes.code import PythonCodeNode
-
-from . import (
-    ai,
-    alerts,
-    api,
-    auth,
-    cache,
-    code,
-    compliance,
-    data,
-    edge,
-    enterprise,
-    logic,
-    mixins,
-    monitoring,
-    security,
-    testing,
-    transaction,
-    transform,
-)
-
-# Compatibility alias - AsyncNode is now just Node
-AsyncNode = Node
-
-__all__ = [
-    "Node",
-    "AsyncNode",  # Compatibility alias
-    "CycleAwareNode",
-    "NodeParameter",
-    "NodeRegistry",
-    "register_node",
-    "PythonCodeNode",
-    # Node modules
+"""
+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",
@@ -50,8 +32,198 @@ __all__ = [
     "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/nodes/__init___original.py

@@ -0,0 +1,57 @@
+"""Node system for the Kailash SDK."""
+
+# Import all node modules to ensure registration - fixed circular import
+from kailash.nodes.base import Node, NodeParameter, NodeRegistry, register_node
+from kailash.nodes.base_cycle_aware import CycleAwareNode
+from kailash.nodes.code import PythonCodeNode
+
+from . import (
+    ai,
+    alerts,
+    api,
+    auth,
+    cache,
+    code,
+    compliance,
+    data,
+    edge,
+    enterprise,
+    logic,
+    mixins,
+    monitoring,
+    security,
+    testing,
+    transaction,
+    transform,
+)
+
+# Compatibility alias - AsyncNode is now just Node
+AsyncNode = Node
+
+__all__ = [
+    "Node",
+    "AsyncNode",  # Compatibility alias
+    "CycleAwareNode",
+    "NodeParameter",
+    "NodeRegistry",
+    "register_node",
+    "PythonCodeNode",
+    # Node modules
+    "ai",
+    "alerts",
+    "api",
+    "auth",
+    "cache",
+    "code",
+    "compliance",
+    "data",
+    "edge",
+    "enterprise",
+    "logic",
+    "mixins",
+    "monitoring",
+    "security",
+    "testing",
+    "transaction",
+    "transform",
+]

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/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.dist-info → kailash-0.9.15.dist-info}/METADATA

@@ -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.dist-info → kailash-0.9.15.dist-info}/RECORD

@@ -1,4 +1,4 @@
-kailash/__init__.py,sha256=5ah04rxNTa7lqceRYS0LAu2U7VHLfU09Jek3rd7Rm2k,2853
+kailash/__init__.py,sha256=ffp6pb2WvAiU8rhVtGWfCtb7StsOQLbshcvPDd7NY2o,2946
 kailash/__main__.py,sha256=vr7TVE5o16V6LsTmRFKG6RDKUXHpIWYdZ6Dok2HkHnI,198
 kailash/access_control.py,sha256=MjKtkoQ2sg1Mgfe7ovGxVwhAbpJKvaepPWr8dxOueMA,26058
 kailash/access_control_abac.py,sha256=FPfa_8PuDP3AxTjdWfiH3ntwWO8NodA0py9W8SE5dno,30263
@@ -28,7 +28,7 @@ kailash/channels/mcp_channel.py,sha256=V_BqYXHFb26V_8C6XOasgGZiDxLyN-BiRi5hsBgry
 kailash/channels/session.py,sha256=4ZEutfyQ3fhBlBjXa5e32ZL2ZqEuQKwbAk0DGu00X1A,13068
 kailash/cli/__init__.py,sha256=TvNjX0Q-2IxdWeh6w8rkqyONuFbSleStlRF8b-Aa8Iw,302
 kailash/cli/commands.py,sha256=lv1S1uB0JQE4tiQCJIa1HCbjYDbFE9KwcK3M1jRtRU4,18168
-kailash/cli/validate_imports.py,sha256=ebmruTzNyy_k9EGoXunO_7rntcoqH88lkbN6XyFtZXE,6093
+kailash/cli/validate_imports.py,sha256=fJswjiuXLtZcDjzc7SRRPBBA7hDXgVRwiG04e_f547E,6091
 kailash/cli/validation_audit.py,sha256=0WBzOdh1pkaqYm011bpnumyMf30blvPzq9_nsUQoGno,20308
 kailash/client/__init__.py,sha256=WNR39t4O6TDQLI14uR_MjQpLza2c6rU3YkQCXcGCiSU,293
 kailash/client/enhanced_client.py,sha256=trcDWQsON0Hphj14WozVMbfU7HKuxauknzDfoy1fTlo,9431
@@ -39,7 +39,7 @@ kailash/core/actors/adaptive_pool_controller.py,sha256=tque9heLsLwjrNlM1wZSAYi1R
 kailash/core/actors/connection_actor.py,sha256=M8fOX1a3jvH5PUkfQyk0eBJqCk0SD9KGZCw0TXLON_o,18979
 kailash/core/actors/supervisor.py,sha256=GaTbRRA0REHNnsn0a8NXao-aj9Eh8KkZt6H2YJm7I4w,11975
 kailash/core/ml/__init__.py,sha256=eaD-bmoxMXtwwtKWePsoX1IkcpysX0bMAGyMR7jaAqI,64
-kailash/core/ml/query_patterns.py,sha256=4wV1pBOwUiK80UTKuMXSoRgR0pojtjg2BMNoa5qWpc0,20290
+kailash/core/ml/query_patterns.py,sha256=gDr_WVg_7JK6HSisKZ28Gtrm95M4XVlwtIesXXu4olM,20290
 kailash/core/monitoring/__init__.py,sha256=Qua4i50JYUQcRkWHy1wGyuXGqzqsDVMmdPtud746xts,371
 kailash/core/monitoring/connection_metrics.py,sha256=fvFyHOgMU5lgRB2EB7d-D_F5XERjlmcGAfkrIL0I_OQ,16805
 kailash/core/optimization/__init__.py,sha256=FY5SLLNedH0_aawLYdXHj2rsGdBaaB49QuJ_R9ctHOE,65
@@ -71,7 +71,7 @@ kailash/edge/resource/cloud_integration.py,sha256=0zBBuWKaN5yqoBGLj5c5YcfmLwxCkj
 kailash/edge/resource/cost_optimizer.py,sha256=pPp985nMp6r4MzlR0k8D5PyNEKtkV7EIKkxwfIcZXiA,32916
 kailash/edge/resource/docker_integration.py,sha256=2CnhKF5P4cgwgk-r01Nr3IObJPTLvmk_Yu757Uu8vNg,30375
 kailash/edge/resource/kubernetes_integration.py,sha256=g703nAN3rVQK65lcphnth_6VOZHLo6FGprUYVgc5poQ,33123
-kailash/edge/resource/platform_integration.py,sha256=Rdc3bqz1MYFzPNSKKTkKwNGkl5-HzjvG0xtzwblDy1o,33522
+kailash/edge/resource/platform_integration.py,sha256=EOH_Kw_4MVS71pa3oNkgDxsXEUo0q9qdLBv0GnrGjCc,33509
 kailash/edge/resource/predictive_scaler.py,sha256=FxoYIq1Xd6HOilWydOlxWn0jCIzKcaJqrxePw_YQH2Y,32728
 kailash/edge/resource/resource_analyzer.py,sha256=tcQM2uS_b985fY_-YOOhN_DiDjjVGo1k5c1GFHHE9P8,30043
 kailash/edge/resource/resource_pools.py,sha256=YlKa3d1MMCw2lOv7gz-KIkOg-uLfFbW_uy6nwo3mefU,20107
@@ -80,7 +80,7 @@ kailash/gateway/api.py,sha256=xpK8PIamsqQPpKAJwacyV7RA_Snjv2pc_0ljnnU9Oy4,9534
 kailash/gateway/enhanced_gateway.py,sha256=IlN1XV01FQrF4rGcq_z9LE4uUHAAAQoVsRNToXENen0,13399
 kailash/gateway/resource_resolver.py,sha256=IC1dceiKfjfUWToYCIBcrUapuR3LlDG6RJ4o7haLY10,7746
 kailash/gateway/security.py,sha256=kf4Quf6u7dqhs80fQQ982eHbRb4weDKG0DaYNeKntT4,7557
-kailash/integrations/dataflow_edge.py,sha256=R3Is8JJZcqLNn4op7gidp1dtbT82oY5vn9tXVAWLOrg,8994
+kailash/integrations/dataflow_edge.py,sha256=UqQMrTHmVYkgJt9T3bfcumBexMnvcTtNUIDUYFonuPo,8989
 kailash/mcp_server/__init__.py,sha256=AzrCEat5gdl9Nes8xOs7D4Wj3HpGlms3xLbOrx2diPA,8791
 kailash/mcp_server/advanced_features.py,sha256=76dmttUa0M61ReBbgexf7Igu4CXaXS-CUmFhvTDjKyI,30673
 kailash/mcp_server/ai_registry_server.py,sha256=vMNMvWLegKBVp7YAHVKgltWa2vTXKNvV-_Ni_z1argM,28973
@@ -120,7 +120,7 @@ kailash/middleware/core/schema.py,sha256=uVF-5ZJlLYHOQdsKrG46FnTO1bq_QtDjhUSkIID
 kailash/middleware/core/workflows.py,sha256=kjwwP69-T6eCY7kWIMLUBwVy2CapoPR34cqCETquq0s,12480
 kailash/middleware/database/__init__.py,sha256=UMws94L-vja94AjfzPWIgn0h4_5BGQzI3YaSdqtzeLk,1682
 kailash/middleware/database/base.py,sha256=cWEei9Gb6J-C-bpa4M4T0takfWE3POXWumzYhqX3V4g,2735
-kailash/middleware/database/base_models.py,sha256=XBcHEUmcpl2f6zZHCAgHQ_0jqUB3Gl82XARR83lW5GY,18287
+kailash/middleware/database/base_models.py,sha256=t4HfXKGHZkfLkzoRgXXvlO_wdgsqXhm7S0XP4OIdQXc,18262
 kailash/middleware/database/enums.py,sha256=Yo_wMS7OpsleWtNMESTc2LTf15d93nPnBADIn2EHjeQ,2516
 kailash/middleware/database/migrations.py,sha256=v5VZxsqciwmOl3rzIBQLp5p6-OP8OG_EL3mu65_yrCM,240
 kailash/middleware/database/models.py,sha256=CJwwUEdgxqBteXqpFJr1tWskjypJxViZXjODZlByrFk,17784
@@ -137,9 +137,10 @@ kailash/middleware/mcp/__init__.py,sha256=EdZB8zOMSBEEmudRzs8ksz9QZJYWQMEx7Tm1MO
 kailash/middleware/mcp/client_integration.py,sha256=dY1RmX-g5E6JzUFuWxk7viuOYIh8bMwoUSvHQMVEsYk,18265
 kailash/middleware/mcp/enhanced_server.py,sha256=RUVS7jWHn0ma4F3F23UvuFwUdu7OkSsIRNQmGtkG9I8,18547
 kailash/monitoring/__init__.py,sha256=C5WmkNpk_mmAScqMWiCfkUbjhM5W16dsnRnc3Ial-Uc,475
-kailash/monitoring/alerts.py,sha256=eKX4ooPw1EicumPuswlR_nU18UgRETWvFg8FzCW5pVU,21416
+kailash/monitoring/alerts.py,sha256=Hk3Xs0EEkOIBH2ZhlejJBOsLYaPlvRejAAEGqNQISc0,21400
 kailash/monitoring/metrics.py,sha256=SiAnL3o6K0QaJHgfAuWBa-0pTkW5zymhuPEsj4bgOgM,22022
-kailash/nodes/__init__.py,sha256=p2KSo0dyUBCLClU123qpQ0tyv5S_36PTxosNyW58nyY,1031
+kailash/nodes/__init__.py,sha256=zn4M0f-sIPAq8bG5golQIxmEY8lG5d55Kzg8UNL2lAY,6392
+kailash/nodes/__init___original.py,sha256=p2KSo0dyUBCLClU123qpQ0tyv5S_36PTxosNyW58nyY,1031
 kailash/nodes/base.py,sha256=GR2E1fWf8j1yMvJic7m2NAih7kjY1NtoDi47hHwoZ40,85437
 kailash/nodes/base_async.py,sha256=whxepCiVplrltfzEQuabmnGCpEV5WgfqwgxbLdCyiDk,8864
 kailash/nodes/base_cycle_aware.py,sha256=Xpze9xZzLepWeLpi9Y3tMn1dm2LVv-omr5TSQuGTtWo,13377
@@ -166,7 +167,7 @@ kailash/nodes/ai/ai_providers.py,sha256=egfiOZzPmZ10d3wBCJ6ST4tRFrrtq0kt1VyCqxVp
 kailash/nodes/ai/embedding_generator.py,sha256=akGCzz7zLRSziqEQCiPwL2qWhRWxuM_1RQh-YtVEddw,31879
 kailash/nodes/ai/hybrid_search.py,sha256=k26uDDP_bwrIpv7Yl7PBCPvWSyQEmTlBjI1IpbgDsO4,35446
 kailash/nodes/ai/intelligent_agent_orchestrator.py,sha256=LvBqMKc64zSxFWVCjbLKKel2QwEzoTeJAEgna7rZw00,83097
-kailash/nodes/ai/iterative_llm_agent.py,sha256=Q_letP5mHtO225LBX0Tq5GlPkXkk-yWf3oFEOJTP6Z0,100289
+kailash/nodes/ai/iterative_llm_agent.py,sha256=h8iP1KFhB_eCDs7UvmY_9y0OUBuprYMj2MLM6dR0W2c,100287
 kailash/nodes/ai/llm_agent.py,sha256=NeNJZbV_VOUbULug2LASwyzLyoUO5wi58Bc9sXTubuc,90181
 kailash/nodes/ai/models.py,sha256=wsEeUTuegy87mnLtKgSTg7ggCXvC1n3MsL-iZ4qujHs,16393
 kailash/nodes/ai/self_organizing.py,sha256=B7NwKaBW8OHQBf5b0F9bSs8Wm-5BDJ9IjIkxS9h00mg,62885
@@ -360,6 +361,7 @@ kailash/tracking/storage/base.py,sha256=wWkK1XdrMV0EGxlbFDyfuVnDoIG0tdSPPwz_8iwz
 kailash/tracking/storage/database.py,sha256=O3-qYmgwTccq9jYl25C0L6R398pXPsWkIAoWLL1aZvQ,20048
 kailash/tracking/storage/filesystem.py,sha256=VhWxNvqf_Ta3mIaGqKuOrcCqQiEvJj7S8NK5yRd1V68,19627
 kailash/utils/__init__.py,sha256=pFKhHJxU_kyFE9aGT5recw5E-3nbfVF5pMHepBJWB2E,253
+kailash/utils/circular_dependency_detector.py,sha256=YqhaD_rAfubGebLyXtICX_K7WN2qB6p_T84jVqR4TaA,10821
 kailash/utils/data_paths.py,sha256=pZWoqXPc62kB1iJlIXRUZSzXTglEUrJ3hML0YmXuC5k,2148
 kailash/utils/data_validation.py,sha256=LYQWHtB-BRSAGQDMdZQGUKOZCGeoeia2fIqM0UfJFSU,6851
 kailash/utils/export.py,sha256=WBazN03LOCI03TsIElNv31wSZ_uTLPl8THnqdohgyTk,37361
@@ -403,10 +405,10 @@ kailash/workflow/templates.py,sha256=XQMAKZXC2dlxgMMQhSEOWAF3hIbe9JJt9j_THchhAm8
 kailash/workflow/type_inference.py,sha256=i1F7Yd_Z3elTXrthsLpqGbOnQBIVVVEjhRpI0HrIjd0,24492
 kailash/workflow/validation.py,sha256=LdbIPQSokCqSLfWTBhJR82pa_0va44pcVu9dpEM4rvY,45177
 kailash/workflow/visualization.py,sha256=nHBW-Ai8QBMZtn2Nf3EE1_aiMGi9S6Ui_BfpA5KbJPU,23187
-kailash-0.9.14.dist-info/licenses/LICENSE,sha256=9GYZHXVUmx6FdFRNzOeE_w7a_aEGeYbqTVmFtJlrbGk,13438
-kailash-0.9.14.dist-info/licenses/NOTICE,sha256=9ssIK4LcHSTFqriXGdteMpBPTS1rSLlYtjppZ_bsjZ0,723
-kailash-0.9.14.dist-info/METADATA,sha256=4j6DBNRv5DSiH0VPQ1H3IhTw8vh06MYdDAJebLSmGg0,23528
-kailash-0.9.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kailash-0.9.14.dist-info/entry_points.txt,sha256=M_q3b8PG5W4XbhSgESzIJjh3_4OBKtZFYFsOdkr2vO4,45
-kailash-0.9.14.dist-info/top_level.txt,sha256=z7GzH2mxl66498pVf5HKwo5wwfPtt9Aq95uZUpH6JV0,8
-kailash-0.9.14.dist-info/RECORD,,
+kailash-0.9.15.dist-info/licenses/LICENSE,sha256=9GYZHXVUmx6FdFRNzOeE_w7a_aEGeYbqTVmFtJlrbGk,13438
+kailash-0.9.15.dist-info/licenses/NOTICE,sha256=9ssIK4LcHSTFqriXGdteMpBPTS1rSLlYtjppZ_bsjZ0,723
+kailash-0.9.15.dist-info/METADATA,sha256=xXck9LkEnFmoRYJW_c5EPsOOWwkH6uI8d5biAA2Nf3w,23528
+kailash-0.9.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kailash-0.9.15.dist-info/entry_points.txt,sha256=M_q3b8PG5W4XbhSgESzIJjh3_4OBKtZFYFsOdkr2vO4,45
+kailash-0.9.15.dist-info/top_level.txt,sha256=z7GzH2mxl66498pVf5HKwo5wwfPtt9Aq95uZUpH6JV0,8
+kailash-0.9.15.dist-info/RECORD,,