flock-core 0.4.0b39__tar.gz → 0.4.0b42__tar.gz

{flock_core-0.4.0b39 → flock_core-0.4.0b42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.4.0b39
+Version: 0.4.0b42
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE

{flock_core-0.4.0b39 → flock_core-0.4.0b42}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flock-core"
-version = "0.4.0b-39"
+version = "0.4.0b-42"
 description = "Declarative LLM Orchestration at Scale"
 readme = "README.md"
 authors = [

{flock_core-0.4.0b39 → flock_core-0.4.0b42}/src/flock/core/api/custom_endpoint.py

@@ -27,6 +27,8 @@ class FlockEndpoint(BaseModel):
     # Optional schema models
     request_model: type[BaseModel] | None = None
     response_model: type[BaseModel] | None = None
+    # Query-string parameters as a Pydantic model (treated as Depends())
+    query_model: type[BaseModel] | None = None
 
     # OpenAPI / Swagger metadata
     summary: str | None = None
@@ -34,6 +36,9 @@ class FlockEndpoint(BaseModel):
     name: str | None = None  # Route name in FastAPI
     include_in_schema: bool = True
 
+    # FastAPI dependency injections (e.g. security)
+    dependencies: list[Any] | None = None
+
     model_config = {
         "arbitrary_types_allowed": True,
         "validate_default": True,

{flock_core-0.4.0b39 → flock_core-0.4.0b42}/src/flock/core/api/main.py

@@ -133,65 +133,82 @@ class FlockAPI:
         if self.custom_endpoints:
             import inspect
 
-            from fastapi import Request
+            from fastapi import Body, Depends, Request
 
             # Register any endpoints collected during __init__ (self.custom_endpoints)
             if self.custom_endpoints:
-                from fastapi import Body
-
-                def _create_handler_factory(callback: Callable[..., Any], req_model: type[BaseModel] | None):
-
+                def _create_handler_factory(callback: Callable[..., Any], req_model: type[BaseModel] | None, query_model: type[BaseModel] | None):
+                    async def _invoke(request: Request, body, query):
+                        payload: dict[str, Any] = {"flock": self.flock}
+                        if request:
+                            payload.update(request.path_params)
+                            if query is None:
+                                payload["query"] = dict(request.query_params)
+                            else:
+                                payload["query"] = query
+                        else:
+                            payload["query"] = query or {}
+                        if body is not None:
+                            payload["body"] = body
+                        elif request and request.method in {"POST", "PUT", "PATCH"} and req_model is None:
+                            try:
+                                payload["body"] = await request.json()
+                            except Exception:
+                                payload["body"] = await request.body()
+
+                        sig = inspect.signature(callback)
+                        filtered_kwargs = {k: v for k, v in payload.items() if k in sig.parameters}
+                        if inspect.iscoroutinefunction(callback):
+                            return await callback(**filtered_kwargs)
+                        return callback(**filtered_kwargs)
+
+                    # Dynamically build wrapper with appropriate signature so FastAPI can document it
+                    params: list[str] = []
                     if req_model is not None:
-
-                        async def _route_handler(body: req_model = Body(...), request: Request = None):  # type: ignore[arg-type,valid-type]
-                            payload: dict[str, Any] = {
-                                "body": body,
-                                "query": dict(request.query_params) if request else {},
-                                "flock": self.flock,
-                                **(request.path_params if request else {}),
-                            }
-
-                            sig = inspect.signature(callback)
-                            filtered_kwargs = {k: v for k, v in payload.items() if k in sig.parameters}
-
-                            if inspect.iscoroutinefunction(callback):
-                                return await callback(**filtered_kwargs)
-                            return callback(**filtered_kwargs)
+                        params.append("body")
+                    if query_model is not None:
+                        params.append("query")
+
+                    # Build wrapper function based on which params are present
+                    if req_model and query_model:
+                        async def _route_handler(
+                            request: Request,
+                            body: req_model = Body(...),  # type: ignore[arg-type,valid-type]
+                            query: query_model = Depends(),  # type: ignore[arg-type,valid-type]
+                        ):
+                            return await _invoke(request, body, query)
+
+                    elif req_model and not query_model:
+                        async def _route_handler(
+                            request: Request,
+                            body: req_model = Body(...),  # type: ignore[arg-type,valid-type]
+                        ):
+                            return await _invoke(request, body, None)
+
+                    elif query_model and not req_model:
+                        async def _route_handler(
+                            request: Request,
+                            query: query_model = Depends(),  # type: ignore[arg-type,valid-type]
+                        ):
+                            return await _invoke(request, None, query)
 
                     else:
-
                         async def _route_handler(request: Request):
-                            payload: dict[str, Any] = {
-                                "query": dict(request.query_params),
-                                "flock": self.flock,
-                                **request.path_params,
-                            }
-
-                            if request.method in {"POST", "PUT", "PATCH"}:
-                                try:
-                                    payload["body"] = await request.json()
-                                except Exception:
-                                    payload["body"] = await request.body()
-
-                            sig = inspect.signature(callback)
-                            filtered_kwargs = {k: v for k, v in payload.items() if k in sig.parameters}
-
-                            if inspect.iscoroutinefunction(callback):
-                                return await callback(**filtered_kwargs)
-                            return callback(**filtered_kwargs)
+                            return await _invoke(request, None, None)
 
                     return _route_handler
 
                 for ep in self.custom_endpoints:
                     self.app.add_api_route(
                         ep.path,
-                        _create_handler_factory(ep.callback, ep.request_model),
+                        _create_handler_factory(ep.callback, ep.request_model, ep.query_model),
                         methods=ep.methods or ["GET"],
                         name=ep.name or f"custom:{ep.path}",
                         include_in_schema=ep.include_in_schema,
                         response_model=ep.response_model,
                         summary=ep.summary,
                         description=ep.description,
+                        dependencies=ep.dependencies,
                     )
 
     # --- Core Execution Helper Methods ---

{flock_core-0.4.0b39 → flock_core-0.4.0b42}/src/flock/core/execution/batch_executor.py

@@ -1,4 +1,5 @@
 import asyncio
+import concurrent.futures  # For real parallelism via threads
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
@@ -184,52 +185,77 @@ class BatchProcessor:
             )
             progress.start()
 
-        results = [None] * len(
-            prepared_batch_inputs
-        )  # Pre-allocate results list
-        tasks = []
-        semaphore = asyncio.Semaphore(
-            max_workers if parallel and not effective_use_temporal else 1
-        )  # Semaphore for parallel local
-
-        async def worker(index, item_inputs):
-            async with semaphore:
-                full_input = {**(static_inputs or {}), **item_inputs}
-                context = FlockContext()
-                context.set_variable(FLOCK_BATCH_SILENT_MODE, silent_mode)
-
-                run_desc = f"Batch item {index + 1}"
-                logger.debug(f"{run_desc} started.")
-                try:
-                    result = await self.flock.run_async(
-                        start_agent,
-                        full_input,
-                        box_result=box_results,
-                        context=context,
-                    )
-                    results[index] = result
-                    logger.debug(f"{run_desc} finished successfully.")
-                except Exception as e:
-                    logger.error(
-                        f"{run_desc} failed: {e}", exc_info=not return_errors
-                    )
-                    if return_errors:
-                        results[index] = e
-                    else:
-                        # If not returning errors, ensure the exception propagates
-                        # to stop asyncio.gather if running in parallel.
-                        if parallel and not effective_use_temporal:
-                            raise  # Re-raise to stop gather
-                        else:
-                            # For sequential, we just store None or the exception if return_errors=True
-                            # For Temporal, error handling happens within the workflow/activity usually
-                            results[index] = e if return_errors else None
-                finally:
-                    if progress_context:
-                        progress.update(
-                            progress_task_id, advance=1
-                        )  # Update progress
+        results = [None] * len(prepared_batch_inputs)  # Pre-allocate results list
+
+        # --- Worker Definitions ---
+        # We implement two flavours:
+        #   * async_worker: used for Temporal or sequential runs (keeps the original behaviour)
+        #   * thread_worker: executes the run in a dedicated thread via ThreadPoolExecutor for true parallelism.
+
+        async def async_worker(index: int, item_inputs: dict[str, Any]):
+            """Original coroutine worker used for non-threaded execution paths."""
+            full_input = {**(static_inputs or {}), **item_inputs}
+            context = FlockContext()
+            context.set_variable(FLOCK_BATCH_SILENT_MODE, silent_mode)
+
+            run_desc = f"Batch item {index + 1}"
+            logger.debug(f"{run_desc} started (async).")
+            try:
+                result = await self.flock.run_async(
+                    start_agent,
+                    full_input,
+                    box_result=box_results,
+                    context=context,
+                )
+                results[index] = result
+                logger.debug(f"{run_desc} finished successfully.")
+            except Exception as e:
+                logger.error(f"{run_desc} failed: {e}", exc_info=not return_errors)
+                if return_errors:
+                    results[index] = e
+                else:
+                    raise  # Propagate to calling gather
+            finally:
+                if progress_context:
+                    progress.update(progress_task_id, advance=1)
+
+        # ThreadPool worker for real parallelism (suitable for blocking I/O)
+        def _thread_worker(index: int, item_inputs: dict[str, Any]):
+            """Synchronous helper executed inside a worker thread."""
+            full_input = {**(static_inputs or {}), **item_inputs}
+            run_desc = f"Batch item {index + 1}"
+            logger.debug(f"{run_desc} started (thread).")
+            try:
+                # Use the synchronous wrapper to avoid nested event-loop issues inside threads
+                result = self.flock.run(
+                    start_agent=start_agent,
+                    input=full_input,
+                    box_result=box_results,
+                )
+                logger.debug(f"{run_desc} finished successfully.")
+                return index, result, None
+            except Exception as e:
+                logger.error(f"{run_desc} failed: {e}")
+                return index, None, e
 
+        async def thread_worker(executor, index: int, item_inputs: dict[str, Any]):
+            """Coroutine wrapper that submits _thread_worker to the specified executor."""
+            loop = asyncio.get_running_loop()
+            idx, res, err = await loop.run_in_executor(
+                executor, _thread_worker, index, item_inputs
+            )
+            # Handle result / error on the asyncio side
+            if err:
+                if return_errors:
+                    results[idx] = err
+                else:
+                    raise err
+            else:
+                results[idx] = res
+            if progress_context:
+                progress.update(progress_task_id, advance=1)
+
+        tasks = []
         try:
             if effective_use_temporal:
                 # Temporal Batching (Simplified: sequential execution for this example)
@@ -238,25 +264,32 @@ class BatchProcessor:
                     "Running batch using Temporal (executing sequentially for now)..."
                 )
                 for i, item_data in enumerate(prepared_batch_inputs):
-                    await worker(i, item_data)  # Run sequentially for demo
+                    await async_worker(i, item_data)  # Run sequentially for demo
                 # TODO: Implement true parallel Temporal workflow execution if needed
 
             elif parallel:
+                # --- Real parallelism using ThreadPoolExecutor ---
                 logger.info(
-                    f"Running batch in parallel with max_workers={max_workers}..."
+                    f"Running batch in parallel (threads) with max_workers={max_workers}..."
                 )
-                for i, item_data in enumerate(prepared_batch_inputs):
-                    tasks.append(asyncio.create_task(worker(i, item_data)))
-                await asyncio.gather(
-                    *tasks
-                )  # gather handles exceptions based on return_errors logic in worker
+                loop = asyncio.get_running_loop()
+                with concurrent.futures.ThreadPoolExecutor(
+                    max_workers=max_workers, thread_name_prefix="flock-batch"
+                ) as executor:
+                    for i, item_data in enumerate(prepared_batch_inputs):
+                        tasks.append(
+                            asyncio.create_task(
+                                thread_worker(executor, i, item_data)
+                            )
+                        )
+
+                    # Wait for all tasks allowing exceptions to propagate as needed
+                    await asyncio.gather(*tasks)
 
             else:  # Sequential Local
                 logger.info("Running batch sequentially...")
                 for i, item_data in enumerate(prepared_batch_inputs):
-                    await worker(
-                        i, item_data
-                    )  # Already handles errors internally based on return_errors
+                    await async_worker(i, item_data)  # Already handles errors internally based on return_errors
 
             logger.info("Batch execution finished.")
 

{flock_core-0.4.0b39 → flock_core-0.4.0b42}/src/flock/core/flock.py

@@ -117,7 +117,7 @@ class Flock(BaseModel, Serializable):
     # Internal agent storage - not part of the Pydantic model for direct serialization
     _agents: dict[str, FlockAgent]
     _start_agent_name: str | None = None  # For potential pre-configuration
-    _start_input: dict = {}  # For potential pre-configuration
+    _start_input: dict = {}  # Instance attribute overwritten in __init__; kept for typing clarity
 
     # Pydantic v2 model config
     model_config = {
@@ -277,7 +277,7 @@ class Flock(BaseModel, Serializable):
     def run(
         self,
         start_agent: FlockAgent | str | None = None,
-        input: dict = {},
+        input: dict | None = None,
         context: FlockContext | None = None,
         run_id: str = "",
         box_result: bool = True,

{flock_core-0.4.0b39 → flock_core-0.4.0b42}/src/flock/core/flock_registry.py

@@ -169,17 +169,31 @@ class FlockRegistry:
             return None
 
     # --- Agent Registration ---
-    def register_agent(self, agent: FlockAgent) -> None:
-        """Registers a FlockAgent instance by its name."""
+    def register_agent(self, agent: FlockAgent, *, force: bool = False) -> None:
+        """Registers a FlockAgent instance by its name.
+
+        Args:
+            agent: The agent instance to register.
+            force: If True, allow overwriting an existing **different** agent registered under the same name.
+                   If False and a conflicting registration exists, a ValueError is raised.
+        """
         if not hasattr(agent, "name") or not agent.name:
             logger.error(
                 "Attempted to register an agent without a valid 'name' attribute."
             )
             return
-        if agent.name in self._agents and self._agents[agent.name] != agent:
+
+        if agent.name in self._agents and self._agents[agent.name] is not agent:
+            # Same agent already registered → silently ignore; different instance → error/force.
+            if not force:
+                raise ValueError(
+                    f"Agent '{agent.name}' already registered with a different instance. "
+                    "Pass force=True to overwrite the existing registration."
+                )
             logger.warning(
-                f"Agent '{agent.name}' already registered. Overwriting."
+                f"Overwriting existing agent '{agent.name}' registration due to force=True."
             )
+
         self._agents[agent.name] = agent
         logger.debug(f"Registered agent: {agent.name}")
 

{flock_core-0.4.0b39 → flock_core-0.4.0b42}/uv.lock

@@ -1208,7 +1208,7 @@ wheels = [
 
 [[package]]
 name = "flock-core"
-version = "0.4.0b39"
+version = "0.4.0b42"
 source = { editable = "." }
 dependencies = [
     { name = "azure-search-documents" },