flock-core 0.4.542__py3-none-any.whl → 0.5.0__py3-none-any.whl

flock/core/flock_router.py

@@ -1,83 +0,0 @@
-"""Base router class for the Flock framework."""
-
-from abc import ABC, abstractmethod
-from typing import Any, Literal
-
-from pydantic import BaseModel, Field
-
-from flock.core.context.context import FlockContext
-
-
-class HandOffRequest(BaseModel):
-    """Base class for handoff returns."""
-
-    next_agent: str = Field(default="", description="Next agent to invoke")
-    # match = use the output fields of the current agent that also exists as input field of the next agent
-    # add = add the output of the current agent to the input of the next agent
-    output_to_input_merge_strategy: Literal["match", "add"] = Field(
-        default="match"
-    )
-    add_input_fields: list[str] | None = Field(
-        default=None,
-        description="List of input fields to add to the next agent",
-    )
-    add_output_fields: list[str] | None = Field(
-        default=None,
-        description="List of output fields to add to the next agent",
-    )
-    add_description: str | None = Field(
-        default=None, description="Add this description to the next agent"
-    )
-    override_next_agent: Any | None = Field(
-        default=None,
-        description="Override the next agent to hand off to",
-    )
-    override_context: FlockContext | None = Field(
-        default=None, description="Override context parameters"
-    )
-
-
-class FlockRouterConfig(BaseModel):
-    """Configuration for a router.
-
-    This class defines the configuration parameters for a router.
-    Subclasses can extend this to add additional parameters.
-    """
-
-    enabled: bool = Field(
-        default=True, description="Whether the router is enabled"
-    )
-    # agents: list[str] | None = Field(
-    #     default=None,
-    #     description="List of agents to choose from",
-    # )
-
-
-class FlockRouter(BaseModel, ABC):
-    """Base class for all routers.
-
-    A router is responsible for determining the next agent in a workflow
-    based on the current agent's output.
-    """
-
-    name: str = Field(..., description="Name of the router")
-    config: FlockRouterConfig = Field(default_factory=FlockRouterConfig)
-
-    @abstractmethod
-    async def route(
-        self,
-        current_agent: Any,
-        result: dict[str, Any],
-        context: FlockContext,
-    ) -> HandOffRequest:
-        """Determine the next agent to hand off to based on the current agent's output.
-
-        Args:
-            current_agent: The agent that just completed execution
-            result: The output from the current agent
-            context: The global execution context
-
-        Returns:
-            A HandOff object containing the next agent and input data
-        """
-        pass

flock/core/flock_scheduler.py

@@ -1,166 +0,0 @@
-# src/flock/core/scheduler.py (new file or inside flock.py)
-import asyncio
-import traceback
-from datetime import datetime, timedelta, timezone
-
-from croniter import croniter  # pip install croniter
-
-from flock.core.flock import Flock
-from flock.core.flock_agent import FlockAgent  # For type hinting
-from flock.core.logging.logging import get_logger
-
-logger = get_logger("flock.scheduler")
-
-class FlockScheduler:
-    def __init__(self, flock_instance: Flock):
-        self.flock = flock_instance
-        self._scheduled_tasks: list[tuple[FlockAgent, croniter | timedelta, datetime | None]] = []
-        self._stop_event = asyncio.Event()
-        self._is_running = False
-
-    def _parse_schedule_expression(self, expression: str) -> croniter | timedelta:
-        """Parses a schedule expression.
-        Supports cron syntax and simple intervals like 'every Xm', 'every Xh', 'every Xd'.
-        """
-        expression = expression.strip().lower()
-        if expression.startswith("every "):
-            try:
-                parts = expression.split(" ")
-                value = int(parts[1][:-1])
-                unit = parts[1][-1]
-                if unit == 's': return timedelta(seconds=value)
-                if unit == 'm': return timedelta(minutes=value)
-                elif unit == 'h': return timedelta(hours=value)
-                elif unit == 'd': return timedelta(days=value)
-                else: raise ValueError(f"Invalid time unit: {unit}")
-            except Exception as e:
-                logger.error(f"Invalid interval expression '{expression}': {e}")
-                raise ValueError(f"Invalid interval expression: {expression}") from e
-        else:
-            # Assume cron expression
-            if not croniter.is_valid(expression):
-                raise ValueError(f"Invalid cron expression: {expression}")
-            return croniter(expression, datetime.now(timezone.utc))
-
-    def add_agent(self, agent: FlockAgent):
-        """Adds an agent to the scheduler if it has a schedule expression."""
-        # Assuming schedule_expression is stored in agent._flock_config or a dedicated field
-        schedule_expression = None
-        if hasattr(agent, '_flock_config') and isinstance(agent._flock_config, dict):
-            schedule_expression = agent._flock_config.get('schedule_expression')
-        elif hasattr(agent, 'schedule_expression'): # If directly on agent
-             schedule_expression = agent.schedule_expression
-        elif hasattr(agent, 'config') and hasattr(agent.config, 'schedule_expression'): # If on agent.config
-            schedule_expression = agent.config.schedule_expression
-
-
-        if not schedule_expression:
-            logger.warning(f"Agent '{agent.name}' has no schedule_expression. Skipping.")
-            return
-
-        try:
-            parsed_schedule = self._parse_schedule_expression(schedule_expression)
-            self._scheduled_tasks.append((agent, parsed_schedule, None)) # agent, schedule, last_run_utc
-            logger.info(f"Scheduled agent '{agent.name}' with expression: {schedule_expression}")
-        except ValueError as e:
-            logger.error(f"Could not schedule agent '{agent.name}': {e}")
-
-    def _load_scheduled_agents_from_flock(self):
-        """Scans the Flock instance for agents with scheduling configuration."""
-        self._scheduled_tasks = [] # Clear existing before loading
-        for agent_name, agent_instance in self.flock.agents.items():
-            self.add_agent(agent_instance)
-        logger.info(f"Loaded {len(self._scheduled_tasks)} scheduled agents from Flock '{self.flock.name}'.")
-
-    async def _run_agent_task(self, agent: FlockAgent, trigger_time: datetime):
-        logger.info(f"Triggering scheduled agent '{agent.name}' at {trigger_time.isoformat()}")
-        try:
-            # Input for a scheduled agent could include the trigger time
-            await self.flock.run_async(start_agent=agent.name, input={"trigger_time": trigger_time})
-            logger.info(f"Scheduled agent '{agent.name}' finished successfully.")
-        except Exception as e:
-            logger.error(f"Error running scheduled agent '{agent.name}': {e}\n{traceback.format_exc()}")
-
-    async def _scheduler_loop(self):
-        self._is_running = True
-        logger.info("FlockScheduler loop started.")
-        while not self._stop_event.is_set():
-            now_utc = datetime.now(timezone.utc)
-            tasks_to_run_this_cycle = []
-
-            for i, (agent, schedule, last_run_utc) in enumerate(self._scheduled_tasks):
-                should_run = False
-                next_run_utc = None
-
-                if isinstance(schedule, croniter):
-                    # For cron, get the next scheduled time AFTER the last run (or now if never run)
-                    base_time = last_run_utc if last_run_utc else now_utc
-                    # Croniter's get_next gives the next time *after* the base_time.
-                    # If last_run_utc is None (first run), we check if the *current* now_utc
-                    # is past the first scheduled time.
-                    # A simpler check: is `now_utc` >= `schedule.get_next(datetime, base_time=last_run_utc if last_run_utc else now_utc - timedelta(seconds=1))` ?
-                    # Let's refine croniter check to be more precise.
-                    # If we are past the *next* scheduled time since *last check*
-                    if last_run_utc is None: # First run check
-                        next_run_utc = schedule.get_next(datetime, start_time=now_utc - timedelta(seconds=1)) # Check if first run is due
-                        if next_run_utc <= now_utc:
-                            should_run = True
-                    else:
-                        next_run_utc = schedule.get_next(datetime, start_time=last_run_utc)
-                        if next_run_utc <= now_utc:
-                            should_run = True
-
-                elif isinstance(schedule, timedelta): # Simple interval
-                    if last_run_utc is None or (now_utc - last_run_utc >= schedule):
-                        should_run = True
-                        next_run_utc = now_utc # Or now_utc + schedule for next interval start
-                    else:
-                        next_run_utc = last_run_utc + schedule
-
-
-                if should_run:
-                    tasks_to_run_this_cycle.append(self._run_agent_task(agent, now_utc))
-                    # Update last_run_utc for this agent *before* awaiting its execution
-                    # For cron, advance the iterator to the *current* scheduled time that triggered it.
-                    if isinstance(schedule, croniter):
-                         current_cron_trigger = schedule.get_current(datetime) # This is the time it *should* have run
-                         self._scheduled_tasks[i] = (agent, schedule, current_cron_trigger)
-
-                    elif isinstance(schedule, timedelta):
-                        self._scheduled_tasks[i] = (agent, schedule, now_utc) # Mark as run now
-
-            if tasks_to_run_this_cycle:
-                await asyncio.gather(*tasks_to_run_this_cycle, return_exceptions=True)
-
-            try:
-                # Sleep for a short interval, e.g., 10 seconds, or until stop_event is set
-                await asyncio.wait_for(self._stop_event.wait(), timeout=10.0)
-            except asyncio.TimeoutError:
-                pass # Timeout is normal, means continue loop
-        self._is_running = False
-        logger.info("FlockScheduler loop stopped.")
-
-    async def start(self) -> asyncio.Task | None: # Modified to return Task or None
-        if self._is_running:
-            logger.warning("Scheduler is already running.")
-            return None # Or return the existing task if you store it
-
-        self._load_scheduled_agents_from_flock()
-        if not self._scheduled_tasks:
-            logger.info("No scheduled agents found. Scheduler will not start a loop task.")
-            return None # Return None if no tasks to schedule
-
-        self._stop_event.clear()
-        loop_task = asyncio.create_task(self._scheduler_loop())
-        # Store the task if you need to reference it, e.g., for forced cancellation beyond _stop_event
-        # self._loop_task = loop_task
-        return loop_task # Return the created task
-
-    async def stop(self):
-        if not self._is_running and not self._stop_event.is_set(): # Check if stop already called
-            logger.info("Scheduler is not running or already signaled to stop.")
-            return
-        logger.info("Stopping FlockScheduler...")
-        self._stop_event.set()
-        # If you stored self._loop_task, you can await it here or in the lifespan manager
-        # await self._loop_task # (This might block if loop doesn't exit quickly)

flock/core/flock_server_manager.py

@@ -1,136 +0,0 @@
-"""Manages Server-Lifecycles within the larger lifecycle of Flock."""
-
-import asyncio
-from contextlib import AsyncExitStack
-
-from anyio import Lock
-from pydantic import BaseModel, ConfigDict, Field
-
-from flock.core.mcp.flock_mcp_server import FlockMCPServerBase
-
-
-class FlockServerManager(BaseModel):
-    """Async-context-manager to start/stop a set of Flock MCP servers."""
-
-    servers: list[FlockMCPServerBase] | None = Field(
-        ..., exclude=True, description="The servers to manage."
-    )
-
-    stack: AsyncExitStack | None = Field(
-        default=None,
-        exclude=True,
-        description="Central exit stack for managing the execution context of the servers.",
-    )
-
-    lock: Lock | None = Field(
-        default=None, exclude=True, description="Global lock for mutex access."
-    )
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-    )
-
-    def __init__(
-        self,
-        servers: list[FlockMCPServerBase] | None = None,
-        stack: AsyncExitStack | None = None,
-        lock: asyncio.Lock | None = None,
-    ) -> None:
-        """Initialize the FlockServerManager with optional server, stack, and lock references."""
-        super().__init__(
-            servers=servers,
-            stack=stack,
-            lock=lock,
-        )
-
-    def add_server_sync(self, server: FlockMCPServerBase) -> None:
-        """Add a server to be managed by the ServerManager.
-
-        Note:
-          IT IS CRUCIAL THAT THIS METHOD IS NOT CALLED
-          WHEN THE SERVER MANAGER HAS ALREADY BEEN INTIALIZED
-          (with server_manager as manager: ...)
-          OTHERWISE EXECUTION WILL BREAK DOWN.
-        """
-        if self.servers is None:
-            self.servers = []
-
-        self.servers.append(server)
-
-    def remove_server_sync(self, server: FlockMCPServerBase) -> None:
-        """Remove a server from the list of managed servers.
-
-        Note:
-          IT IS CRUCIAL THAT THIS METHOD IS NOT CALLED
-          WHEN THE SERVER MANAGER HAS ALREADY BEEN INITIALIZED
-          (with server_manager as manager: ...)
-          OTHERWISE EXECUTION WILL BREAK DOWN.
-        """
-        if self.servers and server in self.servers:
-            self.servers.remove(server)
-
-    # -- For future use: Allow adding and removal of servers during runtime ---
-    async def add_server_during_runtime(
-        self, server: FlockMCPServerBase
-    ) -> None:
-        """Add a server to the manager and, if already running, start it immediately."""
-        if self.lock is None:
-            self.lock = asyncio.Lock()
-
-        async with self.lock:
-            if self.servers is None:
-                self.servers = []
-
-            self.servers.append(server)
-
-        # If we are already running in async-with, enter the context now
-        if self.stack is not None:
-            await self.stack.enter_async_context(server)
-
-    async def remove_server_during_runtime(
-        self, server: FlockMCPServerBase
-    ) -> None:
-        """Tear down and remove a server from the manager at runtime."""
-        if self.lock is None:
-            self.lock = asyncio.Lock()
-
-        retrieved_server: FlockMCPServerBase | None = None
-
-        async with self.lock:
-            if not self.servers or server not in self.servers:
-                return  # Skip as to not impede application flow
-            else:
-                try:
-                    self.servers.remove(server)
-                    retrieved_server = server
-                except ValueError:
-                    # The server is not present (a little paranoid at this point, but still...)
-                    return
-
-        # tell the server to shut down.
-        if retrieved_server:
-            # trigger the server's own exit hook (this closes its connection_manager, sessions, tools....)
-            await retrieved_server.__aexit__(None, None, None)
-
-    async def __aenter__(self) -> "FlockServerManager":
-        """Enter the asynchronous context for the server manager."""
-        if not self.stack:
-            self.stack = AsyncExitStack()
-
-        if not self.servers:
-            self.servers = []
-
-        if not self.lock:
-            self.lock = asyncio.Lock()
-
-        for srv in self.servers:
-            await self.stack.enter_async_context(srv)
-
-        return self
-
-    async def __aexit__(self, exc_type, exc, tb) -> None:
-        """Exit the asynchronous context for the server manager."""
-        # Unwind the servers in LIFO order
-        if self.stack is not None:
-            await self.stack.aclose()
-            self.stack = None