flock-core 0.5.0b28__py3-none-any.whl → 0.5.0b51__py3-none-any.whl

flock/core/mixin/prompt_parser.py

@@ -1,125 +0,0 @@
-"""A mixin class for parsing agent prompts and building clean signatures for DSPy."""
-
-# DEPRECATED! This mixin is no longer used in the current version of Flock. It was used to parse agent prompts and build clean signatures for DSPy.
-# TODO: DELETE THIS FILE!
-
-from flock.core.util.input_resolver import split_top_level
-
-
-class PromptParserMixin:
-    """A mixin class for parsing agent prompts and building clean signatures for DSPy."""
-
-    def _parse_key_descriptions(self, keys_str: str) -> list[tuple[str, str]]:
-        """Parse a comma-separated string into a list of (key, description) tuples.
-
-        This function processes a configuration string that defines one or more keys, where each key may
-        include a type hint and an optional human-readable description. The expected format for each key is:
-
-            key: type_hint | description
-
-        If the pipe symbol ("|") is absent, the description is set to an empty string.
-
-        The splitting is performed using split_top_level() so that commas inside type hints are preserved.
-
-        For example, given:
-            "query: str | The search query, context: dict | The full conversation context"
-        it returns:
-            [("query", "The search query"), ("context", "The full conversation context")]
-
-        Args:
-            keys_str (str): A comma-separated string of key definitions.
-
-        Returns:
-            List[Tuple[str, str]]: A list of (key, description) tuples.
-        """
-        key_descs = []
-        for part in split_top_level(keys_str):
-            if not part:
-                continue
-            if "|" in part:
-                key_type_part, desc = part.split("|", 1)
-                desc = desc.strip()
-            else:
-                key_type_part = part
-                desc = ""
-            key = key_type_part.split(":", 1)[0].strip()
-            key_descs.append((key, desc))
-        return key_descs
-
-    def _build_clean_signature(self, keys_str: str) -> str:
-        """Build a clean signature string from the configuration string by removing the description parts.
-
-        Given a string like:
-            "query: str | The search query, context: dict | The full conversation context"
-        this method returns:
-            "query: str, context: dict"
-
-        This function uses split_top_level() to avoid splitting on commas that are inside type hints.
-
-        Args:
-            keys_str (str): The configuration string containing keys, type hints, and optional descriptions.
-
-        Returns:
-            str: A clean signature string with only keys and type hints.
-        """
-        parts = []
-        for part in split_top_level(keys_str):
-            if not part:
-                continue
-            if "|" in part:
-                clean_part = part.split("|", 1)[0].strip()
-            else:
-                clean_part = part.strip()
-            parts.append(clean_part)
-        return ", ".join(parts)
-
-    def _build_descriptions(self) -> tuple[dict[str, str], dict[str, str]]:
-        """Build dictionaries of input and output descriptions from the agent's configuration.
-
-        Returns:
-            A tuple containing:
-            - input_desc: A dictionary mapping each input key (without type hints) to its description.
-            - output_desc: A dictionary mapping each output key (without type hints) to its description.
-        """
-        input_desc: dict[str, str] = {}
-        if self.input:
-            for key, desc in self._parse_key_descriptions(self.input):
-                input_desc[key] = desc
-
-        output_desc: dict[str, str] = {}
-        if self.output:
-            for key, desc in self._parse_key_descriptions(self.output):
-                output_desc[key] = desc
-
-        return input_desc, output_desc
-
-    def _build_prompt(
-        self, input_desc: dict[str, str], output_desc: dict[str, str]
-    ) -> str:
-        """Build a clean signature prompt from the agent's configuration.
-
-        This method uses the original input and output strings (removing the description parts)
-        to create a signature string that is passed to DSPy. For example, if:
-        - self.input is "query: str | The search query, context: dict | The full conversation context"
-        - self.output is "result: str | The result"
-        then the prompt will be:
-        "query: str, context: dict -> result: str"
-
-        **Note:** The descriptive metadata is preserved in the dictionaries obtained from _build_descriptions,
-        which are passed separately to DSPy.
-
-        Args:
-            input_desc: Dictionary of input key descriptions (for metadata only).
-            output_desc: Dictionary of output key descriptions (for metadata only).
-
-        Returns:
-            A clean signature string for DSPy.
-        """
-        clean_input = (
-            self._build_clean_signature(self.input) if self.input else ""
-        )
-        clean_output = (
-            self._build_clean_signature(self.output) if self.output else ""
-        )
-        # Combine the clean input and output signatures using "->"
-        return f"{clean_input} -> {clean_output}"

flock/core/orchestration/__init__.py

@@ -1,15 +0,0 @@
-# src/flock/core/orchestration/__init__.py
-"""Orchestration package public API.
-
-Avoid importing submodules at package import time to prevent heavy side effects
-and keep tests fast and deterministic. Import modules directly where needed.
-"""
-
-__all__ = [
-    "FlockExecution",
-    "FlockServerManager",
-    "FlockBatchProcessor",
-    "FlockEvaluator",
-    "FlockWebServer",
-    "FlockInitialization",
-]

flock/core/orchestration/flock_batch_processor.py

@@ -1,94 +0,0 @@
-# src/flock/core/orchestration/flock_batch_processor.py
-"""Batch processing functionality for Flock orchestrator."""
-
-from typing import TYPE_CHECKING, Any
-
-from box import Box
-from pandas import DataFrame
-
-from flock.core.logging.logging import get_logger
-
-if TYPE_CHECKING:
-    from flock.core.flock import Flock
-    from flock.core.flock_agent import FlockAgent
-
-logger = get_logger("flock.batch_processor")
-
-
-class FlockBatchProcessor:
-    """Handles batch processing functionality for Flock orchestrator."""
-
-    def __init__(self, flock: "Flock"):
-        self.flock = flock
-
-    async def run_batch_async(
-        self,
-        start_agent: "FlockAgent | str",
-        batch_inputs: list[dict[str, Any]] | DataFrame | str,
-        input_mapping: dict[str, str] | None = None,
-        static_inputs: dict[str, Any] | None = None,
-        parallel: bool = True,
-        max_workers: int = 5,
-        use_temporal: bool | None = None,
-        box_results: bool = True,
-        return_errors: bool = False,
-        silent_mode: bool = False,
-        write_to_csv: str | None = None,
-        hide_columns: list[str] | None = None,
-        delimiter: str = ",",
-    ) -> list[Box | dict | None | Exception]:
-        """Runs the specified agent/workflow for each item in a batch asynchronously (delegated)."""
-        # Import processor locally
-        from flock.core.execution.batch_executor import BatchProcessor
-
-        processor = BatchProcessor(self.flock)  # Pass flock instance
-        return await processor.run_batch_async(
-            start_agent=start_agent,
-            batch_inputs=batch_inputs,
-            input_mapping=input_mapping,
-            static_inputs=static_inputs,
-            parallel=parallel,
-            max_workers=max_workers,
-            use_temporal=use_temporal,
-            box_results=box_results,
-            return_errors=return_errors,
-            silent_mode=silent_mode,
-            write_to_csv=write_to_csv,
-            hide_columns=hide_columns,
-            delimiter=delimiter,
-        )
-
-    def run_batch(
-        self,
-        start_agent: "FlockAgent | str",
-        batch_inputs: list[dict[str, Any]] | DataFrame | str,
-        input_mapping: dict[str, str] | None = None,
-        static_inputs: dict[str, Any] | None = None,
-        parallel: bool = True,
-        max_workers: int = 5,
-        use_temporal: bool | None = None,
-        box_results: bool = True,
-        return_errors: bool = False,
-        silent_mode: bool = False,
-        write_to_csv: str | None = None,
-        hide_columns: list[str] | None = None,
-        delimiter: str = ",",
-    ) -> list[Box | dict | None | Exception]:
-        """Synchronous wrapper for batch processing."""
-        return self.flock._execution._run_sync(
-            self.run_batch_async(
-                start_agent=start_agent,
-                batch_inputs=batch_inputs,
-                input_mapping=input_mapping,
-                static_inputs=static_inputs,
-                parallel=parallel,
-                max_workers=max_workers,
-                use_temporal=use_temporal,
-                box_results=box_results,
-                return_errors=return_errors,
-                silent_mode=silent_mode,
-                write_to_csv=write_to_csv,
-                hide_columns=hide_columns,
-                delimiter=delimiter,
-            )
-        )

flock/core/orchestration/flock_evaluator.py

@@ -1,113 +0,0 @@
-# src/flock/core/orchestration/flock_evaluator.py
-"""Evaluation functionality for Flock orchestrator."""
-
-from collections.abc import Callable
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal
-
-from datasets import Dataset
-from pandas import DataFrame
-
-from flock.core.flock_agent import FlockAgent
-from flock.core.logging.logging import get_logger
-
-if TYPE_CHECKING:
-    from flock.core.flock import Flock
-
-
-logger = get_logger("flock.evaluator")
-
-
-class FlockEvaluator:
-    """Handles evaluation functionality for Flock orchestrator."""
-
-    def __init__(self, flock: "Flock"):
-        self.flock = flock
-
-    async def evaluate_async(
-        self,
-        dataset: str | Path | list[dict[str, Any]] | DataFrame | Dataset,
-        start_agent: FlockAgent | str,
-        input_mapping: dict[str, str],
-        answer_mapping: dict[str, str],
-        metrics: list[
-            str
-            | Callable[[Any, Any], bool | float | dict[str, Any]]
-            | FlockAgent
-        ],
-        metric_configs: dict[str, dict[str, Any]] | None = None,
-        static_inputs: dict[str, Any] | None = None,
-        parallel: bool = True,
-        max_workers: int = 5,
-        use_temporal: bool | None = None,
-        error_handling: Literal["raise", "skip", "log"] = "log",
-        output_file: str | Path | None = None,
-        return_dataframe: bool = True,
-        silent_mode: bool = False,
-        metadata_columns: list[str] | None = None,
-    ) -> "DataFrame | list[dict[str, Any]]":
-        """Evaluates the Flock's performance against a dataset (delegated)."""
-        # Import processor locally
-        from flock.core.execution.evaluation_executor import EvaluationExecutor
-
-        processor = EvaluationExecutor(self.flock)  # Pass flock instance
-        return await processor.evaluate_async(
-            dataset=dataset,
-            start_agent=start_agent,
-            input_mapping=input_mapping,
-            answer_mapping=answer_mapping,
-            metrics=metrics,
-            metric_configs=metric_configs,
-            static_inputs=static_inputs,
-            parallel=parallel,
-            max_workers=max_workers,
-            use_temporal=use_temporal,
-            error_handling=error_handling,
-            output_file=output_file,
-            return_dataframe=return_dataframe,
-            silent_mode=silent_mode,
-            metadata_columns=metadata_columns,
-        )
-
-    def evaluate(
-        self,
-        dataset: str | Path | list[dict[str, Any]] | DataFrame | Dataset,
-        start_agent: FlockAgent | str,
-        input_mapping: dict[str, str],
-        answer_mapping: dict[str, str],
-        metrics: list[
-            str
-            | Callable[[Any, Any], bool | float | dict[str, Any]]
-            | FlockAgent
-        ],
-        metric_configs: dict[str, dict[str, Any]] | None = None,
-        static_inputs: dict[str, Any] | None = None,
-        parallel: bool = True,
-        max_workers: int = 5,
-        use_temporal: bool | None = None,
-        error_handling: Literal["raise", "skip", "log"] = "log",
-        output_file: str | Path | None = None,
-        return_dataframe: bool = True,
-        silent_mode: bool = False,
-        metadata_columns: list[str] | None = None,
-    ) -> "DataFrame | list[dict[str, Any]]":
-        """Synchronous wrapper for evaluation."""
-        return self.flock._execution._run_sync(
-            self.evaluate_async(
-                dataset=dataset,
-                start_agent=start_agent,
-                input_mapping=input_mapping,
-                answer_mapping=answer_mapping,
-                metrics=metrics,
-                metric_configs=metric_configs,
-                static_inputs=static_inputs,
-                parallel=parallel,
-                max_workers=max_workers,
-                use_temporal=use_temporal,
-                error_handling=error_handling,
-                output_file=output_file,
-                return_dataframe=return_dataframe,
-                silent_mode=silent_mode,
-                metadata_columns=metadata_columns,
-            )
-        )

flock/core/orchestration/flock_execution.py

@@ -1,295 +0,0 @@
-# src/flock/core/orchestration/flock_execution.py
-"""Execution management functionality for Flock orchestrator."""
-
-import asyncio
-import contextvars
-import uuid
-from concurrent.futures import ThreadPoolExecutor
-from typing import TYPE_CHECKING, Any, TypeVar
-
-from box import Box
-from opentelemetry import trace
-from opentelemetry.baggage import set_baggage
-
-from flock.config import DEFAULT_MODEL
-from flock.core.context.context import FlockContext
-from flock.core.context.context_manager import initialize_context
-from flock.core.execution.local_executor import run_local_workflow
-from flock.core.execution.temporal_executor import run_temporal_workflow
-from flock.core.logging.logging import get_logger
-
-if TYPE_CHECKING:
-    from flock.core.flock import Flock
-    from flock.core.flock_agent import FlockAgent
-
-logger = get_logger("flock.execution")
-tracer = trace.get_tracer(__name__)
-_R = TypeVar("_R")
-
-
-class FlockExecution:
-    """Handles execution management for Flock including run, run_async, and execution coordination."""
-
-    def __init__(self, flock: "Flock"):
-        self.flock = flock
-
-    def _run_sync(self, coro) -> _R:
-        """Execute *coro* synchronously.
-
-        * If no loop is running → ``asyncio.run``.
-        * Otherwise run ``asyncio.run`` inside a fresh thread **with**
-          context-vars propagation.
-        """
-        try:
-            asyncio.get_running_loop()
-        except RuntimeError:  # no loop → simple
-            return asyncio.run(coro)
-
-        # A loop is already running – Jupyter / ASGI / etc.
-        ctx = contextvars.copy_context()  # propagate baggage
-        with ThreadPoolExecutor(max_workers=1) as pool:
-            future = pool.submit(ctx.run, asyncio.run, coro)
-            try:
-                return future.result()
-            finally:
-                if not future.done():
-                    future.cancel()
-
-    def run(
-        self,
-        agent: "FlockAgent | str | None" = None,
-        input: dict | None = None,
-        context: FlockContext | None = None,
-        run_id: str = "",
-        box_result: bool = True,
-        agents: list["FlockAgent"] | None = None,
-        servers: list[Any] | None = None,
-        memo: dict[str, Any] | None = None,
-    ) -> Box | dict:
-        """Synchronous execution wrapper."""
-        return self._run_sync(
-            self.run_async(
-                agent=agent,
-                input=input,
-                context=context,
-                run_id=run_id,
-                box_result=box_result,
-                agents=agents,
-                servers=servers,
-                memo=memo,
-            )
-        )
-
-    async def run_async(
-        self,
-        agent: "FlockAgent | str | None" = None,
-        input: dict | None = None,
-        context: FlockContext | None = None,
-        run_id: str = "",
-        box_result: bool = True,
-        agents: list["FlockAgent"] | None = None,
-        servers: list[Any] | None = None,
-        memo: dict[str, Any] | None = None,
-    ) -> Box | dict:
-        """Entry point for running an agent system asynchronously."""
-        # Import here to allow forward reference resolution
-        from flock.core.flock_agent import FlockAgent as ConcreteFlockAgent
-        from flock.core.mcp.flock_mcp_server import (
-            FlockMCPServer as ConcreteFlockServer,
-        )
-
-        with tracer.start_as_current_span("flock.run_async") as span:
-            # Add passed servers so that agents have access to them.
-            if servers:
-                for server_obj in servers:
-                    if isinstance(server_obj, ConcreteFlockServer):
-                        self.flock.add_server(server=server_obj)
-                    else:
-                        logger.warning(
-                            f"Item in 'servers' list is not a FlockMCPServer: {type(server_obj)}"
-                        )
-
-            # Add passed agents
-            if agents:
-                for agent_obj in agents:
-                    if isinstance(agent_obj, ConcreteFlockAgent):
-                        self.flock.add_agent(agent_obj)
-                    else:
-                        logger.warning(
-                            f"Item in 'agents' list is not a FlockAgent: {type(agent_obj)}"
-                        )
-
-            # Determine starting agent name
-            start_agent_name = self._resolve_start_agent(agent)
-
-            # Setup execution context and input
-            run_input = input if input is not None else self.flock._start_input
-            # Accept Pydantic BaseModel instances as input by converting to dict
-            try:
-                from pydantic import BaseModel as _BM
-                if not isinstance(run_input, dict) and isinstance(run_input, _BM):
-                    run_input = run_input.model_dump(exclude_none=True)  # type: ignore[attr-defined]
-            except Exception:
-                pass
-            effective_run_id = run_id or f"flockrun_{uuid.uuid4().hex[:8]}"
-
-            # Set span attributes
-            span.set_attribute("start_agent", start_agent_name)
-            span.set_attribute("input", str(run_input))
-            span.set_attribute("run_id", effective_run_id)
-            span.set_attribute("enable_temporal", self.flock.enable_temporal)
-
-            logger.info(
-                f"Initiating Flock run '{self.flock.name}'. Model: '{self.flock.model}'. Start Agent: '{start_agent_name}'. Temporal: {self.flock.enable_temporal}."
-            )
-
-            try:
-                # Setup execution context
-                run_context = self._setup_execution_context(
-                    context, start_agent_name, run_input, effective_run_id
-                )
-
-                # Execute workflow with server management
-                async with self.flock._mgr:
-                    logger.info("Entering managed server context. Servers starting up.")
-                    logger.info(
-                        "Starting agent execution",
-                        agent=start_agent_name,
-                        enable_temporal=self.flock.enable_temporal,
-                    )
-
-                    # Execute workflow using appropriate engine
-                    result = await self._execute_workflow(run_context, memo)
-
-                    # Set result attributes on span
-                    span.set_attribute("result.type", str(type(result)))
-                    result_str = str(result)
-                    span.set_attribute(
-                        "result.preview",
-                        result_str[:1000] + ("..." if len(result_str) > 1000 else ""),
-                    )
-
-                    # Format and return result
-                    return self._format_result(result, box_result)
-
-            except Exception as e:
-                logger.error(f"Flock run '{self.flock.name}' failed: {e}", exc_info=True)
-                span.record_exception(e)
-                span.set_status(trace.Status(trace.StatusCode.ERROR, str(e)))
-
-                # Return a consistent error structure
-                error_output = {
-                    "error": str(e),
-                    "details": f"Flock run '{self.flock.name}' failed.",
-                    "run_id": effective_run_id,
-                    "start_agent": start_agent_name,
-                }
-                return Box(error_output) if box_result else error_output
-
-    def _resolve_start_agent(self, agent: "FlockAgent | str | None") -> str:
-        """Resolve the start agent name from various input types."""
-        from flock.core.flock_agent import FlockAgent as ConcreteFlockAgent
-        from flock.core.registry import get_registry
-
-        registry = get_registry()
-
-        # Determine starting agent name
-        start_agent_name: str | None = None
-        if isinstance(agent, ConcreteFlockAgent):
-            start_agent_name = agent.name
-            if start_agent_name not in self.flock._agents:  # Add if not already present
-                self.flock.add_agent(agent)
-        elif isinstance(agent, str):
-            start_agent_name = agent
-        else:  # start_agent is None
-            start_agent_name = self.flock._start_agent_name
-
-        # Default to first agent if only one exists and none specified
-        if not start_agent_name and len(self.flock._agents) == 1:
-            start_agent_name = next(iter(self.flock._agents.keys()))
-        elif not start_agent_name:
-            raise ValueError(
-                "No start_agent specified and multiple/no agents exist in the Flock instance."
-            )
-
-        # Check if start_agent is in agents
-        if start_agent_name not in self.flock._agents:
-            # Try loading from registry if not found locally yet
-            reg_agent = registry.get_agent(start_agent_name)
-            if reg_agent:
-                self.flock.add_agent(reg_agent)
-                logger.info(f"Loaded start agent '{start_agent_name}' from registry.")
-            else:
-                raise ValueError(
-                    f"Start agent '{start_agent_name}' not found locally or in registry."
-                )
-
-        return start_agent_name
-
-    def _setup_execution_context(
-        self,
-        context: FlockContext | None,
-        start_agent_name: str,
-        run_input: dict,
-        run_id: str,
-    ) -> FlockContext:
-        """Setup the execution context for the workflow."""
-        resolved_start_agent = self.flock._agents.get(start_agent_name)
-        if not resolved_start_agent:  # Should have been handled by now
-            raise ValueError(f"Start agent '{start_agent_name}' not found after checks.")
-
-        run_context = context if context else FlockContext()
-        set_baggage("run_id", run_id)  # Set for OpenTelemetry
-
-        initialize_context(
-            run_context,
-            start_agent_name,
-            run_input,
-            run_id,
-            not self.flock.enable_temporal,  # local_debug is inverse of enable_temporal
-            self.flock.model or resolved_start_agent.model or DEFAULT_MODEL,
-        )
-
-        # Add agent definitions to context for routing/serialization within workflow
-        for agent_name_iter, agent_instance_iter in self.flock.agents.items():
-            agent_dict_repr = agent_instance_iter.to_dict()  # Agents handle their own serialization
-            run_context.add_agent_definition(
-                agent_type=type(agent_instance_iter),
-                agent_name=agent_name_iter,
-                agent_data=agent_dict_repr,
-            )
-
-        # Add temporal config to context if enabled
-        if self.flock.enable_temporal and self.flock.temporal_config:
-            run_context.set_variable(
-                "flock.temporal_workflow_config",
-                self.flock.temporal_config.model_dump(mode="json"),
-            )
-
-        return run_context
-
-    async def _execute_workflow(
-        self, run_context: FlockContext, memo: dict[str, Any] | None = None
-    ) -> dict[str, Any]:
-        """Execute the workflow using the appropriate execution engine."""
-        if not self.flock.enable_temporal:
-            return await run_local_workflow(run_context, box_result=False)
-        else:
-            return await run_temporal_workflow(
-                self.flock,  # Pass the Flock instance
-                run_context,
-                box_result=False,
-                memo=memo,
-            )
-
-    def _format_result(self, result: dict[str, Any], box_result: bool) -> Box | dict:
-        """Format the execution result."""
-        if box_result:
-            try:
-                logger.debug("Boxing final result.")
-                return Box(result)
-            except ImportError:
-                logger.warning("Box library not installed, returning raw dict.")
-                return result
-        else:
-            return result