flock-core 0.3.30__py3-none-any.whl → 0.3.32__py3-none-any.whl

flock/cli/yaml_editor.py

@@ -0,0 +1,283 @@
+"""YAML Editor for Flock CLI.
+
+This module provides functionality to view, edit, and validate YAML configurations
+for Flock and FlockAgent instances.
+"""
+
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+
+import questionary
+import yaml
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+
+from flock.core.flock import Flock
+from flock.core.flock_agent import FlockAgent
+from flock.core.util.cli_helper import init_console
+
+# Create console instance
+console = Console()
+
+
+def yaml_editor(flock_or_agent: Flock | FlockAgent | None = None):
+    """YAML Editor main entry point.
+
+    Args:
+        flock_or_agent: Optional Flock or FlockAgent instance to edit
+    """
+    init_console()
+    console.print(Panel("[bold green]YAML Editor[/]"), justify="center")
+
+    if flock_or_agent is None:
+        # If no object provided, provide options to load from file
+        _yaml_file_browser()
+        return
+
+    while True:
+        init_console()
+        console.print(Panel("[bold green]YAML Editor[/]"), justify="center")
+
+        # Determine object type
+        if isinstance(flock_or_agent, Flock):
+            obj_type = "Flock"
+            console.print(
+                f"Editing [bold cyan]Flock[/] with {len(flock_or_agent._agents)} agents"
+            )
+        elif isinstance(flock_or_agent, FlockAgent):
+            obj_type = "FlockAgent"
+            console.print(
+                f"Editing [bold cyan]FlockAgent[/]: {flock_or_agent.name}"
+            )
+        else:
+            console.print("[bold red]Error: Unknown object type[/]")
+            input("\nPress Enter to continue...")
+            return
+
+        console.line()
+
+        choice = questionary.select(
+            "What would you like to do?",
+            choices=[
+                questionary.Separator(line=" "),
+                "View Current YAML",
+                "Edit YAML Directly",
+                "Abstract Editor (Visual)",
+                "Validate YAML",
+                "Save to File",
+                questionary.Separator(),
+                "Back to Main Menu",
+            ],
+        ).ask()
+
+        if choice == "View Current YAML":
+            _view_yaml(flock_or_agent)
+        elif choice == "Edit YAML Directly":
+            flock_or_agent = _edit_yaml_directly(flock_or_agent)
+        elif choice == "Abstract Editor (Visual)":
+            flock_or_agent = _abstract_editor(flock_or_agent)
+        elif choice == "Validate YAML":
+            _validate_yaml(flock_or_agent)
+        elif choice == "Save to File":
+            _save_to_file(flock_or_agent)
+        elif choice == "Back to Main Menu":
+            break
+
+        if choice != "Back to Main Menu":
+            input("\nPress Enter to continue...")
+
+
+def _yaml_file_browser():
+    """Browser for YAML files to load."""
+    console.print("\n[bold]YAML File Browser[/]")
+    console.line()
+
+    current_dir = os.getcwd()
+    console.print(f"Current directory: [cyan]{current_dir}[/]")
+
+    # List .yaml/.yml files in current directory
+    yaml_files = list(Path(current_dir).glob("*.yaml")) + list(
+        Path(current_dir).glob("*.yml")
+    )
+
+    if not yaml_files:
+        console.print("[yellow]No YAML files found in current directory.[/]")
+        input("\nPress Enter to continue...")
+        return
+
+    # Display files
+    table = Table(title="YAML Files")
+    table.add_column("Filename", style="cyan")
+    table.add_column("Size", style="green")
+    table.add_column("Last Modified", style="yellow")
+
+    for file in yaml_files:
+        table.add_row(
+            file.name, f"{file.stat().st_size} bytes", f"{file.stat().st_mtime}"
+        )
+
+    console.print(table)
+
+    # TODO: Add file selection and loading
+
+
+def _view_yaml(obj: Flock | FlockAgent):
+    """View the YAML representation of an object.
+
+    Args:
+        obj: The object to view as YAML
+    """
+    yaml_str = obj.to_yaml()
+
+    # Display with syntax highlighting
+    syntax = Syntax(
+        yaml_str,
+        "yaml",
+        theme="monokai",
+        line_numbers=True,
+        code_width=100,
+        word_wrap=True,
+    )
+
+    init_console()
+    console.print(Panel("[bold green]YAML View[/]"), justify="center")
+    console.print(syntax)
+
+
+def _edit_yaml_directly(obj: Flock | FlockAgent) -> Flock | FlockAgent:
+    """Edit the YAML representation directly using an external editor.
+
+    Args:
+        obj: The object to edit
+
+    Returns:
+        The updated object
+    """
+    # Convert to YAML
+    yaml_str = obj.to_yaml()
+
+    # Create a temporary file
+    with tempfile.NamedTemporaryFile(
+        suffix=".yaml", mode="w+", delete=False
+    ) as tmp:
+        tmp.write(yaml_str)
+        tmp_path = tmp.name
+
+    try:
+        # Determine which editor to use
+        editor = os.environ.get(
+            "EDITOR", "notepad" if os.name == "nt" else "nano"
+        )
+
+        # Open the editor
+        console.print(
+            f"\nOpening {editor} to edit YAML. Save and exit when done."
+        )
+        subprocess.call([editor, tmp_path])
+
+        # Read updated YAML
+        with open(tmp_path) as f:
+            updated_yaml = f.read()
+
+        # Parse back to object
+        try:
+            if isinstance(obj, Flock):
+                updated_obj = Flock.from_yaml(updated_yaml)
+                console.print("\n[green]✓[/] YAML parsed successfully!")
+                return updated_obj
+            elif isinstance(obj, FlockAgent):
+                updated_obj = FlockAgent.from_yaml(updated_yaml)
+                console.print("\n[green]✓[/] YAML parsed successfully!")
+                return updated_obj
+        except Exception as e:
+            console.print(f"\n[bold red]Error parsing YAML:[/] {e!s}")
+            console.print("\nKeeping original object.")
+            return obj
+
+    finally:
+        # Clean up the temporary file
+        try:
+            os.unlink(tmp_path)
+        except:
+            pass
+
+
+def _abstract_editor(obj: Flock | FlockAgent) -> Flock | FlockAgent:
+    """Edit object using an abstract form-based editor.
+
+    Args:
+        obj: The object to edit
+
+    Returns:
+        The updated object
+    """
+    console.print("\n[yellow]Abstract visual editor not yet implemented.[/]")
+    console.print("Will provide a form-based editor for each field.")
+
+    # For now, just return the original object
+    return obj
+
+
+def _validate_yaml(obj: Flock | FlockAgent):
+    """Validate the YAML representation of an object.
+
+    Args:
+        obj: The object to validate
+    """
+    try:
+        yaml_str = obj.to_yaml()
+
+        # Attempt to parse with PyYAML
+        yaml.safe_load(yaml_str)
+
+        # Attempt to deserialize back to object
+        if isinstance(obj, Flock):
+            Flock.from_yaml(yaml_str)
+        elif isinstance(obj, FlockAgent):
+            FlockAgent.from_yaml(yaml_str)
+
+        console.print("\n[green]✓[/] YAML validation successful!")
+    except Exception as e:
+        console.print(f"\n[bold red]YAML validation failed:[/] {e!s}")
+
+
+def _save_to_file(obj: Flock | FlockAgent):
+    """Save object to a YAML file.
+
+    Args:
+        obj: The object to save
+    """
+    # Determine default filename based on object type
+    if isinstance(obj, Flock):
+        default_name = "my_flock.flock.yaml"
+    elif isinstance(obj, FlockAgent):
+        default_name = f"{obj.name}.agent.yaml"
+    else:
+        default_name = "unknown.yaml"
+
+    # Get file path
+    file_path = questionary.text(
+        "Enter file path to save YAML:",
+        default=default_name,
+    ).ask()
+
+    # Ensure the file has the correct extension
+    if not file_path.endswith((".yaml", ".yml")):
+        file_path += ".yaml"
+
+    # Create directory if it doesn't exist
+    save_path = Path(file_path)
+    save_path.parent.mkdir(parents=True, exist_ok=True)
+
+    try:
+        # Save to file
+        with open(file_path, "w") as f:
+            f.write(obj.to_yaml())
+
+        console.print(f"\n[green]✓[/] Saved to {file_path}")
+    except Exception as e:
+        console.print(f"\n[bold red]Error saving file:[/] {e!s}")

flock/core/flock.py

@@ -73,6 +73,10 @@ class Flock(BaseModel, Serializable):
     It is serializable to various formats like YAML and JSON.
     """
 
+    name: str = Field(
+        default_factory=lambda: f"flock_{uuid.uuid4().hex[:8]}",
+        description="A unique identifier for this Flock instance.",
+    )
     model: str | None = Field(
         default="openai/gpt-4o",
         description="Default model identifier to be used for agents if not specified otherwise.",
@@ -104,6 +108,7 @@ class Flock(BaseModel, Serializable):
 
     def __init__(
         self,
+        name: str | None = None,
         model: str | None = "openai/gpt-4o",
         description: str | None = None,
         enable_temporal: bool = False,
@@ -527,6 +532,45 @@ class Flock(BaseModel, Serializable):
             host=host, port=port, server_name=server_name, create_ui=create_ui
         )
 
+    # --- CLI Start Method ---
+    def start_cli(
+        self,
+        server_name: str = "Flock CLI",
+        show_results: bool = False,
+        edit_mode: bool = False,
+    ) -> None:
+        """Start a CLI interface for this Flock instance.
+
+        This method loads the CLI with the current Flock instance already available,
+        allowing users to execute, edit, or manage agents from the existing configuration.
+
+        Args:
+            server_name: Optional name for the CLI interface
+            show_results: Whether to initially show results of previous runs
+            edit_mode: Whether to open directly in edit mode
+        """
+        # Import locally to avoid circular imports
+        try:
+            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."
+            )
+            return
+
+        logger.info(
+            f"Starting CLI interface with loaded Flock instance ({len(self._agents)} agents)"
+        )
+
+        # Pass the current Flock instance to the CLI
+        start_loaded_flock_cli(
+            flock=self,
+            server_name=server_name,
+            show_results=show_results,
+            edit_mode=edit_mode,
+        )
+
     # --- Static Method Loaders (Keep for convenience) ---
     @staticmethod
     def load_from_file(file_path: str) -> Flock:

flock/core/flock_registry.py

@@ -528,87 +528,5 @@ def _auto_register_by_path():
             )
 
 
-def _auto_register_core():
-    logger.debug("Auto-registering core Flock components and tools...")
-    # Register base classes themselves if needed by name (e.g., for type checks)
-    # _registry_instance.register_component(FlockEvaluator)
-    # _registry_instance.register_component(FlockModule)
-    # _registry_instance.register_component(FlockRouter)
-
-    # Import and register known implementations
-    try:
-        from flock.evaluators.declarative.declarative_evaluator import (
-            DeclarativeEvaluator,
-        )
-
-        _registry_instance.register_component(DeclarativeEvaluator)
-    except ImportError:
-        logger.warning("DeclarativeEvaluator not found for auto-registration.")
-    try:
-        from flock.evaluators.memory.memory_evaluator import MemoryEvaluator
-
-        _registry_instance.register_component(MemoryEvaluator)
-    except ImportError:
-        logger.warning("MemoryEvaluator not found for auto-registration.")
-    # Add other standard evaluators...
-
-    try:
-        from flock.modules.output.output_module import OutputModule
-
-        _registry_instance.register_component(OutputModule)
-    except ImportError:
-        logger.warning("OutputModule not found for auto-registration.")
-    try:
-        from flock.modules.performance.metrics_module import MetricsModule
-
-        _registry_instance.register_component(MetricsModule)
-    except ImportError:
-        logger.warning("MetricsModule not found for auto-registration.")
-    try:
-        from flock.modules.memory.memory_module import MemoryModule
-
-        _registry_instance.register_component(MemoryModule)
-    except ImportError:
-        logger.warning("MemoryModule not found for auto-registration.")
-    # Add other standard modules...
-
-    try:
-        from flock.routers.default.default_router import DefaultRouter
-
-        _registry_instance.register_component(DefaultRouter)
-    except ImportError:
-        logger.warning("DefaultRouter not found for auto-registration.")
-    try:
-        from flock.routers.llm.llm_router import LLMRouter
-
-        _registry_instance.register_component(LLMRouter)
-    except ImportError:
-        logger.warning("LLMRouter not found for auto-registration.")
-    try:
-        from flock.routers.agent.agent_router import AgentRouter
-
-        _registry_instance.register_component(AgentRouter)
-    except ImportError:
-        logger.warning("AgentRouter not found for auto-registration.")
-    # Add other standard routers...
-
-    # Auto-register standard tools
-    try:
-        from flock.core.tools import (
-            azure_tools,
-            basic_tools,
-            llm_tools,
-            markdown_tools,
-        )
-        from flock.core.tools.dev_tools import github
-
-        _registry_instance.register_module_components(basic_tools)
-        _registry_instance.register_module_components(azure_tools)
-        _registry_instance.register_module_components(github)
-        _registry_instance.register_module_components(llm_tools)
-        _registry_instance.register_module_components(markdown_tools)
-    except ImportError as e:
-        logger.warning(f"Could not auto-register standard tools: {e}")
-
-
-_auto_register_core()
+# Bootstrapping the registry
+_auto_register_by_path()

flock/core/mixin/dspy_integration.py

@@ -5,7 +5,6 @@ import re  # Import re for parsing
 import typing
 from typing import Any, Literal
 
-from flock.core.flock_registry import get_registry  # Use FlockRegistry
 from flock.core.logging.logging import get_logger
 
 # Import split_top_level (assuming it's moved or copied appropriately)
@@ -15,7 +14,6 @@ from flock.core.logging.logging import get_logger
 # Define split_top_level here or ensure it's imported
 
 logger = get_logger("mixin.dspy")
-FlockRegistry = get_registry()  # Get singleton instance
 
 # Type definition for agent type override
 AgentType = Literal["ReAct", "Completion", "ChainOfThought"] | None
@@ -69,6 +67,11 @@ def _resolve_type_string(type_str: str) -> type:
     Handles built-ins, registered types, and common typing generics like
     List, Dict, Optional, Union, Literal.
     """
+    # Import registry here to avoid circular imports
+    from flock.core.flock_registry import get_registry
+
+    FlockRegistry = get_registry()
+
     type_str = type_str.strip()
     logger.debug(f"Attempting to resolve type string: '{type_str}'")
 

flock/core/serialization/serialization_utils.py

@@ -3,20 +3,20 @@
 
 import importlib
 from collections.abc import Mapping, Sequence
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from pydantic import BaseModel
 
-# Import the registry
-# from .callable_registry import CallableRegistry # Old way
-from flock.core.flock_registry import (
-    COMPONENT_BASE_TYPES,
-    get_registry,  # New way
-)
+# Use TYPE_CHECKING to avoid circular imports
+if TYPE_CHECKING:
+    pass
+
 from flock.core.logging.logging import get_logger
 
 logger = get_logger("serialization.utils")
-FlockRegistry = get_registry()  # Get singleton instance
+
+# Remove this line to avoid circular import at module level
+# FlockRegistry = get_registry()  # Get singleton instance
 
 # --- Serialization Helper ---
 
@@ -26,6 +26,11 @@ def serialize_item(item: Any) -> Any:
     Converts known callables to their path strings using FlockRegistry.
     Converts Pydantic models using model_dump.
     """
+    # Import the registry lazily when needed
+    from flock.core.flock_registry import get_registry
+
+    FlockRegistry = get_registry()
+
     if isinstance(item, BaseModel):
         dumped = item.model_dump(mode="json", exclude_none=True)
         return serialize_item(dumped)
@@ -74,6 +79,11 @@ def deserialize_item(item: Any) -> Any:
     Converts reference dicts back to actual callables or types using FlockRegistry.
     Handles nested lists and dicts.
     """
+    # Import the registry lazily when needed
+    from flock.core.flock_registry import get_registry
+
+    FlockRegistry = get_registry()
+
     if isinstance(item, Mapping):
         if "__callable_ref__" in item and len(item) == 1:
             path_str = item["__callable_ref__"]
@@ -138,6 +148,11 @@ def deserialize_component(
     """Deserializes a component (Module, Evaluator, Router) from its dict representation.
     Uses the 'type' field to find the correct class via FlockRegistry.
     """
+    # Import the registry and COMPONENT_BASE_TYPES lazily when needed
+    from flock.core.flock_registry import COMPONENT_BASE_TYPES, get_registry
+
+    FlockRegistry = get_registry()
+
     if data is None:
         return None
     if not isinstance(data, dict):

flock/evaluators/declarative/declarative_evaluator.py

@@ -9,6 +9,8 @@ from flock.core.mixin.prompt_parser import PromptParserMixin
 
 
 class DeclarativeEvaluatorConfig(FlockEvaluatorConfig):
+    """Configuration for the DeclarativeEvaluator."""
+
     agent_type_override: str | None = None
     model: str | None = "openai/gpt-4o"
     use_cache: bool = True

flock/modules/memory/memory_module.py

@@ -6,8 +6,12 @@ from typing import Any, Literal
 from pydantic import Field
 from tqdm import tqdm
 
-from flock.core import FlockAgent, FlockModule, FlockModuleConfig
 from flock.core.context.context import FlockContext
+
+# if TYPE_CHECKING:
+#     from flock.core import FlockAgent
+from flock.core.flock_agent import FlockAgent
+from flock.core.flock_module import FlockModule, FlockModuleConfig
 from flock.core.logging.logging import get_logger
 from flock.modules.memory.memory_parser import MemoryMappingParser
 from flock.modules.memory.memory_storage import FlockMemoryStore, MemoryEntry
@@ -282,7 +286,10 @@ class MemoryModule(FlockModule):
         return set(concept_list)
 
     async def _summarize_mode(
-        self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
     ) -> str:
         """Extract information chunks using summary mode."""
         split_signature = agent.create_dspy_signature_class(
@@ -300,7 +307,10 @@ class MemoryModule(FlockModule):
         return "\n".join(split_result.chunks)
 
     async def _semantic_splitter_mode(
-        self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
     ) -> str | list[dict[str, str]]:
         """Extract information chunks using semantic mode."""
         split_signature = agent.create_dspy_signature_class(
@@ -318,7 +328,10 @@ class MemoryModule(FlockModule):
         return split_result.chunks
 
     async def _character_splitter_mode(
-        self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
     ) -> list[str]:
         """Extract information chunks by splitting text into fixed character lengths."""
         full_text = json.dumps(inputs) + (json.dumps(result) if result else "")

flock/modules/output/output_module.py

@@ -3,11 +3,13 @@
 import json
 import os
 from datetime import datetime
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from pydantic import Field
 
-from flock.core import FlockAgent
+if TYPE_CHECKING:
+    from flock.core import FlockAgent
+
 from flock.core.context.context import FlockContext
 from flock.core.flock_module import FlockModule, FlockModuleConfig
 from flock.core.logging.formatters.themed_formatter import (
@@ -17,6 +19,10 @@ from flock.core.logging.formatters.themes import OutputTheme
 from flock.core.logging.logging import get_logger
 from flock.core.serialization.json_encoder import FlockJSONEncoder
 
+# from flock.core.logging.formatters.themes import OutputTheme
+# from flock.core.logging.logging import get_logger
+# from flock.core.serialization.json_encoder import FlockJSONEncoder
+
 logger = get_logger("module.output")
 
 
@@ -168,7 +174,7 @@ class OutputModule(FlockModule):
 
     async def post_evaluate(
         self,
-        agent: FlockAgent,
+        agent: "FlockAgent",
         inputs: dict[str, Any],
         result: dict[str, Any],
         context: FlockContext | None = None,

{flock_core-0.3.30.dist-info → flock_core-0.3.32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.3.30
+Version: 0.3.32
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE