quantalogic 0.51.0__tar.gz → 0.52.0__tar.gz

{quantalogic-0.51.0 → quantalogic-0.52.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.51.0
+Version: 0.52.0
 Summary: QuantaLogic ReAct Agents
 Author: Raphaël MANSUY
 Author-email: raphael.mansuy@gmail.com
@@ -88,6 +88,8 @@ At [QuantaLogic](https://www.quantalogic.app), we spotted a black hole: amazing
 - [Quick Start](#quick-start)
 - [ReAct Framework: Dynamic Agents](#react-framework-dynamic-agents)
 - [Flow Module: Structured Workflows](#flow-module-structured-workflows)
+  - 📘 **[Workflow YAML DSL Specification](./quantalogic/flow/flow_yaml.md)**: Comprehensive guide to defining powerful, structured workflows using our Domain-Specific Language
+  - 📚 **[Flow YAML Documentation](https://quantalogic.github.io/quantalogic/flow/flow_yaml)**: Dive into the official documentation for a deeper understanding of Flow YAML and its applications
 - [ReAct vs. Flow: Pick Your Power](#react-vs-flow-pick-your-power)
 - [Using the CLI](#using-the-cli)
 - [Examples That Spark Joy](#examples-that-spark-joy)
@@ -357,7 +359,15 @@ Perfect for coding, debugging, or answering wild questions on the fly.
 
 ## Flow Module: Structured Workflows 
 
-The **Flow module** is your architect—building workflows that hum with precision. It’s all about nodes, transitions, and a steady rhythm, ideal for repeatable missions.
+The **Flow module** is your architect—building workflows that hum with precision. It's all about nodes, transitions, and a steady rhythm, ideal for repeatable missions.
+
+🔍 **Want to dive deeper?** Check out our comprehensive [Workflow YAML DSL Specification](./quantalogic/flow/flow_yaml.md), a detailed guide that walks you through defining powerful, structured workflows. From basic node configurations to complex transition logic, this documentation is your roadmap to mastering workflow design with QuantaLogic.
+
+📚 **For a deeper understanding of Flow YAML and its applications, please refer to the official [Flow YAML Documentation](https://quantalogic.github.io/quantalogic/flow/flow_yaml).**
+
+The Flow YAML documentation provides a comprehensive overview of the Flow YAML language, including its syntax, features, and best practices. It's a valuable resource for anyone looking to create complex workflows with QuantaLogic.
+
+Additionally, the Flow YAML documentation includes a number of examples and tutorials to help you get started with creating your own workflows. These examples cover a range of topics, from simple workflows to more complex scenarios, and are designed to help you understand how to use Flow YAML to create powerful and flexible workflows.
 
 ### The Building Blocks
 - **Nodes**: Tasks like functions or LLM calls. 
@@ -629,6 +639,83 @@ mypy quantalogic  # Check types
 ruff check quantalogic  # Lint it
 ```
 
+### Create Custom Tools
+The `create_tool()` function transforms any Python function into a reusable Tool:
+
+```python
+from quantalogic.tools import create_tool
+
+def weather_lookup(city: str, country: str = "US") -> dict:
+    """Retrieve current weather for a given location.
+    
+    Args:
+        city: Name of the city to look up
+        country: Two-letter country code (default: US)
+    
+    Returns:
+        Dictionary with weather information
+    """
+    # Implement weather lookup logic here
+    return {"temperature": 22, "condition": "Sunny"}
+
+# Convert the function to a Tool
+weather_tool = create_tool(weather_lookup)
+
+# Now you can use it as a Tool
+print(weather_tool.to_markdown())  # Generate tool documentation
+result = weather_tool.execute(city="New York")  # Execute as a tool
+```
+
+#### Using Custom Tools with ReAct Agent
+
+Here's how to integrate custom tools with a ReAct Agent:
+
+```python
+from quantalogic import Agent
+from quantalogic.tools import create_tool, PythonTool
+
+# Create a custom stock price lookup tool
+def get_stock_price(symbol: str) -> str:
+    """Get the current price of a stock by its ticker symbol.
+    
+    Args:
+        symbol: Stock ticker symbol (e.g., AAPL, MSFT)
+    
+    Returns:
+        Current stock price information
+    """
+    # In a real implementation, you would fetch from an API
+    prices = {"AAPL": 185.92, "MSFT": 425.27, "GOOGL": 175.43}
+    if symbol in prices:
+        return f"{symbol} is currently trading at ${prices[symbol]}"
+    return f"Could not find price for {symbol}"
+
+# Create an agent with standard and custom tools
+agent = Agent(
+    model_name="gpt-4o",
+    tools=[
+        PythonTool(),  # Standard Python execution tool
+        create_tool(get_stock_price)  # Custom stock price tool
+    ]
+)
+
+# The agent can now use both tools to solve tasks
+result = agent.solve_task(
+    "Write a Python function to calculate investment growth, "  
+    "then analyze Apple stock's current price"
+)
+
+print(result)
+```
+
+In this example, the agent can seamlessly use both the standard `PythonTool` and your custom stock price lookup tool to complete the task.
+
+Key features of `create_tool()`:
+- 🔧 Automatically converts functions to Tools
+- 📝 Extracts metadata from function signature and docstring
+- 🔍 Supports both synchronous and asynchronous functions
+- 🛠️ Generates tool documentation and validation
+
 ---
 
 ## Contributing 

{quantalogic-0.51.0 → quantalogic-0.52.0}/README.md

@@ -42,6 +42,8 @@ At [QuantaLogic](https://www.quantalogic.app), we spotted a black hole: amazing
 - [Quick Start](#quick-start)
 - [ReAct Framework: Dynamic Agents](#react-framework-dynamic-agents)
 - [Flow Module: Structured Workflows](#flow-module-structured-workflows)
+  - 📘 **[Workflow YAML DSL Specification](./quantalogic/flow/flow_yaml.md)**: Comprehensive guide to defining powerful, structured workflows using our Domain-Specific Language
+  - 📚 **[Flow YAML Documentation](https://quantalogic.github.io/quantalogic/flow/flow_yaml)**: Dive into the official documentation for a deeper understanding of Flow YAML and its applications
 - [ReAct vs. Flow: Pick Your Power](#react-vs-flow-pick-your-power)
 - [Using the CLI](#using-the-cli)
 - [Examples That Spark Joy](#examples-that-spark-joy)
@@ -311,7 +313,15 @@ Perfect for coding, debugging, or answering wild questions on the fly.
 
 ## Flow Module: Structured Workflows 
 
-The **Flow module** is your architect—building workflows that hum with precision. It’s all about nodes, transitions, and a steady rhythm, ideal for repeatable missions.
+The **Flow module** is your architect—building workflows that hum with precision. It's all about nodes, transitions, and a steady rhythm, ideal for repeatable missions.
+
+🔍 **Want to dive deeper?** Check out our comprehensive [Workflow YAML DSL Specification](./quantalogic/flow/flow_yaml.md), a detailed guide that walks you through defining powerful, structured workflows. From basic node configurations to complex transition logic, this documentation is your roadmap to mastering workflow design with QuantaLogic.
+
+📚 **For a deeper understanding of Flow YAML and its applications, please refer to the official [Flow YAML Documentation](https://quantalogic.github.io/quantalogic/flow/flow_yaml).**
+
+The Flow YAML documentation provides a comprehensive overview of the Flow YAML language, including its syntax, features, and best practices. It's a valuable resource for anyone looking to create complex workflows with QuantaLogic.
+
+Additionally, the Flow YAML documentation includes a number of examples and tutorials to help you get started with creating your own workflows. These examples cover a range of topics, from simple workflows to more complex scenarios, and are designed to help you understand how to use Flow YAML to create powerful and flexible workflows.
 
 ### The Building Blocks
 - **Nodes**: Tasks like functions or LLM calls. 
@@ -583,6 +593,83 @@ mypy quantalogic  # Check types
 ruff check quantalogic  # Lint it
 ```
 
+### Create Custom Tools
+The `create_tool()` function transforms any Python function into a reusable Tool:
+
+```python
+from quantalogic.tools import create_tool
+
+def weather_lookup(city: str, country: str = "US") -> dict:
+    """Retrieve current weather for a given location.
+    
+    Args:
+        city: Name of the city to look up
+        country: Two-letter country code (default: US)
+    
+    Returns:
+        Dictionary with weather information
+    """
+    # Implement weather lookup logic here
+    return {"temperature": 22, "condition": "Sunny"}
+
+# Convert the function to a Tool
+weather_tool = create_tool(weather_lookup)
+
+# Now you can use it as a Tool
+print(weather_tool.to_markdown())  # Generate tool documentation
+result = weather_tool.execute(city="New York")  # Execute as a tool
+```
+
+#### Using Custom Tools with ReAct Agent
+
+Here's how to integrate custom tools with a ReAct Agent:
+
+```python
+from quantalogic import Agent
+from quantalogic.tools import create_tool, PythonTool
+
+# Create a custom stock price lookup tool
+def get_stock_price(symbol: str) -> str:
+    """Get the current price of a stock by its ticker symbol.
+    
+    Args:
+        symbol: Stock ticker symbol (e.g., AAPL, MSFT)
+    
+    Returns:
+        Current stock price information
+    """
+    # In a real implementation, you would fetch from an API
+    prices = {"AAPL": 185.92, "MSFT": 425.27, "GOOGL": 175.43}
+    if symbol in prices:
+        return f"{symbol} is currently trading at ${prices[symbol]}"
+    return f"Could not find price for {symbol}"
+
+# Create an agent with standard and custom tools
+agent = Agent(
+    model_name="gpt-4o",
+    tools=[
+        PythonTool(),  # Standard Python execution tool
+        create_tool(get_stock_price)  # Custom stock price tool
+    ]
+)
+
+# The agent can now use both tools to solve tasks
+result = agent.solve_task(
+    "Write a Python function to calculate investment growth, "  
+    "then analyze Apple stock's current price"
+)
+
+print(result)
+```
+
+In this example, the agent can seamlessly use both the standard `PythonTool` and your custom stock price lookup tool to complete the task.
+
+Key features of `create_tool()`:
+- 🔧 Automatically converts functions to Tools
+- 📝 Extracts metadata from function signature and docstring
+- 🔍 Supports both synchronous and asynchronous functions
+- 🛠️ Generates tool documentation and validation
+
 ---
 
 ## Contributing 

{quantalogic-0.51.0 → quantalogic-0.52.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "quantalogic"
-version = "0.51.0"
+version = "0.52.0"
 description = "QuantaLogic ReAct Agents"
 authors = ["Raphaël MANSUY <raphael.mansuy@gmail.com>"]
 readme = "README.md"

quantalogic-0.52.0/quantalogic/flow/__init__.py

@@ -0,0 +1,40 @@
+"""
+Flow Package Initialization
+
+This module initializes the flow package and provides package-level imports.
+Now supports nested workflows for hierarchical flow definitions.
+
+Key Visualization Utilities:
+- generate_mermaid_diagram(): Convert workflow definitions to visual Mermaid flowcharts
+    - Supports pastel-colored node styling
+    - Generates interactive, readable workflow diagrams
+    - Handles complex workflows with multiple node types
+
+    - Generates descriptive labels
+    - Supports conditional node detection
+"""
+
+from loguru import logger
+
+# Expose key components for easy importing
+from .flow import Nodes, Workflow, WorkflowEngine
+from .flow_extractor import extract_workflow_from_file
+from .flow_generator import generate_executable_script
+from .flow_manager import WorkflowManager
+from .flow_mermaid import generate_mermaid_diagram
+from .flow_validator import validate_workflow_definition
+
+# Define which symbols are exported when using `from flow import *`
+__all__ = [
+    "WorkflowManager",
+    "Nodes",
+    "Workflow",
+    "WorkflowEngine",
+    "generate_mermaid_diagram",
+    "extract_workflow_from_file",
+    "generate_executable_script",
+    "validate_workflow_definition"
+]
+
+# Package-level logger configuration
+logger.info("Initializing Quantalogic Flow Package")

{quantalogic-0.51.0 → quantalogic-0.52.0}/quantalogic/flow/flow_extractor.py

@@ -3,6 +3,7 @@ import os
 
 from loguru import logger
 
+from quantalogic.flow.flow_generator import generate_executable_script  # Import from flow_generator
 from quantalogic.flow.flow_manager import WorkflowManager  # Added for YAML saving
 from quantalogic.flow.flow_manager_schema import (
     FunctionDefinition,
@@ -396,7 +397,7 @@ class WorkflowExtractor(ast.NodeVisitor):
                     "sub_workflow": WorkflowStructure(
                         start=sub_extractor.start_node,
                         transitions=[
-                            TransitionDefinition(from_=t[0], to=t[1], condition=t[2]) for t in sub_extractor.transitions
+                            TransitionDefinition(from_node=t[0], to_node=t[1], condition=t[2]) for t in sub_extractor.transitions
                         ],
                     ),
                     "inputs": list(inputs.keys()),
@@ -494,7 +495,7 @@ def extract_workflow_from_file(file_path):
 
     # Construct TransitionDefinition objects
     transitions = [
-        TransitionDefinition(**{"from": from_node, "to": to_node, "condition": cond})
+        TransitionDefinition(from_node=from_node, to_node=to_node, condition=cond)
         for from_node, to_node, cond in extractor.transitions
     ]
 
@@ -509,95 +510,7 @@ def extract_workflow_from_file(file_path):
     return workflow_def, extractor.global_vars
 
 
-def generate_executable_script(workflow_def: WorkflowDefinition, global_vars: dict, output_file: str) -> None:
-    """
-    Generate an executable Python script from a WorkflowDefinition with global variables.
-
-    Args:
-        workflow_def: The WorkflowDefinition object containing the workflow details.
-        global_vars: Dictionary of global variables extracted from the source file.
-        output_file: The path where the executable script will be written.
-
-    The generated script includes:
-    - A shebang using `uv run` for environment management.
-    - Metadata specifying the required Python version and dependencies.
-    - Global variables from the original script.
-    - Embedded functions included directly in the script.
-    - Workflow instantiation using direct chaining syntax.
-    - A default initial_context matching the example.
-    """
-    with open(output_file, "w") as f:
-        # Write the shebang and metadata
-        f.write("#!/usr/bin/env -S uv run\n")
-        f.write("# /// script\n")
-        f.write('# requires-python = ">=3.12"\n')
-        f.write("# dependencies = [\n")
-        f.write('#     "loguru",\n')
-        f.write('#     "litellm",\n')
-        f.write('#     "pydantic>=2.0",\n')
-        f.write('#     "anyio",\n')
-        f.write('#     "quantalogic>=0.35",\n')
-        f.write('#     "jinja2",\n')
-        f.write('#     "instructor[litellm]",\n')  # Kept for potential structured LLM support
-        f.write("# ]\n")
-        f.write("# ///\n\n")
-
-        # Write necessary imports
-        f.write("import anyio\n")
-        f.write("from typing import List\n")
-        f.write("from loguru import logger\n")
-        f.write("from quantalogic.flow import Nodes, Workflow\n\n")
-
-        # Write global variables
-        for var_name, value in global_vars.items():
-            f.write(f"{var_name} = {repr(value)}\n")
-        f.write("\n")
-
-        # Embed functions from workflow_def
-        for func_name, func_def in workflow_def.functions.items():
-            if func_def.type == "embedded":
-                if func_def.code is not None:
-                    f.write(func_def.code + "\n\n")
-                else:
-                    f.write("\n\n")
-
-        # Define workflow using chaining syntax
-        f.write("# Define the workflow using simplified syntax with automatic node registration\n")
-        f.write("workflow = (\n")
-        f.write(f'    Workflow("{workflow_def.workflow.start}")\n')
-        for trans in workflow_def.workflow.transitions:
-            _from_node = trans.from_
-            to_node = trans.to
-            condition = trans.condition or "None"
-            if condition != "None":
-                # Ensure condition is formatted as a lambda if not already
-                if not condition.startswith("lambda ctx:"):
-                    condition = f"lambda ctx: {condition}"
-            f.write(f'    .then("{to_node}", condition={condition})\n')
-        for observer in workflow_def.observers:
-            f.write(f"    .add_observer({observer})\n")
-        f.write(")\n\n")
-
-        # Main asynchronous function to run the workflow
-        f.write("async def main():\n")
-        f.write('    """Main function to run the story generation workflow."""\n')
-        f.write("    initial_context = {\n")
-        f.write('        "genre": "science fiction",\n')
-        f.write('        "num_chapters": 3,\n')
-        f.write('        "chapters": [],\n')
-        f.write('        "completed_chapters": 0,\n')
-        f.write('        "style": "descriptive"\n')
-        f.write("    }  # Customize initial_context as needed\n")
-        f.write("    engine = workflow.build()\n")
-        f.write("    result = await engine.run(initial_context)\n")
-        f.write('    logger.info(f"Workflow result: {result}")\n\n')
-
-        # Entry point to execute the main function
-        f.write('if __name__ == "__main__":\n')
-        f.write("    anyio.run(main)\n")
-
-    # Set executable permissions (rwxr-xr-x)
-    os.chmod(output_file, 0o755)
+# The generate_executable_script function has been moved to flow_generator.py
 
 
 def print_workflow_definition(workflow_def):
@@ -638,11 +551,11 @@ def print_workflow_definition(workflow_def):
     print("Transitions:")
     for trans in workflow_def.workflow.transitions:
         condition_str = f" [Condition: {trans.condition}]" if trans.condition else ""
-        if isinstance(trans.to, list):
-            for to_node in trans.to:
-                print(f"- {trans.from_} -> {to_node}{condition_str}")
+        if isinstance(trans.to_node, list):
+            for to_node in trans.to_node:
+                print(f"- {trans.from_node} -> {to_node}{condition_str}")
         else:
-            print(f"- {trans.from_} -> {trans.to}{condition_str}")
+            print(f"- {trans.from_node} -> {trans.to_node}{condition_str}")
 
     print("\n#### Observers:")
     for observer in workflow_def.observers:
@@ -650,23 +563,39 @@ def print_workflow_definition(workflow_def):
 
 
 def main():
-    """Demonstrate parsing the story_generator_agent.py workflow and saving it to YAML."""
-    from quantalogic.flow.flow_generator import generate_executable_script  # Ensure correct import
-
-    output_file_python = "./story_generator.py"
-    file_path = "examples/qflow/story_generator_agent.py"
-    yaml_output_path = "story_generator_workflow.yaml"  # Output YAML file path
+    """Demonstrate extracting a workflow from a Python file and saving it to YAML."""
+    import argparse
+    import sys
+    
+    parser = argparse.ArgumentParser(description='Extract workflow from a Python file')
+    parser.add_argument('file_path', nargs='?', default="examples/qflow/story_generator_agent.py",
+                        help='Path to the Python file containing the workflow')
+    parser.add_argument('--output', '-o', default="./generated_workflow.py",
+                        help='Output path for the executable Python script')
+    parser.add_argument('--yaml', '-y', default="workflow_definition.yaml",
+                        help='Output path for the YAML workflow definition')
+    
+    args = parser.parse_args()
+    file_path = args.file_path
+    output_file_python = args.output
+    yaml_output_path = args.yaml
+    
+    if not os.path.exists(file_path):
+        logger.error(f"File '{file_path}' not found. Please provide a valid file path.")
+        logger.info("Example usage: python -m quantalogic.flow.flow_extractor path/to/your/workflow_file.py")
+        sys.exit(1)
+        
     try:
         workflow_def, global_vars = extract_workflow_from_file(file_path)
         logger.info(f"Successfully extracted workflow from '{file_path}'")
         print_workflow_definition(workflow_def)
         generate_executable_script(workflow_def, global_vars, output_file_python)
+        logger.info(f"Executable script generated at '{output_file_python}'")
+        
         # Save the workflow to a YAML file
         manager = WorkflowManager(workflow_def)
         manager.save_to_yaml(yaml_output_path)
         logger.info(f"Workflow saved to YAML file '{yaml_output_path}'")
-    except FileNotFoundError:
-        logger.error(f"File '{file_path}' not found. Please ensure it exists in the specified directory.")
     except Exception as e:
         logger.error(f"Failed to parse or save workflow from '{file_path}': {e}")
 

{quantalogic-0.51.0 → quantalogic-0.52.0}/quantalogic/flow/flow_generator.py

@@ -60,14 +60,18 @@ def generate_executable_script(workflow_def: WorkflowDefinition, global_vars: di
         f.write("workflow = (\n")
         f.write(f'    Workflow("{workflow_def.workflow.start}")\n')
         for trans in workflow_def.workflow.transitions:
-            _from_node = trans.from_
-            to_node = trans.to
+            _from_node = trans.from_node
+            to_node = trans.to_node
             condition = trans.condition or "None"
             if condition != "None":
                 # Ensure condition is formatted as a lambda if not already
                 if not condition.startswith("lambda ctx:"):
                     condition = f"lambda ctx: {condition}"
             f.write(f'    .then("{to_node}", condition={condition})\n')
+        # Add observers if any exist in the workflow definition
+        if hasattr(workflow_def, 'observers'):
+            for observer in workflow_def.observers:
+                f.write(f"    .add_observer({observer})\n")
         f.write(")\n\n")
 
         # Main asynchronous function to run the workflow

{quantalogic-0.51.0 → quantalogic-0.52.0}/quantalogic/flow/flow_manager.py

@@ -65,7 +65,7 @@ class WorkflowManager:
         self.workflow.workflow.transitions = [
             t
             for t in self.workflow.workflow.transitions
-            if t.from_ != name and (isinstance(t.to, str) or name not in t.to)
+            if t.from_node != name and (isinstance(t.to_node, str) or name not in t.to_node)
         ]
         if self.workflow.workflow.start == name:
             self.workflow.workflow.start = None
@@ -99,27 +99,36 @@ class WorkflowManager:
 
     def add_transition(
         self,
-        from_: str,
-        to: Union[str, List[str]],
+        from_node: str,
+        to_node: Union[str, List[str]],
         condition: Optional[str] = None,
+        strict: bool = True,
     ) -> None:
-        """Add a transition between nodes, ensuring all nodes exist."""
-        if from_ not in self.workflow.nodes:
-            raise ValueError(f"Source node '{from_}' does not exist")
-        if isinstance(to, str):
-            if to not in self.workflow.nodes:
-                raise ValueError(f"Target node '{to}' does not exist")
-        else:
-            for t in to:
-                if t not in self.workflow.nodes:
-                    raise ValueError(f"Target node '{t}' does not exist")
+        """Add a transition between nodes.
+        
+        Args:
+            from_node: Source node name
+            to_node: Target node name or list of target node names
+            condition: Optional condition for the transition
+            strict: If True, validates that all nodes exist before adding the transition.
+                   If False, allows adding transitions to non-existent nodes.
+        """
+        if strict:
+            if from_node not in self.workflow.nodes:
+                raise ValueError(f"Source node '{from_node}' does not exist")
+            if isinstance(to_node, str):
+                if to_node not in self.workflow.nodes:
+                    raise ValueError(f"Target node '{to_node}' does not exist")
+            else:
+                for t in to_node:
+                    if t not in self.workflow.nodes:
+                        raise ValueError(f"Target node '{t}' does not exist")
         # Create TransitionDefinition with named parameters
-        # Create a TransitionDefinition with the correct field names
-        # The field is defined with alias="from" in the schema
-        transition_dict = {"from": from_, "to": to}
-        if condition is not None:
-            transition_dict["condition"] = condition
-        transition = TransitionDefinition.model_validate(transition_dict)
+        transition = TransitionDefinition(
+            from_node=from_node,
+            to_node=to_node,
+            condition=condition
+        )
         self.workflow.workflow.transitions.append(transition)
 
     def set_start_node(self, name: str) -> None:
@@ -281,8 +290,8 @@ class WorkflowManager:
                 sub_workflows[node_name] = sub_wf
                 added_sub_nodes = set()
                 for trans in node_def.sub_workflow.transitions:
-                    from_node = trans.from_
-                    to_nodes = [trans.to] if isinstance(trans.to, str) else trans.to
+                    from_node = trans.from_node
+                    to_nodes = [trans.to_node] if isinstance(trans.to_node, str) else trans.to_node
                     if from_node not in added_sub_nodes:
                         sub_wf.node(from_node)
                         added_sub_nodes.add(from_node)
@@ -362,8 +371,8 @@ class WorkflowManager:
 
         added_nodes = set()
         for trans in self.workflow.workflow.transitions:
-            from_node = trans.from_
-            to_nodes = [trans.to] if isinstance(trans.to, str) else trans.to
+            from_node = trans.from_node
+            to_nodes = [trans.to_node] if isinstance(trans.to_node, str) else trans.to_node
             if from_node not in added_nodes and from_node not in sub_workflows:
                 wf.node(from_node)
                 added_nodes.add(from_node)
@@ -441,7 +450,7 @@ def main():
     manager.add_node(name="start", function="greet")
     manager.add_node(name="end", function="farewell")
     manager.set_start_node("start")
-    manager.add_transition(from_="start", to="end")
+    manager.add_transition(from_node="start", to_node="end")
     manager.add_observer("monitor")  # Add the observer
     manager.save_to_yaml("workflow.yaml")
     new_manager = WorkflowManager()

{quantalogic-0.51.0 → quantalogic-0.52.0}/quantalogic/flow/flow_manager_schema.py

@@ -128,12 +128,11 @@ class NodeDefinition(BaseModel):
 class TransitionDefinition(BaseModel):
     """Definition of a transition between nodes."""
 
-    from_: str = Field(
+    from_node: str = Field(
         ...,
         description="Source node name for the transition.",
-        alias="from",  # Supports YAML aliasing
     )
-    to: Union[str, List[str]] = Field(
+    to_node: Union[str, List[str]] = Field(
         ..., description="Target node(s). A string for sequential, a list for parallel execution."
     )
     condition: Optional[str] = Field(