flock-core 0.4.0b39__py3-none-any.whl → 0.4.0b40__py3-none-any.whl

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/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/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.dist-info → flock_core-0.4.0b40.dist-info}/METADATA

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

{flock_core-0.4.0b39.dist-info → flock_core-0.4.0b40.dist-info}/RECORD

@@ -19,12 +19,12 @@ flock/cli/view_results.py,sha256=dOzK0O1FHSIDERnx48y-2Xke9BkOHS7pcOhs64AyIg0,781
 flock/cli/yaml_editor.py,sha256=K3N0bh61G1TSDAZDnurqW9e_-hO6CtSQKXQqlDhCjVo,12527
 flock/cli/assets/release_notes.md,sha256=bqnk50jxM3w5uY44Dc7MkdT8XmRREFxrVBAG9XCOSSU,4896
 flock/core/__init__.py,sha256=p7lmQULRu9ejIAELfanZiyMhW0CougIPvyFHW2nqBFQ,847
-flock/core/flock.py,sha256=A75h8f_vwZHKNkSVoUie9AZlKbUKpbUX1wNA3VNsPyY,30379
+flock/core/flock.py,sha256=WzLA7-xoAUq7Yn_ioieQIsk6CG_VvvDPeq_S6FWNgOY,30424
 flock/core/flock_agent.py,sha256=JTqaGD_OnZSd3bVU989WMsK1rAT6UGn-JYrPxFV15EE,39576
 flock/core/flock_evaluator.py,sha256=dOXZeDOGZcAmJ9ahqq_2bdGUU1VOXY4skmwTVpAjiVw,1685
 flock/core/flock_factory.py,sha256=_4zsjkEmJnCR7IvJ3SUHnDbX6c7Tt3E4P5ohxwKvE6w,3173
 flock/core/flock_module.py,sha256=UCK6TFe4viXs596zeng0GD3gln4ZNGu_gCWkXIIMREg,3090
-flock/core/flock_registry.py,sha256=Qcu9juUFNyDAOEsqVxauwVlWdfgKZrSzc8yT8JMiK-c,24246
+flock/core/flock_registry.py,sha256=aC-RK0js676DQkjXmNuYHuD5t6GmFhpQoCKaO3i7xFg,24920
 flock/core/flock_router.py,sha256=1OAXDsdaIIFApEfo6SRfFEDoTuGt3Si7n2MXiySEfis,2644
 flock/core/api/__init__.py,sha256=OKlhzDWZJfA6ddBwxQUmATY0TSzESsH032u00iVGvdA,228
 flock/core/api/custom_endpoint.py,sha256=nCm8lhvq1OOVlHB5f1DD1Pgm5U-PgggPlYjlMRK4nPc,1090
@@ -40,7 +40,7 @@ flock/core/context/context.py,sha256=GFqMwYXLheqECGvWcxar7sQ2-GuY3RVynZ7kjwd65R0
 flock/core/context/context_manager.py,sha256=FANSWa6DEhdhtZ7t_9Gza0v80UdpoDOhHbfVOccmjkA,1181
 flock/core/context/context_vars.py,sha256=ASPA29hpENWub4mgRoG62FtTVakCHQZfn6IhJQKe3C8,347
 flock/core/evaluation/utils.py,sha256=ZJkIMC9YT-HA2SPCZ4_bQ98isW1i6nbltVEYbjze-b0,12827
-flock/core/execution/batch_executor.py,sha256=nvsFOVaH4c4uPw_gwZ5jCIULpK59EL1kmcoPTja5kko,13745
+flock/core/execution/batch_executor.py,sha256=mHwCI-DHqApCv_EVCN0ZOUd-LCQLjREpxKbAUPC0pcY,15266
 flock/core/execution/evaluation_executor.py,sha256=D9EO0sU-2qWj3vomjmUUi-DOtHNJNFRf30kGDHuzREE,17702
 flock/core/execution/local_executor.py,sha256=rnIQvaJOs6zZORUcR3vvyS6LPREDJTjaygl_Db0M8ao,952
 flock/core/execution/temporal_executor.py,sha256=dHcb0xuzPFWU_wbwTgI7glLNyyppei93Txs2sapjhaw,6283
@@ -495,8 +495,8 @@ flock/workflow/agent_execution_activity.py,sha256=Gy6FtuVAjf0NiUXmC3syS2eJpNQF4R
 flock/workflow/flock_workflow.py,sha256=iSUF_soFvWar0ffpkzE4irkDZRx0p4HnwmEBi_Ne2sY,9666
 flock/workflow/temporal_config.py,sha256=3_8O7SDEjMsSMXsWJBfnb6XTp0TFaz39uyzSlMTSF_I,3988
 flock/workflow/temporal_setup.py,sha256=YIHnSBntzOchHfMSh8hoLeNXrz3B1UbR14YrR6soM7A,1606
-flock_core-0.4.0b39.dist-info/METADATA,sha256=zZnZWqBTRaem-XCem8L92sWCVkLIf0qe4ZfuMYiz4_U,17125
-flock_core-0.4.0b39.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.4.0b39.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.4.0b39.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.4.0b39.dist-info/RECORD,,
+flock_core-0.4.0b40.dist-info/METADATA,sha256=W-nPONRJfGIBfsyt2hEPqtLqu6mxQto7fP1IYuw1oH8,17125
+flock_core-0.4.0b40.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.4.0b40.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.4.0b40.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.4.0b40.dist-info/RECORD,,