flock-core 0.4.0b4__py3-none-any.whl → 0.4.0b6__py3-none-any.whl

flock/__init__.py

@@ -2,7 +2,9 @@
 
 from rich.panel import Panel
 
+from flock.cli.config import init_config_file, load_config_file
 from flock.cli.constants import (
+    CLI_CFG_FILE,
     CLI_EXIT,
     CLI_NOTES,
     CLI_REGISTRY_MANAGEMENT,
@@ -35,6 +37,16 @@ def main():
     # Show a welcome message on first run with the new tool serialization format
     import os
 
+    cfg_file = os.path.expanduser(f"~/.flock/{CLI_CFG_FILE}")
+    if not os.path.exists(cfg_file):
+        # Create the directory if it doesn't exist
+        os.makedirs(os.path.dirname(cfg_file), exist_ok=True)
+
+        init_config_file()
+    else:
+        # Load the config file
+        load_config_file()
+
     feature_flag_file = os.path.expanduser("~/.flock/tool_serialization_notice")
     if not os.path.exists(feature_flag_file):
         # Create the directory if it doesn't exist

flock/cli/config.py

@@ -0,0 +1,8 @@
+def init_config_file():
+    """Initialize the config file."""
+    pass
+
+
+def load_config_file():
+    """Load the config file."""
+    pass

flock/cli/constants.py

@@ -1,5 +1,16 @@
 """Constants for the CLI module."""
 
+CLI_CFG_FILE = ".env"
+CLI_DEFAULT_ENV_VARS = {
+    "FLICK_API_KEY": "flock-api-key",
+    "FLICK_API_URL": "https://api.flock.com",
+    "FLICK_API_VERSION": "v1",
+    "FLICK_API_KEY": "flock-api-key",
+    "FLICK_API_URL": "https://api.flock.com",
+    "FLICK_API_VERSION": "v1",
+}
+CLI_DEFAULT_FOLDER = ".flock"
+
 CLI_CREATE_AGENT = "Create an agent"
 CLI_CREATE_FLOCK = "Create a new Flock"
 CLI_LOAD_AGENT = "Load an agent"

flock/cli/create_flock.py

@@ -4,12 +4,14 @@ This module provides a wizard-like interface for creating new Flock instances,
 with options for basic configuration and initial agent creation.
 """
 
+from datetime import datetime
 from pathlib import Path
 
 import questionary
 from rich.console import Console
 from rich.panel import Panel
 
+from flock.cli.constants import CLI_DEFAULT_FOLDER
 from flock.cli.loaded_flock_cli import start_loaded_flock_cli
 from flock.core.flock import Flock
 from flock.core.flock_factory import FlockFactory
@@ -31,6 +33,11 @@ def create_flock():
     console.print("[bold]Step 1: Basic Flock Configuration[/]")
     console.line()
 
+    flock_name = questionary.text(
+        "Enter a name for this Flock:",
+        default="",
+    ).ask()
+
     # Get description
     description = questionary.text(
         "Enter a description for this Flock (optional):",
@@ -61,10 +68,11 @@ def create_flock():
         model = model_choice
 
     # Execution options
-    enable_temporal = questionary.confirm(
-        "Enable Temporal for distributed execution?",
-        default=False,
-    ).ask()
+    # enable_temporal = questionary.confirm(
+    #     "Enable Temporal for distributed execution?",
+    #     default=False,
+    # ).ask()
+    enable_temporal = False
 
     # Logging configuration
     enable_logging = questionary.confirm(
@@ -74,6 +82,7 @@ def create_flock():
 
     # Create the Flock instance
     flock = Flock(
+        name=flock_name,
         model=model,
         description=description,
         enable_temporal=enable_temporal,
@@ -200,7 +209,8 @@ def _save_flock_to_yaml(flock):
         flock: The Flock instance to save
     """
     # Get file path
-    default_name = "my_flock.flock.yaml"
+    # default = flock.name + current date in 04_04_2025 format
+    default_name = f"{flock.name}_{datetime.now().strftime('%m_%d_%Y')}"
     file_path = questionary.text(
         "Enter file path to save Flock:",
         default=default_name,
@@ -208,7 +218,9 @@ def _save_flock_to_yaml(flock):
 
     # Ensure the file has the correct extension
     if not file_path.endswith((".yaml", ".yml")):
-        file_path += ".yaml"
+        file_path += ".flock.yaml"
+
+    file_path = CLI_DEFAULT_FOLDER + "/" + file_path
 
     # Create directory if it doesn't exist
     save_path = Path(file_path)

flock/cli/execute_flock.py

@@ -1,10 +1,11 @@
 """Execute a Flock instance with a selected agent.
 
 This module provides functionality to execute a Flock instance with
-a selected agent and input configuration.
+a selected agent and input configuration, including batch processing.
 """
 
 import json
+import os
 
 import questionary
 from rich.console import Console
@@ -16,6 +17,15 @@ from flock.core.util.cli_helper import init_console
 # Create console instance
 console = Console()
 
+# Try importing pandas for DataFrame support
+try:
+    import pandas as pd
+
+    PANDAS_AVAILABLE = True
+except ImportError:
+    pd = None
+    PANDAS_AVAILABLE = False
+
 
 def execute_flock(flock: Flock):
     """Execute a Flock instance.
@@ -198,3 +208,389 @@ def _parse_input_schema(input_schema: str) -> dict[str, dict[str, str]]:
         return {}
 
     return fields
+
+
+def execute_flock_batch(flock: Flock):
+    """Execute a Flock instance in batch mode.
+
+    Args:
+        flock: The Flock instance to execute
+    """
+    if not flock:
+        console.print("[bold red]Error: No Flock instance provided.[/]")
+        return
+
+    agent_names = list(flock._agents.keys())
+
+    if not agent_names:
+        console.print("[yellow]No agents in this Flock to execute.[/]")
+        return
+
+    init_console()
+    console.print(
+        Panel("[bold green]Execute Flock - Batch Mode[/]"), justify="center"
+    )
+
+    # Step 1: Select start agent
+    console.print("\n[bold]Step 1: Select Start Agent[/]")
+
+    start_agent_name = questionary.select(
+        "Select an agent to start with:",
+        choices=agent_names,
+    ).ask()
+
+    if not start_agent_name:
+        return
+
+    start_agent = flock._agents[start_agent_name]
+
+    # Step 2: Configure batch input source
+    console.print("\n[bold]Step 2: Select Batch Input Source[/]")
+
+    if not PANDAS_AVAILABLE:
+        console.print(
+            "[yellow]Warning: pandas not available. CSV input/output functionality will be limited.[/]"
+        )
+
+    input_source_choices = ["Enter batch items manually"]
+
+    if PANDAS_AVAILABLE:
+        input_source_choices.insert(0, "Load from CSV file")
+
+    input_source = questionary.select(
+        "How would you like to provide batch inputs?",
+        choices=input_source_choices,
+    ).ask()
+
+    if not input_source:
+        return
+
+    batch_inputs = []
+    input_mapping = {}
+
+    if input_source == "Load from CSV file" and PANDAS_AVAILABLE:
+        # Ask for CSV file path
+        csv_path = questionary.path(
+            "Enter path to CSV file:",
+        ).ask()
+
+        if not csv_path:
+            return
+
+        try:
+            # Validate path exists
+            if not os.path.exists(csv_path):
+                console.print(
+                    f"[bold red]Error: File '{csv_path}' does not exist.[/]"
+                )
+                return
+
+            # Preview CSV
+            df = pd.read_csv(csv_path)
+            console.print("\n[bold]CSV Preview (first 5 rows):[/]")
+            console.print(df.head().to_string())
+
+            # Configure column mapping
+            console.print("\n[bold]Configure Column Mapping:[/]")
+
+            # Parse input schema (if available)
+            input_fields = _parse_input_schema(start_agent.input)
+
+            # If we have input fields, map CSV columns to them
+            if input_fields:
+                columns = df.columns.tolist()
+
+                for field in input_fields.keys():
+                    field_desc = input_fields[field].get("description", "")
+                    prompt = f"Select column for '{field}'"
+
+                    if field_desc:
+                        prompt += f" ({field_desc})"
+
+                    selected_col = questionary.select(
+                        prompt,
+                        choices=["(Skip this field)"] + columns,
+                    ).ask()
+
+                    if selected_col and selected_col != "(Skip this field)":
+                        input_mapping[selected_col] = field
+            else:
+                # No schema, ask user to map columns manually
+                columns = df.columns.tolist()
+
+                for col in columns:
+                    mapping = questionary.text(
+                        f"Map column '{col}' to input field (leave empty to ignore):",
+                    ).ask()
+
+                    if mapping:
+                        input_mapping[col] = mapping
+
+            if not input_mapping:
+                console.print("[yellow]Warning: No column mapping defined.[/]")
+                if not questionary.confirm(
+                    "Continue without mapping?", default=False
+                ).ask():
+                    return
+
+            # Use the CSV file path directly
+            batch_inputs = csv_path
+
+        except Exception as e:
+            console.print(f"[bold red]Error loading CSV: {e}[/]")
+            return
+
+    elif input_source == "Enter batch items manually":
+        # Parse input schema
+        input_fields = _parse_input_schema(start_agent.input)
+
+        if not input_fields:
+            console.print(
+                "[yellow]No input schema available. Using JSON input.[/]"
+            )
+
+            while True:
+                raw_input = questionary.text(
+                    "Enter batch item as JSON (empty to finish):",
+                    default="{}",
+                ).ask()
+
+                if not raw_input:
+                    break
+
+                try:
+                    item_data = json.loads(raw_input)
+                    batch_inputs.append(item_data)
+                    console.print(f"[green]Added item {len(batch_inputs)}[/]")
+                except json.JSONDecodeError:
+                    console.print("[bold red]Error: Invalid JSON input.[/]")
+
+        else:
+            # We have input fields, ask for each field for each item
+            item_count = 1
+
+            while True:
+                console.print(f"\n[bold]Batch Item {item_count}[/]")
+
+                item_data = {}
+                for field, info in input_fields.items():
+                    field_type = info.get("type", "str")
+                    description = info.get("description", "")
+                    prompt = f"Enter value for '{field}'"
+
+                    if description:
+                        prompt += f" ({description})"
+
+                    prompt += " (empty to skip):"
+
+                    value = questionary.text(prompt).ask()
+
+                    if not value:
+                        continue
+
+                    # Convert value to appropriate type
+                    if field_type == "int":
+                        try:
+                            value = int(value)
+                        except ValueError:
+                            console.print(
+                                f"[yellow]Warning: Could not convert value to int, using as string.[/]"
+                            )
+
+                    item_data[field] = value
+
+                if item_data:
+                    batch_inputs.append(item_data)
+                    console.print(f"[green]Added item {len(batch_inputs)}[/]")
+
+                if not questionary.confirm(
+                    "Add another batch item?",
+                    default=len(batch_inputs)
+                    < 2,  # Default to yes if we have less than 2 items
+                ).ask():
+                    break
+
+                item_count += 1
+
+    if isinstance(batch_inputs, list) and not batch_inputs:
+        console.print("[yellow]No batch items defined. Exiting.[/]")
+        return
+
+    # Step 3: Configure static inputs (if needed)
+    static_inputs = {}
+
+    if questionary.confirm(
+        "Would you like to add static inputs (common to all batch items)?",
+        default=False,
+    ).ask():
+        console.print("\n[bold]Configure Static Inputs[/]")
+
+        raw_static = questionary.text(
+            "Enter static inputs as JSON:",
+            default="{}",
+        ).ask()
+
+        try:
+            static_inputs = json.loads(raw_static)
+        except json.JSONDecodeError:
+            console.print(
+                "[bold red]Error: Invalid JSON for static inputs. Proceeding without static inputs.[/]"
+            )
+            static_inputs = {}
+
+    # Step 4: Configure batch execution options
+    console.print("\n[bold]Step 4: Configure Batch Execution Options[/]")
+
+    # Determine if we should use Temporal
+    use_temporal = False
+    # if questionary.confirm(
+    #     f"Override Temporal setting? (Current: {flock.enable_temporal})",
+    #     default=False,
+    # ).ask():
+    #     use_temporal = questionary.confirm(
+    #         "Use Temporal for batch execution?",
+    #         default=flock.enable_temporal,
+    #     ).ask()
+
+    # Configure parallelism
+    parallel = True
+    max_workers = 5
+
+    if not flock.enable_temporal if use_temporal is None else not use_temporal:
+        parallel = questionary.confirm(
+            "Run batch items in parallel?",
+            default=True,
+        ).ask()
+
+        if parallel:
+            max_workers_input = questionary.text(
+                "Maximum number of parallel workers:",
+                default="5",
+            ).ask()
+
+            try:
+                max_workers = int(max_workers_input)
+            except ValueError:
+                console.print(
+                    "[yellow]Invalid worker count. Using default (5).[/]"
+                )
+                max_workers = 5
+
+    # Configure output options
+    silent_mode = questionary.confirm(
+        "Use silent mode with progress bar? (Recommended for large batches)",
+        default=True,
+    ).ask()
+
+    write_to_csv = None
+    if (
+        PANDAS_AVAILABLE
+        and questionary.confirm(
+            "Write results to CSV file?",
+            default=True,
+        ).ask()
+    ):
+        write_to_csv = questionary.text(
+            "CSV output path:",
+            default="batch_results.csv",
+        ).ask()
+
+    # Logging options
+    enable_logging = questionary.confirm(
+        "Enable detailed logging?",
+        default=False,
+    ).ask()
+
+    # Preview configuration
+    console.print("\n[bold]Batch Configuration Preview:[/]")
+    console.print(f"Agent: {start_agent_name}")
+
+    if isinstance(batch_inputs, str):
+        console.print(f"Input Source: CSV file ({batch_inputs})")
+        console.print(f"Column Mapping: {input_mapping}")
+    else:
+        console.print(f"Input Source: Manual entry ({len(batch_inputs)} items)")
+
+    if static_inputs:
+        console.print(f"Static Inputs: {json.dumps(static_inputs, indent=2)}")
+
+    # temporal_status = (
+    #     "Default" if use_temporal is None else ("Yes" if use_temporal else "No")
+    # )
+    # console.print(f"Use Temporal: {temporal_status}")
+
+    if not (flock.enable_temporal if use_temporal is None else use_temporal):
+        console.print(f"Parallel Execution: {parallel}")
+        if parallel:
+            console.print(f"Max Workers: {max_workers}")
+
+    console.print(f"Silent Mode: {silent_mode}")
+
+    if write_to_csv:
+        console.print(f"Write Results to: {write_to_csv}")
+
+    # Confirm execution
+    confirm = questionary.confirm(
+        "Execute batch with this configuration?",
+        default=True,
+    ).ask()
+
+    if not confirm:
+        return
+
+    # Execute the batch
+    console.print("\n[bold]Executing Batch...[/]")
+
+    try:
+        # Handle logging settings
+        if enable_logging:
+            flock._configure_logging(True)
+
+        # Run the batch
+        results = flock.run_batch(
+            start_agent=start_agent_name,
+            batch_inputs=batch_inputs,
+            input_mapping=input_mapping or None,
+            static_inputs=static_inputs or None,
+            parallel=parallel,
+            max_workers=max_workers,
+            use_temporal=use_temporal,
+            box_results=True,
+            return_errors=True,
+            silent_mode=silent_mode,
+            write_to_csv=write_to_csv,
+        )
+
+        # Display results summary
+        console.print("\n[bold green]Batch Execution Complete![/]")
+
+        success_count = sum(1 for r in results if not isinstance(r, Exception))
+        error_count = sum(1 for r in results if isinstance(r, Exception))
+
+        console.print(f"Total Items: {len(results)}")
+        console.print(f"Successful: {success_count}")
+
+        if error_count > 0:
+            console.print(f"[bold red]Errors: {error_count}[/]")
+
+        # Ask if user wants to see detailed results
+        if questionary.confirm(
+            "View detailed results?",
+            default=False,
+        ).ask():
+            for i, result in enumerate(results):
+                console.print(f"\n[bold]Item {i + 1}:[/]")
+                if isinstance(result, Exception):
+                    console.print(f"[bold red]Error: {result}[/]")
+                else:
+                    # Display as formatted JSON
+                    try:
+                        console.print(json.dumps(result, indent=2))
+                    except:
+                        console.print(str(result))
+
+        if write_to_csv:
+            console.print(f"\n[green]Results written to: {write_to_csv}[/]")
+
+    except Exception as e:
+        console.print(f"\n[bold red]Error during batch execution:[/] {e!s}")

flock/cli/loaded_flock_cli.py

@@ -12,6 +12,7 @@ from flock.cli.constants import (
     CLI_REGISTRY_MANAGEMENT,
     CLI_SETTINGS,
 )
+from flock.core.api import runner
 from flock.core.flock import Flock
 from flock.core.util.cli_helper import init_console
 
@@ -32,7 +33,7 @@ except ImportError:
     manage_agents_available = False
 
 try:
-    from flock.cli.execute_flock import execute_flock
+    from flock.cli.execute_flock import execute_flock, execute_flock_batch
 
     execute_flock_available = True
 except ImportError:
@@ -94,6 +95,7 @@ def start_loaded_flock_cli(
         choices = [
             questionary.Separator(line=" "),
             "Execute Flock",
+            "Execute Flock - Batch Mode",
             "Start Web Server",
             "Start Web Server with UI",
             "Manage Agents",
@@ -131,6 +133,15 @@ def start_loaded_flock_cli(
                 )
                 input("\nPress Enter to continue...")
 
+        elif choice == "Execute Flock - Batch Mode":
+            if execute_flock_available:
+                execute_flock_batch(flock)
+            else:
+                console.print(
+                    "[yellow]Batch execution functionality not yet implemented.[/]"
+                )
+                input("\nPress Enter to continue...")
+
         elif choice == "Start Web Server":
             _start_web_server(flock, create_ui=False)
 
@@ -203,7 +214,7 @@ def _start_web_server(flock: Flock, create_ui: bool = False) -> None:
         port = int(port_input)
 
     server_name_input = questionary.text(
-        "Server name (default: Flock API):", default=server_name
+        "Server name (default: FlockName API):", default=flock.name + " API"
     ).ask()
     if server_name_input:
         server_name = server_name_input
@@ -214,6 +225,10 @@ def _start_web_server(flock: Flock, create_ui: bool = False) -> None:
     )
 
     # Use the Flock's start_api method
-    flock.start_api(
-        host=host, port=port, server_name=server_name, create_ui=create_ui
+    runner.start_flock_api(
+        flock=flock,
+        host=host,
+        port=port,
+        server_name=server_name,
+        create_ui=create_ui,
     )

flock/cli/runner.py

@@ -0,0 +1,41 @@
+# src/flock/cli/runner.py
+"""Provides functionality to start the Flock CLI."""
+
+from typing import TYPE_CHECKING
+
+from flock.core.logging.logging import get_logger
+
+if TYPE_CHECKING:
+    from flock.core.flock import Flock
+
+logger = get_logger("cli.runner")
+
+
+def start_flock_cli(
+    flock: Flock,
+    server_name: str = "Flock CLI",
+    show_results: bool = False,
+    edit_mode: bool = False,
+) -> None:
+    """Start a CLI interface for the given Flock instance."""
+    try:
+        # Import CLI function locally
+        from flock.cli.loaded_flock_cli import start_loaded_flock_cli
+    except ImportError:
+        logger.error(
+            "CLI components not found. Cannot start CLI. "
+            "Ensure the CLI modules are properly installed/available."
+        )
+        return
+
+    logger.info(
+        f"Starting CLI interface for loaded Flock instance '{flock.name}' ({len(flock.agents)} agents)"
+    )
+
+    # Pass the Flock instance to the CLI entry point
+    start_loaded_flock_cli(
+        flock=flock,
+        server_name=server_name,
+        show_results=show_results,
+        edit_mode=edit_mode,
+    )

flock/config.py

@@ -1,8 +1,13 @@
 # flock/config.py
+import os
+
 from decouple import config
 
 from flock.core.logging.telemetry import TelemetryConfig
 
+cfg_file = os.path.expanduser(f"~/.flock/flock.cfg")
+
+
 # -- Connection and External Service Configurations --
 TEMPORAL_SERVER_URL = config("TEMPORAL_SERVER_URL", "localhost:7233")
 DEFAULT_MODEL = config("DEFAULT_MODEL", "openai/gpt-4o")