kailash 0.1.5__py3-none-any.whl → 0.2.0__py3-none-any.whl

kailash/nodes/mcp/server.py

@@ -1,577 +0,0 @@
-"""MCP Server node for hosting Model Context Protocol resources and tools."""
-
-import json
-from typing import Any, Dict, List
-
-from kailash.nodes.base import Node, NodeParameter, register_node
-
-
-@register_node()
-class MCPServer(Node):
-    """
-    Server node for hosting Model Context Protocol (MCP) resources and tools.
-
-    Design Purpose and Philosophy:
-    The MCPServer node allows workflows to expose their data and functionality as
-    standardized MCP resources and tools. This enables other AI applications and
-    agents to discover and interact with workflow capabilities through the MCP protocol.
-
-    Upstream Dependencies:
-    - Resource data to expose (files, databases, APIs)
-    - Tool implementations to register with the server
-    - Prompt templates to make available to clients
-    - Server configuration and authentication settings
-
-    Downstream Consumers:
-    - MCP clients that connect to discover resources
-    - AI applications that need workflow context
-    - Other Kailash workflows acting as MCP clients
-    - External tools and services supporting MCP
-
-    Usage Patterns:
-    1. Start MCP server with specified resources and tools
-    2. Register dynamic resources that update in real-time
-    3. Expose workflow capabilities as callable tools
-    4. Provide prompt templates for standardized interactions
-    5. Handle client connections and protocol compliance
-
-    Implementation Details:
-    - Uses the FastMCP framework for rapid server development
-    - Supports stdio, SSE, and HTTP transports automatically
-    - Implements proper resource discovery and metadata
-    - Provides authentication and access control mechanisms
-    - Handles concurrent client connections efficiently
-
-    Error Handling:
-    - ServerStartupError: When server fails to initialize
-    - ResourceRegistrationError: When resources cannot be registered
-    - ToolExecutionError: When tool calls fail during execution
-    - ClientConnectionError: When client connections are rejected
-    - ProtocolViolationError: When clients violate MCP protocol
-
-    Side Effects:
-    - Starts a network server process listening on specified ports
-    - Registers resources and tools in the MCP protocol registry
-    - May modify external systems when tools are executed
-    - Logs server events and client interactions
-
-    Examples:
-    ```python
-    # Start a basic MCP server with resources
-    server = MCPServer()
-    result = server.run(
-        server_config={
-            "name": "workflow-server",
-            "transport": "stdio"
-        },
-        resources=[
-            {
-                "uri": "workflow://current/status",
-                "name": "Workflow Status",
-                "content": "Running workflow with 5 active nodes"
-            }
-        ],
-        tools=[
-            {
-                "name": "execute_node",
-                "description": "Execute a specific workflow node",
-                "parameters": {
-                    "node_id": {"type": "string", "required": True}
-                }
-            }
-        ]
-    )
-
-    # Register dynamic resources
-    server_with_dynamic = MCPServer()
-    result = server_with_dynamic.run(
-        server_config={
-            "name": "data-server",
-            "transport": "http",
-            "port": 8080
-        },
-        resource_providers={
-            "database://tables/*": "list_database_tables",
-            "file://workspace/*": "list_workspace_files"
-        }
-    )
-    ```
-    """
-
-    def get_parameters(self) -> Dict[str, NodeParameter]:
-        return {
-            "server_config": NodeParameter(
-                name="server_config",
-                type=dict,
-                required=False,
-                default={},
-                description="MCP server configuration (name, transport, port, etc.)",
-            ),
-            "resources": NodeParameter(
-                name="resources",
-                type=list,
-                required=False,
-                default=[],
-                description="Static resources to expose (list of resource objects)",
-            ),
-            "tools": NodeParameter(
-                name="tools",
-                type=list,
-                required=False,
-                default=[],
-                description="Tools to register with the server (list of tool definitions)",
-            ),
-            "prompts": NodeParameter(
-                name="prompts",
-                type=list,
-                required=False,
-                default=[],
-                description="Prompt templates to make available (list of prompt objects)",
-            ),
-            "resource_providers": NodeParameter(
-                name="resource_providers",
-                type=dict,
-                required=False,
-                default={},
-                description="Dynamic resource providers (URI pattern -> provider function)",
-            ),
-            "authentication": NodeParameter(
-                name="authentication",
-                type=dict,
-                required=False,
-                default={},
-                description="Authentication configuration (type, credentials, etc.)",
-            ),
-            "auto_start": NodeParameter(
-                name="auto_start",
-                type=bool,
-                required=False,
-                default=True,
-                description="Whether to automatically start the server",
-            ),
-            "max_connections": NodeParameter(
-                name="max_connections",
-                type=int,
-                required=False,
-                default=10,
-                description="Maximum number of concurrent client connections",
-            ),
-        }
-
-    def run(self, **kwargs) -> Dict[str, Any]:
-        server_config = kwargs["server_config"]
-        resources = kwargs.get("resources", [])
-        tools = kwargs.get("tools", [])
-        prompts = kwargs.get("prompts", [])
-        resource_providers = kwargs.get("resource_providers", {})
-        authentication = kwargs.get("authentication", {})
-        auto_start = kwargs.get("auto_start", True)
-        max_connections = kwargs.get("max_connections", 10)
-
-        try:
-            # Import MCP SDK (graceful fallback if not installed)
-            try:
-                import importlib.util
-
-                mcp_spec = importlib.util.find_spec("mcp")
-                if mcp_spec is not None:
-                    from mcp.server import Server  # noqa: F401
-                    from mcp.server.fastmcp import FastMCP  # noqa: F401
-                    from mcp.types import Prompt, Resource, Tool  # noqa: F401
-
-                    mcp_available = True
-                else:
-                    mcp_available = False
-            except ImportError:
-                mcp_available = False
-
-            if not mcp_available:
-                # Provide mock functionality when MCP SDK is not available
-                return self._mock_mcp_server(
-                    server_config,
-                    resources,
-                    tools,
-                    prompts,
-                    resource_providers,
-                    authentication,
-                    auto_start,
-                    max_connections,
-                )
-
-            # Extract server configuration
-            server_name = server_config.get("name", "kailash-server")
-            transport_type = server_config.get("transport", "stdio")
-            port = server_config.get("port", 8080)
-            host = server_config.get("host", "localhost")
-
-            # For now, provide mock implementation as we need proper MCP server setup
-            return self._mock_fastmcp_server(
-                server_name,
-                transport_type,
-                host,
-                port,
-                resources,
-                tools,
-                prompts,
-                resource_providers,
-                authentication,
-                auto_start,
-                max_connections,
-            )
-
-        except Exception as e:
-            return {
-                "success": False,
-                "error": str(e),
-                "error_type": type(e).__name__,
-                "server_config": server_config,
-            }
-
-    def _mock_mcp_server(
-        self,
-        server_config: dict,
-        resources: List[dict],
-        tools: List[dict],
-        prompts: List[dict],
-        resource_providers: dict,
-        authentication: dict,
-        auto_start: bool,
-        max_connections: int,
-    ) -> Dict[str, Any]:
-        """Mock MCP server when SDK is not available."""
-        server_name = server_config.get("name", "mock-server")
-        transport = server_config.get("transport", "stdio")
-
-        # Validate resources
-        validated_resources = []
-        for resource in resources:
-            if not isinstance(resource, dict):
-                continue
-
-            uri = resource.get("uri")
-            name = resource.get("name", uri)
-            description = resource.get("description", f"Resource: {name}")
-
-            if uri:
-                validated_resources.append(
-                    {
-                        "uri": uri,
-                        "name": name,
-                        "description": description,
-                        "mimeType": resource.get("mimeType", "text/plain"),
-                        "content": resource.get("content"),
-                    }
-                )
-
-        # Validate tools
-        validated_tools = []
-        for tool in tools:
-            if not isinstance(tool, dict):
-                continue
-
-            name = tool.get("name")
-            description = tool.get("description", f"Tool: {name}")
-
-            if name:
-                validated_tools.append(
-                    {
-                        "name": name,
-                        "description": description,
-                        "inputSchema": tool.get("parameters", {}),
-                        "handler": tool.get("handler", f"mock_handler_{name}"),
-                    }
-                )
-
-        # Validate prompts
-        validated_prompts = []
-        for prompt in prompts:
-            if not isinstance(prompt, dict):
-                continue
-
-            name = prompt.get("name")
-            description = prompt.get("description", f"Prompt: {name}")
-
-            if name:
-                validated_prompts.append(
-                    {
-                        "name": name,
-                        "description": description,
-                        "arguments": prompt.get("arguments", []),
-                        "template": prompt.get("template", f"Mock template for {name}"),
-                    }
-                )
-
-        # Mock server status
-        server_status = {
-            "name": server_name,
-            "transport": transport,
-            "status": "running" if auto_start else "configured",
-            "pid": 12345,  # Mock process ID
-            "started_at": "2025-06-01T12:00:00Z",
-            "uptime": "0:00:05",
-            "connections": {"active": 0, "total": 0, "max": max_connections},
-            "capabilities": {
-                "resources": True,
-                "tools": True,
-                "prompts": True,
-                "logging": True,
-            },
-        }
-
-        if transport == "http":
-            host = server_config.get("host", "localhost")
-            port = server_config.get("port", 8080)
-            server_status.update(
-                {
-                    "host": host,
-                    "port": port,
-                    "url": f"http://{host}:{port}",
-                    "endpoints": {
-                        "sse": f"http://{host}:{port}/sse",
-                        "resources": f"http://{host}:{port}/resources",
-                        "tools": f"http://{host}:{port}/tools",
-                        "prompts": f"http://{host}:{port}/prompts",
-                    },
-                }
-            )
-
-        return {
-            "success": True,
-            "server": server_status,
-            "resources": {
-                "registered": validated_resources,
-                "count": len(validated_resources),
-                "providers": (
-                    list(resource_providers.keys()) if resource_providers else []
-                ),
-            },
-            "tools": {"registered": validated_tools, "count": len(validated_tools)},
-            "prompts": {
-                "registered": validated_prompts,
-                "count": len(validated_prompts),
-            },
-            "authentication": {
-                "enabled": bool(authentication),
-                "type": authentication.get("type", "none"),
-            },
-            "mock": True,
-            "message": f"Mock MCP server '{server_name}' configured successfully",
-        }
-
-    def _mock_fastmcp_server(
-        self,
-        server_name: str,
-        transport_type: str,
-        host: str,
-        port: int,
-        resources: List[dict],
-        tools: List[dict],
-        prompts: List[dict],
-        resource_providers: dict,
-        authentication: dict,
-        auto_start: bool,
-        max_connections: int,
-    ) -> Dict[str, Any]:
-        """Mock FastMCP server implementation."""
-
-        # Create mock FastMCP server configuration
-        server_code = f"""
-# Mock FastMCP server code for {server_name}
-from mcp.server.fastmcp import FastMCP
-
-# Create server instance
-mcp = FastMCP("{server_name}")
-
-# Register resources
-{self._generate_resource_code(resources)}
-
-# Register tools
-{self._generate_tool_code(tools)}
-
-# Register prompts
-{self._generate_prompt_code(prompts)}
-
-# Dynamic resource providers
-{self._generate_provider_code(resource_providers)}
-
-if __name__ == "__main__":
-    mcp.run()
-"""
-
-        # Mock server startup
-        startup_info = {
-            "server_name": server_name,
-            "transport": transport_type,
-            "generated_code": server_code,
-            "status": "ready" if auto_start else "configured",
-            "resources_count": len(resources),
-            "tools_count": len(tools),
-            "prompts_count": len(prompts),
-            "providers_count": len(resource_providers),
-        }
-
-        if transport_type == "http":
-            startup_info.update(
-                {
-                    "host": host,
-                    "port": port,
-                    "url": f"http://{host}:{port}",
-                    "sse_endpoint": f"http://{host}:{port}/sse",
-                }
-            )
-
-        return {
-            "success": True,
-            "server": startup_info,
-            "code": server_code,
-            "mock": True,
-            "next_steps": [
-                "Save the generated code to a Python file",
-                "Install MCP dependencies: pip install 'mcp[cli]'",
-                "Run the server: python server_file.py",
-                "Connect clients using the specified transport",
-            ],
-        }
-
-    def _generate_resource_code(self, resources: List[dict]) -> str:
-        """Generate Python code for resource registration."""
-        if not resources:
-            return "# No static resources defined"
-
-        code_lines = []
-        for resource in resources:
-            uri = resource.get("uri", "")
-            content = resource.get("content", "")
-            name = resource.get("name", uri)
-
-            # Escape strings for Python code
-            content_escaped = json.dumps(content) if content else '""'
-
-            code_lines.append(f'@mcp.resource("{uri}")')
-            code_lines.append(f"def get_{self._sanitize_name(uri)}():")
-            code_lines.append(f'    """Resource: {name}"""')
-            code_lines.append(f"    return {content_escaped}")
-            code_lines.append("")
-
-        return "\n".join(code_lines)
-
-    def _generate_tool_code(self, tools: List[dict]) -> str:
-        """Generate Python code for tool registration."""
-        if not tools:
-            return "# No tools defined"
-
-        code_lines = []
-        for tool in tools:
-            name = tool.get("name", "")
-            description = tool.get("description", "")
-            parameters = tool.get("parameters", {})
-
-            # Generate function parameters from schema
-            param_list = []
-
-            # Handle OpenAPI schema format
-            if isinstance(parameters, dict) and "properties" in parameters:
-                properties = parameters.get("properties", {})
-                required = parameters.get("required", [])
-
-                for param_name, param_info in properties.items():
-                    param_type = (
-                        param_info.get("type", "str")
-                        if isinstance(param_info, dict)
-                        else "str"
-                    )
-                    if param_name in required:
-                        param_list.append(f"{param_name}: {param_type}")
-                    else:
-                        param_list.append(f"{param_name}: {param_type} = None")
-            # Handle simple parameter format
-            elif isinstance(parameters, dict):
-                for param_name, param_info in parameters.items():
-                    if isinstance(param_info, dict):
-                        param_type = param_info.get("type", "str")
-                        if param_info.get("required", False):
-                            param_list.append(f"{param_name}: {param_type}")
-                        else:
-                            param_list.append(f"{param_name}: {param_type} = None")
-                    else:
-                        param_list.append(f"{param_name}: str = None")
-
-            param_str = ", ".join(param_list) if param_list else ""
-
-            code_lines.append("@mcp.tool()")
-            code_lines.append(f"def {name}({param_str}):")
-            code_lines.append(f'    """{description}"""')
-            code_lines.append("    # Mock tool implementation")
-            code_lines.append(
-                f'    return {{"tool": "{name}", "status": "executed", "parameters": locals()}}'
-            )
-            code_lines.append("")
-
-        return "\n".join(code_lines)
-
-    def _generate_prompt_code(self, prompts: List[dict]) -> str:
-        """Generate Python code for prompt registration."""
-        if not prompts:
-            return "# No prompts defined"
-
-        code_lines = []
-        for prompt in prompts:
-            name = prompt.get("name", "")
-            template = prompt.get("template", "")
-            arguments = prompt.get("arguments", [])
-
-            # Generate function parameters from arguments
-            param_list = []
-            for arg in arguments:
-                if isinstance(arg, dict):
-                    arg_name = arg.get("name", "")
-                    if arg.get("required", False):
-                        param_list.append(f"{arg_name}: str")
-                    else:
-                        param_list.append(f"{arg_name}: str = ''")
-
-            param_str = ", ".join(param_list) if param_list else ""
-
-            code_lines.append(f'@mcp.prompt("{name}")')
-            code_lines.append(f"def {name}_prompt({param_str}):")
-            code_lines.append(f'    """Prompt: {name}"""')
-            if template:
-                template_escaped = json.dumps(template)
-                code_lines.append(f"    template = {template_escaped}")
-                code_lines.append("    return template.format(**locals())")
-            else:
-                code_lines.append(
-                    f'    return f"Mock prompt: {name} with args: {{locals()}}"'
-                )
-            code_lines.append("")
-
-        return "\n".join(code_lines)
-
-    def _generate_provider_code(self, providers: dict) -> str:
-        """Generate Python code for dynamic resource providers."""
-        if not providers:
-            return "# No dynamic resource providers defined"
-
-        code_lines = []
-        for pattern, provider_func in providers.items():
-            sanitized_pattern = self._sanitize_name(pattern)
-
-            code_lines.append(f'@mcp.resource("{pattern}")')
-            code_lines.append(f"def dynamic_{sanitized_pattern}(**kwargs):")
-            code_lines.append(f'    """Dynamic resource provider for {pattern}"""')
-            code_lines.append("    # Mock dynamic resource implementation")
-            code_lines.append('    return f"Dynamic content for {kwargs}"')
-            code_lines.append("")
-
-        return "\n".join(code_lines)
-
-    def _sanitize_name(self, name: str) -> str:
-        """Sanitize a name for use as Python identifier."""
-        import re
-
-        # Replace non-alphanumeric characters with underscores
-        sanitized = re.sub(r"[^a-zA-Z0-9_]", "_", name)
-        # Ensure it starts with a letter or underscore
-        if sanitized and sanitized[0].isdigit():
-            sanitized = f"r_{sanitized}"
-        return sanitized or "unnamed"

kailash-0.1.5.dist-info/RECORD

@@ -1,88 +0,0 @@
-kailash/__init__.py,sha256=7XGjhqUBqULYrT7-nZ7UM9dd7SAOiZs7o-pUmxuHaaQ,902
-kailash/__main__.py,sha256=vr7TVE5o16V6LsTmRFKG6RDKUXHpIWYdZ6Dok2HkHnI,198
-kailash/manifest.py,sha256=8H4ObT3qvdV0FQDXYUF49ppbmOvnK1PmmpdC6h5npn8,24892
-kailash/sdk_exceptions.py,sha256=l2AWF2BB7cLLPi95CRAxKWUQmD-cCBVgnbgztgn4H_s,6967
-kailash/api/__init__.py,sha256=9Ofp4qTZCry_hovrtSjPjqyZbrccoPqyz9za_TfSHVg,445
-kailash/api/gateway.py,sha256=rp0Doz7HaEgLFXRqZvzMk6EfK-M6HmMHcSAJSv28FL8,12576
-kailash/api/mcp_integration.py,sha256=Pvm65Nb1g4-QGKqweeRE-hMJe0HvqhljHB-UTtItnVc,14541
-kailash/api/workflow_api.py,sha256=8e4YSeeTQQT_9GJ_5-kWQFhL8v5-qqVWFv3ToREzBXE,13177
-kailash/cli/__init__.py,sha256=kJaqsBp3fRmagJhqA6LMwMbEa_Vkz93hIPH3W5Mn5r0,97
-kailash/cli/commands.py,sha256=K5slsaoYSw7ZpVgePvobN6K4w9_dXJugBTIY0aifKik,18236
-kailash/nodes/__init__.py,sha256=dy36thqtYzTWkyLpmV93e7G0RXslzCtByLZvib4WYPM,564
-kailash/nodes/base.py,sha256=Q2gUtyFYQOtq9Y1blikLAm030Ccn-lWtIVp1Q8UNDhI,37823
-kailash/nodes/base_async.py,sha256=7tHM14qSxbZxbqCZeI-Ac4WR-NwpBPOLX5QUfW2HlBQ,4867
-kailash/nodes/ai/__init__.py,sha256=Pct4gxsTFFbS37VWpQruGw8rA7n-Oqh4LUWGDpzdh50,2118
-kailash/nodes/ai/a2a.py,sha256=_gs7avm16SjzvQ2Fw-BdMWjDbTuTUgDdmL4Ehzo9368,43595
-kailash/nodes/ai/agents.py,sha256=yygZw8eJPt7iuRm4jZR-I2wtfIVrIH8OxoorgZ2HNrw,20379
-kailash/nodes/ai/ai_providers.py,sha256=rtFOvsyUlcoD0voeiCHyBR7ELcRMfJa5T2T7wFyB5js,53026
-kailash/nodes/ai/embedding_generator.py,sha256=UZagRpoybTlV_LMCt0HMUuc1TYFh5yLfs38mqdLItEI,31846
-kailash/nodes/ai/intelligent_agent_orchestrator.py,sha256=7fmvG_QA6Rpy56kR1MaTQOgON3TvEFbXx4srBqy_PIw,80518
-kailash/nodes/ai/llm_agent.py,sha256=wRNAiwzxJGcvC0_O-dqeNy7aZ_gmzvac0DLjBqS3vC8,46607
-kailash/nodes/ai/models.py,sha256=t90NvEIEJJxdBXwW0DhKACQG1Um-sJPm-lBdPBt8-ZA,16399
-kailash/nodes/ai/self_organizing.py,sha256=BBjgVoXKKjMYLZoBW6diRqHsSZoPD63poce0tRv6lR4,60692
-kailash/nodes/api/__init__.py,sha256=1yFcWVYyc-bsilknBT5aAGV7jcp-Ysu_afRilNJlD0A,1529
-kailash/nodes/api/auth.py,sha256=cpHUIZ6-YFo3jkW0K4-eBP38EZCl7Lrfibg5XTZaPWo,19427
-kailash/nodes/api/graphql.py,sha256=PH1ccwbw-fsBfKHl8L_whkZSRMgGAPKM7kkLTmwci5s,16994
-kailash/nodes/api/http.py,sha256=XTkHmmVnGyvIqpNhmjUsRNuk-qYzvWdyF89cg5zHxI8,38396
-kailash/nodes/api/rate_limiting.py,sha256=f-cY_ee5juWHyKT3FqtaTk-SjEgMWX2DxU10Y41DZG4,19728
-kailash/nodes/api/rest.py,sha256=yRLcNuIGVq5Nc1z759tc3Nqt3c2d7UnMqE7lZ8tVKMM,43357
-kailash/nodes/code/__init__.py,sha256=L3QBfnITPb6v-Wbq2ezNWt8xDlC4uGaTgrkqIJ9vGKU,1191
-kailash/nodes/code/python.py,sha256=HD1a8sIR6yTTjlm6B7x_fzBOqUE8QU_ybBz1lMrEVpY,35536
-kailash/nodes/data/__init__.py,sha256=dIPx7Dfk3ZQ_SZvU4qYhAtYMTDCj4DeeXOSqMMW92mI,4107
-kailash/nodes/data/readers.py,sha256=_tAxmOsSGLph91Zwj9R98SGSui9K0hd4JinsXQyJyrM,18816
-kailash/nodes/data/retrieval.py,sha256=ANQXk0h5QI_NX_VdgABJEHbKWI3wtiRXCNgoap27M04,7516
-kailash/nodes/data/sharepoint_graph.py,sha256=UIyy8Q-9bGTzj-hjcxne8DkBJvr6Eig1HgY1JqGZqss,22437
-kailash/nodes/data/sources.py,sha256=MaXFPSDg4VN7TN5iNMZxwhxgj6nNpH43tQYmkxhHxjE,3638
-kailash/nodes/data/sql.py,sha256=agu-ZCdHAJKsJI1GCnNrGv7a5WhudpPGYz650vuCUE0,12860
-kailash/nodes/data/streaming.py,sha256=OAME3quVU9NbQFMBM6X-Yiri8Q5WGlEi91U4oGs78Fw,35223
-kailash/nodes/data/vector_db.py,sha256=rywRU65g7ou9v1QPSZmC5esnqC-O0DezGOJS37wKdJs,30556
-kailash/nodes/data/writers.py,sha256=5tv0Qf-Wjhsd03epDUafvlTTLd5Q1NeCYaR-hQfIeJU,16981
-kailash/nodes/logic/__init__.py,sha256=kP24cdxLPdguL1a2GkTkP_bp_mU7MbhveeMLm5-Y8oA,365
-kailash/nodes/logic/async_operations.py,sha256=WLV05FG3u02tuHNFbce-aYhiTL0s45fOrGQcvog3mLU,27512
-kailash/nodes/logic/operations.py,sha256=EYZ6YGx0clCwt7dLadCICBDVaOEoF9D8LBVUUvpkAeI,21840
-kailash/nodes/logic/workflow.py,sha256=xo5IS_dB3bz4ApaCOa0LZXkCoornCcBspQs2laA-eBQ,17178
-kailash/nodes/mcp/__init__.py,sha256=Ea1vtdGpVRGTL4QrRGsrh9mhKIprXFWWBN68E9ljqps,225
-kailash/nodes/mcp/client.py,sha256=YVJlfjnY-DzyxY3AqcgtNcSH5RPAcTUuR703R_SEiTg,20674
-kailash/nodes/mcp/resource.py,sha256=A5luATUYGNiO1ESXmaInpvuGrPwLOk6ioBw_tIhXB0M,24469
-kailash/nodes/mcp/server.py,sha256=jZEIA6xqvsboeqQGT3tn-26pu8y9R46VQOKUmSpxQPk,20836
-kailash/nodes/transform/__init__.py,sha256=sIUk7XMEl3x_XKNiRIyVtHmbLRUa0jHj1fEuUyELT_s,584
-kailash/nodes/transform/chunkers.py,sha256=qh2wYq6bdo5qGoDRLrowDrpl4VinRO4hDOj05DOr3RY,2580
-kailash/nodes/transform/formatters.py,sha256=02T87cQ4nVJoUKV9spEBzKa1YxtbV_KurngbhnfkVao,3078
-kailash/nodes/transform/processors.py,sha256=BZjDigpHD5pFxyZ0sty7-jpdEmD11euQip9N3U4Uzlw,18490
-kailash/runtime/__init__.py,sha256=jDdjbnUKyNnLx8Fc3fydaBERG2MuBN-NBvU_V2_4kmg,187
-kailash/runtime/async_local.py,sha256=h8NrwgXOEX-pgozPS1_TPLCrWeSorf0AqridKX1yI2w,12264
-kailash/runtime/docker.py,sha256=U0nU4fGTLA59H25mBDFC6EkTXry-5bwXkWUgRw1qBqc,23559
-kailash/runtime/local.py,sha256=XiDTiCCAtow9N_kcg68QVdEBHkEsqpG7lVeH0kmh1aI,15944
-kailash/runtime/parallel.py,sha256=VPVSBglVqdnMyyHMgThDedbghK47f6-2Jx7434BAlz4,21129
-kailash/runtime/runner.py,sha256=wzTiC8hHoy3dca5NRImaw2qfjH1bkUJR2UaFwCkTV6Y,3246
-kailash/runtime/testing.py,sha256=UJdLD7Eh45sa3oIWy6Pe0LA6yf9NcY_9r8YXWUwSuEQ,11578
-kailash/tracking/__init__.py,sha256=nhyecV24JuB_D-veJ3qw7h4oO8Sbdmyb6RvPS6VQktU,305
-kailash/tracking/manager.py,sha256=ERzs2qkFSsqZjNEbQhO1lXZm1aipjMeP1PmQIcwgSSE,27069
-kailash/tracking/metrics_collector.py,sha256=8CvNK3lUIN7BfGy0Re-2WrNKM3J0vx8vjfd-uyvaJJs,11820
-kailash/tracking/models.py,sha256=Yt0lgBwTx1ldAKdOh6wKaq6e9XIcGg6X1jUrHEVb8uw,18094
-kailash/tracking/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kailash/tracking/storage/base.py,sha256=bw4WWoG40G8zJCS0zVQ18-BiBYbt3fnZPx64xq0BY0c,2468
-kailash/tracking/storage/database.py,sha256=3pHaohN_tuP3bfV2gCD8vOdqJSZhuKlGRjigWVme0FQ,20022
-kailash/tracking/storage/filesystem.py,sha256=hOifk6bmJozKpMyRHfiPFJ62KOZcXoRwXnKgC9jvCMI,18745
-kailash/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kailash/utils/export.py,sha256=LIahj_qIM0vaC5rFnV_iVGaL92jRp1WkYmi8pEgf6yE,31964
-kailash/utils/templates.py,sha256=WBZMd8-HoGB47nhJTSwxEkJi9etfNppOTiwtlZe2DFI,22049
-kailash/visualization/__init__.py,sha256=6bvgE_Rt8z3Rf4kSvdWvZNaTYvbofRHc_QbGlC0xDYE,1880
-kailash/visualization/api.py,sha256=jKjfxuufSsXZEsEWIu6_FF7XHQsjjO2d5MJfO0F8S20,28890
-kailash/visualization/dashboard.py,sha256=euAyqTu5QWwcUOhLBcdYrKnJdFVX_pQThlNLp-yYbaA,32874
-kailash/visualization/performance.py,sha256=qW4sI8ios8__j5-qXUhN7Pa3mE-9E3JTEBkFkt7fSY8,28053
-kailash/visualization/reports.py,sha256=FKERee_SUm12P3QEBwm4Up_WZYcgXPJfx_0ZAzcUNug,52671
-kailash/workflow/__init__.py,sha256=RyXoTH1WJRXO6gK6oorQI7iWC-yeevEnF6q1ZBVWGKc,438
-kailash/workflow/builder.py,sha256=zoNQT2LUym1ykkoVz5RK4O2aqsmZWGNXHkAnCi8xyUg,7683
-kailash/workflow/graph.py,sha256=WbL8Oq84Kukhzrv75gdxiWJkIt6h7GkHIk0xEI18Ug8,30294
-kailash/workflow/mermaid_visualizer.py,sha256=PU_uVeYqR1m59z-qhbQOJHztf0um3FYw9jpF3j22QYA,22351
-kailash/workflow/mock_registry.py,sha256=oweiPQ-mBuDdzTUbo3qZAW6OaBKNqST_1vX32xMtcL4,1704
-kailash/workflow/runner.py,sha256=QATm4y7botMoOFltcHe8CreeUlobJX0M5nLHQ9usRgo,10839
-kailash/workflow/state.py,sha256=3vZkptVfPYqN-Q9aFwO2sUpmy-l1h5vIMVwh67uTwE4,7722
-kailash/workflow/visualization.py,sha256=gSMT-jaSzQBufV4mDArWVPJj5bpNIxTa_NE796Rm8I8,19536
-kailash-0.1.5.dist-info/licenses/LICENSE,sha256=Axe6g7bTrJkToK9h9j2SpRUKKNaDZDCo2lQ2zPxCE6s,1065
-kailash-0.1.5.dist-info/METADATA,sha256=ypGNmh_M3h3OJq2Zfd3UpiYTLVPHe7XSe5MZlLKXnyY,44188
-kailash-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kailash-0.1.5.dist-info/entry_points.txt,sha256=M_q3b8PG5W4XbhSgESzIJjh3_4OBKtZFYFsOdkr2vO4,45
-kailash-0.1.5.dist-info/top_level.txt,sha256=z7GzH2mxl66498pVf5HKwo5wwfPtt9Aq95uZUpH6JV0,8
-kailash-0.1.5.dist-info/RECORD,,