flock-core 0.4.0b42__py3-none-any.whl → 0.4.0b44__py3-none-any.whl

flock/core/api/__init__.py

@@ -1,11 +1,10 @@
 # src/flock/core/api/__init__.py
 """Flock API Server components."""
 
-from .main import FlockAPI
+
 from .models import FlockAPIRequest, FlockAPIResponse
 
 __all__ = [
-    "FlockAPI",
     "FlockAPIRequest",
     "FlockAPIResponse",
 ]

flock/core/api/endpoints.py

@@ -1,23 +1,26 @@
 # src/flock/core/api/endpoints.py
-"""FastAPI endpoints for the Flock API."""
+"""FastAPI endpoints for the Flock API, using FastAPI's dependency injection."""
 
-import html  # For escaping
 import uuid
-from typing import TYPE_CHECKING  # Added Any for type hinting clarity
+from typing import TYPE_CHECKING
 
 from fastapi import (
     APIRouter,
     BackgroundTasks,
+    Depends,  # Crucial import for dependency injection
     HTTPException,
-    Request as FastAPIRequest,
 )
 
-# Import HTMLResponse for the UI form endpoint
-from fastapi.responses import HTMLResponse
-
 from flock.core.logging.logging import get_logger
 
-# Import models and UI utils
+# Import the dependency provider functions
+# This assumes you'll create 'src/flock/webapp/app/dependencies.py' (or similar)
+# with get_flock_instance and get_run_store functions.
+# For now, to make this file runnable in isolation for generation,
+# we might need temporary stubs or to adjust the import path later.
+# Let's assume a common location for dependencies.
+from flock.webapp.app.dependencies import get_flock_instance, get_run_store
+
 from .models import (
     FlockAPIRequest,
     FlockAPIResponse,
@@ -25,148 +28,196 @@ from .models import (
     FlockBatchResponse,
 )
 
-# Import UI utils - assuming they are now in ui/utils.py
-
-# Use TYPE_CHECKING to avoid circular imports for type hints
 if TYPE_CHECKING:
     from flock.core.flock import Flock
 
-    from .main import FlockAPI
     from .run_store import RunStore
+    # We also need the _run_flock, _run_batch, _type_convert_inputs methods.
+    # These will be part of the Flock instance itself or helper functions
+    # that take Flock/RunStore as arguments. For now, let's assume they
+    # are methods on the Flock instance or can be called statically with it.
 
 logger = get_logger("api.endpoints")
 
-
-# Factory function to create the router with dependencies
-def create_api_router(flock_api: "FlockAPI") -> APIRouter:
-    """Creates the APIRouter and defines endpoints, injecting dependencies."""
+# The create_api_router function no longer needs to be passed the FlockAPI instance
+# as dependencies will be injected directly into the route handlers.
+def create_api_router() -> APIRouter:
+    """Creates the APIRouter for core Flock API endpoints."""
     router = APIRouter()
-    # Get dependencies from the main FlockAPI instance passed in
-    run_store: RunStore = flock_api.run_store
-    flock_instance: Flock = flock_api.flock
 
     # --- API Endpoints ---
-    @router.post("/run/flock", response_model=FlockAPIResponse, tags=["API"])
-    async def run_flock_json(
-        request: FlockAPIRequest, background_tasks: BackgroundTasks
+    @router.post("/run/flock", response_model=FlockAPIResponse, tags=["Flock API Core"])
+    async def run_flock_workflow(
+        request_model: FlockAPIRequest, # Renamed from 'request' to avoid conflict with FastAPI's Request
+        background_tasks: BackgroundTasks,
+        flock_instance: "Flock" = Depends(get_flock_instance), # Injected
+        run_store: "RunStore" = Depends(get_run_store)          # Injected
     ):
-        """Run a flock workflow starting with the specified agent (expects JSON)."""
+        """Run a flock workflow starting with the specified agent."""
         run_id = None
         try:
             run_id = str(uuid.uuid4())
-            run_store.create_run(run_id)  # Use RunStore
-            response = run_store.get_run(
-                run_id
-            )  # Get initial response from store
+            run_store.create_run(run_id)
+            response_data = run_store.get_run(run_id)
+
+            if not response_data:
+                logger.error(f"Failed to create run record for run_id: {run_id}")
+                raise HTTPException(status_code=500, detail="Failed to initialize run.")
 
-            processed_inputs = request.inputs if request.inputs else {}
+            processed_inputs = request_model.inputs if request_model.inputs else {}
             logger.info(
-                f"API request: run flock '{request.agent_name}' (run_id: {run_id})",
+                f"API request: run flock '{request_model.agent_name}' (run_id: {run_id})",
                 inputs=processed_inputs,
             )
 
-            if request.async_run:
+            # The _run_flock logic now needs to be called. It could be a method on
+            # flock_instance, or a static/helper function that takes flock_instance.
+            # Let's assume it's a method on flock_instance for now.
+            # To avoid direct calls to private-like methods from router,
+            # Flock class would expose a public method that handles this internal logic.
+            # For this refactoring step, let's assume a helper `_execute_flock_run` exists
+            # that we can call.
+
+            async def _execute_flock_run_task(run_id_task, agent_name_task, inputs_task):
+                # This is a simplified version of what was in FlockAPI._run_flock
+                try:
+                    if agent_name_task not in flock_instance.agents:
+                        raise ValueError(f"Starting agent '{agent_name_task}' not found")
+                    # Type conversion would ideally be part of the Flock's run logic
+                    # or a utility. For now, assume it's handled or simple.
+                    # typed_inputs = flock_instance._type_convert_inputs(agent_name_task, inputs_task) # Example if kept on Flock
+                    typed_inputs = inputs_task # Simplified for now
+
+                    result = await flock_instance.run_async(
+                        start_agent=agent_name_task, input=typed_inputs
+                    )
+                    run_store.update_run_result(run_id_task, result)
+                except Exception as e_task:
+                    logger.error(f"Error in background flock run {run_id_task}: {e_task!s}", exc_info=True)
+                    run_store.update_run_status(run_id_task, "failed", str(e_task))
+
+
+            if request_model.async_run:
                 logger.debug(
-                    f"Running flock '{request.agent_name}' asynchronously (run_id: {run_id})"
+                    f"Running flock '{request_model.agent_name}' asynchronously (run_id: {run_id})"
                 )
-                # Call the helper method on the passed FlockAPI instance
                 background_tasks.add_task(
-                    flock_api._run_flock,
+                    _execute_flock_run_task,
                     run_id,
-                    request.agent_name,
+                    request_model.agent_name,
                     processed_inputs,
                 )
                 run_store.update_run_status(run_id, "running")
-                response.status = "running"  # Update local response copy too
+                response_data.status = "running"
             else:
                 logger.debug(
-                    f"Running flock '{request.agent_name}' synchronously (run_id: {run_id})"
+                    f"Running flock '{request_model.agent_name}' synchronously (run_id: {run_id})"
                 )
-                # Call the helper method on the passed FlockAPI instance
-                await flock_api._run_flock(
-                    run_id, request.agent_name, processed_inputs
+                await _execute_flock_run_task(
+                     run_id, request_model.agent_name, processed_inputs
                 )
-                response = run_store.get_run(
-                    run_id
-                )  # Fetch updated status/result
+                response_data = run_store.get_run(run_id)
 
-            return response
+            if not response_data:
+                 logger.error(f"Run data lost for run_id: {run_id} after execution.")
+                 raise HTTPException(status_code=500, detail="Run data lost after execution.")
+
+            return response_data
         except ValueError as ve:
-            logger.error(f"Value error starting run: {ve}")
-            if run_id:
-                run_store.update_run_status(run_id, "failed", str(ve))
+            logger.error(f"Value error starting run for agent '{request_model.agent_name}': {ve}", exc_info=True)
+            if run_id: run_store.update_run_status(run_id, "failed", str(ve))
             raise HTTPException(status_code=400, detail=str(ve))
         except Exception as e:
-            error_msg = f"Internal server error: {type(e).__name__}"
-            logger.error(f"Error starting run: {e!s}", exc_info=True)
-            if run_id:
-                run_store.update_run_status(run_id, "failed", error_msg)
+            error_msg = f"Internal server error during flock run: {type(e).__name__}"
+            logger.error(f"Error starting flock run: {e!s}", exc_info=True)
+            if run_id: run_store.update_run_status(run_id, "failed", error_msg)
             raise HTTPException(status_code=500, detail=error_msg)
 
-    @router.post("/run/batch", response_model=FlockBatchResponse, tags=["API"])
-    async def run_batch_json(
-        request: FlockBatchRequest, background_tasks: BackgroundTasks
+    @router.post("/run/batch", response_model=FlockBatchResponse, tags=["Flock API Core"])
+    async def run_batch_workflow(
+        request_model: FlockBatchRequest, # Renamed from 'request'
+        background_tasks: BackgroundTasks,
+        flock_instance: "Flock" = Depends(get_flock_instance),
+        run_store: "RunStore" = Depends(get_run_store)
     ):
-        """Run a batch of inputs through the flock workflow (expects JSON)."""
+        """Run a batch of inputs through the flock workflow."""
         batch_id = None
         try:
-            # Validate agent exists
-            if request.agent_name not in flock_instance.agents:
-                raise ValueError(f"Agent '{request.agent_name}' not found")
+            if request_model.agent_name not in flock_instance.agents:
+                raise ValueError(f"Agent '{request_model.agent_name}' not found in current Flock.")
 
-            # Validate batch inputs
-            if (
-                isinstance(request.batch_inputs, list)
-                and not request.batch_inputs
-            ):
-                raise ValueError("Batch inputs list cannot be empty")
+            if isinstance(request_model.batch_inputs, list) and not request_model.batch_inputs:
+                raise ValueError("Batch inputs list cannot be empty if provided as a list.")
 
             batch_id = str(uuid.uuid4())
-            run_store.create_batch(batch_id)  # Use RunStore
-            response = run_store.get_batch(
-                batch_id
-            )  # Get initial response from store
+            run_store.create_batch(batch_id)
+            response_data = run_store.get_batch(batch_id)
+
+            if not response_data:
+                logger.error(f"Failed to create batch record for batch_id: {batch_id}")
+                raise HTTPException(status_code=500, detail="Failed to initialize batch run.")
 
-            # Log batch size for monitoring
             batch_size = (
-                len(request.batch_inputs)
-                if isinstance(request.batch_inputs, list)
+                len(request_model.batch_inputs)
+                if isinstance(request_model.batch_inputs, list)
                 else "CSV/DataFrame"
             )
             logger.info(
-                f"API request: run batch with '{request.agent_name}' (batch_id: {batch_id})",
+                f"API request: run batch with '{request_model.agent_name}' (batch_id: {batch_id})",
                 batch_size=batch_size,
             )
 
-            # Always run batch processing asynchronously
+            async def _execute_flock_batch_task(batch_id_task, batch_request_task: FlockBatchRequest):
+                # This is a simplified version of what was in FlockAPI._run_batch
+                try:
+                    # Directly use the flock_instance's run_batch_async method
+                    results = await flock_instance.run_batch_async(
+                        start_agent=batch_request_task.agent_name,
+                        batch_inputs=batch_request_task.batch_inputs,
+                        input_mapping=batch_request_task.input_mapping,
+                        static_inputs=batch_request_task.static_inputs,
+                        parallel=batch_request_task.parallel,
+                        max_workers=batch_request_task.max_workers,
+                        use_temporal=batch_request_task.use_temporal,
+                        box_results=batch_request_task.box_results,
+                        return_errors=batch_request_task.return_errors,
+                        silent_mode=True, # API batch runs should be internally silent
+                        write_to_csv=None # API handles CSV writing based on request if needed, not here
+                    )
+                    run_store.update_batch_result(batch_id_task, results)
+                    logger.info(f"Batch run completed (batch_id: {batch_id_task})", num_results=len(results))
+                except Exception as e_task:
+                    logger.error(f"Error in background flock batch {batch_id_task}: {e_task!s}", exc_info=True)
+                    run_store.update_batch_status(batch_id_task, "failed", str(e_task))
+
             logger.debug(
-                f"Running batch with '{request.agent_name}' asynchronously (batch_id: {batch_id})"
+                f"Running batch with '{request_model.agent_name}' asynchronously (batch_id: {batch_id})"
             )
-            # Call the helper method on the passed FlockAPI instance
             background_tasks.add_task(
-                flock_api._run_batch,
+                _execute_flock_batch_task,
                 batch_id,
-                request,
+                request_model, # Pass the Pydantic request model
             )
             run_store.update_batch_status(batch_id, "running")
-            response.status = "running"  # Update local response copy too
+            response_data.status = "running"
 
-            return response
+            return response_data
         except ValueError as ve:
-            error_msg = f"Value error starting batch: {ve}"
-            logger.error(error_msg)
-            if batch_id:
-                run_store.update_batch_status(batch_id, "failed", str(ve))
+            error_msg = f"Value error starting batch for agent '{request_model.agent_name}': {ve}"
+            logger.error(error_msg, exc_info=True)
+            if batch_id: run_store.update_batch_status(batch_id, "failed", str(ve))
             raise HTTPException(status_code=400, detail=str(ve))
         except Exception as e:
-            error_msg = f"Internal server error: {type(e).__name__}: {e!s}"
+            error_msg = f"Internal server error during batch run: {type(e).__name__}: {e!s}"
             logger.error(error_msg, exc_info=True)
-            if batch_id:
-                run_store.update_batch_status(batch_id, "failed", error_msg)
+            if batch_id: run_store.update_batch_status(batch_id, "failed", error_msg)
             raise HTTPException(status_code=500, detail=error_msg)
 
-    @router.get("/run/{run_id}", response_model=FlockAPIResponse, tags=["API"])
-    async def get_run_status(run_id: str):
+    @router.get("/run/{run_id}", response_model=FlockAPIResponse, tags=["Flock API Core"])
+    async def get_run_status(
+        run_id: str,
+        run_store: "RunStore" = Depends(get_run_store)
+    ):
         """Get the status of a specific run."""
         logger.debug(f"API request: get status for run_id: {run_id}")
         run_data = run_store.get_run(run_id)
@@ -175,148 +226,29 @@ def create_api_router(flock_api: "FlockAPI") -> APIRouter:
             raise HTTPException(status_code=404, detail="Run not found")
         return run_data
 
-    @router.get(
-        "/batch/{batch_id}", response_model=FlockBatchResponse, tags=["API"]
-    )
-    async def get_batch_status(batch_id: str):
-        """Get the status of a specific batch run.
-
-        Returns details including:
-        - Total number of items in the batch
-        - Number of completed items
-        - Percentage of completion
-        - Any partial results available (for running batches)
-        - Complete results (for completed batches)
-        """
+    @router.get("/batch/{batch_id}", response_model=FlockBatchResponse, tags=["Flock API Core"])
+    async def get_batch_status(
+        batch_id: str,
+        run_store: "RunStore" = Depends(get_run_store)
+    ):
+        """Get the status and results of a specific batch run."""
         logger.debug(f"API request: get status for batch_id: {batch_id}")
         batch_data = run_store.get_batch(batch_id)
         if not batch_data:
             logger.warning(f"Batch ID not found: {batch_id}")
             raise HTTPException(status_code=404, detail="Batch not found")
-
-        # Add useful info for client display
-        extra_info = {
-            "status": batch_data.status,
-            "completed_items": batch_data.completed_items,
-            "total_items": batch_data.total_items,
-            "progress_percentage": round(batch_data.progress_percentage, 1),
-            "has_partial_results": len(batch_data.results) > 0
-            and batch_data.status == "running",
-            "has_error": batch_data.error is not None,
-        }
-        logger.debug(f"Returning batch status: {extra_info}")
-
         return batch_data
 
-    @router.get("/agents", tags=["API"])
-    async def list_agents():
-        """List all available agents."""
+    @router.get("/agents", tags=["Flock API Core"])
+    async def list_agents(
+        flock_instance: "Flock" = Depends(get_flock_instance)
+    ):
+        """List all available agents in the currently loaded Flock."""
         logger.debug("API request: list agents")
-        # Access flock instance via factory closure
         agents_list = [
             {"name": agent.name, "description": agent.description or agent.name}
             for agent in flock_instance.agents.values()
         ]
         return {"agents": agents_list}
 
-    # --- UI Form Endpoint ---
-    @router.post("/ui/run-agent-form", response_class=HTMLResponse, tags=["UI"])
-    async def run_flock_form(fastapi_req: FastAPIRequest):
-        """Endpoint to handle form submissions from the UI."""
-        run_id = None
-        try:
-            form_data = await fastapi_req.form()
-            agent_name = form_data.get("agent_name")
-            if not agent_name:
-                logger.warning("UI form submission missing agent_name")
-                return HTMLResponse(
-                    '<div id="result-content" class="error-message">Error: Agent name not provided.</div>',
-                    status_code=400,
-                )
-
-            logger.info(f"UI Form submission for agent: {agent_name}")
-            form_inputs = {}
-            # Access flock instance via factory closure
-            agent_def = flock_instance.agents.get(agent_name)
-            # Use helper from flock_api instance for parsing
-            defined_input_fields = (
-                flock_api._parse_input_spec(agent_def.input or "")
-                if agent_def
-                else []
-            )
-
-            for key, value in form_data.items():
-                if key.startswith("inputs."):
-                    form_inputs[key[len("inputs.") :]] = value
-            for field in defined_input_fields:  # Handle checkboxes
-                if (
-                    field["html_type"] == "checkbox"
-                    and field["name"] not in form_inputs
-                ):
-                    form_inputs[field["name"]] = False
-                elif (
-                    field["html_type"] == "checkbox"
-                    and field["name"] in form_inputs
-                ):
-                    form_inputs[field["name"]] = True
-
-            logger.debug(f"Parsed form inputs for UI run: {form_inputs}")
-            run_id = str(uuid.uuid4())
-            run_store.create_run(run_id)
-            logger.debug(
-                f"Running flock '{agent_name}' synchronously from UI (run_id: {run_id})"
-            )
-
-            # Call helper method on flock_api instance
-            await flock_api._run_flock(run_id, agent_name, form_inputs)
-
-            final_status = run_store.get_run(run_id)
-            if final_status and final_status.status == "completed":
-                # Use helper from flock_api instance for formatting
-                formatted_html = flock_api._format_result_to_html(
-                    final_status.result
-                )
-                logger.info(f"UI run completed successfully (run_id: {run_id})")
-                return HTMLResponse(
-                    f"<div id='result-content'>{formatted_html}</div>"
-                )  # Wrap in target div
-            elif final_status and final_status.status == "failed":
-                logger.error(
-                    f"UI run failed (run_id: {run_id}): {final_status.error}"
-                )
-                error_msg = html.escape(final_status.error or "Unknown error")
-                return HTMLResponse(
-                    f"<div id='result-content' class='error-message'>Run Failed: {error_msg}</div>",
-                    status_code=500,
-                )
-            else:
-                status_str = (
-                    final_status.status if final_status else "Not Found"
-                )
-                logger.warning(
-                    f"UI run {run_id} ended in unexpected state: {status_str}"
-                )
-                return HTMLResponse(
-                    f"<div id='result-content' class='error-message'>Run ended unexpectedly. Status: {status_str}</div>",
-                    status_code=500,
-                )
-
-        except ValueError as ve:
-            logger.error(f"Value error processing UI form run: {ve}")
-            if run_id:
-                run_store.update_run_status(run_id, "failed", str(ve))
-            return HTMLResponse(
-                f"<div id='result-content' class='error-message'>Error: {html.escape(str(ve))}</div>",
-                status_code=400,
-            )
-        except Exception as e:
-            error_msg = f"Internal server error: {type(e).__name__}"
-            logger.error(f"Error processing UI form run: {e!s}", exc_info=True)
-            if run_id:
-                run_store.update_run_status(run_id, "failed", error_msg)
-            return HTMLResponse(
-                f"<div id='result-content' class='error-message'>{html.escape(error_msg)}</div>",
-                status_code=500,
-            )
-
     return router