quantalogic 0.51.0__py3-none-any.whl → 0.52.0__py3-none-any.whl

quantalogic/flow/__init__.py

@@ -3,13 +3,26 @@ 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__ = [
@@ -17,6 +30,10 @@ __all__ = [
     "Nodes",
     "Workflow",
     "WorkflowEngine",
+    "generate_mermaid_diagram",
+    "extract_workflow_from_file",
+    "generate_executable_script",
+    "validate_workflow_definition"
 ]
 
 # Package-level logger configuration

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/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/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/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(

quantalogic/flow/flow_mermaid.py

@@ -0,0 +1,240 @@
+import re
+from typing import Dict, List, Optional, Set, Tuple
+
+from quantalogic.flow.flow_manager import WorkflowManager
+from quantalogic.flow.flow_manager_schema import NodeDefinition, WorkflowDefinition
+
+
+def get_node_label_and_type(node_name: str, node_def: Optional[NodeDefinition], has_conditions: bool) -> Tuple[str, str, str]:
+    """
+    Generate a label, type identifier, and shape for a node based on its definition and transition context.
+
+    Args:
+        node_name: The name of the node.
+        node_def: The NodeDefinition object from the workflow, or None if undefined.
+        has_conditions: True if the node has outgoing transitions with conditions.
+
+    Returns:
+        A tuple of (display label, type key for styling, shape identifier).
+    """
+    # No truncation unless necessary, escape quotes for safety
+    escaped_name = node_name.replace('"', '\\"')
+
+    # Use diamond shape for nodes with conditional transitions, rectangle otherwise
+    shape = "diamond" if has_conditions else "rect"
+
+    if not node_def:
+        return f"{escaped_name} (unknown)", "unknown", shape
+    
+    if node_def.function:
+        return f"{escaped_name} (function)", "function", shape
+    elif node_def.llm_config:
+        if node_def.llm_config.response_model:
+            return f"{escaped_name} (structured LLM)", "structured_llm", shape
+        return f"{escaped_name} (LLM)", "llm", shape
+    elif node_def.sub_workflow:
+        return f"{escaped_name} (Sub-Workflow)", "sub_workflow", shape
+    return f"{escaped_name} (unknown)", "unknown", shape
+
+
+def generate_mermaid_diagram(
+    workflow_def: WorkflowDefinition,
+    include_subgraphs: bool = False,
+    title: Optional[str] = None,
+    include_legend: bool = True
+) -> str:
+    """
+    Generate a Mermaid flowchart diagram from a WorkflowDefinition with pastel colors and optimal UX.
+
+    Args:
+        workflow_def: The workflow definition to visualize.
+        include_subgraphs: If True, nests sub-workflows in Mermaid subgraphs.
+        title: Optional title for the diagram.
+        include_legend: If True, adds a comment-based legend explaining node types.
+
+    Returns:
+        A string containing the Mermaid syntax for the flowchart.
+
+    Raises:
+        ValueError: If node names contain invalid Mermaid characters.
+    """
+    # Pastel color scheme for a soft, user-friendly look
+    node_styles: Dict[str, str] = {
+        "function": "fill:#90CAF9,stroke:#42A5F5,stroke-width:2px",           # Pastel Blue
+        "structured_llm": "fill:#A5D6A7,stroke:#66BB6A,stroke-width:2px",    # Pastel Green
+        "llm": "fill:#CE93D8,stroke:#AB47BC,stroke-width:2px",               # Pastel Purple
+        "sub_workflow": "fill:#FFCCBC,stroke:#FF7043,stroke-width:2px",      # Pastel Orange
+        "unknown": "fill:#CFD8DC,stroke:#B0BEC5,stroke-width:2px"            # Pastel Grey
+    }
+
+    # Shape mappings for Mermaid syntax
+    shape_syntax: Dict[str, Tuple[str, str]] = {
+        "rect": ("[", "]"),      # Rectangle for standard nodes
+        "diamond": ("{{", "}}")   # Diamond for decision points
+    }
+
+    # Validate node names for Mermaid compatibility (alphanumeric, underscore, hyphen)
+    invalid_chars = r'[^a-zA-Z0-9_-]'
+    all_nodes: Set[str] = set()
+    if workflow_def.workflow.start:
+        if re.search(invalid_chars, workflow_def.workflow.start):
+            raise ValueError(f"Invalid node name '{workflow_def.workflow.start}' for Mermaid")
+        all_nodes.add(workflow_def.workflow.start)
+    for trans in workflow_def.workflow.transitions:
+        if re.search(invalid_chars, trans.from_node):
+            raise ValueError(f"Invalid node name '{trans.from_node}' for Mermaid")
+        all_nodes.add(trans.from_node)
+        if isinstance(trans.to_node, str):
+            if re.search(invalid_chars, trans.to_node):
+                raise ValueError(f"Invalid node name '{trans.to_node}' for Mermaid")
+            all_nodes.add(trans.to_node)
+        else:
+            for to_node in trans.to_node:
+                if re.search(invalid_chars, to_node):
+                    raise ValueError(f"Invalid node name '{to_node}' for Mermaid")
+                all_nodes.add(to_node)
+
+    # Determine which nodes have conditional transitions
+    conditional_nodes: Set[str] = set()
+    for trans in workflow_def.workflow.transitions:
+        if trans.condition and isinstance(trans.to_node, str):
+            conditional_nodes.add(trans.from_node)
+
+    # Generate node definitions and track types/shapes
+    node_defs: List[str] = []
+    node_types: Dict[str, str] = {}
+    node_shapes: Dict[str, str] = {}
+    for node in all_nodes:
+        node_def = workflow_def.nodes.get(node)
+        has_conditions = node in conditional_nodes
+        label, node_type, shape = get_node_label_and_type(node, node_def, has_conditions)
+        start_shape, end_shape = shape_syntax[shape]
+        node_defs.append(f'{node}{start_shape}"{label}"{end_shape}')
+        node_types[node] = node_type
+        node_shapes[node] = shape
+
+    # Generate arrows for transitions (all solid lines)
+    arrows: List[str] = []
+    for trans in workflow_def.workflow.transitions:
+        from_node = trans.from_node
+        if isinstance(trans.to_node, str):
+            to_node = trans.to_node
+            condition = trans.condition
+            if condition:
+                cond = condition.replace('"', '\\"')[:30] + ("..." if len(condition) > 30 else "")
+                arrows.append(f'{from_node} -->|"{cond}"| {to_node}')  # Solid arrow with condition
+            else:
+                arrows.append(f'{from_node} --> {to_node}')
+        else:
+            for to_node in trans.to_node:
+                arrows.append(f'{from_node} --> {to_node}')  # Solid arrow for parallel
+
+    # Assemble the Mermaid syntax
+    mermaid_code = "```mermaid\n"
+    mermaid_code += "graph TD\n"  # Top-down layout
+    if title:
+        mermaid_code += f"    %% Diagram: {title}\n"
+
+    # Optional legend for UX
+    if include_legend:
+        mermaid_code += "    %% Legend:\n"
+        mermaid_code += "    %% - Rectangle: Process Step\n"
+        mermaid_code += "    %% - Diamond: Decision Point\n"
+        mermaid_code += "    %% - Colors: Blue (Function), Green (Structured LLM), Purple (LLM), Orange (Sub-Workflow), Grey (Unknown)\n"
+
+    # Add node definitions
+    for node_def in node_defs:
+        mermaid_code += f"    {node_def}\n"
+
+    # Add transition arrows
+    for arrow in arrows:
+        mermaid_code += f"    {arrow}\n"
+
+    # Add styles for node types (no stroke-dasharray for solid appearance)
+    for node, node_type in node_types.items():
+        if node_type in node_styles:
+            mermaid_code += f"    style {node} {node_styles[node_type]}\n"
+
+    # Highlight the start node with a thicker border
+    if workflow_def.workflow.start and workflow_def.workflow.start in node_types:
+        mermaid_code += f"    style {workflow_def.workflow.start} stroke-width:4px\n"
+
+    # Optional: Subgraphs for sub-workflows
+    if include_subgraphs:
+        for node, node_def in workflow_def.nodes.items():
+            if node_def and node_def.sub_workflow:
+                mermaid_code += f"    subgraph {node}_sub[Sub-Workflow: {node}]\n"
+                sub_nodes = {node_def.sub_workflow.start} if node_def.sub_workflow.start else set()
+                for trans in node_def.sub_workflow.transitions:
+                    sub_nodes.add(trans.from_node)
+                    if isinstance(trans.to_node, str):
+                        sub_nodes.add(trans.to_node)
+                    else:
+                        sub_nodes.update(trans.to_node)
+                for sub_node in sub_nodes:
+                    mermaid_code += f"        {sub_node}[[{sub_node}]]\n"
+                mermaid_code += "    end\n"
+
+    mermaid_code += "```\n"
+    return mermaid_code
+
+
+def main() -> None:
+    """
+    Create a complex workflow and print its improved Mermaid diagram representation.
+    """
+    manager = WorkflowManager()
+
+    # Add functions
+    manager.add_function(
+        name="analyze_sentiment",
+        type_="embedded",
+        code="async def analyze_sentiment(summary: str) -> str:\n    return 'positive' if 'good' in summary.lower() else 'negative'",
+    )
+    manager.add_function(
+        name="extract_keywords",
+        type_="embedded",
+        code="async def extract_keywords(summary: str) -> str:\n    return 'key1, key2'",
+    )
+    manager.add_function(
+        name="publish_content",
+        type_="embedded",
+        code="async def publish_content(summary: str, sentiment: str, keywords: str) -> str:\n    return 'Published'",
+    )
+    manager.add_function(
+        name="revise_content",
+        type_="embedded",
+        code="async def revise_content(summary: str) -> str:\n    return 'Revised summary'",
+    )
+
+    # Add LLM node
+    llm_config = {
+        "model": "grok/xai",
+        "system_prompt": "You are a concise summarizer.",
+        "prompt_template": "Summarize the following text: {{ input_text }}",
+        "temperature": "0.5",
+        "max_tokens": "150",
+    }
+    manager.add_node(name="summarize_text", llm_config=llm_config, output="summary")
+
+    # Add function nodes
+    manager.add_node(name="sentiment_analysis", function="analyze_sentiment", output="sentiment")
+    manager.add_node(name="keyword_extraction", function="extract_keywords", output="keywords")
+    manager.add_node(name="publish", function="publish_content", output="status")
+    manager.add_node(name="revise", function="revise_content", output="revised_summary")
+
+    # Define workflow structure
+    manager.set_start_node("summarize_text")
+    manager.add_transition(from_node="summarize_text", to_node=["sentiment_analysis", "keyword_extraction"])
+    manager.add_transition(from_node="sentiment_analysis", to_node="publish", condition="ctx['sentiment'] == 'positive'")
+    manager.add_transition(from_node="sentiment_analysis", to_node="revise", condition="ctx['sentiment'] == 'negative'")
+    manager.add_transition(from_node="keyword_extraction", to_node="publish")
+
+    # Generate and print the diagram
+    workflow_def = manager.workflow
+    diagram = generate_mermaid_diagram(workflow_def, include_subgraphs=False, title="Content Processing Workflow")
+    print(diagram)
+
+
+if __name__ == "__main__":
+    main()