flock-core 0.1.2__py3-none-any.whl → 0.2.2__py3-none-any.whl

flock/core/agent_registry.py

@@ -1,162 +0,0 @@
-from collections.abc import Callable
-
-from flock.core.agent import Agent
-from flock.core.logging import flock_logger, performance_handler
-
-
-class Registry:
-    """Registry for storing and managing agents and tools.
-
-    This singleton class maintains a centralized registry of agents and tools,
-    which is particularly important for Temporal workflows where only basic Python
-    types can be passed between activities.
-    """
-
-    _instance = None
-
-    def __new__(cls):
-        """Singleton pattern implementation."""
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            with performance_handler.track_time("registry_initialization"):
-                flock_logger.info("Initializing new Registry instance")
-                cls._instance._initialize()
-        return cls._instance
-
-    def _initialize(self):
-        """Initialize the registry's storage."""
-        self._agents: list[Agent] = []
-        self._tools: list[tuple[str, Callable]] = []
-        flock_logger.debug("Registry storage initialized")
-
-    def register_tool(self, tool_name: str, tool: Callable) -> None:
-        """Register a tool with the registry.
-
-        Args:
-            tool_name: The name to register the tool under
-            tool: The tool function to register
-        """
-        try:
-            with performance_handler.track_time("tool_registration"):
-                self._tools.append((tool_name, tool))
-                flock_logger.info(f"Registered tool: {tool_name}")
-                flock_logger.debug("Tool details", tool_name=tool_name, tool_type=type(tool).__name__)
-        except Exception as e:
-            flock_logger.error(
-                "Tool registration failed",
-                tool_name=tool_name,
-                error=str(e),
-            )
-            raise
-
-    def register_agent(self, agent: Agent) -> None:
-        """Register an agent with the registry.
-
-        Args:
-            agent: The agent instance to register
-        """
-        try:
-            with performance_handler.track_time("agent_registration"):
-                self._agents.append(agent)
-                flock_logger.info(f"Registered agent: {agent.name}")
-                flock_logger.debug(
-                    "Agent details",
-                    name=agent.name,
-                    type=type(agent).__name__,
-                    model=agent.model,
-                )
-        except Exception as e:
-            flock_logger.error(
-                "Agent registration failed",
-                agent_name=getattr(agent, "name", "unknown"),
-                error=str(e),
-            )
-            raise
-
-    def get_agent(self, name: str) -> Agent | None:
-        """Retrieve an agent by name.
-
-        Args:
-            name: The name of the agent to retrieve
-
-        Returns:
-            The agent instance if found, None otherwise
-        """
-        try:
-            with performance_handler.track_time("agent_retrieval"):
-                for agent in self._agents:
-                    if agent.name == name:
-                        flock_logger.debug(f"Retrieved agent: {name}")
-                        return agent
-
-                flock_logger.warning(f"Agent not found: {name}")
-                return None
-        except Exception as e:
-            flock_logger.error(
-                "Agent retrieval failed",
-                agent_name=name,
-                error=str(e),
-            )
-            raise
-
-    def get_tool(self, name: str) -> Callable | None:
-        """Retrieve a tool by name.
-
-        Args:
-            name: The name of the tool to retrieve
-
-        Returns:
-            The tool function if found, None otherwise
-        """
-        try:
-            with performance_handler.track_time("tool_retrieval"):
-                for tool_name, tool in self._tools:
-                    if tool_name == name:
-                        flock_logger.debug(f"Retrieved tool: {name}")
-                        return tool
-
-                flock_logger.warning(f"Tool not found: {name}")
-                return None
-        except Exception as e:
-            flock_logger.error(
-                "Tool retrieval failed",
-                tool_name=name,
-                error=str(e),
-            )
-            raise
-
-    def get_tools(self, names: list[str] | None) -> list[Callable]:
-        """Retrieve multiple tools by name.
-
-        Args:
-            names: List of tool names to retrieve
-
-        Returns:
-            List of found tool functions (may be empty if none found)
-        """
-        try:
-            with performance_handler.track_time("tools_retrieval"):
-                if not names:
-                    flock_logger.debug("No tool names provided")
-                    return []
-
-                tools = [self.get_tool(name) for name in names]
-                found_tools = [name for name, tool in zip(names, tools) if tool is not None]
-
-                if found_tools:
-                    flock_logger.debug(
-                        "Retrieved tools",
-                        requested=len(names),
-                        found=len(found_tools),
-                    )
-                    return [tool for tool in tools if tool is not None]
-
-                flock_logger.warning("No tools found", requested=names)
-                return []
-        except Exception as e:
-            flock_logger.error(
-                "Tools retrieval failed",
-                tool_names=names,
-                error=str(e),
-            )
-            raise

flock/core/context.py

@@ -1,279 +0,0 @@
-from dataclasses import asdict, dataclass, field
-from datetime import datetime
-from typing import Any, Literal
-
-from flock.core.context_vars import FLOCK_LAST_AGENT, FLOCK_LAST_RESULT
-from flock.core.logging import flock_logger, performance_handler
-from flock.core.serializable import Serializable
-
-
-@dataclass
-class AgentRunRecord:
-    agent: str = field(default="")  # Agent name
-    input_data: dict[str, Any] = field(default_factory=dict)
-    output_data: dict[str, Any] = field(default_factory=dict)
-    timestamp: str = field(default="")
-    hand_off: str = field(default="")  # Next agent name
-
-
-@dataclass
-class AgentDefinition:
-    agent_type: str = field(default="")
-    agent_name: str = field(default="")
-    agent_data: dict = field(default=dict)
-    serializer: Literal["json", "cloudpickle", "msgpack"] = field(default="cloudpickle")
-
-
-@dataclass
-class FlockContext(Serializable):
-    state: dict[str, Any] = field(default_factory=dict)
-    history: list[AgentRunRecord] = field(default_factory=list)
-    agent_definitions: dict[str, AgentDefinition] = field(default_factory=dict)
-    run_id: str = field(default="")
-    workflow_id: str = field(default="")
-    workflow_timestamp: str = field(default="")
-
-    def record(self, agent_name: str, data: dict[str, Any], timestamp: str, hand_off: str) -> None:
-        """Record an agent run and update the state with the agent's output."""
-        try:
-            with performance_handler.track_time("record_agent_run"):
-                flock_logger.info(f"Recording agent run: {agent_name}")
-                record = AgentRunRecord(
-                    agent=agent_name, output_data=data.copy(), timestamp=timestamp, hand_off=hand_off
-                )
-                self.history.append(record)
-                flock_logger.debug(
-                    "Created run record",
-                    agent=agent_name,
-                    output_keys=list(data.keys()),
-                )
-
-                self.set_variable(f"{agent_name}.result", data)
-                self.set_variable(FLOCK_LAST_RESULT, data)
-                self.set_variable(FLOCK_LAST_AGENT, agent_name)
-                flock_logger.debug("Updated context state with agent output")
-
-        except Exception as e:
-            flock_logger.error(
-                "Failed to record agent run",
-                agent=agent_name,
-                error=str(e),
-            )
-            raise
-
-    def get_variable(self, key: str) -> Any:
-        """Get the current value of a state variable."""
-        try:
-            with performance_handler.track_time("get_variable"):
-                value = self.state.get(key)
-                if value is None:
-                    flock_logger.warning(f"Variable not found in state: {key}")
-                else:
-                    flock_logger.debug(f"Retrieved variable: {key}")
-                return value
-        except Exception as e:
-            flock_logger.error(
-                "Failed to get variable",
-                key=key,
-                error=str(e),
-            )
-            raise
-
-    def set_variable(self, key: str, value: Any) -> None:
-        """Set the value of a state variable."""
-        try:
-            with performance_handler.track_time("set_variable"):
-                self.state[key] = value
-                flock_logger.debug(f"Set variable: {key}")
-        except Exception as e:
-            flock_logger.error(
-                "Failed to set variable",
-                key=key,
-                error=str(e),
-            )
-            raise
-
-    def deepcopy(self) -> "FlockContext":
-        """Create a deep copy of the context."""
-        try:
-            with performance_handler.track_time("context_deepcopy"):
-                flock_logger.debug("Creating deep copy of context")
-                copy = FlockContext.from_dict(self.to_dict())
-                flock_logger.debug(
-                    "Context copied",
-                    state_vars=len(copy.state),
-                    history_records=len(copy.history),
-                )
-                return copy
-        except Exception as e:
-            flock_logger.error(
-                "Failed to create context copy",
-                error=str(e),
-            )
-            raise
-
-    def get_agent_history(self, agent_name: str) -> list[AgentRunRecord]:
-        """Return all agent run records for a given agent name."""
-        try:
-            with performance_handler.track_time("get_agent_history"):
-                records = [record for record in self.history if record.agent == agent_name]
-                flock_logger.debug(
-                    f"Retrieved history records for {agent_name}",
-                    count=len(records),
-                )
-                return records
-        except Exception as e:
-            flock_logger.error(
-                "Failed to get history records",
-                agent=agent_name,
-                error=str(e),
-            )
-            raise
-
-    def next_input_for(self, agent) -> Any:
-        """By default, the next input for an agent is taken from the context state.
-
-        If the agent.input is a comma-separated list (e.g., "input1, input2"),
-        this method will return a dictionary with keys for each of the input names,
-        fetching the latest values from the state.
-
-        If only a single input is specified, the raw value is returned.
-        """
-        try:
-            with performance_handler.track_time("next_input_preparation"):
-                flock_logger.info(f"Preparing next input for agent: {agent.name}")
-
-                if hasattr(agent, "input") and isinstance(agent.input, str):
-                    keys = [k.strip() for k in agent.input.split(",") if k.strip()]
-                    flock_logger.debug(f"Input keys: {keys}")
-
-                    if len(keys) == 1:
-                        value = self.get_variable(keys[0])
-                        flock_logger.debug(f"Single input value retrieved for key: {keys[0]}")
-                        return value
-                    else:
-                        values = {key: self.get_variable(key) for key in keys}
-                        flock_logger.debug(f"Multiple input values retrieved for keys: {keys}")
-                        return values
-                else:
-                    # Fallback to "init_input"
-                    flock_logger.debug("No input defined, falling back to init_input")
-                    return self.get_variable("init_input")
-        except Exception as e:
-            flock_logger.error(
-                "Failed to prepare next input",
-                agent=getattr(agent, "name", str(agent)),
-                error=str(e),
-            )
-            raise
-
-    def get_agent_definition(self, agent_name: str) -> AgentDefinition | None:
-        """Get the definition for a specific agent."""
-        try:
-            with performance_handler.track_time("get_agent_definition"):
-                for definition in self.agent_definitions:
-                    if definition.name == agent_name:
-                        flock_logger.debug(f"Retrieved definition for agent: {agent_name}")
-                        return definition
-
-                flock_logger.warning(f"No definition found for agent: {agent_name}")
-                return None
-        except Exception as e:
-            flock_logger.error(
-                "Failed to get agent definition",
-                agent=agent_name,
-                error=str(e),
-            )
-            raise
-
-    def add_agent_definition(self, agent_type: type, agent_name: str, agent_data: Any) -> None:
-        """Add a new agent definition to the context."""
-        try:
-            with performance_handler.track_time("add_agent_definition"):
-                definition = AgentDefinition(
-                    agent_type=agent_type.__name__,
-                    agent_name=agent_name,
-                    agent_data=agent_data,
-                )
-                self.agent_definitions[agent_name] = definition
-                flock_logger.info(
-                    f"Added agent definition",
-                    agent=agent_name,
-                    type=agent_type.__name__,
-                )
-        except Exception as e:
-            flock_logger.error(
-                "Failed to add agent definition",
-                agent=agent_name,
-                type=agent_type.__name__,
-                error=str(e),
-            )
-            raise
-
-    # Allow dict-like access for convenience.
-    def __getitem__(self, key: str) -> Any:
-        value = self.state[key]
-        return value
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.state[key] = value
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert the context to a dictionary for serialization."""
-        try:
-            with performance_handler.track_time("context_to_dict"):
-                flock_logger.debug("Converting context to dictionary")
-
-                def convert(obj):
-                    if isinstance(obj, datetime):
-                        return obj.isoformat()
-                    if hasattr(obj, "__dataclass_fields__"):  # Is a dataclass
-                        return asdict(obj, dict_factory=lambda x: {k: convert(v) for k, v in x})
-                    return obj
-
-                result = convert(asdict(self))
-                flock_logger.debug(
-                    "Context converted to dictionary",
-                    state_size=len(result.get("state", {})),
-                    history_size=len(result.get("history", [])),
-                )
-                return result
-        except Exception as e:
-            flock_logger.error(
-                "Failed to convert context to dictionary",
-                error=str(e),
-            )
-            raise
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "FlockContext":
-        """Create a context instance from a dictionary."""
-        try:
-            with performance_handler.track_time("context_from_dict"):
-                flock_logger.debug("Creating context from dictionary")
-
-                def convert(obj):
-                    if isinstance(obj, dict):
-                        if "timestamp" in obj:  # AgentRunRecord
-                            return AgentRunRecord(**{**obj, "timestamp": datetime.fromisoformat(obj["timestamp"])})
-                        if "agent_type" in obj:  # AgentDefinition
-                            return AgentDefinition(**obj)
-                        return {k: convert(v) for k, v in obj.items()}
-                    if isinstance(obj, list):
-                        return [convert(v) for v in obj]
-                    return obj
-
-                converted = convert(data)
-                context = cls(**converted)
-                flock_logger.debug(
-                    "Created context from dictionary",
-                    state_vars=len(context.state),
-                    history_records=len(context.history),
-                )
-                return context
-        except Exception as e:
-            flock_logger.error(
-                "Failed to create context from dictionary",
-                error=str(e),
-            )
-            raise

flock/core/handoff/handoff_base.py

@@ -1,12 +0,0 @@
-from typing import Any
-
-from flock.core.agent import Agent
-from flock.core.context import FlockContext
-
-
-class HandoffBase:
-    """Base class for handoff implementations."""
-
-    next_agent: str | Agent
-    input: dict[str, Any]
-    context: FlockContext

flock/core/logging/error_handler.py

@@ -1,84 +0,0 @@
-import sys
-from types import TracebackType
-
-from temporalio import workflow
-
-with workflow.unsafe.imports_passed_through():
-    from rich.console import Console
-    from rich.panel import Panel
-    from rich.syntax import Syntax
-    from rich.traceback import Traceback
-
-from flock.core.logging.logger import flock_logger
-
-
-class ErrorHandler:
-    """Handles error formatting and display using Rich."""
-
-    def __init__(self, console: Console | None = None):
-        self.console = console or Console()
-
-    def format_exception(
-        self,
-        exc_type: type[BaseException],
-        exc_value: BaseException,
-        exc_tb: TracebackType,
-        *,
-        show_locals: bool = True,
-    ) -> Panel:
-        """Format an exception with Rich styling."""
-        # Create a Rich traceback
-        rich_tb = Traceback.from_exception(
-            exc_type,
-            exc_value,
-            exc_tb,
-            show_locals=show_locals,
-        )
-
-        # If there's source code available, syntax highlight it
-        if exc_tb and exc_tb.tb_frame.f_code.co_filename != "<string>":
-            try:
-                with open(exc_tb.tb_frame.f_code.co_filename) as f:
-                    source = f.read()
-                syntax = Syntax(
-                    source,
-                    "python",
-                    line_numbers=True,
-                    highlight_lines={exc_tb.tb_lineno},
-                )
-            except:
-                syntax = None
-        else:
-            syntax = None
-
-        # Create a panel with the traceback
-        return Panel(
-            rich_tb,
-            title=f"[red]{exc_type.__name__}[/]: {exc_value!s}",
-            border_style="red",
-            padding=(1, 2),
-        )
-
-    def handle_exception(
-        self,
-        exc_type: type[BaseException],
-        exc_value: BaseException,
-        exc_tb: TracebackType,
-    ) -> None:
-        """Handle an exception by formatting and displaying it."""
-        panel = self.format_exception(exc_type, exc_value, exc_tb)
-        self.console.print(panel)
-        # Also log the error through our logger
-        flock_logger.error(
-            f"Exception occurred: {exc_type.__name__}: {exc_value!s}",
-            error_type=exc_type.__name__,
-            error_details=str(exc_value),
-        )
-
-    def install(self) -> None:
-        """Install this error handler as the default exception handler."""
-        sys.excepthook = self.handle_exception
-
-
-# Global error handler instance
-error_handler = ErrorHandler()

flock/core/logging/formatters.py

@@ -1,122 +0,0 @@
-from typing import Any
-
-from devtools import pprint
-from temporalio import workflow
-
-with workflow.unsafe.imports_passed_through():
-    from rich.console import Console
-    from rich.panel import Panel
-    from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
-    from rich.table import Table
-
-
-class StructuredFormatter:
-    """Formats structured data for Rich output."""
-
-    @staticmethod
-    def create_status_table(data: dict[str, Any]) -> Table:
-        """Create a Rich table for displaying status information."""
-        table = Table(show_header=True, header_style="bold magenta")
-        table.add_column("Key")
-        table.add_column("Value")
-
-        for key, value in data.items():
-            table.add_row(str(key), str(value))
-
-        return table
-
-    @staticmethod
-    def create_progress_bar(description: str = "Progress") -> Progress:
-        """Create a Rich progress bar with time tracking."""
-        return Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            BarColumn(),
-            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
-            TimeElapsedColumn(),
-        )
-
-    @staticmethod
-    def create_workflow_panel(
-        workflow_id: str, status: str, details: dict[str, Any], title: str = "Workflow Status"
-    ) -> Panel:
-        """Create a Rich panel for workflow information."""
-        table = StructuredFormatter.create_status_table({"Workflow ID": workflow_id, "Status": status, **details})
-        return Panel(table, title=title, border_style="blue")
-
-    @staticmethod
-    def create_activity_panel(
-        activity_id: str, name: str, status: str, details: dict[str, Any], title: str = "Activity Status"
-    ) -> Panel:
-        """Create a Rich panel for activity information."""
-        table = StructuredFormatter.create_status_table(
-            {"Activity ID": activity_id, "Name": name, "Status": status, **details}
-        )
-        return Panel(table, title=title, border_style="magenta")
-
-
-class PerformanceFormatter:
-    """Formats performance metrics for Rich output."""
-
-    @staticmethod
-    def create_timing_tree(timings: dict[str, float]) -> str:
-        """Create a tree-like structure showing execution timings."""
-        if not timings:
-            return "No timings recorded"
-
-        result = "Performance Metrics:\n"
-        for operation, duration in timings.items():
-            result += f"├── {operation}: {duration:.3f}s\n"
-        return result[:-1]  # Remove trailing newline
-
-    @staticmethod
-    def create_performance_panel(metrics: dict[str, Any], title: str = "Performance Metrics") -> Panel:
-        """Create a panel showing performance metrics."""
-        table = StructuredFormatter.create_status_table(metrics)
-        return Panel(table, title=title, border_style="cyan")
-
-
-class AgentResultFormatter:
-    """Formats agent results in a beautiful Rich table."""
-
-    @staticmethod
-    def format_result(result: dict[str, Any], agent_name: str) -> Panel:
-        """Format an agent's result as a Rich panel containing a table."""
-        # Create a table with a nice header
-        table = Table(
-            show_header=True,
-            header_style="bold green",
-            title=f"Agent Results: {agent_name}",
-            title_style="bold blue",
-            border_style="bright_blue",
-        )
-        table.add_column("Output", style="cyan")
-        table.add_column("Value", style="green")
-
-        # Add each result to the table
-        for key, value in result.items():
-            # Format multi-line values (like blog headers) nicely
-            if isinstance(value, (list, tuple)) or (isinstance(value, str) and "\n" in value):
-                formatted_value = "\n".join(value) if isinstance(value, (list, tuple)) else value
-                # Add some padding for multi-line values
-                table.add_row(key, f"\n{formatted_value}\n")
-            else:
-                table.add_row(key, str(value))
-
-        pprint(result)
-
-        # Wrap the table in a panel for a nice border
-        return Panel(
-            table,
-            title="🎯 Agent Output",
-            title_align="left",
-            border_style="blue",
-            padding=(1, 2),
-        )
-
-    @staticmethod
-    def print_result(result: dict[str, Any], agent_name: str, console: Console | None = None) -> None:
-        """Print an agent's result using Rich formatting."""
-        console = console or Console()
-        panel = AgentResultFormatter.format_result(result, agent_name)
-        console.print(panel)