flock-core 0.4.0b24__tar.gz → 0.4.0b26__tar.gz

{flock_core-0.4.0b24 → flock_core-0.4.0b26}/PKG-INFO

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

{flock_core-0.4.0b24 → flock_core-0.4.0b26}/pyproject.toml

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

{flock_core-0.4.0b24 → flock_core-0.4.0b26}/src/flock/__init__.py

@@ -1,35 +1,31 @@
 """Flock package initialization."""
 
-from rich.panel import Panel
-
-from flock.cli.config import init_config_file, load_config_file
-from flock.cli.constants import (
-    CLI_CFG_FILE,
-    CLI_EXIT,
-    CLI_NOTES,
-    CLI_REGISTRY_MANAGEMENT,
-    CLI_THEME_BUILDER,
-)
-from flock.cli.load_release_notes import load_release_notes
-from flock.cli.settings import settings_editor
-from flock.core.logging.formatters.theme_builder import theme_builder
-
 
 def main():
     """Main function."""
     import questionary
     from rich.console import Console
+    from rich.panel import Panel
 
+    from flock.cli.config import init_config_file, load_config_file
     from flock.cli.constants import (
+        CLI_CFG_FILE,
         CLI_CREATE_AGENT,
         CLI_CREATE_FLOCK,
+        CLI_EXIT,
         CLI_LOAD_AGENT,
         CLI_LOAD_EXAMPLE,
         CLI_LOAD_FLOCK,
+        CLI_NOTES,
+        CLI_REGISTRY_MANAGEMENT,
         CLI_SETTINGS,
         CLI_START_WEB_SERVER,
+        CLI_THEME_BUILDER,
     )
     from flock.cli.load_flock import load_flock
+    from flock.cli.load_release_notes import load_release_notes
+    from flock.cli.settings import settings_editor
+    from flock.core.logging.formatters.theme_builder import theme_builder
     from flock.core.util.cli_helper import init_console
 
     console = Console()

{flock_core-0.4.0b24 → flock_core-0.4.0b26}/src/flock/cli/load_release_notes.py

@@ -1,14 +1,12 @@
 from pathlib import Path
 
-from flock.core.util.cli_helper import display_hummingbird
-
 
 def load_release_notes():
     """Load release notes."""
     from rich.console import Console
     from rich.markdown import Markdown
 
-    from flock.core.util.cli_helper import init_console
+    from flock.core.util.cli_helper import display_hummingbird, init_console
 
     console = Console()
     file_path = Path(__file__).parent / "assets" / "release_notes.md"
@@ -19,5 +17,4 @@ def load_release_notes():
     with open(file_path) as file:
         release_notes = file.read()
 
-    
     console.print(Markdown(release_notes))

flock_core-0.4.0b26/src/flock/core/execution/temporal_executor.py

@@ -0,0 +1,57 @@
+# src/your_package/core/execution/temporal_executor.py
+
+from flock.core.context.context import FlockContext
+from flock.core.context.context_vars import FLOCK_RUN_ID
+from flock.core.logging.logging import get_logger
+from flock.workflow.activities import (
+    run_agent,  # Activity function used in Temporal
+)
+from flock.workflow.temporal_setup import create_temporal_client, setup_worker
+
+logger = get_logger("flock")
+
+
+async def run_temporal_workflow(
+    context: FlockContext,
+    box_result: bool = True,
+) -> dict:
+    """Execute the agent workflow via Temporal for robust, distributed processing.
+
+    Args:
+        context: The FlockContext instance with state and history.
+        box_result: If True, wraps the result in a Box for nicer display.
+
+    Returns:
+        A dictionary containing the workflow result.
+    """
+    try:
+        from flock.workflow.flock_workflow import (
+            FlockWorkflow,  # Your workflow class
+        )
+
+        logger.info("Setting up Temporal workflow")
+        await setup_worker(workflow=FlockWorkflow, activity=run_agent)
+        logger.debug("Creating Temporal client")
+        flock_client = await create_temporal_client()
+        workflow_id = context.get_variable(FLOCK_RUN_ID)
+        logger.info("Executing Temporal workflow", workflow_id=workflow_id)
+        context_dict = context.model_dump()
+        result = await flock_client.execute_workflow(
+            FlockWorkflow.run,
+            context_dict,
+            id=workflow_id,
+            task_queue="flock-queue",
+        )
+
+        agent_name = context.get_variable("FLOCK_CURRENT_AGENT")
+        logger.debug("Formatting Temporal result", agent=agent_name)
+
+        if box_result:
+            from box import Box
+
+            logger.debug("Boxing Temporal result")
+            return Box(result)
+        return result
+    except Exception as e:
+        logger.error("Error executing Temporal workflow", error=e)
+        raise e

{flock_core-0.4.0b24 → flock_core-0.4.0b26}/src/flock/core/flock.py

@@ -17,7 +17,14 @@ from typing import (
 
 # Third-party imports
 from box import Box
-from datasets import Dataset
+from temporalio import workflow
+
+with workflow.unsafe.imports_passed_through():
+    from datasets import Dataset
+
+    from flock.core.execution.local_executor import (
+        run_local_workflow,
+    )
 from opentelemetry import trace
 from opentelemetry.baggage import get_baggage, set_baggage
 from pandas import DataFrame
@@ -27,7 +34,6 @@ from pydantic import BaseModel, Field
 from flock.config import DEFAULT_MODEL, TELEMETRY
 from flock.core.context.context import FlockContext
 from flock.core.context.context_manager import initialize_context
-from flock.core.execution.local_executor import run_local_workflow
 from flock.core.execution.temporal_executor import run_temporal_workflow
 from flock.core.flock_evaluator import FlockEvaluator
 from flock.core.logging.logging import LOGGERS, get_logger, get_module_loggers
@@ -59,9 +65,9 @@ FlockRegistry = get_registry()  # Get the registry instance
 # Define TypeVar for generic class methods like from_dict
 T = TypeVar("T", bound="Flock")
 
-from rich.traceback import install
+# from rich.traceback import install
 
-install(show_locals=True)
+# install(show_locals=True)
 
 
 class Flock(BaseModel, Serializable):
@@ -340,6 +346,10 @@ class Flock(BaseModel, Serializable):
                     "No start_agent specified and multiple/no agents exist."
                 )
 
+            # Check if start_agent is in agents
+            if start_agent_name not in self._agents:
+                raise ValueError(f"Start agent '{start_agent_name}' not found.")
+
             run_input = input if input is not None else self._start_input
             effective_run_id = run_id or f"flockrun_{uuid.uuid4().hex[:8]}"
 

{flock_core-0.4.0b24 → flock_core-0.4.0b26}/src/flock/core/flock_agent.py

@@ -19,7 +19,6 @@ if TYPE_CHECKING:
 
 from opentelemetry import trace
 from pydantic import BaseModel, Field
-from rich.console import Console
 
 # Core Flock components (ensure these are importable)
 from flock.core.context.context import FlockContext
@@ -38,8 +37,6 @@ from flock.core.serialization.serialization_utils import (
     serialize_item,
 )
 
-console = Console()
-
 logger = get_logger("agent")
 tracer = trace.get_tracer(__name__)
 T = TypeVar("T", bound="FlockAgent")
@@ -230,8 +227,7 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
 
                 if self.write_to_file:
                     self._save_output(self.name, result)
-                if self.wait_for_input:
-                    console.input(prompt="Press Enter to continue...")
+
             except Exception as module_error:
                 logger.error(
                     "Error during terminate",

{flock_core-0.4.0b24 → flock_core-0.4.0b26}/src/flock/core/util/cli_helper.py

@@ -1,15 +1,10 @@
 from importlib.metadata import PackageNotFoundError, version
 
-from rich.console import Console
-from rich.syntax import Text
-
 try:
     __version__ = version("flock-core")
 except PackageNotFoundError:
     __version__ = "0.2.0"
 
-console = Console()
-
 
 def display_hummingbird():
     """Display the hummingbird."""
@@ -45,6 +40,10 @@ def display_hummingbird():
 
 def init_console(clear_screen: bool = True, show_banner: bool = True):
     """Display the Flock banner."""
+    from rich.console import Console
+    from rich.syntax import Text
+
+    console = Console()
     banner_text = Text(
         f"""
 🦆    🐓     🐤     🐧
@@ -70,6 +69,10 @@ def init_console(clear_screen: bool = True, show_banner: bool = True):
 
 def display_banner_no_version():
     """Display the Flock banner."""
+    from rich.console import Console
+    from rich.syntax import Text
+
+    console = Console()
     banner_text = Text(
         """
 🦆    🐓     🐤     🐧

{flock_core-0.4.0b24 → flock_core-0.4.0b26}/src/flock/evaluators/declarative/declarative_evaluator.py

@@ -1,9 +1,12 @@
 from collections.abc import Generator
 from typing import Any
 
-import dspy
+from temporalio import workflow
+
+with workflow.unsafe.imports_passed_through():
+    import dspy
+
 from pydantic import Field, PrivateAttr
-from rich.console import Console
 
 from flock.core.flock_agent import FlockAgent
 from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
@@ -12,8 +15,6 @@ from flock.core.logging.logging import get_logger
 from flock.core.mixin.dspy_integration import DSPyIntegrationMixin
 from flock.core.mixin.prompt_parser import PromptParserMixin
 
-console = Console()
-
 logger = get_logger("evaluators.declarative")
 
 
@@ -56,6 +57,9 @@ class DeclarativeEvaluator(
         """Evaluate using DSPy, with optional asynchronous streaming."""
         # --- Setup Signature and LM ---
         try:
+            from rich.console import Console
+
+            console = Console()
             _dspy_signature = self.create_dspy_signature_class(
                 agent.name,
                 agent.description,

{flock_core-0.4.0b24 → flock_core-0.4.0b26}/src/flock/modules/performance/metrics_module.py

@@ -24,6 +24,9 @@ class MetricPoint(BaseModel):
     value: int | float | str
     tags: dict[str, str] = {}
 
+    class Config:
+        arbitrary_types_allowed = True
+
 
 class MetricsModuleConfig(FlockModuleConfig):
     """Configuration for performance metrics collection."""

flock_core-0.4.0b26/src/flock/workflow/temporal_setup.py

@@ -0,0 +1,63 @@
+import asyncio
+import traceback
+import uuid
+
+from temporalio.client import Client
+from temporalio.worker import Worker
+
+
+async def create_temporal_client() -> Client:
+    client = await Client.connect("localhost:7233")
+    return client
+
+
+async def setup_worker(workflow, activity) -> Client:
+    """Setup the worker and return the result of the worker.run() call."""
+    try:
+        # debug
+        # print("workflow =", workflow)
+        # print("isclass     :", inspect.isclass(workflow))
+        # print(
+        #     "has _defn   :",
+        #     hasattr(workflow, "_temporalio_workflow_definition"),
+        # )
+        worker_client = await create_temporal_client()
+        worker = Worker(
+            worker_client,
+            task_queue="flock-queue",
+            workflows=[workflow],
+            activities=[activity],
+        )
+        result = asyncio.create_task(worker.run())
+        await asyncio.sleep(1)
+        return result
+    except Exception:
+        print("\n=== Worker construction failed ===")
+        traceback.print_exc()
+        raise
+
+
+async def run_worker(client: Client, task_queue: str, workflows, activities):
+    worker = Worker(
+        client,
+        task_queue=task_queue,
+        workflows=workflows,
+        activities=activities,
+    )
+    await worker.run()
+
+
+async def run_activity(client: Client, name: str, func, param):
+    run_id = f"{name}_{uuid.uuid4().hex[:4]}"
+
+    try:
+        result = await client.execute_activity(
+            func,
+            param,
+            id=run_id,
+            task_queue="flock-queue",
+            start_to_close_timeout=300,  # e.g., 5 minutes
+        )
+        return result
+    except Exception:
+        raise

{flock_core-0.4.0b24 → flock_core-0.4.0b26}/tests/core/test_flock_core.py

@@ -59,17 +59,17 @@ def test_flock_init_custom(mocker):
         model="custom_model",
         description="My custom flock",
         enable_temporal=True,
-        enable_logging=["flock", "agent"],
+        enable_logging=True,
         show_flock_banner=False
     )
     assert flock.name == "custom_flock"
     assert flock.model == "custom_model"
     assert flock.description == "My custom flock"
     assert flock.enable_temporal
-    assert flock.enable_logging == ["flock", "agent"]
+    assert flock.enable_logging
     assert not flock.show_flock_banner
 
-    mock_configure_logging.assert_called_once_with(["flock", "agent"])
+    mock_configure_logging.assert_called_once_with(True)
     mock_set_temporal.assert_called_once()
     mock_ensure_session.assert_called_once()
 
@@ -97,14 +97,13 @@ def test_add_agent_sets_default_model(basic_flock):
     basic_flock.add_agent(agent_no_model)
     assert agent_no_model.model == "flock-default-model"
 
-def test_add_agent_duplicate(basic_flock, simple_agent, caplog):
-    """Test adding an agent with a name that already exists."""
+def test_add_agent_duplicate(basic_flock, simple_agent):
+    """Test adding an agent with a name that already exists raises ValueError."""
     basic_flock.add_agent(simple_agent)
     new_agent_same_name = SimpleAgent(name="agent1", input="query2", output="result2")
-    basic_flock.add_agent(new_agent_same_name)
-
-    assert "already exists. Overwriting" in caplog.text
-    assert basic_flock.agents["agent1"] is new_agent_same_name # Should be overwritten
+    
+    with pytest.raises(ValueError, match="Agent with this name already exists"):
+        basic_flock.add_agent(new_agent_same_name)
 
 def test_add_agent_invalid_type(basic_flock):
     """Test adding something that is not a FlockAgent."""
@@ -225,29 +224,33 @@ async def test_run_async_result_boxing(basic_flock, simple_agent, mocker):
 def test_run_sync_wrapper(basic_flock, mocker):
     """Test that the synchronous run method correctly calls run_async."""
     # Mock run_async to avoid actual async execution
-    mock_run_async = mocker.patch.object(basic_flock, 'run_async', new_callable=AsyncMock)
+    mock_run_async = mocker.patch('flock.core.flock.Flock.run_async', new_callable=AsyncMock)
     mock_run_async.return_value = {"result": "async_ran"}
-
-    # Mock asyncio loop handling
+    
+    # Mock the asyncio module functions
     mock_loop = MagicMock()
-    mock_get_loop = mocker.patch('asyncio.get_running_loop', return_value=mock_loop)
+    mock_get_loop = mocker.patch('asyncio.get_running_loop', side_effect=RuntimeError)
+    mock_new_loop = mocker.patch('asyncio.new_event_loop', return_value=mock_loop)
+    mock_set_loop = mocker.patch('asyncio.set_event_loop')
+    mock_get_event_loop = mocker.patch('asyncio.get_event_loop', return_value=mock_loop)
+    
+    # Configure the loop for the "not running" branch
+    mock_loop.is_running.return_value = False
     mock_loop.run_until_complete.return_value = {"result": "async_ran"}
-
+    
     # Call the synchronous run method
     sync_result = basic_flock.run(start_agent="agent1", input={"query": "sync_test"})
-
-    # Assert run_async was called
-    mock_run_async.assert_awaited_once_with(
-        start_agent="agent1",
-        input={"query": "sync_test"},
-        context=None,
-        run_id="",
-        box_result=True,
-        agents=None,
-    )
-    # Assert the result from run_until_complete is returned
-    assert sync_result == {"result": "async_ran"}
+    
+    # Assert everything was called correctly
+    mock_get_loop.assert_called_once()
+    mock_new_loop.assert_called_once()
+    mock_set_loop.assert_called_once_with(mock_loop)
+    mock_get_event_loop.assert_called_once()
+    mock_loop.is_running.assert_called_once()
     mock_loop.run_until_complete.assert_called_once()
+    
+    # Assert the result is correct
+    assert sync_result == {"result": "async_ran"}
 
 
 # --- Serialization Delegation Tests ---
@@ -278,7 +281,7 @@ def test_from_dict_delegates_to_serializer(mocker):
 
 def test_load_from_file_delegates_to_loader(mocker):
     """Verify Flock.load_from_file calls the loader function."""
-    mock_loader_func = mocker.patch('flock.core.loader.load_flock_from_file')
+    mock_loader_func = mocker.patch('flock.core.util.loader.load_flock_from_file')
     mock_flock_instance = Flock(name="loaded_from_file", enable_logging=False, show_flock_banner=False)
     mock_loader_func.return_value = mock_flock_instance
     file_path = "dummy/path/flock.yaml"

{flock_core-0.4.0b24 → flock_core-0.4.0b26}/tests/serialization/test_file_path_serialization.py

@@ -98,7 +98,7 @@ def test_loading_component_from_file_path():
                 path = line.split("file_path:", 1)[1].strip()
                 if path:
                     # Check that this is an absolute path that exists
-                    assert path.startswith("/")
+                    assert path.startswith("/") or path.startswith("C:")
                     assert os.path.exists(path), f"Path does not exist: {path}"
         
     finally:

{flock_core-0.4.0b24 → flock_core-0.4.0b26}/uv.lock

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

flock_core-0.4.0b24/src/flock/core/execution/temporal_executor.py

@@ -1,49 +0,0 @@
-# src/your_package/core/execution/temporal_executor.py
-
-from flock.core.context.context import FlockContext
-from flock.core.context.context_vars import FLOCK_RUN_ID
-from flock.core.logging.logging import get_logger
-from flock.workflow.activities import (
-    run_agent,  # Activity function used in Temporal
-)
-from flock.workflow.temporal_setup import create_temporal_client, setup_worker
-from flock.workflow.workflow import FlockWorkflow  # Your workflow class
-
-logger = get_logger("flock")
-
-
-async def run_temporal_workflow(
-    context: FlockContext,
-    box_result: bool = True,
-) -> dict:
-    """Execute the agent workflow via Temporal for robust, distributed processing.
-
-    Args:
-        context: The FlockContext instance with state and history.
-        box_result: If True, wraps the result in a Box for nicer display.
-
-    Returns:
-        A dictionary containing the workflow result.
-    """
-    logger.info("Setting up Temporal workflow")
-    await setup_worker(workflow=FlockWorkflow, activity=run_agent)
-    logger.debug("Creating Temporal client")
-    flock_client = await create_temporal_client()
-    workflow_id = context.get_variable(FLOCK_RUN_ID)
-    logger.info("Executing Temporal workflow", workflow_id=workflow_id)
-    result = await flock_client.execute_workflow(
-        FlockWorkflow.run,
-        context.to_dict(),
-        id=workflow_id,
-        task_queue="flock-queue",
-    )
-
-    agent_name = context.get_variable("FLOCK_CURRENT_AGENT")
-    logger.debug("Formatting Temporal result", agent=agent_name)
-
-    if box_result:
-        from box import Box
-
-        logger.debug("Boxing Temporal result")
-        return Box(result)
-    return result

flock_core-0.4.0b24/src/flock/workflow/temporal_setup.py

@@ -1,38 +0,0 @@
-import asyncio
-import uuid
-
-from temporalio.client import Client
-from temporalio.worker import Worker
-
-
-async def create_temporal_client() -> Client:
-    client = await Client.connect("localhost:7233")
-    return client
-
-
-async def setup_worker(workflow, activity) -> Client:
-    worker_client = await create_temporal_client()
-    worker = Worker(worker_client, task_queue="flock-queue", workflows=[workflow], activities=[activity])
-    asyncio.create_task(worker.run())
-    await asyncio.sleep(1)
-
-
-async def run_worker(client: Client, task_queue: str, workflows, activities):
-    worker = Worker(client, task_queue=task_queue, workflows=workflows, activities=activities)
-    await worker.run()
-
-
-async def run_activity(client: Client, name: str, func, param):
-    run_id = f"{name}_{uuid.uuid4().hex[:4]}"
-
-    try:
-        result = await client.execute_activity(
-            func,
-            param,
-            id=run_id,
-            task_queue="flock-queue",
-            start_to_close_timeout=300,  # e.g., 5 minutes
-        )
-        return result
-    except Exception:
-        raise