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

flock/core/api/run_store.py

@@ -1,224 +0,0 @@
-# src/flock/core/api/run_store.py
-"""Manages the state of active and completed Flock runs."""
-
-import threading
-from datetime import datetime
-from typing import Any
-
-from flock.core.logging.logging import get_logger
-
-from .models import (  # Import from the models file
-    FlockAPIResponse,
-    FlockBatchResponse,
-)
-
-logger = get_logger("api.run_store")
-
-
-class RunStore:
-    """Stores and manages the state of Flock runs."""
-
-    def __init__(self):
-        self._runs: dict[str, FlockAPIResponse] = {}
-        self._batches: dict[str, FlockBatchResponse] = {}
-        self._lock = threading.Lock()  # Basic lock for thread safety
-
-    def create_run(self, run_id: str) -> FlockAPIResponse:
-        """Creates a new run record with 'starting' status."""
-        with self._lock:
-            if run_id in self._runs:
-                logger.warning(f"Run ID {run_id} already exists. Overwriting.")
-            response = FlockAPIResponse(
-                run_id=run_id, status="starting", started_at=datetime.now()
-            )
-            self._runs[run_id] = response
-            logger.debug(f"Created run record for run_id: {run_id}")
-            return response
-
-    def get_run(self, run_id: str) -> FlockAPIResponse | None:
-        """Gets the status of a run."""
-        with self._lock:
-            return self._runs.get(run_id)
-
-    def update_run_status(
-        self, run_id: str, status: str, error: str | None = None
-    ):
-        """Updates the status and potentially error of a run."""
-        with self._lock:
-            if run_id in self._runs:
-                self._runs[run_id].status = status
-                if error:
-                    self._runs[run_id].error = error
-                if status in ["completed", "failed"]:
-                    self._runs[run_id].completed_at = datetime.now()
-                logger.debug(f"Updated status for run_id {run_id} to {status}")
-            else:
-                logger.warning(
-                    f"Attempted to update status for non-existent run_id: {run_id}"
-                )
-
-    def update_run_result(self, run_id: str, result: dict):
-        """Updates the result of a completed run."""
-        with self._lock:
-            if run_id in self._runs:
-                # Ensure result is serializable (e.g., convert Box)
-                final_result = (
-                    dict(result) if hasattr(result, "to_dict") else result
-                )
-                self._runs[run_id].result = final_result
-                self._runs[run_id].status = "completed"
-                self._runs[run_id].completed_at = datetime.now()
-                logger.debug(f"Updated result for completed run_id: {run_id}")
-            else:
-                logger.warning(
-                    f"Attempted to update result for non-existent run_id: {run_id}"
-                )
-
-    def create_batch(self, batch_id: str) -> FlockBatchResponse:
-        """Creates a new batch record with 'starting' status."""
-        with self._lock:
-            if batch_id in self._batches:
-                logger.warning(
-                    f"Batch ID {batch_id} already exists. Overwriting."
-                )
-            response = FlockBatchResponse(
-                batch_id=batch_id,
-                status="starting",
-                results=[],
-                started_at=datetime.now(),
-                total_items=0,
-                completed_items=0,
-                progress_percentage=0.0,
-            )
-            self._batches[batch_id] = response
-            logger.debug(f"Created batch record for batch_id: {batch_id}")
-            return response
-
-    def get_batch(self, batch_id: str) -> FlockBatchResponse | None:
-        """Gets the status of a batch run."""
-        with self._lock:
-            return self._batches.get(batch_id)
-
-    def update_batch_status(
-        self, batch_id: str, status: str, error: str | None = None
-    ):
-        """Updates the status and potentially error of a batch run."""
-        with self._lock:
-            if batch_id in self._batches:
-                self._batches[batch_id].status = status
-                if error:
-                    self._batches[batch_id].error = error
-                if status in ["completed", "failed"]:
-                    self._batches[batch_id].completed_at = datetime.now()
-                    # When completed, ensure progress is 100%
-                    if (
-                        status == "completed"
-                        and self._batches[batch_id].total_items > 0
-                    ):
-                        self._batches[batch_id].completed_items = self._batches[
-                            batch_id
-                        ].total_items
-                        self._batches[batch_id].progress_percentage = 100.0
-                logger.debug(
-                    f"Updated status for batch_id {batch_id} to {status}"
-                )
-            else:
-                logger.warning(
-                    f"Attempted to update status for non-existent batch_id: {batch_id}"
-                )
-
-    def update_batch_result(self, batch_id: str, results: list[Any]):
-        """Updates the results of a completed batch run."""
-        with self._lock:
-            if batch_id in self._batches:
-                # Ensure results are serializable
-                final_results = [
-                    dict(r) if hasattr(r, "to_dict") else r for r in results
-                ]
-                self._batches[batch_id].results = final_results
-                self._batches[batch_id].status = "completed"
-                self._batches[batch_id].completed_at = datetime.now()
-
-                # Update progress tracking
-                self._batches[batch_id].completed_items = len(final_results)
-                self._batches[batch_id].total_items = len(final_results)
-                self._batches[batch_id].progress_percentage = 100.0
-
-                logger.debug(
-                    f"Updated results for completed batch_id: {batch_id}"
-                )
-            else:
-                logger.warning(
-                    f"Attempted to update results for non-existent batch_id: {batch_id}"
-                )
-
-    def set_batch_total_items(self, batch_id: str, total_items: int):
-        """Sets the total number of items in a batch."""
-        try:
-            with self._lock:
-                if batch_id in self._batches:
-                    self._batches[batch_id].total_items = total_items
-                    # Recalculate percentage
-                    if total_items > 0:
-                        self._batches[batch_id].progress_percentage = (
-                            self._batches[batch_id].completed_items
-                            / total_items
-                            * 100.0
-                        )
-                    logger.debug(
-                        f"Set total_items for batch_id {batch_id} to {total_items}"
-                    )
-                else:
-                    logger.warning(
-                        f"Attempted to set total_items for non-existent batch_id: {batch_id}"
-                    )
-        except Exception as e:
-            logger.error(f"Error setting batch total items: {e}", exc_info=True)
-
-    def update_batch_progress(
-        self,
-        batch_id: str,
-        completed_items: int,
-        partial_results: list[Any] = None,
-    ):
-        """Updates the progress of a batch run and optionally adds partial results.
-
-        Args:
-            batch_id: The ID of the batch to update
-            completed_items: The number of items that have been completed
-            partial_results: Optional list of results for completed items to add to the batch
-        """
-        try:
-            with self._lock:
-                if batch_id in self._batches:
-                    self._batches[batch_id].completed_items = completed_items
-
-                    # Calculate percentage if we have a total
-                    if self._batches[batch_id].total_items > 0:
-                        self._batches[batch_id].progress_percentage = (
-                            completed_items
-                            / self._batches[batch_id].total_items
-                            * 100.0
-                        )
-
-                    # Add partial results if provided
-                    if partial_results:
-                        # Ensure results are serializable
-                        final_results = [
-                            dict(r) if hasattr(r, "to_dict") else r
-                            for r in partial_results
-                        ]
-                        self._batches[batch_id].results = final_results
-
-                    logger.debug(
-                        f"Updated progress for batch_id {batch_id}: {completed_items}/{self._batches[batch_id].total_items} "
-                        f"({self._batches[batch_id].progress_percentage:.1f}%)"
-                    )
-                else:
-                    logger.warning(
-                        f"Attempted to update progress for non-existent batch_id: {batch_id}"
-                    )
-        except Exception as e:
-            logger.error(f"Error updating batch progress: {e}", exc_info=True)
-
-    # Add methods for cleanup, persistence, etc. later

flock/core/api/runner.py

@@ -1,44 +0,0 @@
-# src/flock/api/runner.py
-"""Provides functionality to start the Flock API server."""
-
-from collections.abc import Callable, Sequence
-from typing import TYPE_CHECKING, Any
-
-from flock.core.api.custom_endpoint import FlockEndpoint
-from flock.core.logging.logging import get_logger
-
-if TYPE_CHECKING:
-    from flock.core.flock import Flock
-
-logger = get_logger("api.runner")
-
-
-def start_flock_api(
-    flock: "Flock",
-    host: str = "127.0.0.1",
-    port: int = 8344,
-    server_name: str = "Flock API",
-    create_ui: bool = False,
-    custom_endpoints: Sequence[FlockEndpoint] | dict[tuple[str, list[str] | None], Callable[..., Any]] | None = None,
-) -> None:
-    """Start a REST API server for the given Flock instance."""
-    try:
-        # Import API class locally to avoid making it a hard dependency for core flock
-        from flock.core.api import FlockAPI
-    except ImportError:
-        logger.error(
-            "API components not found. Cannot start API. "
-            "Ensure 'fastapi' and 'uvicorn' are installed."
-        )
-        return
-
-    logger.info(
-        f"Preparing to start API server for Flock '{flock.name}' on {host}:{port} {'with UI' if create_ui else 'without UI'}"
-    )
-    api_instance = FlockAPI(flock, custom_endpoints=custom_endpoints)  # Pass the Flock instance to the API
-    api_instance.start(
-        host=host,
-        port=port,
-        server_name=server_name,
-        create_ui=create_ui,
-    )

flock/core/api/service.py

@@ -1,214 +0,0 @@
-# flock/core/api/service.py
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from flock.core.api.endpoints import FlockBatchRequest
-    from flock.core.api.run_store import RunStore
-    from flock.core.flock import Flock
-
-
-from flock.core.logging.logging import get_logger
-
-logger = get_logger("flock.api")
-
-class FlockApiService:
-    def __init__(self, flock_instance: "Flock", run_store_instance: "RunStore"):
-        self.flock = flock_instance
-        self.run_store = run_store_instance
-    # You would move the _run_flock, _run_batch, _type_convert_inputs methods here
-    # from the old FlockAPI class.
-    async def _run_flock(
-        self, run_id: str, agent_name: str, inputs: dict[str, Any]
-    ):
-        """Executes a flock workflow run (internal helper)."""
-        try:
-            if agent_name not in self.flock.agents:
-                raise ValueError(f"Starting agent '{agent_name}' not found")
-
-            typed_inputs = self._type_convert_inputs(agent_name, inputs)
-
-            logger.debug(
-                f"Executing flock workflow starting with '{agent_name}' (run_id: {run_id})",
-                inputs=typed_inputs,
-            )
-            # Flock.run_async now handles context creation and execution
-            result = await self.flock.run_async(
-                start_agent=agent_name, input=typed_inputs
-            )
-            self.run_store.update_run_result(run_id, result)
-
-            final_agent_name = (
-                result.get("agent_name", "N/A") if isinstance(result, dict) else "N/A"
-            ) # Handle if result is not a dict (e.g. Box)
-            logger.info(
-                f"Flock workflow completed (run_id: {run_id})",
-                final_agent=final_agent_name,
-            )
-        except Exception as e:
-            logger.error(
-                f"Error in flock run {run_id} (started with '{agent_name}'): {e!s}",
-                exc_info=True,
-            )
-            self.run_store.update_run_status(run_id, "failed", str(e))
-            raise
-
-    async def _run_batch(self, batch_id: str, request: "FlockBatchRequest"):
-        """Executes a batch of runs (internal helper)."""
-        try:
-            if request.agent_name not in self.flock.agents:
-                raise ValueError(f"Agent '{request.agent_name}' not found")
-
-            logger.debug(
-                f"Executing batch run starting with '{request.agent_name}' (batch_id: {batch_id})",
-                batch_size=len(request.batch_inputs)
-                if isinstance(request.batch_inputs, list)
-                else "CSV/DataFrame",
-            )
-
-            # --- Re-integrating the threaded batch execution from Flock.run_batch_async ---
-            import asyncio
-            import threading
-            from concurrent.futures import ThreadPoolExecutor
-
-            def run_batch_sync_in_thread():
-                loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
-                try:
-                    batch_size = (
-                        len(request.batch_inputs)
-                        if isinstance(request.batch_inputs, list)
-                        else 0 # Or attempt to get from DataFrame/CSV load
-                    )
-                    if batch_size > 0:
-                        self.run_store.set_batch_total_items(batch_id, batch_size)
-
-                    class ProgressTracker:
-                        def __init__(self, store, b_id, total_size):
-                            self.store, self.batch_id, self.total_size = store, b_id, total_size
-                            self.current_count, self.partial_results, self._lock = 0, [], threading.Lock()
-                        def increment(self, res=None):
-                            with self._lock:
-                                self.current_count += 1
-                                if res is not None: self.partial_results.append(res)
-                                try: self.store.update_batch_progress(self.batch_id, self.current_count, self.partial_results)
-                                except Exception as e_prog: logger.error(f"Error updating progress: {e_prog}")
-                                return self.current_count
-
-                    progress_tracker = ProgressTracker(self.run_store, batch_id, batch_size)
-
-                    async def progress_aware_worker(index, item_inputs):
-                        try:
-                            # Call Flock's run_async for a single item
-                            item_result = await self.flock.run_async(
-                                start_agent=request.agent_name,
-                                input=item_inputs,
-                                box_result=request.box_results,
-                            )
-                            progress_tracker.increment(item_result)
-                            return item_result
-                        except Exception as item_err:
-                            logger.error(f"Error processing batch item {index}: {item_err}")
-                            progress_tracker.increment(item_err if request.return_errors else None)
-                            if request.return_errors: return item_err
-                            return None
-
-                    batch_inputs_list = request.batch_inputs
-                    actual_results_list = []
-
-                    if isinstance(batch_inputs_list, list):
-                        tasks = []
-                        for i, item_inputs in enumerate(batch_inputs_list):
-                            full_inputs = {**(request.static_inputs or {}), **item_inputs}
-                            tasks.append(progress_aware_worker(i, full_inputs))
-
-                        if request.parallel and request.max_workers > 1:
-                            semaphore = asyncio.Semaphore(request.max_workers)
-                            async def bounded_worker(idx, inputs_item):
-                                async with semaphore: return await progress_aware_worker(idx, inputs_item)
-                            bounded_tasks = [bounded_worker(i, {**(request.static_inputs or {}), **item}) for i, item in enumerate(batch_inputs_list)]
-                            actual_results_list = loop.run_until_complete(asyncio.gather(*bounded_tasks, return_exceptions=request.return_errors))
-                        else:
-                            for i, item_inputs in enumerate(batch_inputs_list):
-                                full_inputs = {**(request.static_inputs or {}), **item_inputs}
-                                actual_results_list.append(loop.run_until_complete(progress_aware_worker(i, full_inputs)))
-                    else: # DataFrame or CSV path - let Flock's batch processor handle this directly
-                        # This path relies on self.flock.run_batch_async being able to run within this new event loop.
-                        # It might be simpler to always convert DataFrame/CSV to list of dicts before this point.
-                        actual_results_list = loop.run_until_complete(
-                            self.flock.run_batch_async(
-                                start_agent=request.agent_name,
-                                batch_inputs=request.batch_inputs, # DataFrame or path
-                                input_mapping=request.input_mapping,
-                                static_inputs=request.static_inputs,
-                                parallel=request.parallel, # Will be re-evaluated by internal BatchProcessor
-                                max_workers=request.max_workers,
-                                use_temporal=request.use_temporal, # Will be re-evaluated
-                                box_results=request.box_results,
-                                return_errors=request.return_errors,
-                                silent_mode=True, # Internal batch runs silently for API
-                                write_to_csv=None # API handles CSV output separately if needed
-                            )
-                        )
-                        # Progress for DataFrame/CSV would need integration into BatchProcessor or this loop
-                        if actual_results_list:
-                             self.run_store.set_batch_total_items(batch_id, len(actual_results_list))
-                             self.run_store.update_batch_progress(batch_id, len(actual_results_list), actual_results_list)
-
-
-                    self.run_store.update_batch_result(batch_id, actual_results_list)
-                    logger.info(f"Batch run completed (batch_id: {batch_id})", num_results=len(actual_results_list))
-                    return actual_results_list
-                except Exception as thread_err:
-                    logger.error(f"Error in batch run thread {batch_id}: {thread_err!s}", exc_info=True)
-                    self.run_store.update_batch_status(batch_id, "failed", str(thread_err))
-                    return None
-                finally:
-                    loop.close()
-            # --- End of re-integrated threaded batch execution ---
-
-            # Submit the synchronous function to a thread pool from the main event loop
-            main_loop = asyncio.get_running_loop()
-            with ThreadPoolExecutor(thread_name_prefix="flock-api-batch") as pool:
-                await main_loop.run_in_executor(pool, run_batch_sync_in_thread)
-
-        except Exception as e:
-            logger.error(
-                f"Error setting up batch run {batch_id} (started with '{request.agent_name}'): {e!s}",
-                exc_info=True,
-            )
-            self.run_store.update_batch_status(batch_id, "failed", str(e))
-            raise
-
-
-
-
-
-    def _type_convert_inputs(
-        self, agent_name: str, inputs: dict[str, Any]
-    ) -> dict[str, Any]:
-        """Converts input values (esp. from forms) to expected Python types."""
-        typed_inputs = {}
-        agent_def = self.flock.agents.get(agent_name)
-        if not agent_def or not agent_def.input or not isinstance(agent_def.input, str):
-            return inputs # Return original if no spec or spec is not a string
-
-        parsed_fields = self._parse_input_spec(agent_def.input) # Relies on the old UI helper
-        field_types = {f["name"]: f["type"] for f in parsed_fields}
-
-        for k, v in inputs.items():
-            target_type_str = field_types.get(k)
-            if target_type_str:
-                if target_type_str.startswith("bool"):
-                    typed_inputs[k] = str(v).lower() in ["true", "on", "1", "yes"] if isinstance(v, str) else bool(v)
-                elif target_type_str.startswith("int"):
-                    try: typed_inputs[k] = int(v)
-                    except (ValueError, TypeError): logger.warning(f"Could not convert '{k}' value '{v}' to int for agent '{agent_name}'"); typed_inputs[k] = v
-                elif target_type_str.startswith("float"):
-                    try: typed_inputs[k] = float(v)
-                    except (ValueError, TypeError): logger.warning(f"Could not convert '{k}' value '{v}' to float for agent '{agent_name}'"); typed_inputs[k] = v
-                # TODO: Add list/dict parsing (e.g., json.loads) if type_str indicates these,
-                # especially if inputs come from HTML forms as strings.
-                else: typed_inputs[k] = v
-            else:
-                typed_inputs[k] = v
-        return typed_inputs

flock/core/config/flock_agent_config.py

@@ -1,11 +0,0 @@
-
-
-from pydantic import BaseModel
-
-
-class FlockAgentConfig(BaseModel):
-    """FlockAgentConfig is a class that holds the configuration for a Flock agent.
-    It is used to store various settings and parameters that can be accessed throughout the agent's lifecycle.
-    """
-
-    pass

flock/core/config/scheduled_agent_config.py

@@ -1,40 +0,0 @@
-
-
-
-from pydantic import Field
-
-from flock.core.config.flock_agent_config import FlockAgentConfig
-
-
-class ScheduledAgentConfig(FlockAgentConfig):
-    """Configuration specific to agents that run on a schedule."""
-    schedule_expression: str = Field(
-        ...,
-        description="Defines when the agent should run. "
-                    "Examples: 'every 60m', 'every 1h', 'daily at 02:00', '0 */2 * * *' (cron expression)"
-    )
-    enabled: bool = Field(
-        True,
-        description="Whether the scheduled agent is enabled. "
-                    "If False, the agent will not run even if the schedule expression is valid."
-    )
-    initial_run: bool = Field(
-        False,
-        description="If True, the agent will run immediately after being scheduled, "
-                    "regardless of the schedule expression."
-    )
-    max_runs: int = Field(
-        0,
-        description="Maximum number of times the agent can run. "
-                    "0 means unlimited runs. If set, the agent will stop running after reaching this limit."
-    )
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        # Ensure schedule_expression is always set
-        if 'schedule_expression' not in kwargs:
-            raise ValueError("schedule_expression is required for ScheduledAgentConfig")
-
-        # Validate initial_run and max_runs
-        if self.initial_run and self.max_runs > 0:
-            raise ValueError("Cannot set initial_run to True if max_runs is greater than 0")