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

kailash/nexus/__init__.py

@@ -1,21 +0,0 @@
-"""Kailash Nexus - Multi-channel workflow orchestration framework."""
-
-from .factory import (
-    create_api_nexus,
-    create_cli_nexus,
-    create_development_nexus,
-    create_mcp_nexus,
-    create_nexus,
-    create_production_nexus,
-)
-from .gateway import NexusGateway
-
-__all__ = [
-    "NexusGateway",
-    "create_nexus",
-    "create_api_nexus",
-    "create_cli_nexus",
-    "create_mcp_nexus",
-    "create_development_nexus",
-    "create_production_nexus",
-]

kailash/nexus/cli/__init__.py

@@ -1,5 +0,0 @@
-"""Nexus CLI module for command-line workflow interaction."""
-
-from .main import main
-
-__all__ = ["main"]

kailash/nexus/cli/__main__.py

@@ -1,6 +0,0 @@
-"""Entry point for Nexus CLI when run as a module."""
-
-from .main import main
-
-if __name__ == "__main__":
-    main()

kailash/nexus/cli/main.py

@@ -1,176 +0,0 @@
-"""Main CLI interface for Nexus workflow orchestration.
-
-This module provides command-line access to Nexus workflows running on a server.
-It connects to a running Nexus instance and allows listing and executing workflows.
-"""
-
-import argparse
-import json
-import sys
-from typing import Any, Dict, Optional
-
-import requests
-
-
-class NexusCLI:
-    """Command-line interface for Nexus workflows."""
-
-    def __init__(self, base_url: str = "http://localhost:8000"):
-        """Initialize CLI with Nexus server URL.
-
-        Args:
-            base_url: Base URL of the Nexus server
-        """
-        self.base_url = base_url.rstrip("/")
-
-    def list_workflows(self) -> None:
-        """List all available workflows."""
-        try:
-            response = requests.get(f"{self.base_url}/workflows", timeout=5)
-            response.raise_for_status()
-
-            workflows = response.json()
-
-            if not workflows:
-                print("No workflows available.")
-                return
-
-            print("Available workflows:")
-            for workflow_name in sorted(workflows.keys()):
-                print(f"  - {workflow_name}")
-
-        except requests.RequestException as e:
-            print(f"Error connecting to Nexus server: {e}", file=sys.stderr)
-            sys.exit(1)
-        except json.JSONDecodeError as e:
-            print(f"Error parsing server response: {e}", file=sys.stderr)
-            sys.exit(1)
-
-    def run_workflow(
-        self, workflow_name: str, parameters: Optional[Dict[str, Any]] = None
-    ) -> None:
-        """Execute a workflow with optional parameters.
-
-        Args:
-            workflow_name: Name of the workflow to execute
-            parameters: Optional parameters for the workflow
-        """
-        try:
-            payload = {"parameters": parameters or {}}
-
-            response = requests.post(
-                f"{self.base_url}/workflows/{workflow_name}", json=payload, timeout=30
-            )
-            response.raise_for_status()
-
-            result = response.json()
-
-            # Handle enterprise workflow execution format
-            if "outputs" in result:
-                # Extract results from each node
-                for node_name, node_result in result["outputs"].items():
-                    if "result" in node_result:
-                        node_output = node_result["result"]
-                        # Print meaningful output
-                        for key, value in node_output.items():
-                            print(f"{key}: {value}")
-            else:
-                # Handle direct result format
-                print(json.dumps(result, indent=2))
-
-        except requests.RequestException as e:
-            print(f"Error executing workflow: {e}", file=sys.stderr)
-            sys.exit(1)
-        except json.JSONDecodeError as e:
-            print(f"Error parsing execution result: {e}", file=sys.stderr)
-            sys.exit(1)
-
-    def parse_parameters(self, param_strings: list) -> Dict[str, Any]:
-        """Parse parameter strings in key=value format.
-
-        Args:
-            param_strings: List of parameter strings in "key=value" format
-
-        Returns:
-            Dictionary of parsed parameters
-        """
-        parameters = {}
-
-        for param_str in param_strings:
-            if "=" not in param_str:
-                print(
-                    f"Invalid parameter format: {param_str}. Use key=value format.",
-                    file=sys.stderr,
-                )
-                sys.exit(1)
-
-            key, value = param_str.split("=", 1)
-
-            # Try to parse as JSON for complex values, otherwise use as string
-            try:
-                parameters[key] = json.loads(value)
-            except json.JSONDecodeError:
-                parameters[key] = value
-
-        return parameters
-
-
-def main():
-    """Main CLI entry point."""
-    parser = argparse.ArgumentParser(
-        description="Nexus CLI - Command-line interface for workflow orchestration",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  python -m kailash.nexus.cli list
-  python -m kailash.nexus.cli run my-workflow
-  python -m kailash.nexus.cli run my-workflow --param name=value --param count=5
-
-  # Connect to different server:
-  python -m kailash.nexus.cli --url http://localhost:8001 list
-        """,
-    )
-
-    parser.add_argument(
-        "--url",
-        default="http://localhost:8000",
-        help="Base URL of the Nexus server (default: http://localhost:8000)",
-    )
-
-    subparsers = parser.add_subparsers(dest="command", help="Available commands")
-
-    # List command
-    list_parser = subparsers.add_parser("list", help="List available workflows")
-
-    # Run command
-    run_parser = subparsers.add_parser("run", help="Execute a workflow")
-    run_parser.add_argument("workflow", help="Name of the workflow to execute")
-    run_parser.add_argument(
-        "--param",
-        action="append",
-        default=[],
-        help="Workflow parameters in key=value format (can be used multiple times)",
-    )
-
-    args = parser.parse_args()
-
-    if not args.command:
-        parser.print_help()
-        sys.exit(1)
-
-    # Initialize CLI client
-    cli = NexusCLI(base_url=args.url)
-
-    # Execute command
-    if args.command == "list":
-        cli.list_workflows()
-    elif args.command == "run":
-        parameters = cli.parse_parameters(args.param)
-        cli.run_workflow(args.workflow, parameters)
-    else:
-        parser.print_help()
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

kailash/nexus/factory.py

@@ -1,413 +0,0 @@
-"""Factory functions for creating Nexus Gateway instances."""
-
-import logging
-from typing import Any, Dict, List, Optional, Union
-
-from ..workflow import Workflow
-from .gateway import NexusConfig, NexusGateway
-
-logger = logging.getLogger(__name__)
-
-
-def create_nexus(
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    # Channel configuration
-    enable_api: bool = True,
-    enable_cli: bool = True,
-    enable_mcp: bool = True,
-    # API settings
-    api_host: str = "localhost",
-    api_port: int = 8000,
-    api_cors_origins: Optional[List[str]] = None,
-    # CLI settings
-    cli_interactive: bool = False,
-    cli_prompt: str = "nexus> ",
-    # MCP settings
-    mcp_host: str = "localhost",
-    mcp_port: int = 3001,
-    mcp_server_name: Optional[str] = None,
-    # Session management
-    session_timeout: int = 3600,
-    session_cleanup_interval: int = 300,
-    # Event routing
-    enable_event_routing: bool = True,
-    event_queue_size: int = 10000,
-    # Advanced settings
-    enable_health_monitoring: bool = True,
-    health_check_interval: int = 30,
-    graceful_shutdown_timeout: int = 30,
-    # Initial workflows
-    workflows: Optional[Dict[str, Workflow]] = None,
-    # Custom configuration
-    **kwargs,
-) -> NexusGateway:
-    """Create a Nexus Gateway with the specified configuration.
-
-    This is the main entry point for creating a Nexus Gateway instance
-    with sensible defaults for different use cases.
-
-    Args:
-        name: Gateway name (defaults to "kailash-nexus")
-        description: Gateway description
-
-        # Channel Configuration
-        enable_api: Enable HTTP API channel
-        enable_cli: Enable CLI channel
-        enable_mcp: Enable MCP channel
-
-        # API Channel Settings
-        api_host: API server host
-        api_port: API server port
-        api_cors_origins: CORS origins for API
-
-        # CLI Channel Settings
-        cli_interactive: Enable interactive CLI mode
-        cli_prompt: CLI prompt template
-
-        # MCP Channel Settings
-        mcp_host: MCP server host
-        mcp_port: MCP server port
-        mcp_server_name: MCP server name
-
-        # Session Management
-        session_timeout: Session timeout in seconds
-        session_cleanup_interval: Session cleanup interval in seconds
-
-        # Event Routing
-        enable_event_routing: Enable cross-channel event routing
-        event_queue_size: Event queue size
-
-        # Advanced Settings
-        enable_health_monitoring: Enable background health monitoring
-        health_check_interval: Health check interval in seconds
-        graceful_shutdown_timeout: Graceful shutdown timeout in seconds
-
-        # Initial Workflows
-        workflows: Dictionary of workflows to register initially
-
-        # Custom Configuration
-        **kwargs: Additional configuration options
-
-    Returns:
-        Configured NexusGateway instance
-
-    Examples:
-        Create a basic Nexus with all channels:
-        >>> nexus = create_nexus()
-
-        Create API-only Nexus:
-        >>> nexus = create_nexus(
-        ...     enable_cli=False,
-        ...     enable_mcp=False,
-        ...     api_port=9000
-        ... )
-
-        Create Nexus with custom configuration:
-        >>> nexus = create_nexus(
-        ...     name="my-nexus",
-        ...     description="Custom multi-channel gateway",
-        ...     api_port=8080,
-        ...     mcp_port=3002,
-        ...     session_timeout=7200,  # 2 hours
-        ...     workflows={"my_workflow": my_workflow_instance}
-        ... )
-    """
-
-    # Build configuration
-    config = NexusConfig(
-        name=name or "kailash-nexus",
-        description=description or "Multi-channel workflow orchestration gateway",
-        # Channel configuration
-        enable_api=enable_api,
-        enable_cli=enable_cli,
-        enable_mcp=enable_mcp,
-        # API settings
-        api_host=api_host,
-        api_port=api_port,
-        api_cors_origins=api_cors_origins or ["*"],
-        # CLI settings
-        cli_interactive=cli_interactive,
-        cli_prompt_template=cli_prompt,
-        # MCP settings
-        mcp_host=mcp_host,
-        mcp_port=mcp_port,
-        mcp_server_name=mcp_server_name or f"{name or 'kailash'}-nexus-mcp",
-        # Session management
-        session_timeout=session_timeout,
-        session_cleanup_interval=session_cleanup_interval,
-        # Event routing
-        enable_event_routing=enable_event_routing,
-        event_queue_size=event_queue_size,
-        # Advanced settings
-        enable_health_monitoring=enable_health_monitoring,
-        health_check_interval=health_check_interval,
-        graceful_shutdown_timeout=graceful_shutdown_timeout,
-    )
-
-    # Apply any additional kwargs to config
-    for key, value in kwargs.items():
-        if hasattr(config, key):
-            setattr(config, key, value)
-        else:
-            logger.warning(f"Unknown configuration option: {key}")
-
-    # Create gateway
-    nexus = NexusGateway(config)
-
-    # Register initial workflows if provided
-    if workflows:
-        for workflow_name, workflow in workflows.items():
-            nexus.register_workflow(workflow_name, workflow)
-            logger.info(f"Registered initial workflow: {workflow_name}")
-
-    logger.info(f"Created Nexus Gateway: {config.name}")
-    logger.info(
-        f"Enabled channels: API={enable_api}, CLI={enable_cli}, MCP={enable_mcp}"
-    )
-
-    return nexus
-
-
-def create_api_nexus(
-    name: Optional[str] = None,
-    port: int = 8000,
-    host: str = "localhost",
-    cors_origins: Optional[List[str]] = None,
-    workflows: Optional[Dict[str, Workflow]] = None,
-    **kwargs,
-) -> NexusGateway:
-    """Create an API-only Nexus Gateway.
-
-    This is a convenience function for creating a Nexus Gateway
-    that only exposes the HTTP API channel.
-
-    Args:
-        name: Gateway name
-        port: API server port
-        host: API server host
-        cors_origins: CORS origins
-        workflows: Initial workflows to register
-        **kwargs: Additional configuration options
-
-    Returns:
-        Configured NexusGateway with only API channel enabled
-
-    Example:
-        >>> nexus = create_api_nexus(
-        ...     name="api-only-nexus",
-        ...     port=9000,
-        ...     workflows={"my_workflow": workflow}
-        ... )
-    """
-    return create_nexus(
-        name=name or "kailash-api-nexus",
-        description="API-only workflow gateway",
-        enable_api=True,
-        enable_cli=False,
-        enable_mcp=False,
-        api_host=host,
-        api_port=port,
-        api_cors_origins=cors_origins,
-        workflows=workflows,
-        **kwargs,
-    )
-
-
-def create_cli_nexus(
-    name: Optional[str] = None,
-    interactive: bool = True,
-    prompt: str = "nexus-cli> ",
-    workflows: Optional[Dict[str, Workflow]] = None,
-    **kwargs,
-) -> NexusGateway:
-    """Create a CLI-only Nexus Gateway.
-
-    This is a convenience function for creating a Nexus Gateway
-    that only exposes the CLI channel.
-
-    Args:
-        name: Gateway name
-        interactive: Enable interactive CLI mode
-        prompt: CLI prompt template
-        workflows: Initial workflows to register
-        **kwargs: Additional configuration options
-
-    Returns:
-        Configured NexusGateway with only CLI channel enabled
-
-    Example:
-        >>> nexus = create_cli_nexus(
-        ...     name="cli-nexus",
-        ...     interactive=True,
-        ...     workflows={"help": help_workflow}
-        ... )
-    """
-    return create_nexus(
-        name=name or "kailash-cli-nexus",
-        description="CLI-only workflow gateway",
-        enable_api=False,
-        enable_cli=True,
-        enable_mcp=False,
-        cli_interactive=interactive,
-        cli_prompt=prompt,
-        workflows=workflows,
-        **kwargs,
-    )
-
-
-def create_mcp_nexus(
-    name: Optional[str] = None,
-    port: int = 3001,
-    host: str = "localhost",
-    server_name: Optional[str] = None,
-    workflows: Optional[Dict[str, Workflow]] = None,
-    **kwargs,
-) -> NexusGateway:
-    """Create an MCP-only Nexus Gateway.
-
-    This is a convenience function for creating a Nexus Gateway
-    that only exposes the MCP channel.
-
-    Args:
-        name: Gateway name
-        port: MCP server port
-        host: MCP server host
-        server_name: MCP server name
-        workflows: Initial workflows to register
-        **kwargs: Additional configuration options
-
-    Returns:
-        Configured NexusGateway with only MCP channel enabled
-
-    Example:
-        >>> nexus = create_mcp_nexus(
-        ...     name="mcp-nexus",
-        ...     port=3002,
-        ...     workflows={"ai_tool": ai_workflow}
-        ... )
-    """
-    return create_nexus(
-        name=name or "kailash-mcp-nexus",
-        description="MCP-only workflow gateway",
-        enable_api=False,
-        enable_cli=False,
-        enable_mcp=True,
-        mcp_host=host,
-        mcp_port=port,
-        mcp_server_name=server_name,
-        workflows=workflows,
-        **kwargs,
-    )
-
-
-def create_development_nexus(
-    name: Optional[str] = None,
-    api_port: int = 8000,
-    mcp_port: int = 3001,
-    workflows: Optional[Dict[str, Workflow]] = None,
-    **kwargs,
-) -> NexusGateway:
-    """Create a development-focused Nexus Gateway.
-
-    This configuration is optimized for development with:
-    - All channels enabled
-    - Interactive CLI
-    - Health monitoring
-    - Verbose logging
-    - Short timeouts for faster iteration
-
-    Args:
-        name: Gateway name
-        api_port: API server port
-        mcp_port: MCP server port
-        workflows: Initial workflows to register
-        **kwargs: Additional configuration options
-
-    Returns:
-        Configured NexusGateway optimized for development
-
-    Example:
-        >>> nexus = create_development_nexus(
-        ...     name="dev-nexus",
-        ...     workflows={"test": test_workflow}
-        ... )
-    """
-    return create_nexus(
-        name=name or "kailash-dev-nexus",
-        description="Development multi-channel gateway",
-        # Enable all channels
-        enable_api=True,
-        enable_cli=True,
-        enable_mcp=True,
-        # Development-friendly settings
-        api_port=api_port,
-        mcp_port=mcp_port,
-        cli_interactive=True,
-        cli_prompt="dev-nexus> ",
-        # Faster cleanup for development
-        session_timeout=1800,  # 30 minutes
-        session_cleanup_interval=60,  # 1 minute
-        health_check_interval=10,  # 10 seconds
-        graceful_shutdown_timeout=10,  # 10 seconds
-        # Enhanced monitoring
-        enable_health_monitoring=True,
-        enable_event_routing=True,
-        workflows=workflows,
-        **kwargs,
-    )
-
-
-def create_production_nexus(
-    name: Optional[str] = None,
-    api_port: int = 80,
-    mcp_port: int = 3001,
-    workflows: Optional[Dict[str, Workflow]] = None,
-    **kwargs,
-) -> NexusGateway:
-    """Create a production-optimized Nexus Gateway.
-
-    This configuration is optimized for production with:
-    - Conservative timeouts
-    - Enhanced monitoring
-    - Larger queue sizes
-    - Robust error handling
-
-    Args:
-        name: Gateway name
-        api_port: API server port (defaults to 80 for production)
-        mcp_port: MCP server port
-        workflows: Initial workflows to register
-        **kwargs: Additional configuration options
-
-    Returns:
-        Configured NexusGateway optimized for production
-
-    Example:
-        >>> nexus = create_production_nexus(
-        ...     name="prod-nexus",
-        ...     api_port=8080,
-        ...     workflows=production_workflows
-        ... )
-    """
-    return create_nexus(
-        name=name or "kailash-prod-nexus",
-        description="Production multi-channel gateway",
-        # Production ports
-        api_port=api_port,
-        mcp_port=mcp_port,
-        # Conservative timeouts
-        session_timeout=7200,  # 2 hours
-        session_cleanup_interval=300,  # 5 minutes
-        health_check_interval=60,  # 1 minute
-        graceful_shutdown_timeout=60,  # 1 minute
-        # Larger queues for production load
-        event_queue_size=50000,
-        # Enhanced monitoring
-        enable_health_monitoring=True,
-        enable_event_routing=True,
-        # CLI disabled by default in production
-        enable_cli=False,
-        workflows=workflows,
-        **kwargs,
-    )