flock-core 0.5.0b28__py3-none-any.whl → 0.5.56b0__py3-none-any.whl

flock/examples.py

@@ -0,0 +1,128 @@
+"""Concrete demo wiring matching the design document."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+if __name__ == "__main__" and __package__ is None:
+    sys.path.append(str(Path(__file__).resolve().parents[2]))
+
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, Field
+
+from flock.artifacts import Artifact
+from flock.components import EngineComponent
+from flock.orchestrator import Flock
+from flock.registry import flock_tool, flock_type, type_registry
+from flock.runtime import EvalInputs, EvalResult
+from flock.utilities import LoggingUtility, MetricsUtility
+
+
+if TYPE_CHECKING:
+    from flock.agent import AgentBuilder
+
+
+@flock_type
+class Idea(BaseModel):
+    topic: str
+    genre: str
+
+
+@flock_type
+class Movie(BaseModel):
+    fun_title: str = Field(description="Fun title in CAPS")
+    runtime: int = Field(ge=60, le=400)
+    synopsis: str
+
+
+@flock_type
+class Tagline(BaseModel):
+    line: str
+
+
+@flock_tool
+def announce(tagline: Tagline) -> dict[str, str]:
+    return {"announced": tagline.line}
+
+
+class MovieEngine(EngineComponent):
+    async def evaluate(self, agent, ctx, inputs: EvalInputs) -> EvalResult:
+        idea = Idea(**inputs.artifacts[0].payload)
+        synopsis = f"{idea.topic} told as a {idea.genre} adventure."
+        movie = Movie(fun_title=idea.topic.upper(), runtime=120, synopsis=synopsis)
+        artifact = Artifact(
+            type=type_registry.name_for(Movie),
+            payload=movie.model_dump(),
+            produced_by=agent.name,
+        )
+        return EvalResult(artifacts=[artifact])
+
+
+class TaglineEngine(EngineComponent):
+    async def evaluate(self, agent, ctx, inputs: EvalInputs) -> EvalResult:
+        movie = Movie(**inputs.artifacts[0].payload)
+        tagline = Tagline(line=f"Don't miss {movie.fun_title}!")
+        artifact = Artifact(
+            type=type_registry.name_for(Tagline),
+            payload=tagline.model_dump(),
+            produced_by=agent.name,
+        )
+        return EvalResult(artifacts=[artifact])
+
+
+def create_demo_orchestrator(
+    model: str | None = None,
+) -> tuple[Flock, dict[str, AgentBuilder]]:
+    orchestrator = Flock(model)
+
+    movie = (
+        orchestrator.agent("movie")
+        .description("Generate a movie concept.")
+        .consumes(Idea)
+        .publishes(Movie)
+        .only_for("tagline", "presenter")
+        .with_utilities(MetricsUtility(), LoggingUtility())
+        .with_engines(MovieEngine())
+    )
+
+    tagline = (
+        orchestrator.agent("tagline")
+        .description("Generate a tagline.")
+        .consumes(Movie, where=lambda m: 60 <= m.runtime <= 200, from_agents={"movie"})
+        .publishes(Tagline)
+        .with_engines(TaglineEngine())
+    )
+
+    presenter = (
+        orchestrator.agent("presenter")
+        .description("Announce the winner.")
+        .consumes(Tagline, mode="both")
+        .calls(announce)
+    )
+
+    return orchestrator, {"movie": movie, "tagline": tagline, "presenter": presenter}
+
+
+__all__ = [
+    "Idea",
+    "Movie",
+    "Tagline",
+    "announce",
+    "create_demo_orchestrator",
+]
+
+if __name__ == "__main__":
+    import asyncio
+
+    async def _demo_run() -> None:
+        orchestrator, agents = create_demo_orchestrator()
+        idea = Idea(topic="AI agents collaborating", genre="comedy")
+        outputs = await orchestrator.arun(agents["movie"], idea)
+        await orchestrator.run_until_idle()
+        for artifact in outputs:
+            print(f"{artifact.type}: {artifact.payload}")
+
+    asyncio.run(_demo_run())

flock/{core/util → helper}/cli_helper.py

@@ -1,7 +1,8 @@
 from importlib.metadata import PackageNotFoundError, version
 
+
 try:
-    __version__ = version("flock-core")
+    __version__ = version("flock-flow")
 except PackageNotFoundError:
     __version__ = "0.2.0"
 
@@ -51,7 +52,7 @@ def init_console(clear_screen: bool = True, show_banner: bool = True, model: str
 │ ▒█▀▀▀ █░░ █▀▀█ █▀▀ █░█ │
 │ ▒█▀▀▀ █░░ █░░█ █░░ █▀▄ │
 │ ▒█░░░ ▀▀▀ ▀▀▀▀ ▀▀▀ ▀░▀ │
-╰━━━━━━━━v{__version__}━━━━━━━╯
+╰━━━━━━━━v{__version__}━━━━━━━━━╯
 🦆     🐤    🐧     🐓
 """,
         justify="center",
@@ -63,7 +64,7 @@ def init_console(clear_screen: bool = True, show_banner: bool = True, model: str
     if show_banner:
         console.print(banner_text)
         console.print(
-            "[italic]'Kea'[/] milestone - [bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n"
+            "[italic]'Raven'[/] milestone - [bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n"
         )
 
     if model:

flock/{core/logging → logging}/__init__.py

@@ -1,6 +1,5 @@
 """Flock logging system with Rich integration and structured logging support."""
 
-from .logging import configure_logging
-
-__all__ = ["configure_logging"]
+# from flock.logging import configure_logging
 
+# __all__ = ["configure_logging"]

flock/{core/logging → logging}/formatters/enum_builder.py

@@ -4,14 +4,13 @@ import os
 import pathlib
 import re
 
-theme_folder = pathlib.Path(__file__).parent.parent.parent.parent / "themes"
+
+theme_folder = pathlib.Path(__file__).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_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:

flock/{core/logging → logging}/formatters/theme_builder.py

@@ -153,9 +153,7 @@ def generate_default_rich_block(theme: dict | None = None) -> dict[str, Any]:
         ),
         "panel_padding": random.choice([[1, 2], [1, 1], [2, 2], [0, 2]]),
         "panel_title_align": random.choice(["left", "center", "right"]),
-        "table_row_styles": random.choice(
-            [["", "dim"], ["", "italic"], ["", "underline"]]
-        ),
+        "table_row_styles": random.choice([["", "dim"], ["", "italic"], ["", "underline"]]),
     }
     # Extra table layout properties (non-content).
     default_extra_table_props = {
@@ -175,13 +173,12 @@ def generate_default_rich_block(theme: dict | None = None) -> dict[str, Any]:
         "table_caption_justify": "center",
         "table_highlight": False,
     }
-    defaults = {
+    return {
         **default_color_props,
         **extra_color_props,
         **default_non_color_props,
         **default_extra_table_props,
     }
-    return defaults
 
 
 def load_theme_from_file(filepath: str) -> dict:
@@ -207,9 +204,7 @@ def get_default_styles(theme: dict | None) -> dict[str, Any]:
     else:
         defaults = generate_default_rich_block(theme)
         rich_props = theme.get("rich", {})
-        final_styles = {
-            key: rich_props.get(key, defaults[key]) for key in defaults
-        }
+        final_styles = {key: rich_props.get(key, defaults[key]) for key in defaults}
     # Ensure tuple for padding properties.
     final_styles["panel_padding"] = tuple(final_styles["panel_padding"])
     if "table_padding" in final_styles:
@@ -272,33 +267,23 @@ def create_rich_renderable(
         table.add_column("Key", style=styles["column_output"])
         table.add_column("Value", style=styles["column_value"])
         for k, v in value.items():
-            table.add_row(
-                str(k), create_rich_renderable(v, level + 1, theme, styles)
-            )
+            table.add_row(str(k), create_rich_renderable(v, level + 1, theme, styles))
         return table
 
-    elif isinstance(value, (list, tuple)):
+    if isinstance(value, (list, tuple)):
         if all(isinstance(item, dict) for item in value):
             sub_tables = []
             for i, item in enumerate(value):
                 sub_tables.append(f"[bold]Item {i + 1}[/bold]")
-                sub_tables.append(
-                    create_rich_renderable(item, level + 1, theme, styles)
-                )
+                sub_tables.append(create_rich_renderable(item, level + 1, theme, styles))
             return Group(*sub_tables)
-        else:
-            rendered_items = [
-                create_rich_renderable(item, level + 1, theme, styles)
-                for item in value
-            ]
-            if all(isinstance(item, str) for item in rendered_items):
-                return "\n".join(rendered_items)
-            else:
-                return Group(*rendered_items)
-    else:
-        if isinstance(value, str) and "\n" in value:
-            return f"\n{value}\n"
-        return str(value)
+        rendered_items = [create_rich_renderable(item, level + 1, theme, styles) for item in value]
+        if all(isinstance(item, str) for item in rendered_items):
+            return "\n".join(rendered_items)
+        return Group(*rendered_items)
+    if isinstance(value, str) and "\n" in value:
+        return f"\n{value}\n"
+    return str(value)
 
 
 # --- Theme Builder Functions --- #
@@ -312,9 +297,7 @@ def load_theme_files(theme_dir: pathlib.Path) -> list[pathlib.Path]:
 def display_color_palette(theme: dict) -> None:
     """Display the color palette from a theme's [colors] sections with a color preview."""
     console = Console()
-    palette_table = Table(
-        title="Color Palette", show_header=True, header_style="bold"
-    )
+    palette_table = Table(title="Color Palette", show_header=True, header_style="bold")
     palette_table.add_column("Section", style="bold")
     palette_table.add_column("Key", style="italic")
     palette_table.add_column("Value", style="bold")
@@ -331,9 +314,7 @@ def display_color_palette(theme: dict) -> None:
     console.print(palette_table)
 
 
-def generate_sample_rich_blocks(
-    chosen_theme: dict, count: int
-) -> list[dict[str, Any]]:
+def generate_sample_rich_blocks(chosen_theme: dict, count: int) -> list[dict[str, Any]]:
     """Generate a list of sample rich blocks (randomized layout) using the chosen theme's colors."""
     samples = []
     for _ in range(count):
@@ -349,9 +330,7 @@ def generate_sample_table(sample_theme: dict, dummy_data: dict) -> Panel:
     # For simplicity, we create our own panel.
     styles = get_default_styles(sample_theme)
     # Build a basic table (using our earlier functions)
-    table = create_rich_renderable(
-        dummy_data, theme=sample_theme, styles=styles
-    )
+    table = create_rich_renderable(dummy_data, theme=sample_theme, styles=styles)
     return Panel(
         table,
         title="Sample Table",
@@ -373,7 +352,7 @@ def save_theme(theme: dict, filename: pathlib.Path) -> None:
 
 def theme_builder():
     console = Console(force_terminal=True, color_system="truecolor")
-    themes_dir = pathlib.Path(__file__).parent.parent.parent.parent / "themes"
+    themes_dir = pathlib.Path(__file__).parent.parent.parent / "themes"
     theme_files = load_theme_files(themes_dir)
 
     if not theme_files:
@@ -443,9 +422,7 @@ def theme_builder():
     samples = []
     for i, rich_block in enumerate(sample_rich_blocks):
         # Build a sample theme: copy the chosen theme and override its [rich] block.
-        sample_theme = dict(
-            chosen_theme
-        )  # shallow copy (good enough if colors remain unchanged)
+        sample_theme = dict(chosen_theme)  # shallow copy (good enough if colors remain unchanged)
         sample_theme["rich"] = rich_block
         sample_table = generate_sample_table(sample_theme, dummy_data)
         samples.append((sample_theme, sample_table))
@@ -468,9 +445,7 @@ def theme_builder():
         return
 
     # Ask for file name to save the chosen theme.
-    filename = console.input(
-        "\nEnter a filename to save the chosen theme (e.g. mytheme.toml): "
-    )
+    filename = console.input("\nEnter a filename to save the chosen theme (e.g. mytheme.toml): ")
     save_path = themes_dir / filename
     save_theme(chosen_sample_theme, save_path)
     console.print(f"\n[green]Theme saved as {save_path}.[/green]")

flock/{core/logging → logging}/formatters/themed_formatter.py

@@ -5,21 +5,21 @@ import random
 import re
 from typing import Any
 
-from temporalio import workflow
-
-from flock.core.logging.formatters.themes import OutputTheme
+import toml  # install with: pip install toml
+from pydantic import BaseModel
 
-with workflow.unsafe.imports_passed_through():
-    from pygments.style import Style
-    from pygments.token import Token
-    from rich import box
-    from rich.console import Console, Group
-    from rich.panel import Panel
-    from rich.syntax import PygmentsSyntaxTheme, Syntax
-    from rich.table import Table
-    from rich.theme import Theme
+# with workflow.unsafe.imports_passed_through():
+from pygments.style import Style
+from pygments.token import Token
+from rich import box
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.syntax import PygmentsSyntaxTheme, Syntax
+from rich.table import Table
+from rich.theme import Theme
 
-import toml  # install with: pip install toml
+# from temporalio import workflow
+from flock.logging.formatters.themes import OutputTheme
 
 
 def resolve_style_string(style_str: str, theme: dict) -> str:
@@ -76,18 +76,10 @@ def generate_default_rich_block(theme: dict | None = None) -> dict[str, Any]:
         cursor_cursor = theme["colors"]["cursor"].get("cursor", "#d0d0d0")
         cursor_text = theme["colors"]["cursor"].get("text", "#151515")
 
-        primary_background = theme["colors"]["primary"].get(
-            "background", "#161719"
-        )
-        primary_foreground = theme["colors"]["primary"].get(
-            "foreground", "#c5c8c6"
-        )
-        selection_background = theme["colors"]["selection"].get(
-            "background", "#444444"
-        )
-        selection_text = theme["colors"]["selection"].get(
-            "text", primary_foreground
-        )
+        primary_background = theme["colors"]["primary"].get("background", "#161719")
+        primary_foreground = theme["colors"]["primary"].get("foreground", "#c5c8c6")
+        selection_background = theme["colors"]["selection"].get("background", "#444444")
+        selection_text = theme["colors"]["selection"].get("text", primary_foreground)
     else:
         bright_black = "black"
         bright_blue = "blue"
@@ -155,9 +147,7 @@ def generate_default_rich_block(theme: dict | None = None) -> dict[str, Any]:
         "panel_padding": random.choice([[1, 2], [1, 1], [2, 2], [0, 2]]),
         "panel_title_align": random.choice(["left", "center", "right"]),
         # Add table_row_styles property.
-        "table_row_styles": random.choice(
-            [["", "dim"], ["", "italic"], ["", "underline"]]
-        ),
+        "table_row_styles": random.choice([["", "dim"], ["", "italic"], ["", "underline"]]),
     }
     # Extra table layout properties (non content properties).
     default_extra_table_props = {
@@ -178,13 +168,12 @@ def generate_default_rich_block(theme: dict | None = None) -> dict[str, Any]:
         "table_highlight": False,
     }
     # Combine all defaults.
-    defaults = {
+    return {
         **default_color_props,
         **extra_color_props,
         **default_non_color_props,
         **default_extra_table_props,
     }
-    return defaults
 
 
 def load_theme_from_file(filepath: str) -> dict:
@@ -221,9 +210,7 @@ def get_default_styles(theme: dict | None) -> dict[str, Any]:
     else:
         defaults = generate_default_rich_block(theme)
         rich_props = theme.get("rich", {})
-        final_styles = {
-            key: rich_props.get(key, defaults[key]) for key in defaults
-        }
+        final_styles = {key: rich_props.get(key, defaults[key]) for key in defaults}
 
     # Ensure that panel_padding and table_padding are tuples.
     final_styles["panel_padding"] = tuple(final_styles["panel_padding"])
@@ -256,14 +243,6 @@ def create_rich_renderable(
     if styles is None:
         styles = get_default_styles(theme)
 
-    # Convert Pydantic BaseModel instances to dicts for rendering
-    try:
-        from pydantic import BaseModel
-        if isinstance(value, BaseModel):
-            value = value.model_dump()
-    except ImportError:
-        pass
-
     # If the value is a dictionary, render it as a table.
     if isinstance(value, dict):
         # Convert table_box string into an actual box style.
@@ -309,41 +288,31 @@ def create_rich_renderable(
         return table
 
     # If the value is a list or tuple, render each item.
-    elif isinstance(value, list | tuple):
+    if isinstance(value, list | tuple):
         if all(isinstance(item, dict) for item in value):
             sub_tables = []
             for i, item in enumerate(value):
                 sub_tables.append(f"[bold]Item {i + 1}[/bold]")
                 sub_tables.append(
-                    create_rich_renderable(
-                        item, level + 1, theme, styles, max_length=max_length
-                    )
+                    create_rich_renderable(item, level + 1, theme, styles, max_length=max_length)
                 )
             return Group(*sub_tables)
-        else:
-            rendered_items = [
-                create_rich_renderable(
-                    item, level + 1, theme, styles, max_length=max_length
-                )
-                for item in value
-            ]
-            if all(isinstance(item, str) for item in rendered_items):
-                return "\n".join(rendered_items)
-            else:
-                return Group(*rendered_items)
+        rendered_items = [
+            create_rich_renderable(item, level + 1, theme, styles, max_length=max_length)
+            for item in value
+        ]
+        if all(isinstance(item, str) for item in rendered_items):
+            return "\n".join(rendered_items)
+        return Group(*rendered_items)
 
     # Otherwise, return a string representation.
-    else:
-        s = str(value).strip()
-        if max_length > 0 and len(s) > max_length:
-            omitted = len(s) - max_length
-            s = (
-                s[:max_length]
-                + f"[bold bright_yellow]...(+{omitted}chars)[/bold bright_yellow]"
-            )
-        if isinstance(value, str) and "\n" in value:
-            return f"\n{s}\n"
-        return s
+    s = str(value).strip()
+    if max_length > 0 and len(s) > max_length:
+        omitted = len(s) - max_length
+        s = s[:max_length] + f"[bold bright_yellow]...(+{omitted}chars)[/bold bright_yellow]"
+    if isinstance(value, str) and "\n" in value:
+        return f"\n{s}\n"
+    return s
 
 
 def load_syntax_theme_from_file(filepath: str) -> dict:
@@ -352,12 +321,10 @@ def load_syntax_theme_from_file(filepath: str) -> dict:
         theme = toml.load(f)
 
     if "colors" not in theme:
-        raise ValueError(
-            f"Theme file {filepath} does not contain a 'colors' section."
-        )
+        raise ValueError(f"Theme file {filepath} does not contain a 'colors' section.")
 
     # Map theme colors to syntax categories
-    syntax_theme = {
+    return {
         "background": theme["colors"]["primary"].get("background", "#161719"),
         "text": theme["colors"]["primary"].get("foreground", "#c5c8c6"),
         "comment": theme["colors"]["normal"].get("black", "#666666"),
@@ -371,8 +338,6 @@ def load_syntax_theme_from_file(filepath: str) -> dict:
         "error": theme["colors"]["bright"].get("red", "#ff5555"),
     }
 
-    return syntax_theme
-
 
 def create_rich_syntax_theme(syntax_theme: dict) -> Theme:
     """Convert a syntax theme dict to a Rich-compatible Theme."""
@@ -476,6 +441,7 @@ class ThemedAgentResultFormatter:
         table = Table(**table_kwargs)
         table.add_column("Output", style=styles["column_output"])
         table.add_column("Value", style=styles["column_value"])
+
         for key, value in result.items():
             rich_renderable = create_rich_renderable(
                 value,
@@ -497,58 +463,46 @@ class ThemedAgentResultFormatter:
                 padding=styles["panel_padding"],
                 style=styles["panel_style"],
             )
-        else:
-            syntax = Syntax(
-                s,  # The formatted string
-                "python",  # Highlight as Python (change this for other formats)
-                theme=self.syntax_style,  # Choose a Rich theme (matches your color setup)
-                line_numbers=False,
-            )
-            return Panel(
-                syntax,
-                title=agent_name,
-                title_align=styles["panel_title_align"],
-                border_style=styles["panel_border_style"],
-                padding=styles["panel_padding"],
-                style=styles["panel_style"],
-            )
+        syntax = Syntax(
+            s,  # The formatted string
+            "python",  # Highlight as Python (change this for other formats)
+            theme=self.syntax_style,  # Choose a Rich theme (matches your color setup)
+            line_numbers=False,
+        )
+        return Panel(
+            syntax,
+            title=agent_name,
+            title_align=styles["panel_title_align"],
+            border_style=styles["panel_border_style"],
+            padding=styles["panel_padding"],
+            style=styles["panel_style"],
+        )
 
-    def display_result(self, result: dict[str, Any], agent_name: str) -> None:
+    def display_result(self, result: list[BaseModel], agent_name: str) -> None:
         """Print an agent's result using Rich formatting."""
         theme = self.theme
-        themes_dir = (
-            pathlib.Path(__file__).parent.parent.parent.parent / "themes"
-        )
+        themes_dir = pathlib.Path(__file__).parent.parent.parent / "themes"
         all_themes = list(themes_dir.glob("*.toml"))
-        theme = (
-            theme.value + ".toml"
-            if not theme.value.endswith(".toml")
-            else theme.value
-        )
-        theme = (
-            pathlib.Path(__file__).parent.parent.parent.parent
-            / "themes"
-            / theme
-        )
+        theme = theme.value + ".toml" if not theme.value.endswith(".toml") else theme.value
+        theme = pathlib.Path(__file__).parent.parent.parent / "themes" / theme
 
         if pathlib.Path(theme) not in all_themes:
-            raise ValueError(
-                f"Invalid theme: {theme}\nAvailable themes: {all_themes}"
-            )
+            raise ValueError(f"Invalid theme: {theme}\nAvailable themes: {all_themes}")
 
         theme_dict = load_theme_from_file(theme)
 
         styles = get_default_styles(theme_dict)
         self.styles = styles
-        self.syntax_style = create_pygments_syntax_theme(
-            load_syntax_theme_from_file(theme)
-        )
+        self.syntax_style = create_pygments_syntax_theme(load_syntax_theme_from_file(theme))
 
         console = Console()
-        panel = self.format_result(
-            result=result,
-            agent_name=agent_name,
-            theme=theme_dict,
-            styles=styles,
-        )
-        console.print(panel)
+        for item in result:
+            # basemodel to dict
+            item = item.model_dump()
+            panel = self.format_result(
+                result=item,
+                agent_name=agent_name,
+                theme=theme_dict,
+                styles=styles,
+            )
+            console.print(panel)