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

kailash/workflow/validation.py

@@ -390,6 +390,49 @@ class CycleLinter:
                                 )
                             )
 
+                        # Check for potentially problematic mappings
+                        if source_param in [
+                            "result",
+                            "output",
+                            "data",
+                        ] and target_param in ["result", "output", "data"]:
+                            if source_param != target_param:
+                                self.issues.append(
+                                    ValidationIssue(
+                                        severity=IssueSeverity.INFO,
+                                        category="parameter_mapping",
+                                        code="CYC010A",
+                                        message=f"Generic parameter mapping '{source_param}' -> '{target_param}' in cycle {cycle_id}",
+                                        cycle_id=cycle_id,
+                                        suggestion="Consider using more specific parameter names for clarity",
+                                        documentation_link="guide/mistakes/063-cyclic-parameter-propagation-multi-fix.md",
+                                    )
+                                )
+
+                        # Check for dot notation in mappings
+                        if (
+                            "." in source_param
+                            and target_param == source_param.split(".")[-1]
+                        ):
+                            # This is actually a good pattern - dot notation to specific field
+                            pass
+                        elif "." not in source_param and "." not in target_param:
+                            # Simple mapping - check if it makes sense
+                            if source_param.startswith(
+                                "temp_"
+                            ) or target_param.startswith("temp_"):
+                                self.issues.append(
+                                    ValidationIssue(
+                                        severity=IssueSeverity.INFO,
+                                        category="parameter_mapping",
+                                        code="CYC010B",
+                                        message=f"Temporary parameter mapping '{source_param}' -> '{target_param}' in cycle {cycle_id}",
+                                        cycle_id=cycle_id,
+                                        suggestion="Consider using permanent parameter names for production workflows",
+                                        documentation_link="guide/mistakes/063-cyclic-parameter-propagation-multi-fix.md",
+                                    )
+                                )
+
                     # Check for missing parameter propagation
                     if not mapping and len(cycle_nodes) > 1:
                         self.issues.append(
@@ -589,20 +632,53 @@ class CycleLinter:
 
     def _has_unsafe_parameter_access(self, code: str) -> bool:
         """Check if PythonCodeNode has unsafe parameter access."""
-        # Look for direct parameter access without try/except
+        import re
+
+        # Look for direct parameter access without try/except or safety checks
         lines = code.split("\n")
 
+        # Common parameter names that might be unsafe
+        unsafe_patterns = [
+            r"\b(data|input|params|context|kwargs|args)\[",  # Direct indexing
+            r"\b(data|input|params|context|kwargs|args)\.",  # Direct attribute access
+            r"\b(data|input|params|context|kwargs|args)\.get\(",  # .get() without default
+        ]
+
+        # Safety patterns that indicate safe access
+        safety_patterns = [
+            r"try\s*:",
+            r"except\s*:",
+            r"if\s+.*\s+is\s+not\s+None\s*:",
+            r"if\s+.*\s+in\s+",
+            r"\.get\(.*,.*\)",  # .get() with default value
+            r"isinstance\s*\(",
+            r"hasattr\s*\(",
+        ]
+
+        has_unsafe_access = False
+        has_safety_checks = False
+
         for line in lines:
             line = line.strip()
             if line and not line.startswith("#"):
-                # Check for variable access that might be parameters
-                if re.match(r"^[a-zA-Z_]\w*\s*=", line):
-                    var_name = line.split("=")[0].strip()
-                    # If variable is used before definition, might be parameter
-                    if not self._is_defined_before_use(var_name, code):
-                        return True
+                # Check for unsafe patterns
+                for pattern in unsafe_patterns:
+                    if re.search(pattern, line):
+                        has_unsafe_access = True
+                        break
 
-        return False
+                # Check for safety patterns
+                for pattern in safety_patterns:
+                    if re.search(pattern, line):
+                        has_safety_checks = True
+                        break
+
+        # Also check for undefined variables (potential parameters)
+        undefined_vars = self._find_undefined_variables(code)
+        if undefined_vars:
+            has_unsafe_access = True
+
+        return has_unsafe_access and not has_safety_checks
 
     def _is_defined_before_use(self, var_name: str, code: str) -> bool:
         """Check if variable is defined before use in code."""
@@ -619,6 +695,66 @@ class CycleLinter:
 
         return True
 
+    def _find_undefined_variables(self, code: str) -> list[str]:
+        """Find variables that are used but not defined in the code."""
+        import re
+
+        lines = code.split("\n")
+        defined_vars = set()
+        used_vars = set()
+
+        # Built-in variables and functions that don't need definition
+        builtin_vars = {
+            "len",
+            "sum",
+            "min",
+            "max",
+            "dict",
+            "list",
+            "set",
+            "str",
+            "int",
+            "float",
+            "bool",
+            "sorted",
+            "print",
+            "isinstance",
+            "type",
+            "hasattr",
+            "getattr",
+            "True",
+            "False",
+            "None",
+            "range",
+            "enumerate",
+            "zip",
+            "any",
+            "all",
+        }
+
+        for line in lines:
+            line = line.strip()
+            if line and not line.startswith("#"):
+                # Find variable definitions
+                if (
+                    "=" in line
+                    and not line.startswith("if")
+                    and not line.startswith("elif")
+                ):
+                    var_match = re.match(r"^([a-zA-Z_]\w*)\s*=", line)
+                    if var_match:
+                        defined_vars.add(var_match.group(1))
+
+                # Find variable uses
+                variables = re.findall(r"\b([a-zA-Z_]\w*)\b", line)
+                for var in variables:
+                    if var not in builtin_vars and not var.startswith("_"):
+                        used_vars.add(var)
+
+        # Return variables that are used but not defined
+        undefined = used_vars - defined_vars
+        return list(undefined)
+
     def _is_valid_condition_syntax(self, condition: str) -> bool:
         """Check if convergence condition has valid Python syntax."""
         try:

kailash/workflow/visualization.py

@@ -18,7 +18,7 @@ class WorkflowVisualizer:
 
     def __init__(
         self,
-        workflow: Workflow,
+        workflow: Workflow | None = None,
         node_colors: dict[str, str] | None = None,
         edge_colors: dict[str, str] | None = None,
         layout: str = "hierarchical",
@@ -26,7 +26,7 @@ class WorkflowVisualizer:
         """Initialize visualizer.
 
         Args:
-            workflow: Workflow to visualize
+            workflow: Workflow to visualize (can be set later)
             node_colors: Custom node color map
             edge_colors: Custom edge color map
             layout: Layout algorithm to use
@@ -70,9 +70,12 @@ class WorkflowVisualizer:
         """Get colors for all nodes in workflow."""
         colors = []
         for node_id in self.workflow.graph.nodes():
-            node_instance = self.workflow.nodes[node_id]
-            node_type = node_instance.node_type
-            colors.append(self._get_node_color(node_type))
+            node_instance = target_workflow.nodes.get(node_id)
+            if node_instance:
+                node_type = node_instance.node_type
+                colors.append(self._get_node_color(node_type))
+            else:
+                colors.append(self.node_colors["default"])
         return colors
 
     def _get_node_labels(self) -> dict[str, str]:
@@ -119,11 +122,15 @@ class WorkflowVisualizer:
 
         return edge_labels
 
-    def _calculate_layout(self) -> dict[str, tuple[float, float]]:
+    def _calculate_layout(self, workflow: 'Workflow' = None) -> dict[str, tuple[float, float]]:
         """Calculate node positions for visualization."""
+        target_workflow = workflow or self.workflow
+        if not target_workflow:
+            return {}
+            
         # Try to use stored positions first
         pos = {}
-        for node_id, node_instance in self.workflow.nodes.items():
+        for node_id, node_instance in target_workflow.nodes.items():
             if node_instance.position != (0, 0):
                 pos[node_id] = node_instance.position
 
@@ -133,32 +140,69 @@ class WorkflowVisualizer:
                 # Use hierarchical layout for DAGs
                 try:
                     # Create layers based on topological order
-                    layers = self._create_layers()
+                    layers = self._create_layers(target_workflow)
                     pos = self._hierarchical_layout(layers)
                 except Exception:
                     # Fallback to spring layout
-                    pos = nx.spring_layout(self.workflow.graph, k=3, iterations=50)
+                    pos = nx.spring_layout(target_workflow.graph, k=3, iterations=50)
             elif self.layout == "circular":
-                pos = nx.circular_layout(self.workflow.graph)
+                pos = nx.circular_layout(target_workflow.graph)
             elif self.layout == "spring":
-                pos = nx.spring_layout(self.workflow.graph, k=2, iterations=100)
+                pos = nx.spring_layout(target_workflow.graph, k=2, iterations=100)
             else:
                 # Default to spring layout
-                pos = nx.spring_layout(self.workflow.graph)
+                pos = nx.spring_layout(target_workflow.graph)
 
         return pos
+    
+    def _get_layout_positions(self, workflow: Workflow) -> dict[str, tuple[float, float]]:
+        """Get layout positions for workflow nodes."""
+        # Temporarily store workflow and calculate layout
+        original_workflow = self.workflow
+        self.workflow = workflow
+        try:
+            return self._calculate_layout()
+        finally:
+            self.workflow = original_workflow
+    
+    def _get_node_colors(self, workflow: Workflow) -> list[str]:
+        """Get node colors for workflow."""
+        colors = []
+        for node_id in workflow.graph.nodes():
+            node_instance = workflow.get_node(node_id)
+            if node_instance:
+                node_type = node_instance.__class__.__name__.lower()
+                # Map node types to color categories
+                if "data" in node_type or "csv" in node_type or "json" in node_type:
+                    color_key = "data"
+                elif "transform" in node_type or "python" in node_type:
+                    color_key = "transform"
+                elif "switch" in node_type or "merge" in node_type:
+                    color_key = "logic"
+                elif "llm" in node_type or "ai" in node_type:
+                    color_key = "ai"
+                else:
+                    color_key = "default"
+                colors.append(self.node_colors.get(color_key, self.node_colors["default"]))
+            else:
+                colors.append(self.node_colors["default"])
+        return colors
 
-    def _create_layers(self) -> dict[int, list]:
+    def _create_layers(self, workflow: 'Workflow' = None) -> dict[int, list]:
         """Create layers of nodes for hierarchical layout."""
+        target_workflow = workflow or self.workflow
+        if not target_workflow:
+            return {}
+            
         layers = {}
-        remaining = set(self.workflow.graph.nodes())
+        remaining = set(target_workflow.graph.nodes())
         layer = 0
 
         while remaining:
             # Find nodes with no dependencies in remaining set
             current_layer = []
             for node in remaining:
-                predecessors = set(self.workflow.graph.predecessors(node))
+                predecessors = set(target_workflow.graph.predecessors(node))
                 if not predecessors.intersection(remaining):
                     current_layer.append(node)
 
@@ -196,20 +240,34 @@ class WorkflowVisualizer:
 
     def _draw_graph(
         self,
-        pos: dict[str, tuple[float, float]],
-        node_colors: list[str],
-        show_labels: bool,
-        show_connections: bool,
+        workflow: Workflow | None = None,
+        pos: dict[str, tuple[float, float]] | None = None,
+        node_colors: list[str] | None = None,
+        show_labels: bool = True,
+        show_connections: bool = True,
     ) -> None:
         """Draw the graph with given positions and options."""
+        # Use provided workflow or fall back to instance workflow
+        target_workflow = workflow or self.workflow
+        if not target_workflow:
+            raise ValueError("No workflow provided to draw")
+        
+        # Use default position if not provided
+        if pos is None:
+            pos = self._get_layout_positions(target_workflow)
+        
+        # Use default colors if not provided
+        if node_colors is None:
+            node_colors = self._get_node_colors(target_workflow)
+        
         # Draw nodes
         nx.draw_networkx_nodes(
-            self.workflow.graph, pos, node_color=node_colors, node_size=3000, alpha=0.9
+            target_workflow.graph, pos, node_color=node_colors, node_size=3000, alpha=0.9
         )
 
         # Draw edges
         nx.draw_networkx_edges(
-            self.workflow.graph,
+            target_workflow.graph,
             pos,
             edge_color=self.edge_colors["default"],
             width=2,
@@ -221,16 +279,26 @@ class WorkflowVisualizer:
 
         # Draw labels
         if show_labels:
+            # Temporarily set workflow for label generation
+            old_workflow = self.workflow
+            self.workflow = target_workflow
             labels = self._get_node_labels()
+            self.workflow = old_workflow
+            
             nx.draw_networkx_labels(
-                self.workflow.graph, pos, labels, font_size=10, font_weight="bold"
+                target_workflow.graph, pos, labels, font_size=10, font_weight="bold"
             )
 
         # Draw connection labels
         if show_connections:
+            # Temporarily set workflow for edge label generation
+            old_workflow = self.workflow
+            self.workflow = target_workflow
             edge_labels = self._get_edge_labels()
+            self.workflow = old_workflow
+            
             nx.draw_networkx_edge_labels(
-                self.workflow.graph, pos, edge_labels, font_size=8
+                target_workflow.graph, pos, edge_labels, font_size=8
             )
 
     def visualize(
@@ -255,10 +323,14 @@ class WorkflowVisualizer:
             **kwargs: Additional options passed to plt.savefig
         """
         try:
+            # Check if workflow is available
+            if not self.workflow:
+                raise ValueError("No workflow to visualize. Set workflow property or create visualizer with workflow.")
+                
             plt.figure(figsize=figsize)
 
             # Calculate node positions
-            pos = self._calculate_layout()
+            pos = self._calculate_layout(self.workflow)
 
             # Handle empty workflow case
             if not self.workflow.graph.nodes():
@@ -266,11 +338,11 @@ class WorkflowVisualizer:
                 node_colors = []
             else:
                 # Draw the graph with colors
-                node_colors = self._get_node_colors()
+                node_colors = self._get_node_colors(self.workflow)
 
             # Draw the graph components
-            if pos and node_colors:
-                self._draw_graph(pos, node_colors, show_labels, show_connections)
+            if pos:
+                self._draw_graph(workflow=self.workflow, pos=pos, node_colors=node_colors, show_labels=show_labels, show_connections=show_connections)
 
             # Set title
             if title is None:

{kailash-0.6.6.dist-info → kailash-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kailash
-Version: 0.6.6
+Version: 0.8.0
 Summary: Python SDK for the Kailash container-node architecture
 Home-page: https://github.com/integrum/kailash-python-sdk
 Author: Integrum
@@ -21,7 +21,7 @@ Requires-Dist: matplotlib>=3.5
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: click>=8.0
 Requires-Dist: pytest>=8.3.5
-Requires-Dist: mcp[cli]>=1.9.2
+Requires-Dist: mcp[cli]==1.11.0
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: numpy>=2.2.5
 Requires-Dist: scipy>=1.15.3
@@ -78,6 +78,7 @@ Requires-Dist: passlib>=1.7.4
 Requires-Dist: pyotp>=2.9.0
 Requires-Dist: opentelemetry-instrumentation-fastapi>=0.55b1
 Requires-Dist: seaborn>=0.13.2
+Requires-Dist: sqlparse>=0.5.3
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=3.0; extra == "dev"