flock-core 0.2.13__tar.gz → 0.2.15__tar.gz

{flock_core-0.2.13 → flock_core-0.2.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.2.13
+Version: 0.2.15
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -24,6 +24,7 @@ Requires-Dist: opentelemetry-sdk>=1.30.0
 Requires-Dist: pydantic>=2.10.5
 Requires-Dist: python-box>=7.3.2
 Requires-Dist: python-decouple>=3.8
+Requires-Dist: questionary>=2.1.0
 Requires-Dist: rich>=13.9.4
 Requires-Dist: temporalio>=1.9.0
 Requires-Dist: toml>=0.10.2

{flock_core-0.2.13 → flock_core-0.2.15}/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.13 → flock_core-0.2.15}/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.13 → flock_core-0.2.15}/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.13 → flock_core-0.2.15}/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.13 → flock_core-0.2.15}/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.13 → flock_core-0.2.15}/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.15/examples/02_cook_book/save_and_load/load_01.py

@@ -0,0 +1,14 @@
+
+
+from flock.core import FlockAgent
+from flock.core.logging.formatters.pprint_formatter import PrettyPrintFormatter
+
+
+loaded_bloggy = FlockAgent.load_from_file("examples/data/bloggy.json")
+
+result = loaded_bloggy.run(inputs={"blog_idea": "Idea for a blog post."})
+PrettyPrintFormatter().display_data(result)
+
+
+
+

flock_core-0.2.15/examples/02_cook_book/save_and_load/load_02.py

@@ -0,0 +1,27 @@
+from typing import Any, Dict
+from flock.core import FlockAgent
+from flock.core.logging.formatters.pprint_formatter import PrettyPrintFormatter
+
+# Load agents with custom logic - Everything passed to the constructor is loaded
+custom_bloggy = FlockAgent.load_from_file("examples/data/custom_bloggy.json")
+
+result = custom_bloggy.run(inputs={"blog_idea": "Idea for a blog post."})
+PrettyPrintFormatter().display_data(result)
+
+# Inherited FlockAgents have to load from their own class
+# so that the custom logic is loaded as well.
+# this won't work:
+inherited_agent = FlockAgent.load_from_file("examples/data/inherited_bloggy.json")
+
+result = inherited_agent.run(inputs={"blog_idea": "This will fail"})
+PrettyPrintFormatter().display_data(result)
+
+# this will work:
+class MyInheritedAgent(FlockAgent):
+    async def evaluate(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        return {"result": "Hello, world!"}
+
+inherited_agent = MyInheritedAgent.load_from_file("examples/data/inherited_bloggy.json")
+
+result = inherited_agent.run(inputs={"blog_idea": "Idea for a blog post."})
+PrettyPrintFormatter().display_data(result)

flock_core-0.2.15/examples/02_cook_book/save_and_load/load_03.py

@@ -0,0 +1,10 @@
+
+
+from flock.core import FlockAgent
+from flock.core.logging.formatters.pprint_formatter import PrettyPrintFormatter
+
+# chatty is a rather compley agent. no problem for Flock to load it.
+loaded_bloggy = FlockAgent.load_from_file("examples/data/chatty.json")
+
+result = loaded_bloggy.run(inputs={})
+PrettyPrintFormatter().display_data(result)

flock_core-0.2.15/examples/02_cook_book/save_and_load/load_04.py

@@ -0,0 +1,9 @@
+
+
+from flock.core.flock import Flock
+
+
+flock = Flock.load_from_file("flock.json")
+agent = flock.agents
+
+flock.run(start_agent=agent["bloggy"], input={"blog_idea": "A blog about cats"})

flock_core-0.2.15/examples/02_cook_book/save_and_load/save_01.py

@@ -0,0 +1,13 @@
+
+
+from typing import Any, Dict, Type
+from flock.core import FlockAgent
+from flock.core.logging.formatters.pprint_formatter import PrettyPrintFormatter
+
+
+# Save and load agents
+
+bloggy = FlockAgent(name="bloggy", input="blog_idea", output="funny_blog_title, blog_headers") 
+bloggy.save_to_file("examples/data/bloggy.json")
+
+

flock_core-0.2.15/examples/02_cook_book/save_and_load/save_02.py

@@ -0,0 +1,30 @@
+
+
+from typing import Any, Dict, Type
+from flock.core import FlockAgent
+from flock.core.logging.formatters.pprint_formatter import PrettyPrintFormatter
+
+
+# Save and load agents with custom logic
+
+async def evaluate(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+    return {"result": "Hello, world!"}
+    
+async def on_terminate(agent,input,output):
+    print(f"Agent {agent.name} has been terminated.")
+    
+custom_bloggy = FlockAgent(name="custom_bloggy", 
+                              input="blog_idea", 
+                              output="result", 
+                              terminate_callback=on_terminate,
+                              evaluate_callback=evaluate)
+custom_bloggy.save_to_file("examples/data/custom_bloggy.json")
+
+
+class MyInheritedAgent(FlockAgent):
+    async def evaluate(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        return {"result": "Hello, world!"}
+    
+inherited_agent = MyInheritedAgent(name="inherited_bloggy")
+inherited_agent.save_to_file("examples/data/inherited_bloggy.json")
+

flock_core-0.2.15/examples/02_cook_book/save_and_load/save_03.py

@@ -0,0 +1,40 @@
+"""
+Title: Building Your First Flock Agent
+
+In this example, we'll walk you through creating and running a simple Flock system with a single agent.
+Flock enables you to build LLM-powered agents by simply declaring what data each agent receives and what it
+produces—no more tedious prompt engineering!
+
+What you'll learn:
+  - How to set up the Flock model (using litellm; check out https://docs.litellm.ai/docs/providers for valid model IDs).
+  - How to create a Flock instance that serves as the central orchestrator and context holder.
+  - How to define a simple agent (named "bloggy") by declaring its input and output.
+  - How to add the agent to your Flock.
+  - How to run the agent workflow asynchronously in local debug mode (without needing Temporal).
+
+The "bloggy" agent in this example is designed to take a blog idea as input and generate a funny blog title
+along with a list of blog headers as output.
+
+Let's get started!
+"""
+
+import asyncio
+
+from flock.core.flock import Flock
+from flock.core.flock_agent import FlockAgent
+
+
+MODEL = "openai/gpt-4o"
+
+flock = Flock(model=MODEL, local_debug=True)
+
+
+bloggy = FlockAgent(
+    name="bloggy", 
+    input="blog_idea", 
+    output="funny_blog_title, blog_headers"
+)
+flock.add_agent(bloggy)
+
+flock.save_to_file("examples/data/flock.json")
+

{flock_core-0.2.13 → flock_core-0.2.15}/examples/02_cook_book/self_improvement.py

@@ -75,6 +75,14 @@ class Chat:
         if self.user_query.lower() == "goodbye":
             return None
         return HandOff(next_agent="chatty")
+    
+    
+def optimize_memory(optimized_memory:str):
+    try:
+        with open("memory.txt", "w") as file:
+            file.write(optimized_memory)
+    except FileNotFoundError:
+        pass
 
 
 MODEL = "openai/gpt-4o"
@@ -87,18 +95,29 @@ async def main():
 
     chatty = FlockAgent(
         name="chatty", 
-        description=f"You are Chatty, a friendly assistant that loves to chat. Today is {datetime.now().strftime('%A, %B %d, %Y')}",
+        description=f"""You are Chatty, a friendly assistant that loves to chat. 
+                    Today is {datetime.now().strftime('%A, %B %d, %Y')}.
+                    Use web_search_duckduckgo to search the web, 
+                    +get_web_content_as_markdown to get web content as markdown, 
+                    and code_eval for all tasks that require code execution.
+                    Save knowledge to memory for future reference.
+                    Once in a while optimize your knowledge by calling the optimize_memory tool 
+                    with the optimized memory as input.
+                    """,
         input="user_query, memory | Memory of previous interactions, chat_history | the current chat history", 
         output="answer_to_query, important_new_knowledge_to_add_to_memory | Empty string if no knowledge to add",
         initialize_callback=chat_helper.before_response,
         terminate_callback=chat_helper.after_response,
         config=FlockAgentConfig(disable_output=True),
-        tools=[basic_tools.web_search_tavily],
+        tools=[basic_tools.web_search_duckduckgo, 
+               basic_tools.get_web_content_as_markdown, 
+               basic_tools.code_eval,optimize_memory],
     )
+    
     flock.add_agent(chatty)
 
     chatty.hand_off = chat_helper.hand_off
-   
+
     await flock.run_async(
         start_agent=chatty, 
         input={"memory": "","user_query": "","chat_history": ""}

{flock_core-0.2.13 → flock_core-0.2.15}/examples/03_misc_wip/logging_examples/02_temporal_logging.py

@@ -13,7 +13,7 @@ from flock.core.logging import flock_logger, live_update_handler, performance_ha
 class TemporalLoggingAgent(FlockAgent):
     """Demo agent that showcases logging with Temporal integration."""
 
-    async def run(self, context: FlockContext) -> dict:
+    async def run_async(self, context: FlockContext) -> dict:
         workflow_id = context.state.get("workflow_id", "temporal-demo")
         flock_logger.set_context(workflow_id=workflow_id)
 
@@ -97,7 +97,7 @@ async def main():
             agent = TemporalLoggingAgent(name="local-demo", model="demo-model")
             context = FlockContext()
             context.state["workflow_id"] = workflow_id
-            await agent.run(context)
+            await agent.run_async(context)
         else:
             # Let our error handler format other errors beautifully
             raise

{flock_core-0.2.13 → flock_core-0.2.15}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flock-core"
-version = "0.2.13"
+version = "0.2.15"
 description = "Declarative LLM Orchestration at Scale"
 readme = "README.md"
 authors = [
@@ -29,6 +29,7 @@ dependencies = [
     "pydantic>=2.10.5",
     "python-box>=7.3.2",
     "python-decouple>=3.8",
+    "questionary>=2.1.0",
     "rich>=13.9.4",
     "temporalio>=1.9.0",
     "toml>=0.10.2",

flock_core-0.2.15/src/flock/__init__.py

@@ -0,0 +1,57 @@
+"""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."""
+    import questionary
+    from rich.console import Console
+
+    from flock.cli.constants import (
+        CLI_CREATE_AGENT,
+        CLI_CREATE_FLOCK,
+        CLI_LOAD_AGENT,
+        CLI_LOAD_EXAMPLE,
+        CLI_LOAD_FLOCK,
+        CLI_SETTINGS,
+        CLI_START_ADVANCED_MODE,
+        CLI_START_WEB_SERVER,
+    )
+    from flock.cli.load_flock import load_flock
+    from flock.core.util.cli_helper import display_banner
+
+    console = Console()
+
+    display_banner()
+
+    console.print("Flock Management Console\n", style="bold green")
+
+    result = questionary.select(
+        "What do you want to do?",
+        choices=[
+            questionary.Separator(line=" "),
+            # CLI_CREATE_AGENT,
+            # CLI_CREATE_FLOCK,
+            # CLI_LOAD_AGENT,
+            CLI_LOAD_FLOCK,
+            # CLI_LOAD_EXAMPLE,
+            questionary.Separator(),
+            CLI_THEME_BUILDER,
+            CLI_SETTINGS,
+            questionary.Separator(),
+            CLI_START_ADVANCED_MODE,
+            CLI_START_WEB_SERVER,
+            "Exit",
+        ],
+    ).ask()
+
+    if result == CLI_LOAD_FLOCK:
+        load_flock()
+    if result == CLI_THEME_BUILDER:
+        theme_builder()
+
+
+if __name__ == "__main__":
+    main()

flock_core-0.2.15/src/flock/cli/constants.py

@@ -0,0 +1,23 @@
+"""Constants for the CLI module."""
+
+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)"
+CLI_START_WEB_SERVER = "Start web server (coming soon)"
+CLI_EXIT = "Exit"
+CLI_CHOICES = [
+    CLI_CREATE_AGENT,
+    CLI_CREATE_FLOCK,
+    CLI_LOAD_AGENT,
+    CLI_LOAD_FLOCK,
+    CLI_LOAD_EXAMPLE,
+    CLI_SETTINGS,
+    CLI_START_ADVANCED_MODE,
+    CLI_START_WEB_SERVER,
+    CLI_EXIT,
+]

flock_core-0.2.15/src/flock/cli/create_agent.py

@@ -0,0 +1 @@
+# TODO

flock_core-0.2.15/src/flock/cli/create_flock.py

@@ -0,0 +1 @@
+# TODO

flock_core-0.2.15/src/flock/cli/load_agent.py

@@ -0,0 +1 @@
+# TODO

flock_core-0.2.15/src/flock/cli/load_examples.py

@@ -0,0 +1 @@
+# TODO

flock_core-0.2.15/src/flock/cli/load_flock.py

@@ -0,0 +1,38 @@
+"""Load a Flock from a file."""
+
+from pathlib import Path
+
+import questionary
+from rich.console import Console
+from rich.markdown import Markdown
+
+from flock.core.flock import Flock
+
+
+def filter(file_path) -> bool:
+    """Filter function for file selection."""
+    path = Path(file_path)
+    if path.is_dir():
+        return True
+    return path.is_file() and path.suffix == ".flock"
+
+
+def load_flock():
+    """Load a Flock from a file."""
+    console = Console()
+
+    console.print("\nPlease select a *.flock file\n", style="bold green")
+
+    result = questionary.path("", file_filter=filter).ask()
+
+    selected_file = Path(result)
+    if selected_file.is_file():
+        console.print(f"Selected file: {selected_file}", style="bold green")
+
+        flock = Flock.load_from_file(result)
+
+        console.line()
+        console.print(Markdown("# Flock loaded...."), style="bold orange")
+        console.line()
+
+        flock.run()

flock_core-0.2.15/src/flock/cli/settings.py

@@ -0,0 +1 @@
+# TODO

{flock_core-0.2.13 → flock_core-0.2.15}/src/flock/config.py

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

{flock_core-0.2.13 → flock_core-0.2.15}/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.13 → flock_core-0.2.15}/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