flock-core 0.4.0b13__tar.gz → 0.4.0b15__tar.gz

{flock_core-0.4.0b13 → flock_core-0.4.0b15}/PKG-INFO

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

flock_core-0.4.0b15/batch_results.csv

@@ -0,0 +1,3 @@
+url,reasoning,title,headings,entities_and_metadata,type
+https://lite.cnn.com/2025/04/10/uk/andrew-tate-pointed-gun-woman-uk-civil-case-intl/index.html,"The article from CNN reports on a UK lawsuit alleging that Andrew Tate, a social media influencer and former kickboxer, threatened a woman with a gun. The article details accusations from four women against Tate, including allegations of rape and physical abuse. The piece also discusses Tate's controversial influence in the ""manosphere"" and his legal troubles in various countries. The article is categorized as a news piece, given its reporting style and the nature of the content.","Andrew Tate threatened and pointed gun at woman’s face, UK lawsuit alleges | CNN","['Andrew Tate threatened and pointed gun at woman’s face, UK lawsuit alleges', 'The manosphere']","[{'entity': 'Andrew Tate', 'description': 'Social media influencer and former kickboxer accused in a UK lawsuit'}, {'entity': 'UK', 'description': 'Location of the lawsuit against Andrew Tate'}, {'entity': 'Sana Noor Haq', 'description': 'Author of the CNN article'}, {'entity': 'CNN', 'description': 'Source of the news article'}, {'entity': 'PA Media', 'description': 'News agency reporting on the UK court documents'}, {'entity': 'Crown Prosecution Service', 'description': 'UK authority that declined to prosecute Tate in 2019'}, {'entity': 'Andrew Ford', 'description': 'Solicitor representing Andrew Tate'}, {'entity': 'Tristan Tate', 'description': ""Andrew Tate's brother, also involved in legal issues""}, {'entity': 'Elon Musk', 'description': ""Tech mogul who reinstated Tate's Twitter account""}, {'entity': 'Donald Trump', 'description': 'US President advised by Elon Musk, supported by Tate'}, {'entity': 'Bucharest', 'description': 'Location of legal charges against Tate in Romania'}, {'entity': 'Romania', 'description': 'Country where Tate faces charges of human trafficking and organized crime'}]",news
+https://lite.cnn.com/2025/04/10/us/hudson-river-helicopter-crash/index.html,"The webpage from CNN provides a news report about a helicopter crash in the Hudson River, resulting in six fatalities, including three children. The article includes details about the incident, such as the type of helicopter, the flight path, weather conditions, and the ongoing investigation by the FAA and NTSB. The information extracted includes the title, a heading summarizing the event, and metadata about the authors, publication date, and other relevant details.",Hudson River helicopter crash: 6 people dead after passenger helicopter crashes in the Hudson River | CNN,['6 people dead after passenger helicopter crashes in the Hudson River'],"[{'authors': 'John Miller, Mark Morales, Taylor Romine'}, {'date_published': '2025-04-10'}, {'update_time': '5:56 PM EDT'}, {'location': 'Hudson River, New York City'}, {'aircraft': 'Bell 206L-4 LongRanger IV'}, {'investigating_agencies': 'Federal Aviation Administration, National Transportation Safety Board'}, {'weather_conditions': 'Cloudy with winds around 10 to 15 mph, gusts up to 25 mph, visibility 10 miles'}]",news

{flock_core-0.4.0b13 → flock_core-0.4.0b15}/pyproject.toml

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

{flock_core-0.4.0b13 → flock_core-0.4.0b15}/src/flock/cli/execute_flock.py

@@ -495,6 +495,13 @@ def execute_flock_batch(flock: Flock):
             default="batch_results.csv",
         ).ask()
 
+        hide_columns = questionary.text(
+            "Hide columns (comma-separated - leave blank for hiding no columns):",
+            default="",
+        ).ask()
+
+        hide_columns = hide_columns.split(",") if hide_columns else []
+
     # Logging options
     enable_logging = questionary.confirm(
         "Enable detailed logging?",
@@ -559,6 +566,7 @@ def execute_flock_batch(flock: Flock):
             return_errors=True,
             silent_mode=silent_mode,
             write_to_csv=write_to_csv,
+            hide_columns=hide_columns,
         )
 
         # Display results summary

{flock_core-0.4.0b13 → flock_core-0.4.0b15}/src/flock/cli/manage_agents.py

@@ -165,7 +165,8 @@ def _view_agent_details(agent: FlockAgent):
     basic_info.add_row("Description", str(agent.description))
     basic_info.add_row("Input", str(agent.input))
     basic_info.add_row("Output", str(agent.output))
-    basic_info.add_row("Use Cache", str(agent.use_cache))
+    basic_info.add_row("Write to File", str(agent.write_to_file))
+    basic_info.add_row("Wait for input", str(agent.wait_for_input))
 
     console.print(Panel(basic_info, title="Basic Information"))
 

{flock_core-0.4.0b13 → flock_core-0.4.0b15}/src/flock/core/execution/batch_executor.py

@@ -52,6 +52,8 @@ class BatchProcessor:
         return_errors: bool = False,
         silent_mode: bool = False,
         write_to_csv: str | None = None,
+        hide_columns: list[str] | None = None,
+        delimiter: str = ",",
     ) -> list[Box | dict | None | Exception]:
         """Runs the specified agent/workflow for each item in a batch asynchronously.
 
@@ -70,6 +72,7 @@ class BatchProcessor:
             return_errors: If True, return Exception objects for failed runs instead of raising.
             silent_mode: If True, suppress output and show progress bar instead.
             write_to_csv: Path to save results as CSV file.
+            hide_columns: List of column names to hide from output.
 
         Returns:
             List containing results (Box/dict), None (if error and not return_errors),
@@ -81,7 +84,9 @@ class BatchProcessor:
             Exception: First exception from a run if return_errors is False.
         """
         effective_use_temporal = (
-            use_temporal if use_temporal is not None else self.enable_temporal
+            use_temporal
+            if use_temporal is not None
+            else self.flock.enable_temporal
         )
         exec_mode = (
             "Temporal"
@@ -268,9 +273,11 @@ class BatchProcessor:
         if write_to_csv:
             try:
                 df = pd.DataFrame(results)
+                if hide_columns:
+                    df = df.drop(columns=hide_columns)
                 # create write_to_csv directory if it doesn't exist
                 Path(write_to_csv).parent.mkdir(parents=True, exist_ok=True)
-                df.to_csv(write_to_csv, index=False)
+                df.to_csv(write_to_csv, index=False, sep=delimiter)
                 logger.info(f"Results written to CSV file: {write_to_csv}")
             except Exception as e:
                 logger.error(f"Failed to write results to CSV: {e}")
@@ -290,6 +297,8 @@ class BatchProcessor:
         return_errors: bool = False,
         silent_mode: bool = False,
         write_to_csv: str | None = None,
+        hide_columns: list[str] | None = None,
+        delimiter: str = ",",
     ) -> list[Box | dict | None | Exception]:
         """Synchronous wrapper for run_batch_async."""
         # (Standard asyncio run wrapper - same as in previous suggestion)
@@ -313,6 +322,8 @@ class BatchProcessor:
             return_errors=return_errors,
             silent_mode=silent_mode,
             write_to_csv=write_to_csv,
+            hide_columns=hide_columns,
+            delimiter=delimiter,
         )
 
         if asyncio.get_event_loop() is loop and not loop.is_running():

{flock_core-0.4.0b13 → flock_core-0.4.0b15}/src/flock/core/flock.py

@@ -442,6 +442,8 @@ class Flock(BaseModel, Serializable):
         return_errors: bool = False,
         silent_mode: bool = False,
         write_to_csv: str | None = None,
+        hide_columns: list[str] | None = None,
+        delimiter: str = ",",
     ) -> list[Box | dict | None | Exception]:
         """Runs the specified agent/workflow for each item in a batch asynchronously (delegated)."""
         # Import processor locally
@@ -460,6 +462,8 @@ class Flock(BaseModel, Serializable):
             return_errors=return_errors,
             silent_mode=silent_mode,
             write_to_csv=write_to_csv,
+            hide_columns=hide_columns,
+            delimiter=delimiter,
         )
 
     def run_batch(
@@ -475,6 +479,8 @@ class Flock(BaseModel, Serializable):
         return_errors: bool = False,
         silent_mode: bool = False,
         write_to_csv: str | None = None,
+        hide_columns: list[str] | None = None,
+        delimiter: str = ",",
     ) -> list[Box | dict | None | Exception]:
         """Synchronous wrapper for run_batch_async."""
         # (Standard asyncio run wrapper logic)
@@ -498,6 +504,8 @@ class Flock(BaseModel, Serializable):
             return_errors=return_errors,
             silent_mode=silent_mode,
             write_to_csv=write_to_csv,
+            hide_columns=hide_columns,
+            delimiter=delimiter,
         )
 
         if asyncio.get_event_loop() is loop and not loop.is_running():

{flock_core-0.4.0b13 → flock_core-0.4.0b15}/src/flock/core/flock_agent.py

@@ -2,10 +2,15 @@
 """FlockAgent is the core, declarative base class for all agents in the Flock framework."""
 
 import asyncio
+import json
+import os
 from abc import ABC
 from collections.abc import Callable
+from datetime import datetime
 from typing import TYPE_CHECKING, Any, TypeVar
 
+from flock.core.serialization.json_encoder import FlockJSONEncoder
+
 if TYPE_CHECKING:
     from flock.core.context.context import FlockContext
     from flock.core.flock_evaluator import FlockEvaluator
@@ -14,6 +19,7 @@ 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
@@ -32,6 +38,8 @@ 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")
@@ -73,9 +81,13 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
             description="List of callable tools the agent can use. These must be registered.",
         )
     )
-    use_cache: bool = Field(
-        default=True,
-        description="Enable caching for the agent's evaluator (if supported).",
+    write_to_file: bool = Field(
+        default=False,
+        description="Write the agent's output to a file.",
+    )
+    wait_for_input: bool = Field(
+        default=False,
+        description="Wait for user input after the agent's output is displayed.",
     )
 
     # --- Components ---
@@ -169,6 +181,11 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
             try:
                 for module in self.get_enabled_modules():
                     await module.terminate(self, inputs, result, self.context)
+
+                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",
@@ -356,6 +373,28 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
 
     # --- Serialization Implementation ---
 
+    def _save_output(self, agent_name: str, result: dict[str, Any]) -> None:
+        """Save output to file if configured."""
+        if not self.write_to_file:
+            return
+
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"{agent_name}_output_{timestamp}.json"
+        filepath = os.path.join("output/", filename)
+        os.makedirs("output/", exist_ok=True)
+
+        output_data = {
+            "agent": agent_name,
+            "timestamp": timestamp,
+            "output": result,
+        }
+
+        try:
+            with open(filepath, "w") as f:
+                json.dump(output_data, f, indent=2, cls=FlockJSONEncoder)
+        except Exception as e:
+            logger.warning(f"Failed to save output to file: {e}")
+
     def to_dict(self) -> dict[str, Any]:
         """Convert instance to dictionary representation suitable for serialization."""
         from flock.core.flock_registry import get_registry

{flock_core-0.4.0b13 → flock_core-0.4.0b15}/src/flock/core/logging/formatters/themed_formatter.py

@@ -415,14 +415,12 @@ class ThemedAgentResultFormatter:
         theme: OutputTheme = OutputTheme.afterglow,
         max_length: int = -1,
         render_table: bool = True,
-        wait_for_input: bool = False,
     ):
         """Initialize the formatter with a theme and optional max length."""
         self.theme = theme
         self.styles = None
         self.max_length = max_length
         self.render_table = render_table
-        self.wait_for_input = wait_for_input
 
     def format_result(
         self,
@@ -546,5 +544,3 @@ class ThemedAgentResultFormatter:
             styles=styles,
         )
         console.print(panel)
-        if self.wait_for_input:
-            console.input(prompt="Press Enter to continue...")

{flock_core-0.4.0b13 → flock_core-0.4.0b15}/src/flock/evaluators/declarative/declarative_evaluator.py

@@ -93,6 +93,7 @@ class DeclarativeEvaluator(
 
             streaming_task = dspy.streamify(agent_task)
             stream_generator: Generator = streaming_task(**inputs)
+            delta_content = ""
 
             console.print("\n")
             async for chunk in stream_generator:
@@ -117,7 +118,7 @@ class DeclarativeEvaluator(
             logger.info(f"Evaluating agent '{agent.name}' without streaming.")
             try:
                 # Ensure the call is awaited if the underlying task is async
-                result_obj = await agent_task(**inputs)
+                result_obj = agent_task(**inputs)
                 result_dict = self._process_result(result_obj, inputs)
                 return result_dict
             except Exception as e:

flock_core-0.4.0b15/src/flock/evaluators/test/test_case_evaluator.py

@@ -0,0 +1,36 @@
+from typing import Any
+
+from pydantic import Field
+
+from flock.core.flock_agent import FlockAgent
+from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
+from flock.core.mixin.dspy_integration import DSPyIntegrationMixin
+
+
+class TestCaseEvaluatorConfig(FlockEvaluatorConfig):
+    """Configuration for the TestCaseEvaluator."""
+
+    pass
+
+
+class TestCaseEvaluator(FlockEvaluator, DSPyIntegrationMixin):
+    """Evaluator for test cases."""
+
+    config: TestCaseEvaluatorConfig = Field(
+        default_factory=TestCaseEvaluatorConfig,
+        description="Evaluator configuration",
+    )
+
+    async def evaluate(
+        self, agent: FlockAgent, inputs: dict[str, Any], tools: list[Any]
+    ) -> dict[str, Any]:
+        _dspy_signature = self.create_dspy_signature_class(
+            agent.name,
+            agent.description,
+            f"{agent.input} -> {agent.output}",
+        )
+        output_field_names = list(_dspy_signature.output_fields.keys())
+        result = {}
+        for output_field_name in output_field_names:
+            result[output_field_name] = "Test Result"
+        return result

{flock_core-0.4.0b13 → flock_core-0.4.0b15}/src/flock/modules/output/output_module.py

@@ -1,8 +1,6 @@
 """Output formatting and display functionality for agents."""
 
-import json
 import os
-from datetime import datetime
 from typing import TYPE_CHECKING, Any
 
 from pydantic import Field
@@ -19,7 +17,6 @@ from flock.core.logging.formatters.themed_formatter import (
 )
 from flock.core.logging.formatters.themes import OutputTheme
 from flock.core.logging.logging import get_logger
-from flock.core.serialization.json_encoder import FlockJSONEncoder
 
 # from flock.core.logging.formatters.themes import OutputTheme
 # from flock.core.logging.logging import get_logger
@@ -40,13 +37,6 @@ class OutputModuleConfig(FlockModuleConfig):
     max_length: int = Field(
         default=1000, description="Maximum length for displayed output"
     )
-    wait_for_input: bool = Field(
-        default=False,
-        description="Whether to wait for user input after display",
-    )
-    write_to_file: bool = Field(
-        default=False, description="Whether to save output to file"
-    )
     output_dir: str = Field(
         default="output/", description="Directory for saving output files"
     )
@@ -84,13 +74,10 @@ class OutputModule(FlockModule):
 
     def __init__(self, name: str, config: OutputModuleConfig):
         super().__init__(name=name, config=config)
-        if self.config.write_to_file:
-            os.makedirs(self.config.output_dir, exist_ok=True)
         self._formatter = ThemedAgentResultFormatter(
             theme=self.config.theme,
             max_length=self.config.max_length,
             render_table=self.config.render_table,
-            wait_for_input=self.config.wait_for_input,
         )
 
     def _format_value(self, value: Any, key: str) -> str:
@@ -146,34 +133,6 @@ class OutputModule(FlockModule):
         )
         return text
 
-    def _save_output(self, agent_name: str, result: dict[str, Any]) -> None:
-        """Save output to file if configured."""
-        if not self.config.write_to_file:
-            return
-
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"{agent_name}_output_{timestamp}.json"
-        filepath = os.path.join(self.config.output_dir, filename)
-
-        output_data = {
-            "agent": agent_name,
-            "timestamp": timestamp,
-            "output": result,
-        }
-
-        if self.config.show_metadata:
-            output_data["metadata"] = {
-                "formatted_at": datetime.now().isoformat(),
-                "theme": self.config.theme.value,
-                "max_length": self.config.max_length,
-            }
-
-        try:
-            with open(filepath, "w") as f:
-                json.dump(output_data, f, indent=2, cls=FlockJSONEncoder)
-        except Exception as e:
-            logger.warning(f"Failed to save output to file: {e}")
-
     async def post_evaluate(
         self,
         agent: "FlockAgent",
@@ -191,8 +150,6 @@ class OutputModule(FlockModule):
 
         if is_silent:
             logger.debug("Output suppressed (config or batch silent mode).")
-            # Still save to file if configured, even in silent mode
-            self._save_output(agent.name, result)
             return result  # Skip console output
 
         logger.debug("Formatting and displaying output to console.")
@@ -223,9 +180,6 @@ class OutputModule(FlockModule):
             )
         self._formatter.display_result(result_to_display, agent.name)
 
-        # Save to file if configured
-        self._save_output(agent.name, result)  # Save the original result
-
         return result  # Return the original, unmodified result
 
     def update_theme(self, new_theme: OutputTheme) -> None:

flock_core-0.4.0b15/tests/core/test_flock_batch.py

@@ -0,0 +1,75 @@
+
+
+import os
+import pytest
+import pandas as pd
+from flock.core import Flock, FlockAgent, FlockFactory
+from flock.core.flock_registry import get_registry
+from flock.evaluators.test.test_case_evaluator import TestCaseEvaluator, TestCaseEvaluatorConfig
+
+
+
+@pytest.fixture
+def basic_flock() -> Flock:
+    """Fixture for a basic Flock instance."""
+    return Flock(name="test_basic_flock", model="test-model", enable_logging=False, show_flock_banner=False)
+
+@pytest.fixture
+def simple_agent() -> FlockAgent:
+    """Fixture for a simple agent instance."""
+    agent = FlockFactory.create_default_agent(name="agent1", input="query", output="col1,col2,col3,col4")
+    agent.evaluator = TestCaseEvaluator(name="test_case_evaluator", config=TestCaseEvaluatorConfig())
+    return agent
+
+
+@pytest.fixture(autouse=True)
+def clear_registry():
+    """Fixture to ensure a clean registry for each test."""
+    registry = get_registry()
+    registry._initialize() # Reset internal dictionaries
+    yield # Run the test
+    registry._initialize() # Clean up after test  
+
+
+@pytest.mark.asyncio
+async def test_batch_execution_with_dataframe_input(basic_flock: Flock, simple_agent: FlockAgent):
+    """Test batch execution with CSV input."""
+    batch_inputs = pd.DataFrame({
+        "query": ["test1", "test2", "test3"],
+    })
+    results = await basic_flock.run_batch_async(
+        start_agent=simple_agent,
+        batch_inputs=batch_inputs,
+        input_mapping={"query": "query"},
+        parallel=True,
+    )
+    assert len(results) == 3
+    assert results[0]["col1"] == "Test Result"
+    assert results[1]["col2"] == "Test Result"
+    assert results[2]["col3"] == "Test Result"
+    assert results[2]["col4"] == "Test Result"
+    
+    
+@pytest.mark.asyncio
+async def test_batch_execution_with_dataframe_input_and_csv_output(basic_flock: Flock, simple_agent: FlockAgent):
+    """Test batch execution with CSV input."""
+    batch_inputs = pd.DataFrame({
+        "query": ["test1", "test2", "test3"],
+    })
+    results = await basic_flock.run_batch_async(
+        start_agent=simple_agent,
+        batch_inputs=batch_inputs,
+        input_mapping={"query": "query"},
+        parallel=True,
+        write_to_csv="test_output.csv",
+        hide_columns=["col1", "col2"],
+        delimiter="-",
+    )
+    assert os.path.exists("test_output.csv")
+    df = pd.read_csv("test_output.csv", delimiter="-")
+    assert len(df) == 3
+    assert df.columns.tolist() == ["col3", "col4"]
+    assert df["col3"][0] == "Test Result"
+    assert df["col4"][1] == "Test Result"
+    os.remove("test_output.csv")
+

{flock_core-0.4.0b13 → flock_core-0.4.0b15}/tests/serialization/test_yaml_serialization.py

@@ -130,7 +130,6 @@ class TestFlockYAMLSerialization:
         assert loaded_agent.description == agent.description
         assert loaded_agent.input == agent.input
         assert loaded_agent.output == agent.output
-        assert loaded_agent.use_cache == agent.use_cache # Check defaults
         assert loaded_agent.evaluator is None # Default should be None before factory
         assert loaded_agent.modules == {}
         assert loaded_agent.handoff_router is None

{flock_core-0.4.0b13 → flock_core-0.4.0b15}/uv.lock

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