kailash 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

kailash/nodes/transform/formatters.py

@@ -0,0 +1,96 @@
+"""Text formatting nodes for transforming and preparing text data."""
+
+from typing import Any, Dict
+
+from kailash.nodes.base import Node, NodeParameter, register_node
+
+
+@register_node()
+class ChunkTextExtractorNode(Node):
+    """Extracts text content from chunks for embedding generation."""
+
+    def get_parameters(self) -> Dict[str, NodeParameter]:
+        return {
+            "chunks": NodeParameter(
+                name="chunks",
+                type=list,
+                required=False,
+                description="List of chunks to extract text from",
+            )
+        }
+
+    def run(self, **kwargs) -> Dict[str, Any]:
+        chunks = kwargs.get("chunks", [])
+        # Extract just the content text from chunks
+        texts = [chunk["content"] for chunk in chunks]
+        return {"input_texts": texts}
+
+
+@register_node()
+class QueryTextWrapperNode(Node):
+    """Wraps query string in list for embedding generation."""
+
+    def get_parameters(self) -> Dict[str, NodeParameter]:
+        return {
+            "query": NodeParameter(
+                name="query",
+                type=str,
+                required=False,
+                description="Query string to wrap",
+            )
+        }
+
+    def run(self, **kwargs) -> Dict[str, Any]:
+        query = kwargs.get("query", "")
+        print(f"Debug QueryTextWrapper: received query='{query}'")
+        # Use input_texts for batch embedding (single item list)
+        result = {"input_texts": [query]}
+        print(f"Debug QueryTextWrapper: returning {result}")
+        return result
+
+
+@register_node()
+class ContextFormatterNode(Node):
+    """Formats relevant chunks into context for LLM."""
+
+    def get_parameters(self) -> Dict[str, NodeParameter]:
+        return {
+            "relevant_chunks": NodeParameter(
+                name="relevant_chunks",
+                type=list,
+                required=False,
+                description="List of relevant chunks with scores",
+            ),
+            "query": NodeParameter(
+                name="query",
+                type=str,
+                required=False,
+                description="Original query string",
+            ),
+        }
+
+    def run(self, **kwargs) -> Dict[str, Any]:
+        relevant_chunks = kwargs.get("relevant_chunks", [])
+        query = kwargs.get("query", "")
+        # Format context from relevant chunks
+        context_parts = []
+        for chunk in relevant_chunks:
+            context_parts.append(
+                f"From '{chunk['document_title']}' (Score: {chunk['relevance_score']:.3f}):\n"
+                f"{chunk['content']}\n"
+            )
+
+        context = "\n".join(context_parts)
+
+        # Create prompt for LLM
+        prompt = f"""Based on the following context, please answer the question: "{query}"
+
+Context:
+{context}
+
+Please provide a comprehensive answer based on the information provided above."""
+
+        # Create messages list for LLMAgent
+        messages = [{"role": "user", "content": prompt}]
+
+        return {"formatted_prompt": prompt, "messages": messages, "context": context}

kailash/nodes/transform/processors.py

@@ -261,7 +261,7 @@ class DataTransformer(Node):
                     local_vars["result"] = result
 
                     # Execute the code block
-                    exec(transform_str, safe_globals, local_vars)
+                    exec(transform_str, safe_globals, local_vars)  # noqa: S102
 
                     # Extract the result from local context
                     result = local_vars.get("result", result)
@@ -271,7 +271,7 @@ class DataTransformer(Node):
                     # For lambda functions like: "lambda x: x * 2"
                     if transform_str.strip().startswith("lambda"):
                         # First, compile the lambda function
-                        lambda_func = eval(transform_str, safe_globals)
+                        lambda_func = eval(transform_str, safe_globals)  # noqa: S307
 
                         # Apply the lambda function based on input data
                         if isinstance(result, list):
@@ -324,7 +324,9 @@ class DataTransformer(Node):
                     else:
                         local_vars = input_data.copy()
                         local_vars["result"] = result
-                        result = eval(transform_str, safe_globals, local_vars)
+                        result = eval(
+                            transform_str, safe_globals, local_vars
+                        )  # noqa: S307
 
             except Exception as e:
                 tb = traceback.format_exc()

kailash/runtime/docker.py

@@ -174,7 +174,7 @@ def main():
     logger.info(f"Loaded configuration for {node_data['class']} node")
 
     # Load runtime inputs if available
-    input_path = Path("/data/input/inputs.json")
+    input_path = Path("/examples/data/input/inputs.json")
     runtime_inputs = {}
     if input_path.exists():
         logger.info(f"Loading inputs from {input_path}")
@@ -206,7 +206,7 @@ def main():
     except Exception as e:
         logger.error(f"Node execution failed: {e}")
         # Save error information
-        with open("/data/output/error.json", 'w') as f:
+        with open("/examples/data/output/error.json", 'w') as f:
             json.dump({
                 "error": str(e),
                 "type": e.__class__.__name__
@@ -216,7 +216,7 @@ def main():
     # Save results
     logger.info("Saving execution results")
     try:
-        result_path = Path("/data/output/result.json")
+        result_path = Path("/examples/data/output/result.json")
         with open(result_path, 'w') as f:
             # Handle non-serializable objects with basic conversion
             try:
@@ -266,7 +266,7 @@ COPY node.json /app/node.json
 COPY entrypoint.py /app/entrypoint.py
 
 # Create data directories
-RUN mkdir -p /data/input /data/output
+RUN mkdir -p /examples/data/input /examples/data/output
 
 # Set entrypoint
 ENTRYPOINT ["/app/entrypoint.py"]
@@ -391,9 +391,9 @@ ENTRYPOINT ["/app/entrypoint.py"]
         cmd.extend(
             [
                 "-v",
-                f"{self.input_dir.absolute()}:/data/input",
+                f"{self.input_dir.absolute()}:/examples/data/input",
                 "-v",
-                f"{self.output_dir.absolute()}:/data/output",
+                f"{self.output_dir.absolute()}:/examples/data/output",
             ]
         )
 
@@ -404,6 +404,8 @@ ENTRYPOINT ["/app/entrypoint.py"]
             result = subprocess.run(
                 cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
             )
+            # Result could be used for logging output if needed
+            _ = result
 
             logger.info(f"Container for node {self.node_id} ran successfully")
             return True

kailash/sdk_exceptions.py

@@ -278,16 +278,7 @@ class TemplateError(KailashException):
 
 
 # Code execution exceptions
-class SafetyViolationError(NodeException):
-    """Raised when code execution violates safety rules.
-
-    This typically occurs when:
-    - Potentially dangerous operations are attempted
-    - Resource limits are exceeded
-    - Security policies are violated
-    """
-
-    pass
+# (SafetyViolationError already defined above - removing duplicate)
 
 
 class CodeExecutionError(NodeException):
@@ -302,6 +293,29 @@ class CodeExecutionError(NodeException):
     pass
 
 
+# Resource exceptions
+class KailashNotFoundException(KailashException):
+    """Raised when a requested resource cannot be found.
+
+    This typically occurs when:
+    - A template ID doesn't exist in the registry
+    - A node type is not registered
+    - A file or resource is missing
+    """
+
+    pass
+
+
+# Workflow-specific exceptions
+class KailashWorkflowException(WorkflowException):
+    """Raised for general workflow-related errors.
+
+    This is an alias for WorkflowException for consistency.
+    """
+
+    pass
+
+
 # Legacy exception name compatibility for tests and backwards compatibility
 KailashRuntimeError = RuntimeExecutionError
 KailashValidationError = NodeValidationError

kailash/tracking/metrics_collector.py

@@ -88,7 +88,8 @@ class MetricsCollector:
     metrics during node execution, with support for both process-level and
     system-level monitoring.
 
-    Usage:
+    Usage::
+
         collector = MetricsCollector()
         with collector.collect() as metrics:
             # Execute node code here

kailash/tracking/models.py

@@ -203,26 +203,6 @@ class TaskRun(BaseModel):
 
         # Check other validation rules as needed
 
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary representation."""
-        data = self.model_dump()
-
-        # Convert datetime objects to strings
-        if data.get("started_at"):
-            data["started_at"] = data["started_at"].isoformat()
-        if data.get("ended_at"):
-            data["ended_at"] = data["ended_at"].isoformat()
-        if data.get("completed_at"):
-            data["completed_at"] = data["completed_at"].isoformat()
-        if data.get("created_at"):
-            data["created_at"] = data["created_at"].isoformat()
-
-        # Convert metrics to dict if present
-        if self.metrics:
-            data["metrics"] = self.metrics.to_dict()
-
-        return data
-
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "TaskRun":
         """Create from dictionary representation."""

kailash/tracking/storage/database.py

@@ -320,7 +320,7 @@ class DatabaseStorage(StorageBackend):
                     # Try to sanitize it
                     try:
                         data["input_data"] = {"value": data["input_data"]}
-                    except:
+                    except Exception:
                         data["input_data"] = None
         if data.get("output_data"):
             try:
@@ -331,7 +331,7 @@ class DatabaseStorage(StorageBackend):
                     # Try to sanitize it
                     try:
                         data["output_data"] = {"value": data["output_data"]}
-                    except:
+                    except Exception:
                         data["output_data"] = None
 
         task = TaskRun.model_validate(data)
@@ -405,7 +405,7 @@ class DatabaseStorage(StorageBackend):
                         # Try to sanitize it by wrapping in quotes if needed
                         try:
                             data["input_data"] = {"value": data["input_data"]}
-                        except:
+                        except Exception:
                             data["input_data"] = None
             if data.get("output_data"):
                 try:
@@ -419,7 +419,7 @@ class DatabaseStorage(StorageBackend):
                         # Try to sanitize it
                         try:
                             data["output_data"] = {"value": data["output_data"]}
-                        except:
+                        except Exception:
                             data["output_data"] = None
 
             tasks.append(TaskRun.model_validate(data))

kailash/tracking/storage/filesystem.py

@@ -270,7 +270,6 @@ class FileSystemStorage(StorageBackend):
         run = WorkflowRun.model_validate(run_data)
 
         # Generate new run ID to avoid conflicts
-        original_run_id = run.run_id
         run.run_id = str(uuid4())
 
         # Save run

kailash/utils/templates.py

@@ -327,7 +327,7 @@ A Kailash workflow project.
 
 - `workflows/`: Workflow definitions
 - `nodes/`: Custom node implementations
-- `data/`: Input data files
+- `examples/data/`: Input data files
 - `outputs/`: Output files
 
 ## Usage
@@ -363,7 +363,7 @@ workflow = Workflow(
 )
 
 # Add nodes
-workflow.add_node("reader", CSVReader(), file_path="data/input.csv")
+workflow.add_node("reader", CSVReader(), file_path="examples/examples/data/input.csv")
 workflow.add_node("filter", Filter(), field="value", operator=">", value=100)
 workflow.add_node("sort", Sort(), field="value", reverse=True)
 workflow.add_node("aggregate", Aggregator(), group_by="category", operation="sum")
@@ -482,8 +482,8 @@ workflow = Workflow(
 )
 
 # Data ingestion
-workflow.add_node("csv_reader", CSVReader(), file_path="data/sales_data.csv")
-workflow.add_node("json_reader", JSONReader(), file_path="data/product_data.json")
+workflow.add_node("csv_reader", CSVReader(), file_path="examples/examples/data/sales_data.csv")
+workflow.add_node("json_reader", JSONReader(), file_path="examples/examples/data/product_data.json")
 
 # Transform data
 workflow.add_node("filter_sales", Filter(), field="amount", operator=">", value=1000)
@@ -553,7 +553,7 @@ workflow = Workflow(
 )
 
 # Data ingestion
-workflow.add_node("read_data", CSVReader(), file_path="data/text_data.csv")
+workflow.add_node("read_data", CSVReader(), file_path="examples/examples/data/text_data.csv")
 
 # Preprocessing
 workflow.add_node("extract_text", Map(), field="content")
@@ -616,7 +616,7 @@ workflow = Workflow(
 )
 
 # Read configuration
-workflow.add_node("read_config", JSONReader(), file_path="data/api_config.json")
+workflow.add_node("read_config", JSONReader(), file_path="examples/examples/data/api_config.json")
 
 # Process with AI agent
 workflow.add_node("chat_agent", ChatAgent(),

kailash/visualization/performance.py

@@ -136,7 +136,7 @@ class PerformanceVisualizer:
 
         # Calculate timeline bounds
         min_time = min(t.started_at for t in tasks_with_times)
-        max_time = max(t.ended_at for t in tasks_with_times)
+        max(t.ended_at for t in tasks_with_times)
 
         # Create timeline bars
         y_positions = []
@@ -266,8 +266,8 @@ class PerformanceVisualizer:
                 )
 
         # Memory usage chart
-        bars2 = ax2.bar(x, memory_usage, color="lightgreen", edgecolor="black")
-        bars2_delta = ax2.bar(
+        ax2.bar(x, memory_usage, color="lightgreen", edgecolor="black")
+        ax2.bar(
             x,
             memory_delta,
             bottom=memory_usage,
@@ -482,7 +482,7 @@ class PerformanceVisualizer:
         width = 0.35
 
         # I/O bytes chart
-        bars1 = ax1.bar(
+        ax1.bar(
             x - width / 2,
             io_read_bytes,
             width,
@@ -490,7 +490,7 @@ class PerformanceVisualizer:
             color="lightblue",
             edgecolor="black",
         )
-        bars2 = ax1.bar(
+        ax1.bar(
             x + width / 2,
             io_write_bytes,
             width,
@@ -507,7 +507,7 @@ class PerformanceVisualizer:
         ax1.grid(True, axis="y", alpha=0.3)
 
         # I/O operations count chart
-        bars3 = ax2.bar(
+        ax2.bar(
             x - width / 2,
             io_read_count,
             width,
@@ -515,7 +515,7 @@ class PerformanceVisualizer:
             color="lightblue",
             edgecolor="black",
         )
-        bars4 = ax2.bar(
+        ax2.bar(
             x + width / 2,
             io_write_count,
             width,

kailash/visualization/reports.py

@@ -639,7 +639,7 @@ class WorkflowPerformanceReporter:
 
         summary = analysis["summary"]
         bottlenecks = analysis["bottlenecks"]
-        resource_analysis = analysis["resource_analysis"]
+        analysis["resource_analysis"]
         error_analysis = analysis["error_analysis"]
 
         # Efficiency insights

kailash/workflow/graph.py

@@ -10,11 +10,11 @@ import networkx as nx
 import yaml
 from pydantic import BaseModel, Field, ValidationError
 
-from kailash.nodes import Node
+from kailash.nodes.base import Node
 
 try:
     # For normal runtime, use the actual registry
-    from kailash.nodes import NodeRegistry
+    from kailash.nodes.base import NodeRegistry
 except ImportError:
     # For tests, use the mock registry
     from kailash.workflow.mock_registry import MockRegistry as NodeRegistry
@@ -815,8 +815,8 @@ class Workflow:
 
                 # Try to find another key with a BaseModel
                 for key, value in last_node_results.items():
-                    if isinstance(value, BaseModel) and type(value) == type(
-                        state_model
+                    if isinstance(value, BaseModel) and isinstance(
+                        value, type(state_model)
                     ):
                         return value, results
 

kailash/workflow/mock_registry.py

@@ -43,7 +43,7 @@ NODE_TYPES = [
 for node_type in NODE_TYPES:
     try:
         NodeRegistry._registry[node_type] = MockNode
-    except:
+    except Exception:
         pass