flock-core 0.2.14__tar.gz → 0.2.16__tar.gz

{flock_core-0.2.14 → flock_core-0.2.16}/PKG-INFO

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

{flock_core-0.2.14 → flock_core-0.2.16}/examples/01_introduction/01_simple_example.py

@@ -21,7 +21,9 @@ Let's get started!
 import asyncio
 
 from flock.core.flock import Flock
-from flock.core.flock_agent import FlockAgent
+from flock.core.flock_agent import FlockAgent, FlockAgentOutputConfig
+from flock.core.logging.formatters.themes import OutputTheme
+
 
 
 # --------------------------------

{flock_core-0.2.14 → flock_core-0.2.16}/examples/01_introduction/02_typed_output.py

@@ -23,20 +23,15 @@ import asyncio
 from pprint import pprint
 
 from flock.core.flock import Flock
-from flock.core.flock_agent import FlockAgent
-from flock.core.logging.formatters.base_formatter import FormatterOptions
-from flock.core.logging.formatters.rich_formatters import RichTables
-from flock.core.logging.formatters.themed_formatter import ThemedAgentResultFormatter
+from flock.core.flock_agent import FlockAgent, FlockAgentOutputConfig
+from flock.core.logging.formatters.themes import OutputTheme
 from flock.core.tools import basic_tools
 
 async def main():
     # --------------------------------
     # Create the flock
     # --------------------------------
-    # Some people need some swag in their output
-    # See the formatting examples
-    format_options = FormatterOptions(RichTables)
-    flock = Flock(local_debug=True, output_formatter=format_options)
+    flock = Flock(local_debug=True)
 
 
     # --------------------------------
@@ -48,12 +43,18 @@ async def main():
     # - you can define if the agent should use the cache 
     #   results will get cached and if true and if the input is the same as before, the agent will return the cached result
     #   this is useful for expensive operations like web scraping and for debugging
+    # Some people need some swag in their output
+    # Flock supports rendering the output as a table and you can choose a theme
     agent = FlockAgent(
         name="my_agent",
         input="url",
         output="title, headings: list[str], entities_and_metadata: list[dict[str, str]], type:Literal['news', 'blog', 'opinion piece', 'tweet']",
         tools=[basic_tools.get_web_content_as_markdown],
         use_cache=True,
+        output_config=FlockAgentOutputConfig(
+            render_table=True,
+            theme=OutputTheme.abernathy
+        )
     )
     flock.add_agent(agent)
 

{flock_core-0.2.14 → flock_core-0.2.16}/examples/01_introduction/03_tool_and_code_agent.py

@@ -23,10 +23,9 @@ from devtools import debug
 
 
 from flock.core.flock import Flock
-from flock.core.flock_agent import FlockAgent
-from flock.core.logging.formatters.base_formatter import FormatterOptions
-from flock.core.logging.formatters.rich_formatters import RichTables
+from flock.core.flock_agent import FlockAgent, FlockAgentOutputConfig
 from flock.core.logging.formatters.themed_formatter import ThemedAgentResultFormatter
+from flock.core.logging.formatters.themes import OutputTheme
 from flock.core.tools import basic_tools
 
 MODEL = "openai/gpt-4o"
@@ -35,10 +34,7 @@ async def main():
     # --------------------------------
     # Create the flock
     # --------------------------------
-    # In case the table of example 02 wasn't fancy enough
-    # The author had over 300 cli themes lying around....
-    format_options = FormatterOptions(ThemedAgentResultFormatter, wait_for_input=False, settings={"theme": "adventuretime"})
-    flock = Flock(local_debug=True, output_formatter=format_options)
+    flock = Flock(local_debug=True)
 
 
     # --------------------------------
@@ -53,6 +49,10 @@ async def main():
         input="a_person",
         output="persons_age_in_days",
         tools=[basic_tools.web_search_duckduckgo, basic_tools.code_eval],
+        output_config=FlockAgentOutputConfig(
+            render_table=True,
+            theme=OutputTheme.adventuretime
+        ),
         use_cache=True,
     )
     flock.add_agent(agent)

{flock_core-0.2.14 → flock_core-0.2.16}/examples/01_introduction/05_typed_output2.py

@@ -22,8 +22,6 @@ from typing import Literal
 
 from flock.core.flock import Flock
 from flock.core.flock_agent import FlockAgent
-from flock.core.logging.formatters.base_formatter import FormatterOptions
-from flock.core.logging.formatters.rich_formatters import RichTables
 from flock.core.logging.formatters.themed_formatter import ThemedAgentResultFormatter
 from flock.core.tools import basic_tools
 

{flock_core-0.2.14 → flock_core-0.2.16}/examples/01_introduction/06_simple_hand_off.py

@@ -28,23 +28,20 @@ In later examples, we will explore more advanced hand-off scenarios and fall bac
 import asyncio
 
 from flock.core.flock import Flock
-from flock.core.flock_agent import FlockAgent
-from flock.core.logging.formatters.base_formatter import FormatterOptions
-from flock.core.logging.formatters.rich_formatters import RichTables
+from flock.core.flock_agent import FlockAgent, FlockAgentOutputConfig
+from flock.core.logging.formatters.themes import OutputTheme
 
 
 async def main():
 
-    flock = Flock(local_debug=True, output_formatter=
-                    FormatterOptions(formatter=RichTables, 
-                                   wait_for_input=True, 
-                                   settings={}),
-                    enable_logging=True)
+    flock = Flock(local_debug=True,enable_logging=True)
     
     idea_agent = FlockAgent(
         name="idea_agent",
         input="query",
         output="a_fun_software_project_idea",
+        output_config=FlockAgentOutputConfig(render_table=True, 
+                                             wait_for_input=True), # wait for input to continue
         use_cache=True,
     )
 
@@ -52,6 +49,8 @@ async def main():
         name="project_plan_agent",
         input="a_fun_software_project_idea",
         output="catchy_project_name, project_pitch, techstack, project_implementation_plan",
+        output_config=FlockAgentOutputConfig(render_table=True, 
+                                             wait_for_input=True), # wait for input to continue
         use_cache=True,
     )
     

{flock_core-0.2.14 → flock_core-0.2.16}/examples/02_cook_book/long_research_no_handoff.py

@@ -29,7 +29,7 @@ async def main():
         description="Outline a thorough overview of a topic.",
         input="topic",
         output="title,sections: list[str],section_subheadings: dict[str, list[str]]|mapping from section headings to subheadings",
-        tools=[basic_tools.web_search_tavily],
+        tools=[basic_tools.web_search_tavily, basic_tools.get_web_content_as_markdown],
     )
 
 
@@ -37,7 +37,7 @@ async def main():
         name="draft_agent",
         input="flock.topic,flock.section_heading,flock.section_subheadings: list[str]",
         output="content|markdown-formatted section",
-        tools=[basic_tools.web_search_tavily],
+        tools=[basic_tools.web_search_tavily, basic_tools.get_web_content_as_markdown],
     )
 
      

{flock_core-0.2.14 → flock_core-0.2.16}/pyproject.toml

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

{flock_core-0.2.14 → flock_core-0.2.16}/src/flock/__init__.py

@@ -1,5 +1,8 @@
 """Flock package initialization."""
 
+from flock.cli.constants import CLI_THEME_BUILDER
+from flock.core.logging.formatters.theme_builder import theme_builder
+
 
 def main():
     """Main function."""
@@ -35,6 +38,7 @@ def main():
             CLI_LOAD_FLOCK,
             # CLI_LOAD_EXAMPLE,
             questionary.Separator(),
+            CLI_THEME_BUILDER,
             CLI_SETTINGS,
             questionary.Separator(),
             CLI_START_ADVANCED_MODE,
@@ -45,6 +49,8 @@ def main():
 
     if result == CLI_LOAD_FLOCK:
         load_flock()
+    if result == CLI_THEME_BUILDER:
+        theme_builder()
 
 
 if __name__ == "__main__":

{flock_core-0.2.14 → flock_core-0.2.16}/src/flock/cli/constants.py

@@ -4,6 +4,7 @@ CLI_CREATE_AGENT = "Create an agent"
 CLI_CREATE_FLOCK = "Create a flock"
 CLI_LOAD_AGENT = "Load an agent"
 CLI_LOAD_FLOCK = "Load a *.flock file"
+CLI_THEME_BUILDER = "Theme builder"
 CLI_LOAD_EXAMPLE = "Load a example"
 CLI_SETTINGS = "Settings"
 CLI_START_ADVANCED_MODE = "Start advanced mode (coming soon)"

{flock_core-0.2.14 → flock_core-0.2.16}/src/flock/config.py

@@ -44,4 +44,3 @@ TELEMETRY = TelemetryConfig(
     OTEL_ENABLE_FILE,
     OTEL_ENABLE_SQL,
 )
-TELEMETRY.setup_tracing()

{flock_core-0.2.14 → flock_core-0.2.16}/src/flock/core/execution/local_executor.py

@@ -1,12 +1,16 @@
 # src/your_package/core/execution/local_executor.py
 from flock.core.context.context import FlockContext
 from flock.core.logging.logging import get_logger
-from flock.workflow.activities import run_agent  # This should be the local activity function
+from flock.workflow.activities import (
+    run_agent,  # This should be the local activity function
+)
 
 logger = get_logger("flock")
 
 
-async def run_local_workflow(context: FlockContext, output_formatter, box_result: bool = True) -> dict:
+async def run_local_workflow(
+    context: FlockContext, box_result: bool = True
+) -> dict:
     """Execute the agent workflow locally (for debugging).
 
     Args:
@@ -18,7 +22,7 @@ async def run_local_workflow(context: FlockContext, output_formatter, box_result
         A dictionary containing the workflow result.
     """
     logger.info("Running local debug workflow")
-    result = await run_agent(context, output_formatter)
+    result = await run_agent(context)
     if box_result:
         from box import Box
 

{flock_core-0.2.14 → flock_core-0.2.16}/src/flock/core/execution/temporal_executor.py

@@ -1,9 +1,7 @@
 # src/your_package/core/execution/temporal_executor.py
-from devtools import pprint
 
 from flock.core.context.context import FlockContext
 from flock.core.context.context_vars import FLOCK_RUN_ID
-from flock.core.logging.formatters.formatter_factory import FormatterFactory
 from flock.core.logging.logging import get_logger
 from flock.workflow.activities import (
     run_agent,  # Activity function used in Temporal
@@ -16,7 +14,6 @@ logger = get_logger("flock")
 
 async def run_temporal_workflow(
     context: FlockContext,
-    output_formatter,
     box_result: bool = True,
 ) -> dict:
     """Execute the agent workflow via Temporal for robust, distributed processing.
@@ -43,11 +40,7 @@ async def run_temporal_workflow(
 
     agent_name = context.get_variable("FLOCK_CURRENT_AGENT")
     logger.debug("Formatting Temporal result", agent=agent_name)
-    if output_formatter:
-        formatter = FormatterFactory.create_formatter(output_formatter)
-        formatter.display(result, agent_name, output_formatter.wait_for_input)
-    else:
-        pprint(result)
+
     if box_result:
         from box import Box
 

{flock_core-0.2.14 → flock_core-0.2.16}/src/flock/core/flock.py

@@ -10,13 +10,12 @@ import cloudpickle
 from opentelemetry import trace
 from opentelemetry.baggage import get_baggage, set_baggage
 
+from flock.config import 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_agent import FlockAgent
-from flock.core.logging.formatters.base_formatter import FormatterOptions
-from flock.core.logging.formatters.pprint_formatter import PrettyPrintFormatter
 from flock.core.logging.logging import get_logger
 from flock.core.registry.agent_registry import Registry
 from flock.core.util.cli_helper import display_banner
@@ -24,7 +23,7 @@ from flock.core.util.input_resolver import top_level_to_keys
 
 T = TypeVar("T", bound=FlockAgent)
 logger = get_logger("flock")
-
+TELEMETRY.setup_tracing()
 tracer = trace.get_tracer(__name__)
 
 
@@ -40,9 +39,6 @@ class Flock:
         model: str = "openai/gpt-4o",
         local_debug: bool = False,
         enable_logging: bool = False,
-        output_formatter: FormatterOptions = FormatterOptions(
-            PrettyPrintFormatter
-        ),
         show_cli_banner: bool = True,
     ):
         """Initialize the Flock orchestrator.
@@ -57,9 +53,6 @@ class Flock:
             span.set_attribute("model", model)
             span.set_attribute("local_debug", local_debug)
             span.set_attribute("enable_logging", enable_logging)
-            span.set_attribute(
-                "output_formatter", output_formatter.formatter.__name__
-            )
             logger.info(
                 "Initializing Flock",
                 model=model,
@@ -80,7 +73,6 @@ class Flock:
             self.context = FlockContext()
             self.model = model
             self.local_debug = local_debug
-            self.output_formatter = output_formatter
             self.start_agent: FlockAgent | str | None = None
             self.input: dict = {}
 
@@ -410,13 +402,9 @@ class Flock:
                 )
 
                 if self.local_debug:
-                    return await run_local_workflow(
-                        self.context, self.output_formatter, box_result
-                    )
+                    return await run_local_workflow(self.context, box_result)
                 else:
-                    return await run_temporal_workflow(
-                        self.context, self.output_formatter, box_result
-                    )
+                    return await run_temporal_workflow(self.context, box_result)
             except Exception as e:
                 logger.exception("Execution failed", error=str(e))
                 raise

{flock_core-0.2.14 → flock_core-0.2.16}/src/flock/core/flock_agent.py

@@ -12,6 +12,10 @@ import cloudpickle
 from pydantic import BaseModel, Field
 
 from flock.core.context.context import FlockContext
+from flock.core.logging.formatters.themed_formatter import (
+    ThemedAgentResultFormatter,
+)
+from flock.core.logging.formatters.themes import OutputTheme
 from flock.core.logging.logging import get_logger
 from flock.core.mixin.dspy_integration import AgentType, DSPyIntegrationMixin
 from flock.core.mixin.prompt_parser import PromptParserMixin
@@ -48,6 +52,25 @@ class FlockAgentConfig:
     )
 
 
+@dataclass
+class FlockAgentOutputConfig:
+    """Configuration options for a FlockAgent."""
+
+    render_table: bool = field(
+        default=False, metadata={"description": "Renders a table."}
+    )
+    theme: OutputTheme = field(  # type: ignore
+        default=OutputTheme.afterglow,
+        metadata={"description": "Disables the agent's output."},
+    )
+    max_length: int = field(
+        default=1000, metadata={"description": "Disables the agent's output."}
+    )
+    wait_for_input: bool = field(
+        default=False, metadata={"description": "Wait for input."}
+    )
+
+
 @dataclass
 class HandOff:
     """Base class for handoff returns."""
@@ -136,8 +159,8 @@ class FlockAgent(BaseModel, ABC, PromptParserMixin, DSPyIntegrationMixin):
     """
 
     name: str = Field(..., description="Unique identifier for the agent.")
-    model: str = Field(
-        "openai/gpt-4o", description="The model to use (e.g., 'openai/gpt-4o')."
+    model: str | None = Field(
+        None, description="The model to use (e.g., 'openai/gpt-4o')."
     )
     description: str | Callable[..., str] = Field(
         "", description="A human-readable description of the agent."
@@ -186,6 +209,11 @@ class FlockAgent(BaseModel, ABC, PromptParserMixin, DSPyIntegrationMixin):
         description="Configuration options for the agent, such as serialization settings.",
     )
 
+    output_config: FlockAgentOutputConfig = Field(
+        default_factory=FlockAgentOutputConfig,
+        description="Configuration options for the agent's output.",
+    )
+
     # Lifecycle callback fields: if provided, these callbacks are used instead of overriding the methods.
     initialize_callback: Callable[[dict[str, Any]], Awaitable[None]] | None = (
         Field(
@@ -414,6 +442,7 @@ class FlockAgent(BaseModel, ABC, PromptParserMixin, DSPyIntegrationMixin):
             try:
                 await self.initialize(inputs)
                 result = await self.evaluate(inputs)
+                self.display_output(result)
                 await self.terminate(inputs, result)
                 span.set_attribute("result", str(result))
                 logger.info("Agent run completed", agent=self.name)
@@ -426,6 +455,18 @@ class FlockAgent(BaseModel, ABC, PromptParserMixin, DSPyIntegrationMixin):
                 span.record_exception(run_error)
                 raise
 
+    def display_info(self) -> None:
+        pass
+
+    def display_output(self, result: dict[str, Any]) -> None:
+        """Display the agent's output using the configured output formatter."""
+        ThemedAgentResultFormatter(
+            self.output_config.theme,
+            self.output_config.max_length,
+            self.output_config.render_table,
+            self.output_config.wait_for_input,
+        ).display_result(result, self.name)
+
     async def run_temporal(self, inputs: dict[str, Any]) -> dict[str, Any]:
         """Execute this agent via a Temporal workflow for enhanced fault tolerance and asynchronous processing.
 

flock_core-0.2.16/src/flock/core/logging/formatters/enum_builder.py

@@ -0,0 +1,38 @@
+"""Enum Builder."""
+
+import os
+import pathlib
+import re
+
+theme_folder = pathlib.Path(__file__).parent.parent.parent.parent / "themes"
+
+if not theme_folder.exists():
+    raise FileNotFoundError(f"Theme folder not found: {theme_folder}")
+
+theme_files = [
+    pathlib.Path(f.path).stem for f in os.scandir(theme_folder) if f.is_file()
+]
+
+theme_enum_entries = {}
+for theme in theme_files:
+    safe_name = (
+        theme.replace("-", "_")
+        .replace(" ", "_")
+        .replace("(", "_")
+        .replace(")", "_")
+        .replace("+", "_")
+        .replace(".", "_")
+    )
+
+    if re.match(r"^\d", safe_name):
+        safe_name = f"_{safe_name}"
+
+    theme_enum_entries[safe_name] = theme
+
+with open("theme_enum.py", "w") as f:
+    f.write("from enum import Enum\n\n")
+    f.write("class OutputOptionsTheme(Enum):\n")
+    for safe_name, original_name in theme_enum_entries.items():
+        f.write(f'    {safe_name} = "{original_name}"\n')
+
+print("Generated theme_enum.py ✅")

{flock_core-0.2.14 → flock_core-0.2.16}/src/flock/core/logging/formatters/theme_builder.py

@@ -371,7 +371,7 @@ def save_theme(theme: dict, filename: pathlib.Path) -> None:
 # --- Main Interactive Loop --- #
 
 
-def main():
+def theme_builder():
     console = Console(force_terminal=True, color_system="truecolor")
     themes_dir = pathlib.Path(__file__).parent.parent.parent.parent / "themes"
     theme_files = load_theme_files(themes_dir)
@@ -458,7 +458,7 @@ def main():
     )
     if sel2.lower() == "r":
         console.print("Regenerating samples...")
-        main()  # restart the builder
+        theme_builder()  # restart the builder
         return
     try:
         sel2 = int(sel2)
@@ -474,7 +474,3 @@ def main():
     save_path = themes_dir / filename
     save_theme(chosen_sample_theme, save_path)
     console.print(f"\n[green]Theme saved as {save_path}.[/green]")
-
-
-if __name__ == "__main__":
-    main()