kailash 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

kailash/runtime/access_controlled.py

@@ -134,13 +134,15 @@ class AccessControlledRuntime:
         This method has the exact same signature as the standard runtime,
         ensuring complete compatibility.
         """
-        # Check workflow-level access
-        workflow_decision = self.acm.check_workflow_access(
-            self.user_context, workflow.workflow_id, WorkflowPermission.EXECUTE
-        )
-
-        if not workflow_decision.allowed:
-            raise PermissionError(f"Access denied: {workflow_decision.reason}")
+        # Only check access control if it's enabled
+        if self.acm.enabled:
+            # Check workflow-level access
+            workflow_decision = self.acm.check_workflow_access(
+                self.user_context, workflow.workflow_id, WorkflowPermission.EXECUTE
+            )
+
+            if not workflow_decision.allowed:
+                raise PermissionError(f"Access denied: {workflow_decision.reason}")
 
         # For simplicity, directly execute with the base runtime
         # In a full implementation, we would wrap nodes or intercept execution

kailash/runtime/runner.py

@@ -91,7 +91,10 @@ class WorkflowRunner:
         Returns:
             Status information
         """
-        return self.task_manager.get_run_status(run_id)
+        summary = self.task_manager.get_run_summary(run_id)
+        if summary:
+            return summary.model_dump()
+        return {}
 
     def get_run_history(
         self, workflow_name: str | None = None, limit: int = 10
@@ -105,6 +108,5 @@ class WorkflowRunner:
         Returns:
             List of run summaries
         """
-        return self.task_manager.get_run_history(
-            workflow_name=workflow_name, limit=limit
-        )
+        runs = self.task_manager.list_runs(workflow_name=workflow_name, limit=limit)
+        return [run.model_dump() for run in runs]

kailash/runtime/testing.py

@@ -470,7 +470,7 @@ class NodeTestHelper:
                 pass  # Expected
 
 
-class TestReporter:
+class WorkflowTestReporter:
     """Generate test reports for workflows."""
 
     def __init__(self, task_manager: TaskManager):

kailash/security.py

@@ -627,9 +627,13 @@ def sanitize_input(
 
         # Machine learning frameworks
         try:
-            from sklearn.base import BaseEstimator, TransformerMixin
+            # Check if we're running under coverage to avoid instrumentation conflicts
+            import sys
 
-            allowed_types.extend([BaseEstimator, TransformerMixin])
+            if "coverage" not in sys.modules:
+                from sklearn.base import BaseEstimator, TransformerMixin
+
+                allowed_types.extend([BaseEstimator, TransformerMixin])
         except ImportError:
             pass
 

kailash/servers/enterprise_workflow_server.py

@@ -427,9 +427,8 @@ class EnterpriseWorkflowServer(DurableWorkflowServer):
 
     def _register_root_endpoints(self):
         """Override to add enterprise info to root endpoint."""
-        # Don't call super() to avoid duplicate endpoint registration
 
-        # Register the enterprise root endpoint
+        # Register the enterprise root endpoint first (before super() to take precedence)
         @self.app.get("/")
         async def root():
             """Server information with enterprise details."""
@@ -464,3 +463,60 @@ class EnterpriseWorkflowServer(DurableWorkflowServer):
             }
 
             return base_info
+
+        # Now call super() to get other endpoints (health, workflows, etc.) but skip root
+        # We'll register them manually to avoid route conflicts
+        @self.app.get("/workflows")
+        async def list_workflows():
+            """List all registered workflows."""
+            return {
+                name: {
+                    "type": reg.type,
+                    "description": reg.description,
+                    "version": reg.version,
+                    "tags": reg.tags,
+                    "endpoints": self._get_workflow_endpoints(name),
+                }
+                for name, reg in self.workflows.items()
+            }
+
+        @self.app.get("/health")
+        async def health_check():
+            """Server health check."""
+            health_status = {
+                "status": "healthy",
+                "server_type": "enterprise_workflow_server",
+                "workflows": {},
+                "mcp_servers": {},
+            }
+
+            # Check workflow health
+            for name, reg in self.workflows.items():
+                if reg.type == "embedded":
+                    health_status["workflows"][name] = "healthy"
+                else:
+                    # TODO: Implement proxy health check
+                    health_status["workflows"][name] = "unknown"
+
+            # Check MCP server health
+            for name, server in self.mcp_servers.items():
+                # TODO: Implement MCP health check
+                health_status["mcp_servers"][name] = "unknown"
+
+            return health_status
+
+        @self.app.websocket("/ws")
+        async def websocket_endpoint(websocket):
+            """WebSocket for real-time updates."""
+            from fastapi import WebSocket
+
+            await websocket.accept()
+            try:
+                while True:
+                    # Basic WebSocket echo - subclasses can override
+                    data = await websocket.receive_text()
+                    await websocket.send_text(f"Echo: {data}")
+            except Exception as e:
+                logger.error(f"WebSocket error: {e}")
+            finally:
+                await websocket.close()

kailash/servers/workflow_server.py

@@ -158,6 +158,9 @@ class WorkflowServer:
 
             return health_status
 
+        # Note: Metrics and authentication endpoints are provided by EnterpriseWorkflowServer
+        # Basic WorkflowServer focuses on core workflow functionality
+
         @self.app.websocket("/ws")
         async def websocket_endpoint(websocket: WebSocket):
             """WebSocket for real-time updates."""

kailash/workflow/builder.py

@@ -4,12 +4,10 @@ import logging
 import uuid
 from typing import TYPE_CHECKING, Any
 
+from kailash.nodes.base import Node
 from kailash.sdk_exceptions import ConnectionError, WorkflowValidationError
 from kailash.workflow.graph import Workflow
 
-if TYPE_CHECKING:
-    from kailash.nodes.base import Node
-
 logger = logging.getLogger(__name__)
 
 
@@ -21,6 +19,9 @@ class WorkflowBuilder:
         self.nodes: dict[str, dict[str, Any]] = {}
         self.connections: list[dict[str, str]] = []
         self._metadata: dict[str, Any] = {}
+        # Parameter injection capabilities
+        self.workflow_parameters: dict[str, Any] = {}
+        self.parameter_mappings: dict[str, dict[str, str]] = {}
 
     def add_node(self, *args, **kwargs) -> str:
         """
@@ -74,8 +75,6 @@ class WorkflowBuilder:
                 # Pattern: add_node(NodeClass)
                 return self._add_node_alternative(args[0], None, **kwargs)
             else:
-                from kailash.nodes.base import Node
-
                 if isinstance(args[0], Node):
                     # Pattern: add_node(node_instance)
                     return self._add_node_instance(args[0], None)
@@ -111,8 +110,6 @@ class WorkflowBuilder:
 
         elif len(args) >= 2:
             # Check if first arg is a Node instance
-            from kailash.nodes.base import Node
-
             if isinstance(args[0], Node):
                 # Pattern 4: Instance - add_node(node_instance, "node_id") or add_node(node_instance, "node_id", config)
                 # Config is ignored for instances
@@ -149,8 +146,6 @@ class WorkflowBuilder:
         """Handle legacy fluent API pattern: add_node('node_id', NodeClass, param=value)"""
         import warnings
 
-        from kailash.nodes.base import Node
-
         # If it's a class, validate it's a Node subclass
         if isinstance(node_class_or_type, type) and not issubclass(
             node_class_or_type, Node
@@ -183,8 +178,6 @@ class WorkflowBuilder:
         """Handle alternative pattern: add_node(NodeClass, 'node_id', param=value)"""
         import warnings
 
-        from kailash.nodes.base import Node
-
         # Validate that node_class is actually a Node subclass
         if not isinstance(node_class, type) or not issubclass(node_class, Node):
             raise WorkflowValidationError(
@@ -267,9 +260,6 @@ class WorkflowBuilder:
                 f"Node ID '{node_id}' already exists in workflow"
             )
 
-        # Import Node here to avoid circular imports
-        from kailash.nodes.base import Node
-
         # Handle different input types
         if isinstance(node_type, str):
             # String node type name
@@ -606,12 +596,108 @@ class WorkflowBuilder:
                     f"Failed to connect '{from_node}' to '{to_node}': {e}"
                 ) from e
 
+        # Parameter injection: Find nodes without incoming connections and inject parameters
+        if self.workflow_parameters:
+            nodes_with_inputs = set()
+            for conn in self.connections:
+                if not conn.get("is_workflow_input"):
+                    nodes_with_inputs.add(conn["to_node"])
+
+            nodes_without_inputs = set(self.nodes.keys()) - nodes_with_inputs
+
+            # For each node without inputs, check if it needs workflow parameters
+            for node_id in nodes_without_inputs:
+                node_info = self.nodes[node_id]
+                node_instance = workflow.get_node(node_id)
+
+                if hasattr(node_instance, "get_parameters"):
+                    params = node_instance.get_parameters()
+
+                    # Check which required parameters are missing from config
+                    for param_name, param_def in params.items():
+                        if param_def.required and param_name not in node_info["config"]:
+                            # Check if this parameter should come from workflow parameters
+                            if param_name in self.workflow_parameters:
+                                # Add to node config
+                                node_info["config"][param_name] = (
+                                    self.workflow_parameters[param_name]
+                                )
+                            elif node_id in self.parameter_mappings:
+                                # Check parameter mappings
+                                mapping = self.parameter_mappings[node_id]
+                                if param_name in mapping:
+                                    workflow_param = mapping[param_name]
+                                    if workflow_param in self.workflow_parameters:
+                                        node_info["config"][param_name] = (
+                                            self.workflow_parameters[workflow_param]
+                                        )
+
+        # Store workflow parameters in metadata for runtime reference
+        workflow.metadata["workflow_parameters"] = self.workflow_parameters
+        workflow.metadata["parameter_mappings"] = self.parameter_mappings
+
         logger.info(
             f"Built workflow '{workflow_id}' with "
             f"{len(self.nodes)} nodes and {len(self.connections)} connections"
         )
         return workflow
 
+    def set_workflow_parameters(self, **parameters) -> "WorkflowBuilder":
+        """
+        Set default parameters that will be passed to all nodes.
+
+        Args:
+            **parameters: Key-value pairs of workflow-level parameters
+
+        Returns:
+            Self for chaining
+        """
+        self.workflow_parameters.update(parameters)
+        return self
+
+    def add_parameter_mapping(
+        self, node_id: str, mappings: dict[str, str]
+    ) -> "WorkflowBuilder":
+        """
+        Add parameter mappings for a specific node.
+
+        Args:
+            node_id: Node to configure
+            mappings: Dict mapping workflow param names to node param names
+
+        Returns:
+            Self for chaining
+        """
+        if node_id not in self.parameter_mappings:
+            self.parameter_mappings[node_id] = {}
+        self.parameter_mappings[node_id].update(mappings)
+        return self
+
+    def add_input_connection(
+        self, to_node: str, to_input: str, from_workflow_param: str
+    ) -> "WorkflowBuilder":
+        """
+        Connect a workflow parameter directly to a node input.
+
+        Args:
+            to_node: Target node ID
+            to_input: Input parameter name on the node
+            from_workflow_param: Workflow parameter name
+
+        Returns:
+            Self for chaining
+        """
+        # Add a special connection type for workflow inputs
+        connection = {
+            "from_node": "__workflow_input__",
+            "from_output": from_workflow_param,
+            "to_node": to_node,
+            "to_input": to_input,
+            "is_workflow_input": True,
+        }
+        self.connections.append(connection)
+        return self
+
     def clear(self) -> "WorkflowBuilder":
         """
         Clear builder state.
@@ -622,6 +708,8 @@ class WorkflowBuilder:
         self.nodes = {}
         self.connections = []
         self._metadata = {}
+        self.workflow_parameters = {}
+        self.parameter_mappings = {}
         return self
 
     @classmethod

kailash/workflow/cyclic_runner.py

@@ -184,7 +184,7 @@ class CyclicWorkflowExecutor:
         if not workflow.has_cycles():
             # No cycles, use standard DAG execution
             logger.info("No cycles detected, using standard DAG execution")
-            return self.dag_runner.run(workflow, parameters), run_id
+            return self.dag_runner.execute(workflow, parameters), run_id
 
         # Execute with cycle support
         try:
@@ -370,18 +370,110 @@ class CyclicWorkflowExecutor:
                 )
                 results.update(cycle_results)
             else:
-                # Execute DAG nodes
-                for node_id in stage.nodes:
-                    if node_id not in state.node_outputs:
-                        logger.info(f"Executing DAG node: {node_id}")
-                        node_result = self._execute_node(
-                            workflow, node_id, state, task_manager=task_manager
-                        )
-                        results[node_id] = node_result
-                        state.node_outputs[node_id] = node_result
+                # Execute DAG nodes using extracted method
+                dag_results = self._execute_dag_portion(
+                    workflow, stage.nodes, state, task_manager
+                )
+                results.update(dag_results)
+
+        return results
+
+    def _execute_dag_portion(
+        self,
+        workflow: Workflow,
+        dag_nodes: list[str],
+        state: WorkflowState,
+        task_manager: TaskManager | None = None,
+    ) -> dict[str, Any]:
+        """Execute DAG (non-cyclic) portion of the workflow.
+
+        Args:
+            workflow: Workflow instance
+            dag_nodes: List of DAG node IDs to execute
+            state: Workflow state
+            task_manager: Optional task manager for tracking
+
+        Returns:
+            Dictionary with node IDs as keys and their results as values
+        """
+        results = {}
+
+        for node_id in dag_nodes:
+            if node_id not in state.node_outputs:
+                logger.info(f"Executing DAG node: {node_id}")
+                node_result = self._execute_node(
+                    workflow, node_id, state, task_manager=task_manager
+                )
+                results[node_id] = node_result
+                state.node_outputs[node_id] = node_result
+
+        return results
+
+    def _execute_cycle_groups(
+        self,
+        workflow: Workflow,
+        cycle_groups: list["CycleGroup"],
+        state: WorkflowState,
+        task_manager: TaskManager | None = None,
+    ) -> dict[str, Any]:
+        """Execute cycle groups portion of the workflow.
+
+        Args:
+            workflow: Workflow instance
+            cycle_groups: List of cycle groups to execute
+            state: Workflow state
+            task_manager: Optional task manager for tracking
+
+        Returns:
+            Dictionary with node IDs as keys and their results as values
+        """
+        results = {}
+
+        for cycle_group in cycle_groups:
+            logger.info(f"Executing cycle group: {cycle_group.cycle_id}")
+            cycle_results = self._execute_cycle_group(
+                workflow, cycle_group, state, task_manager
+            )
+            results.update(cycle_results)
 
         return results
 
+    def _propagate_parameters(
+        self,
+        current_params: dict[str, Any],
+        current_results: dict[str, Any],
+        cycle_config: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Handle parameter propagation between cycle iterations.
+
+        Args:
+            current_params: Current iteration parameters
+            current_results: Results from current iteration
+            cycle_config: Cycle configuration (optional)
+
+        Returns:
+            Updated parameters for the next iteration
+        """
+        # Base propagation: copy current results for next iteration
+        next_params = current_results.copy() if current_results else {}
+
+        # Apply any cycle-specific parameter mappings if provided
+        if cycle_config and "parameter_mappings" in cycle_config:
+            mappings = cycle_config["parameter_mappings"]
+            for src_key, dst_key in mappings.items():
+                if src_key in current_results:
+                    next_params[dst_key] = current_results[src_key]
+
+        # Preserve any initial parameters that aren't overridden
+        for key, value in current_params.items():
+            if key not in next_params:
+                next_params[key] = value
+
+        # Filter out None values to avoid validation errors
+        next_params = self._filter_none_values(next_params)
+
+        return next_params
+
     def _execute_cycle_group(
         self,
         workflow: Workflow,