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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.4.0b25
+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.0b25 → flock_core-0.4.0b26}/pyproject.toml

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

{flock_core-0.4.0b25 → 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.0b25 → 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.0b25 → 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):

{flock_core-0.4.0b25 → 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.0b25 → 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.0b25 → 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.0b25 → 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.0b25 → flock_core-0.4.0b26}/uv.lock

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

flock_core-0.4.0b25/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.0b25/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