quantalogic 0.56.0__py3-none-any.whl → 0.57.0__py3-none-any.whl

quantalogic/flow/flow_extractor.py

@@ -3,8 +3,8 @@ 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  # For YAML saving
+from quantalogic.flow.flow_generator import generate_executable_script
+from quantalogic.flow.flow_manager import WorkflowManager
 from quantalogic.flow.flow_manager_schema import (
     BranchCondition,
     FunctionDefinition,
@@ -137,6 +137,7 @@ class WorkflowExtractor(ast.NodeVisitor):
                         if key in [
                             "model",
                             "system_prompt",
+                            "system_prompt_file",
                             "prompt_template",
                             "prompt_file",
                             "temperature",
@@ -170,6 +171,7 @@ class WorkflowExtractor(ast.NodeVisitor):
                         if key in [
                             "model",
                             "system_prompt",
+                            "system_prompt_file",
                             "prompt_template",
                             "prompt_file",
                             "temperature",
@@ -281,6 +283,7 @@ class WorkflowExtractor(ast.NodeVisitor):
                         if key in [
                             "model",
                             "system_prompt",
+                            "system_prompt_file",
                             "prompt_template",
                             "prompt_file",
                             "temperature",
@@ -314,6 +317,7 @@ class WorkflowExtractor(ast.NodeVisitor):
                         if key in [
                             "model",
                             "system_prompt",
+                            "system_prompt_file",
                             "prompt_template",
                             "prompt_file",
                             "temperature",
@@ -597,19 +601,6 @@ def extract_workflow_from_file(file_path):
                 parallel=False,
             )
 
-    # Optional: Deduplicate transitions (uncomment if desired)
-    # seen = set()
-    # unique_transitions = []
-    # for t in extractor.transitions:
-    #     key = (t.from_node, str(t.to_node), t.condition)
-    #     if key not in seen:
-    #         seen.add(key)
-    #         unique_transitions.append(t)
-    # workflow_structure = WorkflowStructure(
-    #     start=extractor.start_node,
-    #     transitions=unique_transitions,
-    #     convergence_nodes=extractor.convergence_nodes,
-    # )
     workflow_structure = WorkflowStructure(
         start=extractor.start_node,
         transitions=extractor.transitions,

quantalogic/flow/flow_generator.py

@@ -3,8 +3,8 @@ import os
 import re
 from typing import Dict, Optional
 
-from quantalogic.flow.flow import Nodes  # Import Nodes to access NODE_REGISTRY
-from quantalogic.flow.flow_manager_schema import BranchCondition, WorkflowDefinition  # Added BranchCondition import
+from quantalogic.flow.flow import Nodes
+from quantalogic.flow.flow_manager_schema import BranchCondition, WorkflowDefinition
 
 
 def generate_executable_script(
@@ -37,21 +37,19 @@ def generate_executable_script(
         start_node = workflow_def.workflow.start
         if start_node and start_node in workflow_def.nodes:
             node_def = workflow_def.nodes[start_node]
-            if node_def.function:
-                if node_def.function in workflow_def.functions:
-                    func_def = workflow_def.functions[node_def.function]
-                    if func_def.type == "embedded" and func_def.code:
-                        try:
-                            tree = ast.parse(func_def.code)
-                            for node in ast.walk(tree):
-                                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-                                    inputs = [param.arg for param in node.args.args]
-                                    # Assign default values: empty string for strings, 0 for numbers, etc.
-                                    for input_name in inputs:
-                                        initial_context[input_name] = ""  # Default to empty string for simplicity
-                                    break
-                        except SyntaxError:
-                            pass
+            if node_def.function and node_def.function in workflow_def.functions:
+                func_def = workflow_def.functions[node_def.function]
+                if func_def.type == "embedded" and func_def.code:
+                    try:
+                        tree = ast.parse(func_def.code)
+                        for node in ast.walk(tree):
+                            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                                inputs = [param.arg for param in node.args.args]
+                                for input_name in inputs:
+                                    initial_context[input_name] = ""  # Default to empty string
+                                break
+                    except SyntaxError:
+                        pass
             elif node_def.llm_config:
                 prompt = node_def.llm_config.prompt_template or ""
                 input_vars = set(re.findall(r"{{\s*([^}]+?)\s*}}", prompt))
@@ -88,10 +86,9 @@ def generate_executable_script(
                                         break
                             except SyntaxError:
                                 pass
-            # Apply inputs_mapping if present
             if node_def.inputs_mapping:
                 for key, value in node_def.inputs_mapping.items():
-                    if not value.startswith("lambda ctx:"):  # Only static mappings contribute to context
+                    if not value.startswith("lambda ctx:"):  # Static mappings only
                         initial_context[value] = ""
 
     with open(output_file, "w") as f:
@@ -126,20 +123,20 @@ def generate_executable_script(
             if node_def.function and node_def.function in workflow_def.functions:
                 func_def = workflow_def.functions[node_def.function]
                 if func_def.type == "embedded" and func_def.code:
-                    # Strip original decorator and apply new one
                     code_lines = func_def.code.split('\n')
-                    func_body = ""
-                    for line in code_lines:
-                        if line.strip().startswith('@Nodes.'):
-                            continue  # Skip original decorator
-                        func_body += line + "\n"
-                    func_body = func_body.rstrip("\n")
-
-                    # Generate new decorator based on node type
+                    func_body = "".join(
+                        line + "\n" for line in code_lines if not line.strip().startswith('@Nodes.')
+                    ).rstrip("\n")
                     decorator = ""
                     if node_def.llm_config:
-                        params = [f"model={repr(node_def.llm_config.model)}"]
-                        if node_def.llm_config.system_prompt:
+                        params = []
+                        if node_def.llm_config.model.startswith("lambda ctx:"):
+                            params.append(f"model={node_def.llm_config.model}")
+                        else:
+                            params.append(f"model={repr(node_def.llm_config.model)}")
+                        if node_def.llm_config.system_prompt_file:
+                            params.append(f"system_prompt_file={repr(node_def.llm_config.system_prompt_file)}")
+                        elif node_def.llm_config.system_prompt:
                             params.append(f"system_prompt={repr(node_def.llm_config.system_prompt)}")
                         if node_def.llm_config.prompt_template:
                             params.append(f"prompt_template={repr(node_def.llm_config.prompt_template)}")
@@ -160,10 +157,9 @@ def generate_executable_script(
                         decorator = f"@Nodes.template_node({', '.join(params)})\n"
                     else:
                         decorator = f"@Nodes.define(output={repr(node_def.output or f'{node_name}_result')})\n"
-                    # Write function with new decorator
                     f.write(f"{decorator}{func_body}\n\n")
 
-        # Define workflow using function names
+        # Define workflow using chaining syntax
         f.write("# Define the workflow with branch and converge support\n")
         f.write("workflow = (\n")
         start_node = workflow_def.workflow.start

quantalogic/flow/flow_manager.py

@@ -326,7 +326,6 @@ class WorkflowManager:
                 if node_def.function not in functions:
                     raise ValueError(f"Function '{node_def.function}' for node '{node_name}' not found")
                 func = functions[node_def.function]
-                # Register with the node name, not the function name
                 Nodes.NODE_REGISTRY[node_name] = (
                     Nodes.define(output=node_def.output)(func),
                     ["user_name"],  # Explicitly define inputs based on function signature
@@ -345,11 +344,25 @@ class WorkflowManager:
                 async def dummy_func(**kwargs):
                     pass
 
+                # Handle callable model if specified in inputs_mapping, else use default
+                def model_callable(ctx):
+                    return llm_config.model  # Default to string from schema
+                if node_def.inputs_mapping and "model" in node_def.inputs_mapping:
+                    model_value = node_def.inputs_mapping["model"]
+                    if isinstance(model_value, str) and model_value.startswith("lambda ctx:"):
+                        try:
+                            model_callable = eval(model_value)
+                        except Exception as e:
+                            logger.warning(f"Failed to evaluate model lambda for {node_name}: {e}")
+                            def model_callable(ctx):
+                                return model_value
+
                 if llm_config.response_model:
                     response_model = self._resolve_model(llm_config.response_model)
                     decorated_func = Nodes.structured_llm_node(
-                        model=llm_config.model,
+                        model=model_callable,
                         system_prompt=llm_config.system_prompt or "",
+                        system_prompt_file=llm_config.system_prompt_file,
                         prompt_template=llm_config.prompt_template,
                         prompt_file=llm_config.prompt_file,
                         response_model=response_model,
@@ -363,8 +376,9 @@ class WorkflowManager:
                     )(dummy_func)
                 else:
                     decorated_func = Nodes.llm_node(
-                        model=llm_config.model,
+                        model=model_callable,
                         system_prompt=llm_config.system_prompt or "",
+                        system_prompt_file=llm_config.system_prompt_file,
                         prompt_template=llm_config.prompt_template,
                         prompt_file=llm_config.prompt_file,
                         output=node_def.output or f"{node_name}_result",

quantalogic/flow/flow_manager_schema.py

@@ -30,7 +30,17 @@ class FunctionDefinition(BaseModel):
     @model_validator(mode="before")
     @classmethod
     def check_function_source(cls, data: Any) -> Any:
-        """Ensure the function definition is valid based on its type."""
+        """Ensure the function definition is valid based on its type.
+
+        Args:
+            data: Raw data to validate.
+
+        Returns:
+            Validated data.
+
+        Raises:
+            ValueError: If the function source configuration is invalid.
+        """
         type_ = data.get("type")
         if type_ == "embedded":
             if not data.get("code"):
@@ -50,9 +60,17 @@ class FunctionDefinition(BaseModel):
 class LLMConfig(BaseModel):
     """Configuration for LLM-based nodes."""
     model: str = Field(
-        default="gpt-3.5-turbo", description="The LLM model to use (e.g., 'gpt-3.5-turbo', 'gemini/gemini-2.0-flash')."
+        default="gpt-3.5-turbo",
+        description=(
+            "The LLM model to use. Can be a static model name (e.g., 'gpt-3.5-turbo', 'gemini/gemini-2.0-flash') "
+            "or a lambda expression (e.g., 'lambda ctx: ctx.get(\"model_name\")') for dynamic selection."
+        ),
     )
     system_prompt: Optional[str] = Field(None, description="System prompt defining the LLM's role or context.")
+    system_prompt_file: Optional[str] = Field(
+        None,
+        description="Path to an external Jinja2 template file for the system prompt. Takes precedence over system_prompt."
+    )
     prompt_template: str = Field(
         default="{{ input }}", description="Jinja2 template for the user prompt. Ignored if prompt_file is set."
     )
@@ -80,7 +98,17 @@ class LLMConfig(BaseModel):
     @model_validator(mode="before")
     @classmethod
     def check_prompt_source(cls, data: Any) -> Any:
-        """Ensure prompt_file and prompt_template are used appropriately."""
+        """Ensure prompt_file and prompt_template are used appropriately.
+
+        Args:
+            data: Raw data to validate.
+
+        Returns:
+            Validated data.
+
+        Raises:
+            ValueError: If prompt configuration is invalid.
+        """
         prompt_file = data.get("prompt_file")
         if prompt_file and not isinstance(prompt_file, str):
             raise ValueError("prompt_file must be a string path to a Jinja2 template file")
@@ -99,7 +127,17 @@ class TemplateConfig(BaseModel):
     @model_validator(mode="before")
     @classmethod
     def check_template_source(cls, data: Any) -> Any:
-        """Ensure template_file and template are used appropriately."""
+        """Ensure template_file and template are used appropriately.
+
+        Args:
+            data: Raw data to validate.
+
+        Returns:
+            Validated data.
+
+        Raises:
+            ValueError: If template configuration is invalid.
+        """
         template_file = data.get("template_file")
         template = data.get("template")
         if not template and not template_file:
@@ -137,7 +175,17 @@ class NodeDefinition(BaseModel):
     @model_validator(mode="before")
     @classmethod
     def check_function_or_sub_workflow_or_llm_or_template(cls, data: Any) -> Any:
-        """Ensure a node has exactly one of 'function', 'sub_workflow', 'llm_config', or 'template_config'."""
+        """Ensure a node has exactly one of 'function', 'sub_workflow', 'llm_config', or 'template_config'.
+
+        Args:
+            data: Raw data to validate.
+
+        Returns:
+            Validated data.
+
+        Raises:
+            ValueError: If node type configuration is invalid.
+        """
         func = data.get("function")
         sub_wf = data.get("sub_workflow")
         llm = data.get("llm_config")

quantalogic/flow/flow_mermaid.py

@@ -87,7 +87,7 @@ def generate_mermaid_diagram(
         "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
-        "template": "fill:#FCE4EC,stroke:#F06292,stroke-width:2px",          # Pastel Pink (new for template)
+        "template": "fill:#FCE4EC,stroke:#F06292,stroke-width:2px",          # Pastel Pink
         "sub_workflow": "fill:#FFCCBC,stroke:#FF7043,stroke-width:2px",      # Pastel Orange
         "unknown": "fill:#CFD8DC,stroke:#B0BEC5,stroke-width:2px"            # Pastel Grey
     }
@@ -148,7 +148,7 @@ def generate_mermaid_diagram(
     if title:
         mermaid_code += f"    %% Diagram: {title}\n"
 
-    # Optional legend for UX, updated to include template nodes
+    # Optional legend for UX
     if include_legend:
         mermaid_code += "    %% Legend:\n"
         if diagram_type == "flowchart":

quantalogic/flow/flow_yaml.linkedin.md

@@ -0,0 +1,31 @@
+Feeling like you're duct-taping AI components instead of building real solutions? 😩 We've ALL been there.
+
+Introducing **QuantaLogic Flow** 🧩: your new (free & open-source!) workflow architect.
+
+Think of it as an AI LEGO set:
+
+✅ Build pipelines blazingly fast.
+✅ Configure complex workflows in simple YAML.
+✅ Get LLMs collaborating effectively.
+✅ Automate tasks from paper analysis to story generation.
+
+Why are engineers loving it?
+
+⚡️ Branching logic that *doesn't* induce stress.
+⚡️ Validation that catches errors early.
+⚡️ Python ↔️ YAML conversion that feels magical.
+⚡️ Input mapping so clean, Marie Kondo would approve.
+
+So, what workflow automation feature would save *you* the most time?
+
+1️⃣ Dynamic LLM content?
+2️⃣ Visual branching?
+3️⃣ Declarative YAML config?
+
+Comment below with your pick! I'll share pro tips for the most requested. 👇
+
+P.S. Know a dev drowning in manual pipeline work? Share this post and be their hero!
+
+Link in comments.
+
+#AIEngineering #WorkflowAutomation