diff --git a/docs/source/examples.rst b/docs/source/examples.rst index d451a368..7ffcb2e9 100644 --- a/docs/source/examples.rst +++ b/docs/source/examples.rst @@ -10,4 +10,5 @@ Examples examples/validating_agent_output examples/advanced_output_handling examples/streaming_agent_output + examples/event_driven autogen diff --git a/examples/Event-driven orchestration for AI systems.ipynb b/examples/Event-driven orchestration for AI systems.ipynb new file mode 100644 index 00000000..94d407b0 --- /dev/null +++ b/examples/Event-driven orchestration for AI systems.ipynb @@ -0,0 +1,462 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Event-driven orchestration for AI systems. Is LlamaIndex Workflows basically Kafka Streams?\n", + "\n", + "Data processing tools like Kafka, Spark, Flink etc. have long been used to build workflows. Today, as people create complex AI systems, they often find themselves (surprise!) needing orchestration frameworks. Is the field really so specific it needs new tools for solving the same problems? We argue that there is no difference: after all, LLMs are just APIs, and the fundamental patterns of workflow architecture remain the same.\n", + "\n", + "A widespread data processing paradigm is event-driven architecture. The purpose of this example is to demonstrate how you can use tried-and-tested tools like Kafka Streams (ported to Python via Faust) to build workflows, side-stepping the need to re-invent the wheel for something as fundamental as event processing. This also comes with reliability and scalability of Kafka, easing production deployment.\n", + "\n", + "We'll walk through the basic concepts of the newly released LlamaIndex Workflows library, and compare them to what you get with Faust.\n", + "\n", + "To get a basic understanding of event-driven workflows, we suggest you check out this guide to LlamaIndex Workflows: https://docs.llamaindex.ai/en/stable/module_guides/workflow/\n", + "\n", + "Here we are using the well-maintained fork of Faust: https://github.com/faust-streaming/faust" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%pip install faust-streaming llama-index -U" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The first example is a simple workflow with two steps:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Analysis:\n", + "This joke plays on the pun of \"fish and ships\" sounding like \"fish and chips,\" a popular dish at seafood restaurants. The joke also incorporates the pirate theme by referencing ships, which is a common element in pirate lore.\n", + "\n", + "Critique:\n", + "Overall, this joke is light-hearted and playful, making it suitable for a general audience. The use of wordplay adds a clever twist to the punchline, making it more engaging for the listener. However, the joke may be considered somewhat predictable as the setup leads directly to the pun, leaving little room for surprise or unexpected humor. Additionally, the joke relies heavily on the pun itself, which may not appeal to all audiences. Overall, while the joke is amusing and well-crafted, it may not be considered particularly original or innovative.\n" + ] + } + ], + "source": [ + "from llama_index.core.workflow import Event, StartEvent, StopEvent, Workflow, step\n", + "\n", + "# `pip install llama-index-llms-openai` if you don't already have it\n", + "from llama_index.llms.openai import OpenAI\n", + "\n", + "\n", + "class JokeEvent(Event):\n", + " joke: str\n", + "\n", + "\n", + "class JokeFlow(Workflow):\n", + " llm = OpenAI()\n", + "\n", + " @step\n", + " async def generate_joke(self, ev: StartEvent) -> JokeEvent:\n", + " topic = ev.topic\n", + "\n", + " prompt = f\"Write your best joke about {topic}.\"\n", + " response = await self.llm.acomplete(prompt)\n", + " return JokeEvent(joke=str(response))\n", + "\n", + " @step\n", + " async def critique_joke(self, ev: JokeEvent) -> StopEvent:\n", + " joke = ev.joke\n", + "\n", + " prompt = f\"Give a thorough analysis and critique of the following joke: {joke}\"\n", + " response = await self.llm.acomplete(prompt)\n", + " return StopEvent(result=str(response))\n", + "\n", + "\n", + "w = JokeFlow(timeout=60, verbose=False)\n", + "result = await w.run(topic=\"pirates\")\n", + "print(str(result))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's try do do the same thing with Faust.\n", + "\n", + "Instead of different event classes, we'll use [channels](https://faust-streaming.github.io/faust/userguide/channels.html) to pass messages between our workflow steps. In this example, we just need to pass single strings, so we'll use a single container type for that. If you want, you of course can use more complex types, including custom classes, dataclasses, etc.\n", + "\n", + "Faust is stream-based, which means it will indefinitely process messages that are sent to the streams in an async loop until the app shuts down. Of course, concurrency also comes out of the box.\n", + "\n", + "The catch with Faust is that it requires a Kafka broker (it's the only dependency). Still, it's quite easy to set up (see https://github.com/wurstmeister/kafka-docker), and your organization is probably already using Kafka for something else.\n", + "\n", + "If you're just playing around, you can execute the following cell to start a Kafka broker in a Docker container." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "55d2b52b9a9ccc72fdfec3122223789b598c10d6009f8660063914434915d338\n" + ] + } + ], + "source": [ + "!docker run -d --name kafka-zookeeper \\\n", + " -p 2181:2181 -p 9092:9092 \\\n", + " -e ADVERTISED_HOST=127.0.0.1 -e NUM_PARTITIONS=10 \\\n", + " -e ZOOKEEPER_HOST=127.0.0.1 \\\n", + " johnnypark/kafka-zookeeper\n", + "\n", + "import time\n", + "time.sleep(30) # Wait for the broker to start" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import asyncio\n", + "import faust\n", + "from llama_index.llms.openai import OpenAI\n", + "\n", + "\n", + "app = faust.App('joke-flow', broker='kafka://localhost:9092', web_enabled=False)\n", + "\n", + "class StringRecord(faust.Record):\n", + " content: str\n", + "\n", + "# We create channels for passing messages between our workflow steps, just like we did with the events before.\n", + "# Start and end channels will be used as entry and exit points, respectively.\n", + "start_channel = app.channel(value_type=StringRecord)\n", + "joke_channel = app.channel(value_type=StringRecord)\n", + "end_channel = app.channel(value_type=StringRecord)\n", + "\n", + "llm = OpenAI()\n", + "results = asyncio.Queue() # For collecting results (in practice, you'd use a database or something)\n", + "\n", + "@app.agent(start_channel, sink=[joke_channel]) # Specify the input and output channels\n", + "async def generate_joke(requests):\n", + " async for request in requests: # Use an async loop to process incoming messages\n", + " prompt = f\"Write your best joke about {request.content}.\"\n", + " response = await llm.acomplete(prompt)\n", + " yield StringRecord(content=str(response))\n", + "\n", + "@app.agent(joke_channel, sink=[end_channel]) # We can even set the sink directly to another agent, like [handle_end]\n", + "async def critique_joke(jokes):\n", + " async for joke in jokes:\n", + " prompt = f\"Give a thorough analysis and critique of the following joke: {joke.content}\"\n", + " response = await llm.acomplete(prompt)\n", + " yield StringRecord(content=str(response))\n", + "\n", + "@app.agent(end_channel)\n", + "async def handle_end(events):\n", + " async for event in events:\n", + " await results.put(event.content) # Put the result in the queue" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To have more control over what channels to use, you can send the messages explicitly without specifying the `sink` parameter:\n", + "\n", + "```python\n", + "@app.agent(start_channel)\n", + "async def generate_joke(requests):\n", + " async for request in requests:\n", + " ...\n", + " await joke_channel.send(value=StringRecord(content=str(response)))\n", + "```\n", + "\n", + "By the way, you can also use Kafka topics in place of channels:\n", + "\n", + "```python\n", + "topic = app.topic('my-topic', value_type=...)\n", + "@app.agent(topic)\n", + "async def process_stream(stream):\n", + " async for record in stream:\n", + " ...\n", + "```\n", + "\n", + "Let's run the example:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Analysis:\n", + "This joke plays on the pun of \"fish and ships\" sounding like \"fish and chips,\" a popular dish at seafood restaurants. The joke also incorporates the pirate theme by referencing ships, which is a common element in pirate lore. The humor comes from the unexpected twist on a familiar phrase and the clever wordplay.\n", + "\n", + "Critique:\n", + "Overall, this joke is light-hearted and fun, making it suitable for a wide audience. The use of wordplay is clever and adds an element of surprise to the punchline. However, the joke may be considered somewhat predictable as the setup hints at the punchline with the mention of ships. Additionally, the humor may not be particularly sophisticated or nuanced, which could limit its appeal to some audiences. Overall, while this joke is entertaining and likely to elicit a chuckle, it may not be memorable or particularly original in the long run.\n" + ] + } + ], + "source": [ + "await app.start()\n", + "await start_channel.send(value=StringRecord(content=\"pirates\"))\n", + "result = await results.get() # Get the first and only result from the queue\n", + "await app.stop()\n", + "\n", + "print(result)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using context\n", + "\n", + "A useful feature of LlamaIndex Workflows is the ability to pass context between steps. Let's see how you can achieve the same effect with Faust.\n", + "\n", + "The simplest way is to pass the context around in a record:\n", + "\n", + "```python\n", + "class Context(faust.Record):\n", + " user_id: str\n", + " query: str\n", + " ...\n", + "\n", + "class RecordWithContext(faust.Record):\n", + " ...\n", + " context: Context\n", + "\n", + "@app.agent\n", + "async def process_stream(stream):\n", + " async for record in stream:\n", + " ...\n", + " # Pass the context to the next agent\n", + " await next_stream.send(value=RecordWithContext(..., context=record.context))\n", + "```\n", + "\n", + "What about persisting state? We can use Faust's [tables](https://faust-streaming.github.io/faust/userguide/tables.html) for that. Tables are distributed key-value stores that can be used as regular Python dictionaries.\n", + "\n", + "```python\n", + "class RecordWithContext(faust.Record):\n", + " ...\n", + " context_id: str\n", + "\n", + "context_table = app.Table('context', default=dict)\n", + "\n", + "@app.agent\n", + "async def process_stream(stream):\n", + " async for record in stream:\n", + " context = context_table.get(record.context_id)\n", + " ...\n", + " context[\"new_key\"] = \"new_value\"\n", + " context_table[record.context_id] = context\n", + " await next_stream.send(value=record)\n", + "```\n", + "\n", + "Refer to Faust [user guide](https://faust-streaming.github.io/faust/userguide/index.html) to learn about these and other more advanced Faust capabilities, like timers, web views, statistics, etc.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Waiting for multiple events\n", + "\n", + "LlamaIndex Context provides a handy `collect_events` method to wait for multiple events. We can replicate the same behavior with Faust by using a table to store the incoming records and then checking if we have received all the required ones. This gives you even more flexibility on how you want to join the events and trigger the next step.\n", + "\n", + "Here's a simple example:\n", + "\n", + "```python\n", + "# The channels for the records we're waiting for\n", + "apples_channel = app.channel(value_type=AppleRecord)\n", + "oranges_channel = app.channel(value_type=OrangeRecord)\n", + "\n", + "# Let's create tables to buffer the records we've received\n", + "apples_buffer = app.Table('apples_buffer', default=lambda: None)\n", + "oranges_buffer = app.Table('oranges_buffer', default=lambda: None)\n", + "\n", + "\n", + "async def try_process_fruits(context_id):\n", + " apples = apples_buffer.get(context_id)\n", + " oranges = oranges_buffer.get(context_id)\n", + " if apples is not None and oranges is not None:\n", + " # Do something with apples and oranges\n", + " ...\n", + "\n", + " del apples_buffer[context_id]\n", + " del oranges_buffer[context_id]\n", + "\n", + "\n", + "@app.agent(apples_channel)\n", + "async def process_first_event(stream):\n", + " async for record in stream:\n", + " apples_buffer[record.id] = record\n", + " await try_process_fruits(record.id)\n", + "\n", + "@app.agent(oranges_channel)\n", + "async def process_second_event(stream):\n", + " async for record in stream:\n", + " oranges_buffer[record.id] = record\n", + " await try_process_fruits(record.id)\n", + "\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Constructing simple workflows in a concise manner using FaustWorkflow\n", + "\n", + "We've created a wrapper around Faust that makes it easy to construct simple workflows in a LlamaIndex-Workflows-like manner, powered by event classes and type annotations. It also allows you to visualize the workflow.\n", + "\n", + "This is our side project, and serves mainly as a proof of concept. If you like the idea and have suggestions for improvement, please let us know!\n", + "\n", + "Here's how you can implement the joke workflow from the previous section using FaustWorkflow:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/whimo/motleycrew/motleycrew/tools/__init__.py:3: LangChainDeprecationWarning: As of langchain-core 0.3.0, LangChain uses pydantic v2 internally. The langchain_core.pydantic_v1 module was a compatibility shim for pydantic v1, and should no longer be used. Please update the code to import from Pydantic directly.\n", + "\n", + "For example, replace imports like: `from langchain_core.pydantic_v1 import BaseModel`\n", + "with: `from pydantic import BaseModel`\n", + "or the v1 compatibility namespace if you are working in a code base that has not been fully upgraded to pydantic 2 yet. \tfrom pydantic.v1 import BaseModel\n", + "\n", + " from motleycrew.tools.tool import MotleyTool\n" + ] + } + ], + "source": [ + "from motleycrew.applications.faust_workflow import FaustWorkflow, Event, step\n", + "\n", + "\n", + "class StartEvent(Event):\n", + " topic: str\n", + "\n", + "class JokeEvent(Event):\n", + " joke: str\n", + "\n", + "class StopEvent(Event):\n", + " result: str\n", + "\n", + "class JokeFlow(FaustWorkflow):\n", + " result_event_type = StopEvent\n", + " llm = OpenAI()\n", + "\n", + " @step\n", + " async def generate_joke(self, ev: StartEvent) -> JokeEvent:\n", + " prompt = f\"Write your best joke about {ev.topic}.\"\n", + " response = await self.llm.acomplete(prompt)\n", + " return JokeEvent(joke=str(response))\n", + "\n", + " @step\n", + " async def critique_joke(self, ev: JokeEvent) -> StopEvent:\n", + " prompt = f\"Give a thorough analysis and critique of the following joke: {ev.joke}\"\n", + " response = await self.llm.acomplete(prompt)\n", + " return StopEvent(result=str(response))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Analysis:\n", + "This joke plays on the pun of \"fish and ships\" sounding like \"fish and chips,\" a popular dish at seafood restaurants. The joke also incorporates the pirate theme by mentioning a pirate going to a seafood restaurant, which adds an element of humor.\n", + "\n", + "Critique:\n", + "Overall, this joke is light-hearted and easy to understand, making it suitable for a wide audience. The use of wordplay is clever and adds a fun twist to the punchline. However, the joke may be considered somewhat predictable as the setup leads directly to the pun, leaving little room for surprise or unexpected humor. Additionally, the joke relies heavily on the pun itself, which may not appeal to everyone's sense of humor. Overall, while this joke is amusing and well-crafted, it may not be particularly memorable or original.\n" + ] + } + ], + "source": [ + "app = faust.App(\"faust-joke-workflow-demo\", broker=\"kafka://localhost:9092\", web_enabled=False)\n", + "joke_workflow = JokeFlow(app=app, timeout=120)\n", + "\n", + "result = await joke_workflow.run(StartEvent(topic=\"pirates\"))\n", + "print(result.result)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "faust_workflow.html\n" + ] + } + ], + "source": [ + "from motleycrew.applications.faust_workflow import draw_faust_workflow\n", + "draw_faust_workflow(joke_workflow)" + ] + }, + { + "attachments": { + "image-2.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![image-2.png](attachment:image-2.png)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/motleycrew/applications/faust_workflow/__init__.py b/motleycrew/applications/faust_workflow/__init__.py new file mode 100644 index 00000000..d9cd8cd9 --- /dev/null +++ b/motleycrew/applications/faust_workflow/__init__.py @@ -0,0 +1,4 @@ +from .faust_workflow import Event, FaustWorkflow, step +from .visualize import draw_faust_workflow + +__all__ = ["Event", "FaustWorkflow", "step", "draw_faust_workflow"] diff --git a/motleycrew/applications/faust_workflow/faust_workflow.py b/motleycrew/applications/faust_workflow/faust_workflow.py new file mode 100644 index 00000000..25167e77 --- /dev/null +++ b/motleycrew/applications/faust_workflow/faust_workflow.py @@ -0,0 +1,168 @@ +import asyncio +import contextvars +from typing import Callable, Dict, List, Tuple, Type, get_type_hints + +from faust import App, Channel, Record + + +class ExecutionContext(Record): + execution_id: int + step_depth: int + step_name: str + + +class Event(Record, abstract=True): + execution_context: ExecutionContext = None + + +def step(func): + func._is_step = True + type_hints = get_type_hints(func) + func._event_types = type_hints.get("ev", type_hints.get("event", None)) + func._output_types = type_hints.get("return", None) + return func + + +class FaustWorkflow: + """ + Event-driven workflow implementation using Faust. + """ + + result_event_type: Type[Event] = None + + def __init__(self, app: App, verbose: bool = False, timeout: int = 60): + self.app = app + self.verbose = verbose + self.timeout = timeout + self.steps: Dict[Type[Event], Callable] = {} + self.channels: Dict[Type[Event], Channel] = {} + self._initialize_steps() + + self.execution_context = contextvars.ContextVar( + "execution_context", + default=ExecutionContext(execution_id=0, step_name=None, step_depth=0), + ) + self.results_by_execution_id: Dict[int, asyncio.Future] = {} + + self.execution_history_lock = asyncio.Lock() + self.execution_history_by_execution_id: Dict[int, List[Tuple[str, str, str]]] = {} + + self._create_final_agent() + + def _initialize_steps(self): + for attr_name in dir(self): + attr = getattr(self, attr_name) + if callable(attr) and hasattr(attr, "_is_step"): + if attr._event_types and attr._output_types: + input_types = ( + attr._event_types.__args__ + if hasattr(attr._event_types, "__args__") + else [attr._event_types] + ) + output_types = ( + attr._output_types.__args__ + if hasattr(attr._output_types, "__args__") + else [attr._output_types] + ) + for input_type in input_types: + self.steps[input_type] = attr + self._create_agent(input_type, output_types, attr) + else: + print(f"Warning: Step {attr_name} has incomplete type hints") + + def _create_agent( + self, input_type: Type[Event], output_types: list[Type[Event]], step_func: Callable + ): + if input_type not in self.channels: + self.channels[input_type] = self.app.channel() + for output_type in output_types: + if output_type not in self.channels: + self.channels[output_type] = self.app.channel() + + @self.app.agent( + self.channels[input_type], name=f"{step_func.__name__}_{input_type.__name__}" + ) + async def agent(stream): + async for event in stream: + if self.verbose: + print( + f"Executing step: {step_func.__name__} with input type {input_type.__name__}" + ) + + self.execution_context.set( + ExecutionContext( + execution_id=event.execution_context.execution_id, + step_depth=event.execution_context.step_depth + 1, + step_name=step_func.__name__, + ) + ) + result = await step_func(event) + if result is None: + continue + + assert any( + isinstance(result, t) for t in output_types + ), f"Step {step_func.__name__} did not return an event of type {output_types}" + await self.send_event(result) + + def _create_final_agent(self): + if self.result_event_type is None: + return + + if self.result_event_type not in self.channels: + self.channels[self.result_event_type] = self.app.channel() + + @self.app.agent(self.channels[self.result_event_type]) + async def final_agent(stream): + async for event in stream: + if isinstance(event, self.result_event_type): + execution_id = event.execution_context.execution_id + if execution_id in self.results_by_execution_id: + self.results_by_execution_id[execution_id].set_result(event) + + async def send_event(self, ev: Event): + """ + Sends an event to the relevant channel. + This method can be used by agents to emit multiple events. + """ + if type(ev) not in self.channels: + raise ValueError(f"No channel found for event type: {type(ev).__name__}") + + channel = self.channels[type(ev)] + + current_context = ev.execution_context + if current_context is None: + current_context = self.execution_context.get() + + ev.execution_context = current_context + async with self.execution_history_lock: + self.execution_history_by_execution_id[current_context.execution_id].append( + (current_context.step_name, current_context.step_depth, type(ev).__name__) + ) + + await channel.send(value=ev) + + if self.verbose: + print(f"Sent event of type {type(ev).__name__} to channel") + + async def run(self, ev: Event) -> Event: + execution_id = self.execution_context.get().execution_id + 1 + async with self.execution_history_lock: + self.execution_history_by_execution_id[execution_id] = [] + + self.results_by_execution_id[execution_id] = asyncio.Future() + + # Start the Faust app if it's not already running + if not self.app.started: + await self.app.start() + + self.execution_context.set( + ExecutionContext(execution_id=execution_id, step_depth=0, step_name=None) + ) + await self.send_event(ev) + + # Wait for the result with a timeout + result = await asyncio.wait_for( + self.results_by_execution_id[execution_id], timeout=self.timeout + ) + return result diff --git a/motleycrew/applications/faust_workflow/visualize.py b/motleycrew/applications/faust_workflow/visualize.py new file mode 100644 index 00000000..7f1233a5 --- /dev/null +++ b/motleycrew/applications/faust_workflow/visualize.py @@ -0,0 +1,71 @@ +from typing import get_args, get_origin + +from pyvis.network import Network + +from .faust_workflow import Event, FaustWorkflow + + +def draw_faust_workflow( + workflow: FaustWorkflow, + filename: str = "faust_workflow.html", + notebook: bool = False, +) -> None: + """Draws the Faust workflow as a graph.""" + net = Network(directed=True, height="750px", width="100%") + + # Add the nodes + edge for stop events + if workflow.result_event_type is not None: + net.add_node( + workflow.result_event_type.__name__, + label=workflow.result_event_type.__name__, + color="#FFA07A", + shape="ellipse", + ) + net.add_node("_done", label="_done", color="#ADD8E6", shape="box") + net.add_edge(workflow.result_event_type.__name__, "_done") + + # Add nodes from all steps + steps = { + name: func + for name, func in workflow.__class__.__dict__.items() + if hasattr(func, "_is_step") + } + + for step_name, step_func in steps.items(): + net.add_node( + step_name, label=step_name, color="#ADD8E6", shape="box" + ) # Light blue for steps + + # Get input and output types + input_type = step_func.__annotations__.get("ev") + output_types = [ + t + for t in step_func.__annotations__.values() + if isinstance(t, type) and issubclass(t, Event) + ] + + if input_type: + input_types = [input_type] if not get_origin(input_type) else get_args(input_type) + for t in input_types: + net.add_node( + t.__name__, + label=t.__name__, + color="#90EE90", + shape="ellipse", + ) + net.add_edge(t.__name__, step_name) + + output_type = step_func.__annotations__.get("return") + if output_type: + output_types = [output_type] if not get_origin(output_type) else get_args(output_type) + for t in output_types: + if t != type(None): + net.add_node( + t.__name__, + label=t.__name__, + color="#90EE90" if t != workflow.result_event_type else "#FFA07A", + shape="ellipse", + ) + net.add_edge(step_name, t.__name__) + + net.show(filename, notebook=notebook)