notebooks/deepdive.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "75be80d6-bc28-478e-93bc-5788ab55d05d",
   "metadata": {},
   "source": [
    "# Deepdive\n",
    "\n",
    "In `quickstart.ipynb` we look at the mainstream usage of `pyiron_workflow`, leveraging `Workflow` as a single point of access, defining custom nodes, and building computational workflows. This notebook builds on that by exploring extra tools for more specialized uses, as well as demonstrating several edge-cases and extension points. We'll try to cover not just the `Workflow` class and the tools it exposes, but everything in the \"public API\" exposed in `pyiron_workflow.__init__`.\n",
    "\n",
    "The target audience here is advanced users who want to make complex workflows. We'll also lay a useful foundation for readers who want to modify the core `pyiron_workflow` infrastructure itself, although that's not our target. Nonetheless, this notebook is still not exhaustive. To go further, investigate the docstrings of the various publicly exposed tools, or dig into the test suite in the source code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "771da684-348b-47e2-ba7c-3c2244e46ba3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyiron_workflow as pwf"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ef866fa-0a8f-412f-bd4a-d2c7da74ccc0",
   "metadata": {},
   "source": [
    "## Adding new functionality with function nodes\n",
    "\n",
    "Let's start by exploring the three main ways of making new content using \"function\" nodes. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cec0079-7c8f-4100-a01e-bf2015ed3a7f",
   "metadata": {},
   "source": [
    "### By dynamic class\n",
    "\n",
    "The recommended approach is to make a new node _class_ by decorating the function with the behaviour you want:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "557ebcd7-81c0-486f-8362-ccb48243c350",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[__main__.MyFunctionClass,\n",
       " pyiron_snippets.factory._FactoryMade,\n",
       " pyiron_workflow.nodes.function.Function,\n",
       " pyiron_workflow.nodes.static_io.StaticNode,\n",
       " pyiron_workflow.node.Node]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@pwf.as_function_node(\"plus\", \"minus\")\n",
    "def MyFunctionClass(x: int = 42) -> tuple[int, int]:\n",
    "    return x + 1, x - 1\n",
    "\n",
    "MyFunctionClass.mro()[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8ace954-c043-4bca-967f-cd8983d953f9",
   "metadata": {},
   "source": [
    "Just like in the quickstart, we that this dynamically creates a new class in `__main__` inheriting from `Node`, and `Function`, just like we'd expect. \n",
    "\n",
    "The `pyiron_snippets.factory._FactoryMade` is just some magic that makes sure this dynamically-defined class is still pickleable. This is important as (unless your IO data itself in unpickleable) it lets us use not only `pickle` but also the standard `concurrent.futures.ProcessPoolExecutor` to parallelize our `pyiron_workflow` content.\n",
    "\n",
    "Also of note here is `pyiron_workflow.nodes.static_io.StaticNode`. You should see this intermediate class in the parentage of most nodes (all of them except `Workflow` at time of writing). Nodes inheriting from this class have their IO interface defined _at the class level_. That means you have access to IO labels, type hints, and default values before ever instantiating a node! (And maybe one day ontological hints too!) You can access this information with `.preview...`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6fe33fae-e481-41e6-b1ce-fe813963ff76",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'inputs': {'x': (int, 42)}, 'outputs': {'plus': int, 'minus': int}}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MyFunctionClass.preview_io()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68cdd4fa-a1bd-4346-a71a-2ddd79087eee",
   "metadata": {},
   "source": [
    "This decorator approach is easy to read, and you can instantiate as many copies of this node as you want, so this is the recommended approach to node defintions. As usual, node input can be set by kwarg at instantiation or run time; `Function` nodes specially can also have input set as a positional argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3fc470e0-971b-4434-82ac-1047be75f2e7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 0)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_func1 = MyFunctionClass(label=\"default_input\")\n",
    "my_func2 = MyFunctionClass(1, label=\"positional_input\")\n",
    "my_func2()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7ac21a4-4b35-48c5-9739-407348691c4a",
   "metadata": {},
   "source": [
    "Of course keywording a positional argument is fine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5aa2ec8d-971b-4827-8d4e-55c70fd8b7fe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(101, 99)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_func2(x=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3afdee95-239a-4cb6-a45b-b1494b927aad",
   "metadata": {},
   "source": [
    "### As a single instance\n",
    "\n",
    "It's also possible we might have an existing function we want to node-ize in a one-of way, without ever keeping track of the underlying node class. We can duplicate the functionality of `MyFunctionClass` the same way for a single instance like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "53e846a5-fa08-4357-a030-b194116d5451",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[__main__.my_function,\n",
       " pyiron_snippets.factory._FactoryMade,\n",
       " pyiron_workflow.nodes.function.Function,\n",
       " pyiron_workflow.nodes.static_io.StaticNode,\n",
       " pyiron_workflow.node.Node]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def my_function(x: int = 42) -> tuple[int, int]:\n",
    "    return x + 1, x - 1\n",
    "\n",
    "my_function_instance = pwf.function_node(my_function, output_labels=(\"plus\", \"minus\"))\n",
    "\n",
    "my_function_instance.__class__.mro()[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "295a78ae-f905-4e22-9fab-07321a439012",
   "metadata": {},
   "source": [
    "Of course other than the name of the immediate class, this looks the same as before, and indeed it is"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6d054c43-b2df-4be0-b13e-3791718008a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert(my_function_instance.__class__.mro()[1:] == MyFunctionClass.mro()[1:])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1446c4b9-9ac6-4118-bdac-205f06b0bf29",
   "metadata": {},
   "source": [
    "There's no particular advantage to making a single instance instead of the typical decorator approach, it just may be slightly more convenient sometimes. In general using the decorator is suggested."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fefe4e42-1f02-4411-be40-5c5033a15698",
   "metadata": {},
   "source": [
    "### By explicit subclass\n",
    "\n",
    "The final path is the traditional OOP coding route of simply making a new class that inherits from `Function`. The only requirement is that it have a `staticmethod` called `node_function` which takes the place of the decorated/passed functions above. You may optionally specify an `_output_labels` property to name the outputs, otherwise they will get scraped from the function return code. This approach can be useful if you want to add some extra functionality on your nodes, e.g. plotting, data analysis -- anything useful but small and tightly coupled enough to the node that you don't feel the need to make a separate node to handle it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "fbba0959-3a9b-4502-9455-664185886945",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maybe our method depends on having output data\n"
     ]
    }
   ],
   "source": [
    "class MySubFunction(pwf.Function):\n",
    "    @staticmethod\n",
    "    def node_function(x: int = 42) -> tuple[int, int]:\n",
    "        return x + 1, x - 1\n",
    "\n",
    "    _output_labels = (\"plus\", \"minus\")\n",
    "\n",
    "    def is_bound(self, n) -> bool:\n",
    "        if self.outputs.plus.value is not pwf.NOT_DATA:\n",
    "            return self.outputs.plus.value > n and self.outputs.minus.value < n\n",
    "        else:\n",
    "            raise RuntimeError(\"Run the node first\")\n",
    "\n",
    "my_subfunc = MySubFunction()\n",
    "\n",
    "try:\n",
    "    my_subfunc.is_bound(33)\n",
    "except RuntimeError:\n",
    "    print(\"Maybe our method depends on having output data\")\n",
    "\n",
    "my_subfunc()\n",
    "assert(my_subfunc.is_bound(42.5) and not my_subfunc.is_bound(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3530eea1-370f-43a2-b177-9bb086e5a7ae",
   "metadata": {},
   "source": [
    "This pattern of subclass-by-decoration, instance-by-call, or traditional subclassing are available under the same syntaxes for all three standard base classes for new nodes: `Function`, `Macro`, and `Dataclass`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c4c25e1-74ff-4fa5-87d1-4610909d8e83",
   "metadata": {},
   "source": [
    "### Parsing awkward functions\n",
    "\n",
    "`pyiron_workflow` is predecated on being able to identify and label not just the inputs of functions, but their outputs. We try to make this convenient by scraping output labels from the raw code of the return value. But, sometimes it doesn't go that easily. Sometimes you might want to wrap an existing function, maybe it even has multiple return values! Or maybe there is no raw source code because the entire function is dynamic (e.g. a lambda function). We don't offer flexible/dynamic output -- the output still needs to be fixed at the class level -- but as long as you are willing to vouch for the function you're wrapping, you can bypass restrictions on parsability of the function code. In this case, you _must_ provide explicit output labels, and you need to set a flag to indicate that parsing should not be performed. Below we show how to do this for an existing function and get a new, importable class by updating the class name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d778740d-03e3-41d2-b5f8-0c2b254d0f8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_awkard_function(x):\n",
    "    \"\"\"\n",
    "    Here is a function that has multiple return values, so we can't parse it by default.\n",
    "    It also awkwardly sometimes returns a string, and other times returns a bool (or \n",
    "    even an array of bools if we were to pass a numpy array in!) so it is going to be \n",
    "    awkward anyhow, since we can't give a very reliable type hint for the input...\n",
    "\n",
    "    But let's explore what we can do to get around this anyhow!\n",
    "    \"\"\"\n",
    "    if isinstance(x, str):\n",
    "        return x\n",
    "    if x > 0:\n",
    "        return True\n",
    "    elif x < 0:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8718f00c-3172-41fe-8266-37012ed47ca6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We can't parse output labels, or compare if the provided ones are valid, when there are multiple `return` statements!\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    pwf.function_node(my_awkard_function, \"some_output_label\")\n",
    "except ValueError:\n",
    "    print(\n",
    "        \"We can't parse output labels, or compare if the provided ones are valid, \"\n",
    "        \"when there are multiple `return` statements!\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "45d2607a-7bf7-4687-803a-cf19c2784087",
   "metadata": {},
   "outputs": [],
   "source": [
    "JustMakeItGo = pwf.as_function_node(\n",
    "    \"some_label\", \n",
    "    validate_output_labels=False,  # Blindly trusts the requested label(s)\n",
    ")(my_awkard_function)\n",
    "JustMakeItGo.__name__ = \"JustMakeItGo\"  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcfadef7-9066-49e2-b875-719ba902b7ab",
   "metadata": {},
   "source": [
    "Note that we've manually set the class name to match the local variable we stored the class in. This is so we can import it correctly later if we want:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "dfc9a84a-bb69-4b24-8c15-6a1de96266b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "from __main__ import JustMakeItGo as ReimportedJMIG\n",
    "\n",
    "assert(ReimportedJMIG is JustMakeItGo)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "919f6f6d-2bb3-4be9-b393-c315522786fa",
   "metadata": {},
   "source": [
    "This node runs fine:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "5850b5ee-eb93-475c-805b-28924723e828",
   "metadata": {},
   "outputs": [],
   "source": [
    "jmig = JustMakeItGo()\n",
    "assert(jmig(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9d53c1a-5722-470d-a872-bf6b2f2a4f23",
   "metadata": {},
   "source": [
    "But it's is still kind of an unfriendly node, since the output type can totally change. Some cases could be even worse, imagine if different return branches returned different numbers of objects! Then sometimes we'd get a value, or other times tuples of values. What a headache. The point is you _can_ force unfriendly functions into our paradigm, but you may not _want_ to. It may be better to just write your own sanitizing wrapper function around them to expose the functionality you care about, or to just write a new function from scratch."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2797772-cda9-46da-aae9-b95d3eabc897",
   "metadata": {},
   "source": [
    "## Macros provide an interface to their subgraph\n",
    "\n",
    "We have access to the same three routes for adding functionality by inheriting from `Macro` just like we do from `Function`. We learned in `quickstart.ipynb` how macros are fundamentally different from function nodes: `Function` nodes are based around _plain python functions_ and can do anything python does and do it every time the function node runs; in contrast, `Macro` nodes use the `pyiron_workflow` framework to _define a graph_, they do it _once at instantiation_, and from then on running the node executes that subgraph. That means you can still write regular python inside your macro definition, but (with the exception of operations that work on data channels via node injection) you can't use that python to process input data and manipulate it because it is (a) acting on data channels not the underlying data held by those channels, and (b) happens only once to the initial data!\n",
    "\n",
    "None of that should be a shock, but here we'll look at _how_ macro nodes accomplish this. First, let's make a couple of trivially simple nodes with which to demo functionality:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "cadd24f1-4a53-4a87-8ed1-29d870ae2fc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "@pwf.as_function_node\n",
    "def TimesTwo(x: int) -> int:\n",
    "    twox = 2 * x\n",
    "    return twox\n",
    "\n",
    "@pwf.as_macro_node\n",
    "def TwoCubed(self, x: int) -> int:\n",
    "    self.two = TimesTwo(x)\n",
    "    self.four = TimesTwo(self.two)\n",
    "    self.eight = TimesTwo(self.four)\n",
    "    return self.eight"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c00e0d6-7a24-4e66-87fa-a3a9b0032ed5",
   "metadata": {},
   "source": [
    "### No outside connections\n",
    "\n",
    "Macros define an explicit interface between the subgraph they hold and the outside world, that means you can't use data (or signal) connections directly between macro child nodes and other nodes. At time of writing, you will be permitted to _form_ the connections, but will get a relatively clear error if you try to actually leverage them.\n",
    "\n",
    "This is the case whether you're working directly with nodes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "7095159b-1314-4347-b208-e8ee781980f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ValueError: Nodes in a data digraph must all be siblings -- i.e. have the same `parent` attribute. Some of these do not: /macro/two5170052368\n",
      "/non_child5170131280\n",
      "/macro/four5170264400\n"
     ]
    }
   ],
   "source": [
    "non_child = TimesTwo(label=\"non_child\")\n",
    "macro = TwoCubed(2, label=\"macro\")\n",
    "\n",
    "non_child.inputs.x = macro.four.outputs.twox\n",
    "\n",
    "try:\n",
    "    non_child()\n",
    "except ValueError as e:\n",
    "    print(\"ValueError:\", e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42ac1c23-c5b2-40b7-bb5e-beb308615507",
   "metadata": {},
   "source": [
    "Or whether they're packaged in a workflow:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "bc2ec413-7a83-4f23-b5a1-f307de413870",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "KeyError: 'The channel /walled_gardens/non_child.x has a connection to the upstream channel /walled_gardens/macro/four.twox, but the upstream owner four was not found among nodes. All nodes in the data flow dependency tree must be included.'\n"
     ]
    }
   ],
   "source": [
    "wf = pwf.Workflow(\"walled_gardens\")\n",
    "wf.non_child = TimesTwo()\n",
    "wf.macro = TwoCubed(2)\n",
    "wf.non_child.inputs.x = wf.macro.four.outputs.twox\n",
    "\n",
    "try:\n",
    "    wf()\n",
    "except KeyError as e:\n",
    "    print(\"KeyError:\", e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c5e5d7d-8136-4af0-b0ba-80bd04d915ad",
   "metadata": {},
   "source": [
    "### Value syncing\n",
    "\n",
    "The prohibition against outside connections guarantees that the macro doesn't receive outside interference, but then how _does_ the macro communicate outside information in and inside information back out?\n",
    "\n",
    "In addition to the regular \"connections\" data and signal channels have, data channels also quietly have a `.value_receiver` method. These guarantee that whenever the value of that channel is updated, the new value is immediately propagated to its receiving partner. Macro's use this for input:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1f9408d0-174d-4140-af45-30cc147b9d3f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 2\n",
      "5 5\n"
     ]
    }
   ],
   "source": [
    "assert(macro.inputs.x is not macro.two.inputs.x)\n",
    "assert(macro.inputs.x.value_receiver is macro.two.inputs.x)\n",
    "\n",
    "print(macro.inputs.x.value, macro.two.inputs.x.value)\n",
    "macro.inputs.x.value = 5\n",
    "print(macro.inputs.x.value, macro.two.inputs.x.value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8041d9e1-6075-4678-b383-54a329fd7e5e",
   "metadata": {},
   "source": [
    "And output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8504c0fd-8b79-4eaa-b6d4-374989e5d67b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NOT_DATA NOT_DATA\n",
      "5 5\n"
     ]
    }
   ],
   "source": [
    "assert(macro.eight.outputs.twox is not macro.outputs.eight)\n",
    "assert(macro.eight.outputs.twox.value_receiver is macro.outputs.eight)\n",
    "\n",
    "print(macro.eight.outputs.twox.value, macro.outputs.eight.value)\n",
    "macro.eight.outputs.twox.value = 5\n",
    "print(macro.eight.outputs.twox.value, macro.outputs.eight.value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "297e2623-6f83-45ef-9fcd-e962d99e5121",
   "metadata": {},
   "source": [
    "### Dynamic input forking\n",
    "\n",
    "Each data channel can have at most one `.value_receiver`, but sometimes our macro input gets sent to more than one child! To accommodate this, under the hood, macros are dynamically creating new nodes to hold input, then pruning these at the end of the macro instantiation if they are unnecessary. In the example below we can see that, at instantiation time, the macro has a new `pyiron_workflow.nodes.standard.UserInput` for both its inputs; for the forked input (`x`) this node persists as a child and is the on the receiving end of the macro input, but for the input with a single recipient (`y`) the intermediate node can be pruned and the macro input is fed straight to the node explicitly created in the macro definition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "db17a6c1-659c-496e-84bf-6508db1dff14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pyiron_workflow.nodes.standard.UserInput'>\n",
      "<class 'pyiron_workflow.nodes.standard.UserInput'>\n",
      "('x', 'pair1', 'pair2', 'alone')\n"
     ]
    }
   ],
   "source": [
    "@pwf.as_macro_node\n",
    "def VerboseFork(self, x: int, y: int) -> tuple[int, int, int]:\n",
    "    print(type(x))\n",
    "    print(type(y))\n",
    "    self.pair1 = TimesTwo(x)\n",
    "    self.pair2 = TimesTwo(x)\n",
    "    self.alone = TimesTwo(y)\n",
    "    return self.pair1, self.pair2, self.alone\n",
    "\n",
    "m = VerboseFork()\n",
    "print(m.child_labels)  # Includes a \"forking\" input child not in the definition!\n",
    "\n",
    "assert(m.inputs.x.value_receiver is m.x.inputs.user_input)\n",
    "assert(m.inputs.y.value_receiver is m.alone.inputs.x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a92c4238-dfcc-4e8a-812b-d2e1df8e735a",
   "metadata": {},
   "source": [
    "### Node injection and macro definitions\n",
    "\n",
    "We saw in the `quickstart.ipynb` how nodes returning only a single value can be operated on as though you were operating on their (only) data output channel, and how data output channels can be operated on to dynamically create new nodes to (delay and) perform the operation. \n",
    "\n",
    "We have also discussed how we mustn't mix-and-match raw python data processing we do in `Function` definitions with the graph setup we do in `Macro` definitions.\n",
    "\n",
    "Here, let's just quickly revisit this concept to show how we can sometimes leverage node injection to do some fairly complex processing of data in a macro after all. We have most but not all operators at our disposal -- some, like `>>` and `<<` bitshift operators are reserved to have actual meaning within the `pyiron_workflow` framework -- as well as a number of extra methods, e.g. `.eq` since we want to reserve `==` for its totally regular meaning and not inject on it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "b3bac532-7e56-40bb-805b-26dd7fd1d649",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__getattr__ <function OutputDataWithInjection.__getattr__ at 0x13416a200>\n",
      "__getitem__ <function OutputDataWithInjection.__getitem__ at 0x13416a2a0>\n",
      "__lt__ <function OutputDataWithInjection.__lt__ at 0x13416a340>\n",
      "__le__ <function OutputDataWithInjection.__le__ at 0x13416a3e0>\n",
      "eq <function OutputDataWithInjection.eq at 0x13416a480>\n",
      "__ne__ <function OutputDataWithInjection.__ne__ at 0x13416a520>\n",
      "__gt__ <function OutputDataWithInjection.__gt__ at 0x13416a5c0>\n",
      "__ge__ <function OutputDataWithInjection.__ge__ at 0x13416a660>\n",
      "bool <function OutputDataWithInjection.bool at 0x13416a700>\n",
      "len <function OutputDataWithInjection.len at 0x13416a7a0>\n",
      "contains <function OutputDataWithInjection.contains at 0x13416a840>\n",
      "__add__ <function OutputDataWithInjection.__add__ at 0x13416a8e0>\n",
      "__sub__ <function OutputDataWithInjection.__sub__ at 0x13416a980>\n",
      "__mul__ <function OutputDataWithInjection.__mul__ at 0x13416aa20>\n",
      "__rmul__ <function OutputDataWithInjection.__rmul__ at 0x13416aac0>\n",
      "__matmul__ <function OutputDataWithInjection.__matmul__ at 0x13416ab60>\n",
      "__truediv__ <function OutputDataWithInjection.__truediv__ at 0x13416ac00>\n",
      "__floordiv__ <function OutputDataWithInjection.__floordiv__ at 0x13416aca0>\n",
      "__mod__ <function OutputDataWithInjection.__mod__ at 0x13416ad40>\n",
      "__pow__ <function OutputDataWithInjection.__pow__ at 0x13416ade0>\n",
      "__and__ <function OutputDataWithInjection.__and__ at 0x13416ae80>\n",
      "__xor__ <function OutputDataWithInjection.__xor__ at 0x13416af20>\n",
      "__or__ <function OutputDataWithInjection.__or__ at 0x13416afc0>\n",
      "__neg__ <function OutputDataWithInjection.__neg__ at 0x13416b060>\n",
      "__pos__ <function OutputDataWithInjection.__pos__ at 0x13416b100>\n",
      "__abs__ <function OutputDataWithInjection.__abs__ at 0x13416b1a0>\n",
      "__invert__ <function OutputDataWithInjection.__invert__ at 0x13416b240>\n",
      "int <function OutputDataWithInjection.int at 0x13416b2e0>\n",
      "float <function OutputDataWithInjection.float at 0x13416b380>\n",
      "__round__ <function OutputDataWithInjection.__round__ at 0x13416b420>\n"
     ]
    }
   ],
   "source": [
    "from types import FunctionType\n",
    "from pyiron_workflow.mixin.injection import OutputDataWithInjection\n",
    "\n",
    "for k, v in OutputDataWithInjection.__dict__.items():\n",
    "    if (\n",
    "        isinstance(v, FunctionType) \n",
    "        and k not in [\"__init__\", \"_get_injection_label\", \"_node_injection\"]\n",
    "    ):\n",
    "        print(k, v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8dcc7997-724b-4f96-82fd-d36a35420d67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fifth_element <GetItem>\n",
      "injected_Add_m891033660658541671 <Add>\n",
      "transformed <Modulo>\n",
      "matches <Equals>\n",
      "injected_Float_m3948375428356599611 <Float>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'matches': True, 'as_float': 0.0}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@pwf.as_macro_node\n",
    "def TheFifthElement(\n",
    "    self,\n",
    "    exactly_five: tuple[int, int, int, int, int], \n",
    "    mod: int = 10, \n",
    "    extra: int = 5,\n",
    "    target: int = 0,\n",
    ") -> tuple[bool, float]:\n",
    "    self.fifth_element = exactly_five[4]  # Access injection\n",
    "    self.transformed = (self.fifth_element + extra) % mod  # Operator injection\n",
    "    self.matches = self.transformed.eq(target)  # Method injection\n",
    "    as_float = self.transformed.float()\n",
    "    return self.matches, as_float\n",
    "\n",
    "five = TheFifthElement((1, 2, 3, 4, 5))\n",
    "for n in five:\n",
    "    print(f\"{n.label} <{n.__class__.__name__}>\")\n",
    "five()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7224ba8d-dab5-449c-ae39-9a0c90e11941",
   "metadata": {},
   "source": [
    "It's always valid to extract your data processing as its own `Function` node and then use that, but we see here there is a reasonable amount of flexibility by leveraging injection. Most of our injected nodes were immediately assigned to an attribute of our macro (and thus re-labeled), but the `(self.fifth_element + extra)` was only ever used in-line and so retains its automatically-generated label. This is also true for `as_float`, which appears only as a local variable -- the variable name is still scraped for the purpose of naming the macro output channel, but the node itself retains its generated label.\n",
    "\n",
    "As a counter-example, we couldn't have written `as_float = float(self.transformed)`, because `self.transformed` (and `exactly_five`, `mod`, `extra`, `target`, and all the other child nodes) are _nodes_ (or output channels) and taking the \"float\" of this nonsensicle! The `.float()` method defined on the injection class gives explicit instruction to generate a new node to handle this transformation on the data values in a delayed manner. We try to add enough such injections to cover your day-to-day needs, but where that fails you simply need to write and use your own node."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "174f818f-59b5-4fba-8519-864a807c4aa8",
   "metadata": {},
   "source": [
    "## Dataclass nodes for grouping inputs\n",
    "\n",
    "The last of the standard approaches for new node functionality is `DataclassNode`. They're a little bit different in that the underlying definition is a class (if it isn't already a `@dataclasses.dataclass` it will be wrapped as one), but otherwise the three standard approaches for making new ones work exactly as for `Macro` and `Function`.\n",
    "\n",
    "Like usual dataclasses, these are for packaging groups of input together into sensible packages, and even allow inheritance for composing together input from different places. The dataclass itself gets stored on the `.dataclass` class attribute of the node class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ae6d7936-3cd1-49e5-893d-1e71a42ced72",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'inputs': {'color': (str, NOT_DATA),\n",
       "  'doors': (int, 2),\n",
       "  'wheels': (int, 4),\n",
       "  'spoiler': (bool, False)},\n",
       " 'outputs': {'dataclass': __main__.Coupe.dataclass}}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@pwf.as_dataclass_node\n",
    "class Car:\n",
    "    color: str\n",
    "    doors: int\n",
    "    wheels: int = 4\n",
    "\n",
    "@pwf.as_dataclass_node\n",
    "class Coupe(Car.dataclass):\n",
    "    doors: int = 2\n",
    "    spoiler: bool = False\n",
    "\n",
    "# Note: Inheritance with dataclasses can be tricky, particularly with regards to the order of \n",
    "# default and non-default parameters. In general, composition is preferable over inheritance and \n",
    "# extension. So this example is somewhat questionable python, but we're just trying to show \n",
    "# some `DataclassNode` syntax, so don't sweat it.\n",
    "\n",
    "Coupe.preview_io()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65c8f696-703a-465a-9c28-c78c26818a14",
   "metadata": {},
   "source": [
    "We can then leverage the dataclass node as an entry point for users to specify data, and write business logic that accepts the entire dataclass as IO:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "70c0a299-90b9-477b-b156-834268858a09",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ticket__ticket': 130, 'red_ticket__ticket': 180}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@pwf.as_function_node(\"repainted\")\n",
    "def Repaint(car: Car.dataclass, new_color: str):\n",
    "    car.color = new_color\n",
    "    return car\n",
    "\n",
    "@pwf.as_function_node\n",
    "def SpeedingTicket(car: Car.dataclass):\n",
    "    ticket = 100\n",
    "    if car.color.lower() == \"red\":\n",
    "        # Red cars go faster, everyone knows\n",
    "        ticket += 50\n",
    "    if car.doors < 4:\n",
    "        # Too sporty looking, eh\n",
    "        ticket += 30\n",
    "    return ticket\n",
    "\n",
    "wf = pwf.Workflow(\"a_tale_of_two_tickets\")\n",
    "wf.car = Coupe(color=\"green\")\n",
    "wf.red_car = Repaint(wf.car, \"RED\")\n",
    "wf.ticket = SpeedingTicket(wf.car)\n",
    "wf.red_ticket = SpeedingTicket(wf.red_car)\n",
    "wf()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "057c2541-5398-4e6e-98ec-131d3ed3a5ea",
   "metadata": {},
   "source": [
    "## Disabling type hints\n",
    "\n",
    "By default, `pyiron_workflow` is strongly hinted, so you can't pass wrongly-typed values or from incompatibly-hinted connections:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "0975cb7b-ac3a-48d5-88e6-fbfd672d98b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TypeError: The channel /Repaint.car cannot take the value `a_string_not_a_Car` (<class 'str'>) because it is not compliant with the type hint <class '__main__.Car.dataclass'>\n"
     ]
    }
   ],
   "source": [
    "repainted = Repaint()\n",
    "repainted.inputs.new_color = \"light urple\"\n",
    "try:\n",
    "    repainted.recovery = None  # We know this will fail and don't care about a recovery file\n",
    "    repainted.inputs.car = \"a_string_not_a_Car\"\n",
    "except TypeError as e:\n",
    "    print(\"TypeError:\", e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa660ff3-8e99-433c-9769-cf0dd63b3908",
   "metadata": {},
   "source": [
    "You can forcably disable this, either for a specific channel or at the node-level for all channels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "ed77ecdf-c673-44ea-aa4b-8aa02822f994",
   "metadata": {},
   "outputs": [],
   "source": [
    "repainted = Repaint()\n",
    "repainted.inputs.new_color = \"light urple\"\n",
    "\n",
    "repainted.deactivate_strict_hints()\n",
    "repainted.inputs.car = \"a_string_not_a_Car\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4153f96b-1ab2-4cef-ba35-fb928c33879b",
   "metadata": {},
   "source": [
    "But, at least in this example, it's not a good idea..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "869cca6f-a4d2-4a83-87f4-1a1bc0a0161a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AttributeError: 'str' object has no attribute 'color'\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    repainted.recovery = None  # We know this will fail and don't care about a recovery file\n",
    "    repainted.run()\n",
    "except AttributeError as e:\n",
    "    print(\"AttributeError:\", e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "213bca93-f211-4805-ba09-afb14dc94b42",
   "metadata": {},
   "source": [
    "## Other transformers\n",
    "\n",
    "`DataclassNode` is an example of a \"transformer\" -- a simple tool for converting input to a particular form of output via a node. There are several others, but they are so simple that there is not much flexibility in instantiating them, just use the \"meta\" node to make a new class and new instance at once.\n",
    "\n",
    "Here we just demo them so you know they exist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "2176aa21-93e8-441a-996d-d7de308f1e15",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>strings</th>\n",
       "      <th>ints</th>\n",
       "      <th>types</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>a</td>\n",
       "      <td>1</td>\n",
       "      <td>&lt;class 'int'&gt;</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>b</td>\n",
       "      <td>2</td>\n",
       "      <td>&lt;class 'float'&gt;</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>c</td>\n",
       "      <td>3</td>\n",
       "      <td>&lt;class 'str'&gt;</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  strings  ints            types\n",
       "0       a     1    <class 'int'>\n",
       "1       b     2  <class 'float'>\n",
       "2       c     3    <class 'str'>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i2df = pwf.inputs_to_dataframe(3)\n",
    "\n",
    "i2df(\n",
    "    row_0 = {\"strings\": \"a\", \"ints\": 1, \"types\": int},\n",
    "    row_1 = {\"strings\": \"b\", \"ints\": 2, \"types\": float},\n",
    "    row_2 = {\"strings\": \"c\", \"ints\": 3, \"types\": str},\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "d4e384e4-02a7-442e-83db-dbe8bb2d56d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'inputs': {'x': (None, NOT_DATA), 'y': (<class 'int'>, 42)}, 'outputs': {'dict': <class 'dict'>}}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'x': 'foobar', 'y': 42}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i2d = pwf.inputs_to_dict(\n",
    "    input_specification={\n",
    "        \"x\": (None, pwf.NOT_DATA),\n",
    "        \"y\": (int, 42)\n",
    "    }\n",
    ")\n",
    "print(i2d.preview_io())\n",
    "i2d(\"foobar\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "27dfa606-6357-471b-9764-598629a401d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 'four', 'five']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i2l = pwf.inputs_to_list(5)\n",
    "i2l(1, 2, 3, \"four\", \"five\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "b6aeec11-829d-497f-a86e-c7de057c9247",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'item_0': 1, 'item_1': 2, 'item_2': 3, 'item_3': 'four', 'item_4': 'five'}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l2o = pwf.list_to_outputs(5)\n",
    "l2o(i2l)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c143e6f-3944-4176-9b20-fc8262bcb2b8",
   "metadata": {},
   "source": [
    "## Workflows\n",
    "\n",
    "Workflows are the main interface point for `pyiron_workflow`, and already discussed in the `quickstart.ipynb`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05d33526-8035-4129-87fa-a7d4b9cc76b7",
   "metadata": {},
   "source": [
    "### Workflow IO\n",
    "\n",
    "It bears re-iterating that they differ from all the other nodes we've talked about so far in that their IO _is not static_. It is mutable and varies with the contents of their children. In fact, it gets re-created at each access! And unlike `Macro` nodes, which act as a walled garden, `Workflow` is really giving direct access to the underlying child IO channels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "76081796-532a-49a0-aac1-37872184624a",
   "metadata": {},
   "outputs": [],
   "source": [
    "wf = pwf.Workflow(\"no_wall\")\n",
    "wf.child = pwf.standard_nodes.UserInput()\n",
    "\n",
    "assert(wf.inputs.child__user_input is wf.child.inputs.user_input)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eeb0b71a-a273-4702-b545-9b8019cac928",
   "metadata": {},
   "source": [
    "If we really want to, we can break the traditional format of `f\"{child.label}__{channel.label}\"` for workflow IO and give it explicit names. Care should be taken that since workflows are mutable, the map may become invalid if the children of the workflow change."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "5202c396-e0da-418b-be59-cbe877715ad2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'out': 'some data'}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf.inputs_map = {\"child__user_input\": \"inp\"}\n",
    "wf.outputs_map = {\"child__user_input\": \"out\"}\n",
    "\n",
    "wf(inp=\"some data\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c8c78a8-24c6-4853-a35a-e4e05d9baa30",
   "metadata": {},
   "source": [
    "### Modifying contents\n",
    "\n",
    "Another way to add a child is to assign the workflow as a parent at instantiation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "139073c2-f4db-477d-9619-d13a9ab6d45c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('child', 'UserInput')"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pwf.standard_nodes.UserInput(parent=wf)\n",
    "wf.child_labels"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "273ea4bf-12e4-4bb0-b5bb-629a60d1f9a5",
   "metadata": {},
   "source": [
    "The key difference between these is that in the latter case, the child node finds out it is a child of the workflow _at instantiation_, while assigning a node to the workflow first fully instantiates it (with some default label, like we see above) and then parents it to the workflow and updates its label according to the workflow attribute name we're using.\n",
    "\n",
    "You can also invoke the `add_child` method to add a node instance as a child directly. If we try this naively, we'll see that the automated name will conflict with an existing child that also used its automated name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "50387019-2f3f-4e4b-92da-11a4283b9405",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AttributeError: UserInput is already the label for a child. Please remove it before assigning another child to this label.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    wf.add_child(pwf.standard_nodes.UserInput())\n",
    "except AttributeError as e:\n",
    "    print(\"AttributeError:\", e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03718bf7-521f-40dc-acdf-a898734c39a6",
   "metadata": {},
   "source": [
    "We could give the child a different name, or we can just allow the workflow to dynamically re-name conflicts:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "eb45a311-ec0a-474f-b17d-3b58ae111b7e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('child', 'UserInput', 'UserInput0')"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf.strict_naming = False\n",
    "wf.add_child(pwf.standard_nodes.UserInput())\n",
    "wf.child_labels"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "349e7a94-8b09-4ba7-8ec8-fcf3135e41bd",
   "metadata": {},
   "source": [
    "In a similar way we can remove children by name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "d280ff55-65f1-4a35-adf2-bae284d53fce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('UserInput', 'UserInput0')"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf.remove_child(\"child\")\n",
    "wf.child_labels"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c51a48f3-0eab-49de-874b-5fdb2a107010",
   "metadata": {},
   "source": [
    "or by instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "6d671322-0212-4462-a7eb-2b7e1f870799",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('UserInput0',)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf.remove_child(wf.UserInput)\n",
    "wf.child_labels"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b917f0a-c354-4fc1-90dc-04bd828da405",
   "metadata": {},
   "source": [
    "We can also replace children, with the caveat that the replacement must have commensurate IO with what is being replaced"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "5f8f3478-d9e5-46c9-96c2-6af101f30173",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NOT_DATA\n",
      "42\n"
     ]
    }
   ],
   "source": [
    "replacement = pwf.standard_nodes.UserInput(42)\n",
    "\n",
    "print(wf.UserInput0.inputs.user_input.value)\n",
    "wf.replace_child(wf.UserInput0, replacement)\n",
    "print(wf.UserInput0.inputs.user_input.value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5093b50f-3d2e-41ef-8e66-6bb884a0f027",
   "metadata": {},
   "source": [
    "### Dictionary representation\n",
    "\n",
    "You can get a simple dictionary representation of a given workflow (or macro) with a `'nodes'` subdictionary linking full labels to node instances, and an `'edges'` dictionary further decomposed into `'data'` and `'signals'` that use tuples of full labels as keys for tuples of (output, input) channel instances:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "9d2cab07-0e64-495f-accd-338eef3e2822",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'nodes': {'/graph_as_dict/inp': <pyiron_workflow.nodes.standard.UserInput at 0x1342ffbd0>,\n",
       "  '/graph_as_dict/a': <pyiron_workflow.nodes.standard.Add at 0x134350f10>,\n",
       "  '/graph_as_dict/b': <pyiron_workflow.nodes.standard.Add at 0x134351150>,\n",
       "  '/graph_as_dict/out': <pyiron_workflow.nodes.standard.Multiply at 0x134352210>},\n",
       " 'edges': {'data': {('/graph_as_dict/inp.user_input',\n",
       "    '/graph_as_dict/b.obj'): (<pyiron_workflow.mixin.injection.OutputDataWithInjection at 0x134350e10>,\n",
       "    <pyiron_workflow.channels.InputData at 0x134351f90>),\n",
       "   ('/graph_as_dict/inp.user_input',\n",
       "    '/graph_as_dict/a.obj'): (<pyiron_workflow.mixin.injection.OutputDataWithInjection at 0x134350e10>, <pyiron_workflow.channels.InputData at 0x134271290>),\n",
       "   ('/graph_as_dict/a.add',\n",
       "    '/graph_as_dict/out.obj'): (<pyiron_workflow.mixin.injection.OutputDataWithInjection at 0x1342a7210>, <pyiron_workflow.channels.InputData at 0x1343457d0>),\n",
       "   ('/graph_as_dict/b.add',\n",
       "    '/graph_as_dict/out.other'): (<pyiron_workflow.mixin.injection.OutputDataWithInjection at 0x134351fd0>, <pyiron_workflow.channels.InputData at 0x134345790>)},\n",
       "  'signal': {}}}"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf = pwf.Workflow(\"graph_as_dict\")\n",
    "wf.inp = pwf.standard_nodes.UserInput(42)\n",
    "wf.a = wf.inp + 2\n",
    "wf.b = wf.inp + 4\n",
    "wf.out = wf.a * wf.b\n",
    "wf.graph_as_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "111fafb5-22f9-4309-b0e6-5025c8325af7",
   "metadata": {},
   "source": [
    "### Signal flow is created at runtime\n",
    "\n",
    "Just like the IO for a workflow is created at runtime, unless automatic execution is explicitly disabled, the execution signals are empty until a run is triggered. This is why the `'signals'` sub-dictionary above is empty. We can create them from the DAG data flow with a run call:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "a1055134-0488-4860-b2c8-e99f79cbdf8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/graph_as_dict/inp.ran --> /graph_as_dict/b.accumulate_and_run\n",
      "/graph_as_dict/inp.ran --> /graph_as_dict/a.accumulate_and_run\n",
      "/graph_as_dict/a.ran --> /graph_as_dict/out.accumulate_and_run\n",
      "/graph_as_dict/b.ran --> /graph_as_dict/out.accumulate_and_run\n"
     ]
    }
   ],
   "source": [
    "wf()\n",
    "for (ran, run) in wf.graph_as_dict[\"edges\"][\"signal\"].keys():\n",
    "    print(ran, \"-->\", run)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95409984-0ab3-4f6b-a5e4-29f896733034",
   "metadata": {},
   "source": [
    "## `NOT_DATA` because `None` is real\n",
    "\n",
    "You will notice that the default value for node input is `NOT_DATA`. This is because `None` is a real and valid input for many functions, e.g. instead of having a mutable input a function might have `some_list_input = [] if some_list_input is None else some_list_input`. `NOT_DATA` is our way of not stepping on the toes of such uses of `None`.\n",
    "\n",
    "There's not a lot to this, except to note that `NOT_DATA` is a \"singleton\", so all its occurrences will pass an \"is\" test:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "5cba153a-f03d-4449-bdf2-c84862ec45ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert(pwf.standard_nodes.UserInput().inputs.user_input.value is pwf.NOT_DATA)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d18c6eba-3a78-448e-92c2-22f317573f39",
   "metadata": {},
   "source": [
    "## Connection ordering and priority\n",
    "\n",
    "When a node runs, it tries to get data by going through its input connections and using the first connection that holds data _other_ than `NOT_DATA`, using its current value (e.g. a default) if none satisfy this. More recent connections are placed higher in the connection list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "10202174-6543-4ac9-bd9f-3a13c3501842",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['source1', 'source2', 'source3']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "source1 = pwf.standard_nodes.UserInput(label=\"source1\")\n",
    "source2 = pwf.standard_nodes.UserInput(label=\"source2\")\n",
    "source3 = pwf.standard_nodes.UserInput(label=\"source3\")\n",
    "receiver = pwf.standard_nodes.UserInput(42)\n",
    "\n",
    "receiver.inputs.user_input = source3\n",
    "receiver.inputs.user_input = source2\n",
    "receiver.inputs.user_input = source1\n",
    "print([c.owner.label for c in receiver.inputs.user_input.connections])\n",
    "receiver.run(run_data_tree=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "4c3f2e88-3a5e-4115-9a36-5d17326c4e7b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "source2(100)  # Populate source2 output\n",
    "receiver.run(run_data_tree=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "734c6a6e-702a-4702-b4b0-e40435ca6e32",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "source1(0)  # Populate source1 output\n",
    "receiver.run(run_data_tree=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a9ba00d-842c-4e75-a220-ea7da32b9ab6",
   "metadata": {},
   "source": [
    "## Caching\n",
    "\n",
    "By default, all nodes exploit caching. I.e. when they run they save a fresh dictionary of their input values; in all subsequent runs if the dictionary of their current input values matches (`==`) that last-used dictionary, they skip executing altogether and leverage their existing outputs.\n",
    "\n",
    "Any changes to the inputs will obviously stop the cache from being retrieved, but for `Composite` nodes it is also reset if any child nodes are added/removed/replaced.\n",
    "\n",
    "Note that since we do a simple `==` on the dictionary of input values, if your workflow non-idempotently passes around mutable data, it's possible you'll wind up in a situation where you get a false cache hit.\n",
    "\n",
    "Caching behaviour can be defined at the class-level as a default, but can be overridden for individual nodes. Let's take a look:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "5a3b01be-6539-4617-98c0-30ef008b394d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'always_new__rand': 444, 'cached__rand': 279}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random \n",
    "\n",
    "@pwf.as_function_node(use_cache=False)\n",
    "def Randint(low=0, high=999):\n",
    "    rand = random.randint(low, high)\n",
    "    return rand\n",
    "\n",
    "wf = pwf.Workflow(\"mixed_caching\")\n",
    "wf.use_cache = False  # Turn _off_ caching for the whole workflow!\n",
    "\n",
    "wf.always_new = Randint()\n",
    "wf.cached = Randint()\n",
    "wf.cached.use_cache = True  # Turn _on_ caching for this node\n",
    "\n",
    "wf()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a556920b-3d8a-42b2-b480-ae9b95ea1207",
   "metadata": {},
   "source": [
    "Running the same workflow again, we see that the cached node just keeps returning the same \"random\" number, while the un-cached node gives us something new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "3bf5d930-901b-4067-be74-b82847bc82fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'always_new__rand': 522, 'cached__rand': 279}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ccfd26a-bace-4eba-922e-7fb6f950cf93",
   "metadata": {},
   "source": [
    "If we look into the caching data, we can see that the non-caching node has not stored any inputs and does not register a cache hit; even if we had previously cached something, if we switch to `use_cache = False`, we won't even look for the cache hit but will just give new data!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "60adbd5e-94d9-44fd-847c-ebc4b9b3ad2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "always_new {'low': 0, 'high': 999} None False\n",
      "cached {'low': 0, 'high': 999} {'low': 0, 'high': 999} True\n"
     ]
    }
   ],
   "source": [
    "for node in wf:\n",
    "    print(node.label, node.inputs.to_value_dict(), node._cached_inputs, node.cache_hit)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecab079a-a757-4276-9b22-5a1d1b771b06",
   "metadata": {},
   "source": [
    "## Mutability\n",
    "\n",
    "In `pyiron_workflow` it's a best-practice to make your nodes functional and idempotent -- i.e. they should not mutate mutable input data! This is python, so we're not going to stop you from doing it, and maybe you'll hit a situation where you really need to...but it's not recommended.\n",
    "\n",
    "Here we'll show a concrete example of what happens when you mutate data, and how this can interact with caching to wind up skipping things you think you should be running."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "fe539e8c-c7e0-4b93-b734-93f1c417f5d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Alice, and I've collected ['Alice']\n",
      "My name is Bob, and I've collected ['Alice', 'Bob']\n",
      "My name is Chandy, and I've collected ['Alice', 'Bob', 'Chandy']\n",
      "My name is Deng, and I've collected ['Alice', 'Bob', 'Chandy', 'Deng']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'a__my_name_is': \"My name is Alice, and I've collected ['Alice']\",\n",
       " 'b__my_name_is': \"My name is Bob, and I've collected ['Alice', 'Bob']\",\n",
       " 'c__my_name_is': \"My name is Chandy, and I've collected ['Alice', 'Bob', 'Chandy']\",\n",
       " 'd__my_name_is': \"My name is Deng, and I've collected ['Alice', 'Bob', 'Chandy', 'Deng']\",\n",
       " 'd__collection': ['Alice', 'Bob', 'Chandy', 'Deng']}"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@pwf.as_function_node\n",
    "def SayMyName(name: str, collection: list[str]) -> tuple[str, list[str]]:\n",
    "    collection.append(name)\n",
    "    my_name_is = f\"My name is {name}, and I've collected {collection}\"\n",
    "    print(my_name_is)\n",
    "    return my_name_is, collection\n",
    "\n",
    "wf = pwf.Workflow(\"mutable_trouble\")\n",
    "wf.a = SayMyName(\"Alice\", [])\n",
    "wf.b = SayMyName(\"Bob\", wf.a.outputs.collection)\n",
    "wf.c = SayMyName(\"Chandy\", wf.b.outputs.collection)\n",
    "wf.d = SayMyName(\"Deng\", wf.c.outputs.collection)\n",
    "wf()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28d65823-4f08-4ebc-bb17-0bb87ad00d7b",
   "metadata": {},
   "source": [
    "So far everything looks good... but beneath the water trouble is lurking! Our mutable `collection` list is input for _all_ our nodes! That means the \"functional\" contract that the current output of a node corresponds to what it will return if it is run with its current input:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "5fa37d8f-867a-4d6e-90ad-e7d9f2b8989f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Alice', 'collection': ['Alice', 'Bob', 'Chandy', 'Deng']}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf.a.inputs.to_value_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "1ca3009f-e207-4aae-8628-d27a868109d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'my_name_is': \"My name is Alice, and I've collected ['Alice']\",\n",
       " 'collection': ['Alice', 'Bob', 'Chandy', 'Deng']}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf.a.outputs.to_value_dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55ad05c4-48a0-4b97-9e8c-a2c4ba3ecffd",
   "metadata": {},
   "source": [
    "It is painfully obvious that the immutable `'my_name_is'` result doesn't correspond to the alleged input, but the `'collection'` doesn't either as the _last_ element should be `'Alice'` regardless of what collection was passed in."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "049cc61e-c7ae-4ba1-adce-5b09390b7839",
   "metadata": {},
   "source": [
    "This effect also impacts the caching, since the _cached_ inputs are also subject to mutability!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "954cac45-566e-4135-8b03-6ca2bf337cb2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Alice', 'collection': ['Alice', 'Bob', 'Chandy', 'Deng']}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf.a._cached_inputs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f7f7cf1-9e94-44a7-8d01-01f38900d2f2",
   "metadata": {},
   "source": [
    "Thus, we're going to encounter the `inputs == _cached_inputs` whether we want it or not, so if we try to re-run the workflow nothing will happen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "ca5e08d3-e3d9-4b6c-99b9-a05521bbaf23",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a__my_name_is': \"My name is Alice, and I've collected ['Alice']\",\n",
       " 'b__my_name_is': \"My name is Bob, and I've collected ['Alice', 'Bob']\",\n",
       " 'c__my_name_is': \"My name is Chandy, and I've collected ['Alice', 'Bob', 'Chandy']\",\n",
       " 'd__my_name_is': \"My name is Deng, and I've collected ['Alice', 'Bob', 'Chandy', 'Deng']\",\n",
       " 'd__collection': ['Alice', 'Bob', 'Chandy', 'Deng']}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8dba253-ca75-4ba7-a252-975c7dc55383",
   "metadata": {},
   "source": [
    "As seen in the caching section, we can disable caching altogether to force the workflow to re-run, despite its mutable data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "6ce2a6ad-b241-48e8-8303-19f2a64c5a26",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a__my_name_is': \"My name is Alice, and I've collected ['Alice']\",\n",
       " 'b__my_name_is': \"My name is Bob, and I've collected ['Alice', 'Bob']\",\n",
       " 'c__my_name_is': \"My name is Chandy, and I've collected ['Alice', 'Bob', 'Chandy']\",\n",
       " 'd__my_name_is': \"My name is Deng, and I've collected ['Alice', 'Bob', 'Chandy', 'Deng']\",\n",
       " 'd__collection': ['Alice', 'Bob', 'Chandy', 'Deng']}"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for n in wf:\n",
    "    n.use_cache = False\n",
    "wf()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3af541f0-0eab-4d7f-be32-cd906bd1fc5a",
   "metadata": {},
   "source": [
    "## Flow control\n",
    "\n",
    "Workflows and macros automatically generate execution signal connections based on the topology of the data flow (once at instantiation for macros, and at each run for workflows). This is possible if and only if the data flow forms a directed acyclic graph (DAG). It's possible you may want to impose a particular execution order even when there is no direct data dependence between two nodes (although this is a bit of a code smell, and you should seriously ask _should_ these nodes have a data dependence?)\n",
    "\n",
    "Under the hood, when each node finishes running, it fires off all the signals in its `emitting_channels` property. Typically this is just `ran`, but the standard library `If` node shows an example of how this can be extended:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "6f15aa9c-c51e-4646-bba4-9debb7840031",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mType:\u001b[0m        property\n",
       "\u001b[0;31mString form:\u001b[0m <property object at 0x1326a60c0>\n",
       "\u001b[0;31mSource:\u001b[0m     \n",
       "\u001b[0;31m# pwf.standard_nodes.If.emitting_channels.fget\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\u001b[0;32mdef\u001b[0m \u001b[0memitting_channels\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mOutputSignal\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtruth\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mNOT_DATA\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m        \u001b[0;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0memitting_channels\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtruth\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m        \u001b[0;32mreturn\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0memitting_channels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msignals\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m        \u001b[0;32mreturn\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0memitting_channels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msignals\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pwf.standard_nodes.If.emitting_channels??"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0fa89a2-41b4-4a24-ae74-07450404653c",
   "metadata": {},
   "source": [
    "These output signal channels can be connected to input signal channels which trigger functions on their owner -- a `run` command for the default input signal channels. This can happen directly (when unparented nodes are connected) or by the mediation of a parent (if the nodes belong to a workflow or macro)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef7a9c52-1562-40d3-ae06-5fa9e8298ea1",
   "metadata": {},
   "source": [
    "The two standard input signals are `run`, which triggers a run whenever _any_ of its connections emits, or `accumulate_and_run`, which triggers a run after _all_ of its connections have emitted at least once:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "3cec7b96-2ad4-48f8-bd30-ac022ee8a758",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  start\n",
      "start  immediate\n",
      "start immediate collecting\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'collecting__z': 'collecting'}"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@pwf.as_function_node\n",
    "def Verbose(x, y, z):\n",
    "    print(x, y, z)\n",
    "    return z\n",
    "\n",
    "wf = pwf.Workflow(\"run_control\")\n",
    "wf.start = Verbose(\"\", \"\", \"start\")\n",
    "wf.immediate = Verbose(wf.start, \"\", \"immediate\")\n",
    "wf.collecting = Verbose(wf.start, wf.immediate, \"collecting\")\n",
    "\n",
    "wf.immediate.signals.input.run = wf.start.signals.output.ran\n",
    "wf.collecting.signals.input.accumulate_and_run = wf.start.signals.output.ran\n",
    "wf.collecting.signals.input.accumulate_and_run = wf.immediate.signals.output.ran\n",
    "\n",
    "wf.starting_nodes = [wf.start]\n",
    "\n",
    "# If _any_ signals are manually set, then _all_ signals and starting nodes must be set\n",
    "# There is no mixing and matching\n",
    "\n",
    "wf.automate_execution = False  # This flag is needed only for Workflows, but not in Macro definitions\n",
    "\n",
    "wf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "d27bb0d5-26ea-4675-8fda-e4ce0b489591",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 12.0.0 (0)\n",
       " -->\n",
       "<!-- Title: clusterrun_control Pages: 1 -->\n",
       "<svg width=\"720pt\" height=\"258pt\"\n",
       " viewBox=\"0.00 0.00 720.00 258.03\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(0.516059 0.516059) rotate(0) translate(4 496)\">\n",
       "<title>clusterrun_control</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-496 1391.19,-496 1391.19,4 -4,4\"/>\n",
       "<text text-anchor=\"middle\" x=\"693.59\" y=\"-5.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">run_control: Workflow</text>\n",
       "<g id=\"clust1\" class=\"cluster\">\n",
       "<title>clusterrun_controlInputs</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust1_l_0\" gradientUnits=\"userSpaceOnUse\" x1=\"8\" y1=\"-257.5\" x2=\"166.75\" y2=\"-257.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust1_l_0)\" stroke=\"#a5a4a5\" points=\"8,-31 8,-484 166.75,-484 166.75,-31 8,-31\"/>\n",
       "<text text-anchor=\"middle\" x=\"87.38\" y=\"-466.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">Inputs</text>\n",
       "</g>\n",
       "<g id=\"clust2\" class=\"cluster\">\n",
       "<title>clusterrun_controlOutputs</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust2_l_1\" gradientUnits=\"userSpaceOnUse\" x1=\"1379.19\" y1=\"-176.5\" x2=\"1241\" y2=\"-176.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust2_l_1)\" stroke=\"#a5a4a5\" points=\"1241,-85 1241,-268 1379.19,-268 1379.19,-85 1241,-85\"/>\n",
       "<text text-anchor=\"middle\" x=\"1310.09\" y=\"-250.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">Outputs</text>\n",
       "</g>\n",
       "<g id=\"clust3\" class=\"cluster\">\n",
       "<title>clusterrun_controlstart</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust3_l_2\" gradientUnits=\"userSpaceOnUse\" x1=\"178.75\" y1=\"-296\" x2=\"523.5\" y2=\"-296\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust3_l_2)\" stroke=\"#bfe2bf\" stroke-width=\"2\" points=\"178.75,-131 178.75,-461 523.5,-461 523.5,-131 178.75,-131\"/>\n",
       "<text text-anchor=\"middle\" x=\"351.12\" y=\"-443.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">start: Verbose</text>\n",
       "</g>\n",
       "<g id=\"clust4\" class=\"cluster\">\n",
       "<title>clusterrun_controlstartInputs</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust4_l_3\" gradientUnits=\"userSpaceOnUse\" x1=\"186.75\" y1=\"-284.5\" x2=\"345.5\" y2=\"-284.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust4_l_3)\" stroke=\"#a5a4a5\" points=\"186.75,-139 186.75,-430 345.5,-430 345.5,-139 186.75,-139\"/>\n",
       "<text text-anchor=\"middle\" x=\"266.12\" y=\"-412.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">Inputs</text>\n",
       "</g>\n",
       "<g id=\"clust5\" class=\"cluster\">\n",
       "<title>clusterrun_controlstartOutputsWithInjection</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust5_l_4\" gradientUnits=\"userSpaceOnUse\" x1=\"515.5\" y1=\"-302.5\" x2=\"373.5\" y2=\"-302.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust5_l_4)\" stroke=\"#a5a4a5\" points=\"373.5,-211 373.5,-394 515.5,-394 515.5,-211 373.5,-211\"/>\n",
       "<text text-anchor=\"middle\" x=\"444.5\" y=\"-376.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">OutputsWithInjection</text>\n",
       "</g>\n",
       "<g id=\"clust6\" class=\"cluster\">\n",
       "<title>clusterrun_controlimmediate</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust6_l_5\" gradientUnits=\"userSpaceOnUse\" x1=\"531.5\" y1=\"-206\" x2=\"876.25\" y2=\"-206\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust6_l_5)\" stroke=\"#bfe2bf\" stroke-width=\"2\" points=\"531.5,-41 531.5,-371 876.25,-371 876.25,-41 531.5,-41\"/>\n",
       "<text text-anchor=\"middle\" x=\"703.88\" y=\"-353.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">immediate: Verbose</text>\n",
       "</g>\n",
       "<g id=\"clust7\" class=\"cluster\">\n",
       "<title>clusterrun_controlimmediateInputs</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust7_l_6\" gradientUnits=\"userSpaceOnUse\" x1=\"539.5\" y1=\"-194.5\" x2=\"698.25\" y2=\"-194.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust7_l_6)\" stroke=\"#a5a4a5\" points=\"539.5,-49 539.5,-340 698.25,-340 698.25,-49 539.5,-49\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-322.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">Inputs</text>\n",
       "</g>\n",
       "<g id=\"clust8\" class=\"cluster\">\n",
       "<title>clusterrun_controlimmediateOutputsWithInjection</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust8_l_7\" gradientUnits=\"userSpaceOnUse\" x1=\"868.25\" y1=\"-248.5\" x2=\"726.25\" y2=\"-248.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust8_l_7)\" stroke=\"#a5a4a5\" points=\"726.25,-157 726.25,-340 868.25,-340 868.25,-157 726.25,-157\"/>\n",
       "<text text-anchor=\"middle\" x=\"797.25\" y=\"-322.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">OutputsWithInjection</text>\n",
       "</g>\n",
       "<g id=\"clust9\" class=\"cluster\">\n",
       "<title>clusterrun_controlcollecting</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust9_l_8\" gradientUnits=\"userSpaceOnUse\" x1=\"884.25\" y1=\"-316\" x2=\"1229\" y2=\"-316\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust9_l_8)\" stroke=\"#bfe2bf\" stroke-width=\"2\" points=\"884.25,-151 884.25,-481 1229,-481 1229,-151 884.25,-151\"/>\n",
       "<text text-anchor=\"middle\" x=\"1056.62\" y=\"-463.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">collecting: Verbose</text>\n",
       "</g>\n",
       "<g id=\"clust10\" class=\"cluster\">\n",
       "<title>clusterrun_controlcollectingInputs</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust10_l_9\" gradientUnits=\"userSpaceOnUse\" x1=\"892.25\" y1=\"-304.5\" x2=\"1051\" y2=\"-304.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust10_l_9)\" stroke=\"#a5a4a5\" points=\"892.25,-159 892.25,-450 1051,-450 1051,-159 892.25,-159\"/>\n",
       "<text text-anchor=\"middle\" x=\"971.63\" y=\"-432.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">Inputs</text>\n",
       "</g>\n",
       "<g id=\"clust11\" class=\"cluster\">\n",
       "<title>clusterrun_controlcollectingOutputsWithInjection</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust11_l_10\" gradientUnits=\"userSpaceOnUse\" x1=\"1221\" y1=\"-250.5\" x2=\"1079\" y2=\"-250.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust11_l_10)\" stroke=\"#a5a4a5\" points=\"1079,-159 1079,-342 1221,-342 1221,-159 1079,-159\"/>\n",
       "<text text-anchor=\"middle\" x=\"1150\" y=\"-324.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">OutputsWithInjection</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlInputsrun -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>clusterrun_controlInputsrun</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"102.38,-69 60.38,-69 60.38,-45 102.38,-45 114.38,-57 102.38,-69\"/>\n",
       "<text text-anchor=\"middle\" x=\"87.38\" y=\"-51.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">run</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlOutputsran -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>clusterrun_controlOutputsran</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1325.09,-123 1283.09,-123 1283.09,-99 1325.09,-99 1337.09,-111 1325.09,-123\"/>\n",
       "<text text-anchor=\"middle\" x=\"1310.09\" y=\"-105.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">ran</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlInputsrun&#45;&gt;clusterrun_controlOutputsran -->\n",
       "<!-- clusterrun_controlInputsaccumulate_and_run -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>clusterrun_controlInputsaccumulate_and_run</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"146.75,-123 16,-123 16,-99 146.75,-99 158.75,-111 146.75,-123\"/>\n",
       "<text text-anchor=\"middle\" x=\"87.38\" y=\"-105.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">accumulate_and_run</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlInputsstart__x -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>clusterrun_controlInputsstart__x</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"87.38\" cy=\"-327\" rx=\"41.6\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"87.38\" y=\"-321.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">start__x</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlstartInputsx -->\n",
       "<g id=\"node14\" class=\"node\">\n",
       "<title>clusterrun_controlstartInputsx</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"266.12\" cy=\"-327\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"266.12\" y=\"-321.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlInputsstart__x&#45;&gt;clusterrun_controlstartInputsx -->\n",
       "<g id=\"edge11\" class=\"edge\">\n",
       "<title>clusterrun_controlInputsstart__x&#45;&gt;clusterrun_controlstartInputsx</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M129.37,-327C144.2,-327 161.57,-327 178.82,-327\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M178.82,-327C196.08,-327 213.23,-327 227.64,-327\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"227.36,-330.5 237.36,-327 227.36,-323.5 227.36,-330.5\"/>\n",
       "</g>\n",
       "<!-- clusterrun_controlInputsstart__y -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>clusterrun_controlInputsstart__y</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"87.38\" cy=\"-381\" rx=\"41.6\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"87.38\" y=\"-375.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">start__y</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlstartInputsy -->\n",
       "<g id=\"node15\" class=\"node\">\n",
       "<title>clusterrun_controlstartInputsy</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"266.12\" cy=\"-381\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"266.12\" y=\"-375.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">y</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlInputsstart__y&#45;&gt;clusterrun_controlstartInputsy -->\n",
       "<g id=\"edge12\" class=\"edge\">\n",
       "<title>clusterrun_controlInputsstart__y&#45;&gt;clusterrun_controlstartInputsy</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M129.37,-381C144.2,-381 161.57,-381 178.82,-381\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M178.82,-381C196.08,-381 213.23,-381 227.64,-381\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"227.36,-384.5 237.36,-381 227.36,-377.5 227.36,-384.5\"/>\n",
       "</g>\n",
       "<!-- clusterrun_controlInputsstart__z -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>clusterrun_controlInputsstart__z</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"87.38\" cy=\"-273\" rx=\"41.6\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"87.38\" y=\"-267.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">start__z</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlstartInputsz -->\n",
       "<g id=\"node16\" class=\"node\">\n",
       "<title>clusterrun_controlstartInputsz</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"266.12\" cy=\"-273\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"266.12\" y=\"-267.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">z</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlInputsstart__z&#45;&gt;clusterrun_controlstartInputsz -->\n",
       "<g id=\"edge13\" class=\"edge\">\n",
       "<title>clusterrun_controlInputsstart__z&#45;&gt;clusterrun_controlstartInputsz</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M129.37,-273C144.2,-273 161.57,-273 178.82,-273\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M178.82,-273C196.08,-273 213.23,-273 227.64,-273\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"227.36,-276.5 237.36,-273 227.36,-269.5 227.36,-276.5\"/>\n",
       "</g>\n",
       "<!-- clusterrun_controlInputsimmediate__y -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>clusterrun_controlInputsimmediate__y</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"87.38\" cy=\"-219\" rx=\"65.97\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"87.38\" y=\"-213.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">immediate__y</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlimmediateInputsy -->\n",
       "<g id=\"node23\" class=\"node\">\n",
       "<title>clusterrun_controlimmediateInputsy</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"618.88\" cy=\"-183\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-177.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">y</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlInputsimmediate__y&#45;&gt;clusterrun_controlimmediateInputsy -->\n",
       "<g id=\"edge14\" class=\"edge\">\n",
       "<title>clusterrun_controlInputsimmediate__y&#45;&gt;clusterrun_controlimmediateInputsy</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M142.22,-208.74C151.45,-204.84 160.18,-199.44 166.75,-192 183.88,-172.59 158.65,-151.31 178.75,-135 201.36,-116.65 249.2,-113.41 305.32,-117.94\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M305.32,-117.94C402.07,-125.73 523.42,-156.61 582.41,-172.86\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"581.46,-176.23 592.03,-175.54 583.33,-169.49 581.46,-176.23\"/>\n",
       "</g>\n",
       "<!-- clusterrun_controlInputsimmediate__z -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>clusterrun_controlInputsimmediate__z</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"87.38\" cy=\"-165\" rx=\"65.97\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"87.38\" y=\"-159.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">immediate__z</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlimmediateInputsz -->\n",
       "<g id=\"node24\" class=\"node\">\n",
       "<title>clusterrun_controlimmediateInputsz</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"618.88\" cy=\"-75\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-69.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">z</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlInputsimmediate__z&#45;&gt;clusterrun_controlimmediateInputsz -->\n",
       "<g id=\"edge15\" class=\"edge\">\n",
       "<title>clusterrun_controlInputsimmediate__z&#45;&gt;clusterrun_controlimmediateInputsz</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M140.13,-153.81C149.77,-149.98 159.17,-144.85 166.75,-138 176.19,-129.46 168.33,-119.3 178.75,-112 231.34,-75.15 296.65,-58.48 360.69,-52.73\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M360.69,-52.73C449.17,-44.78 535.23,-57.67 581.92,-66.91\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"580.94,-70.28 591.44,-68.87 582.35,-63.43 580.94,-70.28\"/>\n",
       "</g>\n",
       "<!-- clusterrun_controlInputscollecting__z -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>clusterrun_controlInputscollecting__z</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"87.38\" cy=\"-435\" rx=\"61.09\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"87.38\" y=\"-429.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">collecting__z</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlcollectingInputsz -->\n",
       "<g id=\"node32\" class=\"node\">\n",
       "<title>clusterrun_controlcollectingInputsz</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"971.63\" cy=\"-401\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"971.63\" y=\"-395.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">z</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlInputscollecting__z&#45;&gt;clusterrun_controlcollectingInputsz -->\n",
       "<g id=\"edge16\" class=\"edge\">\n",
       "<title>clusterrun_controlInputscollecting__z&#45;&gt;clusterrun_controlcollectingInputsz</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M138.64,-445.21C207.14,-458.2 333.81,-479 443,-479 443,-479 443,-479 473.64,-479\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M473.64,-479C497.97,-479 541.6,-479 619.88,-479 738.8,-479 875.1,-435.75 936.96,-413.66\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"937.99,-417.01 946.2,-410.31 935.61,-410.43 937.99,-417.01\"/>\n",
       "</g>\n",
       "<!-- clusterrun_controlOutputsfailed -->\n",
       "<g id=\"node10\" class=\"node\">\n",
       "<title>clusterrun_controlOutputsfailed</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1325.09,-177 1283.09,-177 1283.09,-153 1325.09,-153 1337.09,-165 1325.09,-177\"/>\n",
       "<text text-anchor=\"middle\" x=\"1310.09\" y=\"-159.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">failed</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlOutputscollecting__z -->\n",
       "<g id=\"node11\" class=\"node\">\n",
       "<title>clusterrun_controlOutputscollecting__z</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"1310.09\" cy=\"-219\" rx=\"61.09\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"1310.09\" y=\"-213.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">collecting__z</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlstartInputsrun -->\n",
       "<g id=\"node12\" class=\"node\">\n",
       "<title>clusterrun_controlstartInputsrun</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"281.12,-177 239.12,-177 239.12,-153 281.12,-153 293.12,-165 281.12,-177\"/>\n",
       "<text text-anchor=\"middle\" x=\"266.12\" y=\"-159.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">run</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlstartOutputsWithInjectionran -->\n",
       "<g id=\"node17\" class=\"node\">\n",
       "<title>clusterrun_controlstartOutputsWithInjectionran</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"459,-249 417,-249 417,-225 459,-225 471,-237 459,-249\"/>\n",
       "<text text-anchor=\"middle\" x=\"444\" y=\"-231.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">ran</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlstartInputsrun&#45;&gt;clusterrun_controlstartOutputsWithInjectionran -->\n",
       "<!-- clusterrun_controlstartInputsaccumulate_and_run -->\n",
       "<g id=\"node13\" class=\"node\">\n",
       "<title>clusterrun_controlstartInputsaccumulate_and_run</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"325.5,-231 194.75,-231 194.75,-207 325.5,-207 337.5,-219 325.5,-231\"/>\n",
       "<text text-anchor=\"middle\" x=\"266.12\" y=\"-213.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">accumulate_and_run</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlimmediateInputsrun -->\n",
       "<g id=\"node20\" class=\"node\">\n",
       "<title>clusterrun_controlimmediateInputsrun</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"633.88,-249 591.88,-249 591.88,-225 633.88,-225 645.88,-237 633.88,-249\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-231.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">run</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlstartOutputsWithInjectionran&#45;&gt;clusterrun_controlimmediateInputsrun -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>clusterrun_controlstartOutputsWithInjectionran&#45;&gt;clusterrun_controlimmediateInputsrun</title>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M471.26,-237C485.77,-237 504.77,-237 524.27,-237\"/>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M524.27,-237C543.76,-237 563.74,-237 580.21,-237\"/>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"580.14,-240.5 590.14,-237 580.14,-233.5 580.14,-240.5\"/>\n",
       "</g>\n",
       "<!-- clusterrun_controlcollectingInputsaccumulate_and_run -->\n",
       "<g id=\"node29\" class=\"node\">\n",
       "<title>clusterrun_controlcollectingInputsaccumulate_and_run</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1031,-251 900.25,-251 900.25,-227 1031,-227 1043,-239 1031,-251\"/>\n",
       "<text text-anchor=\"middle\" x=\"971.63\" y=\"-233.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">accumulate_and_run</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlstartOutputsWithInjectionran&#45;&gt;clusterrun_controlcollectingInputsaccumulate_and_run -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>clusterrun_controlstartOutputsWithInjectionran&#45;&gt;clusterrun_controlcollectingInputsaccumulate_and_run</title>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M471.41,-238.92C488.99,-241.68 511.07,-248.29 523.5,-264 534.59,-278.01 518.25,-332.01 531.5,-344 555.96,-366.14 612.74,-378.73 674.02,-381.79\"/>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M674.02,-381.79C755.02,-385.84 843.87,-373.23 876.25,-344 889.18,-332.32 873.23,-279.49 884.25,-266 886.3,-263.49 888.58,-261.21 891.04,-259.14\"/>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"892.59,-262.33 898.78,-253.73 888.58,-256.59 892.59,-262.33\"/>\n",
       "</g>\n",
       "<!-- clusterrun_controlstartOutputsWithInjectionfailed -->\n",
       "<g id=\"node18\" class=\"node\">\n",
       "<title>clusterrun_controlstartOutputsWithInjectionfailed</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"459,-303 417,-303 417,-279 459,-279 471,-291 459,-303\"/>\n",
       "<text text-anchor=\"middle\" x=\"444\" y=\"-285.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">failed</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlstartOutputsWithInjectionz -->\n",
       "<g id=\"node19\" class=\"node\">\n",
       "<title>clusterrun_controlstartOutputsWithInjectionz</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"444\" cy=\"-345\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"444\" y=\"-339.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">z</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlimmediateInputsx -->\n",
       "<g id=\"node22\" class=\"node\">\n",
       "<title>clusterrun_controlimmediateInputsx</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"618.88\" cy=\"-291\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-285.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlstartOutputsWithInjectionz&#45;&gt;clusterrun_controlimmediateInputsx -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>clusterrun_controlstartOutputsWithInjectionz&#45;&gt;clusterrun_controlimmediateInputsx</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M469.04,-337.49C483.83,-332.87 503.85,-326.62 524.4,-320.2\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M524.4,-320.2C544.95,-313.78 566.04,-307.19 582.97,-301.9\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"583.82,-305.31 592.32,-298.98 581.73,-298.62 583.82,-305.31\"/>\n",
       "</g>\n",
       "<!-- clusterrun_controlcollectingInputsx -->\n",
       "<g id=\"node30\" class=\"node\">\n",
       "<title>clusterrun_controlcollectingInputsx</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"971.63\" cy=\"-347\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"971.63\" y=\"-341.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlstartOutputsWithInjectionz&#45;&gt;clusterrun_controlcollectingInputsx -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>clusterrun_controlstartOutputsWithInjectionz&#45;&gt;clusterrun_controlcollectingInputsx</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M466.44,-355.37C483.59,-363.05 508.49,-372.88 531.5,-377 605.56,-390.26 653.66,-397.09 701.29,-397.37\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M701.29,-397.37C750.66,-397.66 799.52,-390.91 876.25,-377 879.99,-376.32 880.66,-375.23 884.25,-374 900.99,-368.25 919.72,-362.33 935.45,-357.51\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"936.31,-360.91 944.86,-354.65 934.27,-354.21 936.31,-360.91\"/>\n",
       "</g>\n",
       "<!-- clusterrun_controlimmediateOutputsWithInjectionran -->\n",
       "<g id=\"node25\" class=\"node\">\n",
       "<title>clusterrun_controlimmediateOutputsWithInjectionran</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"811.75,-195 769.75,-195 769.75,-171 811.75,-171 823.75,-183 811.75,-195\"/>\n",
       "<text text-anchor=\"middle\" x=\"796.75\" y=\"-177.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">ran</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlimmediateInputsrun&#45;&gt;clusterrun_controlimmediateOutputsWithInjectionran -->\n",
       "<!-- clusterrun_controlimmediateInputsaccumulate_and_run -->\n",
       "<g id=\"node21\" class=\"node\">\n",
       "<title>clusterrun_controlimmediateInputsaccumulate_and_run</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"678.25,-141 547.5,-141 547.5,-117 678.25,-117 690.25,-129 678.25,-141\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-123.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">accumulate_and_run</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlimmediateOutputsWithInjectionran&#45;&gt;clusterrun_controlcollectingInputsaccumulate_and_run -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>clusterrun_controlimmediateOutputsWithInjectionran&#45;&gt;clusterrun_controlcollectingInputsaccumulate_and_run</title>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M824.2,-192.03C835.06,-195.71 848.2,-200.13 861.51,-204.54\"/>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M861.51,-204.54C869.17,-207.08 876.88,-209.61 884.25,-212 889.53,-213.71 895,-215.46 900.51,-217.22\"/>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"899.07,-220.43 909.66,-220.11 901.18,-213.76 899.07,-220.43\"/>\n",
       "</g>\n",
       "<!-- clusterrun_controlimmediateOutputsWithInjectionfailed -->\n",
       "<g id=\"node26\" class=\"node\">\n",
       "<title>clusterrun_controlimmediateOutputsWithInjectionfailed</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"811.75,-249 769.75,-249 769.75,-225 811.75,-225 823.75,-237 811.75,-249\"/>\n",
       "<text text-anchor=\"middle\" x=\"796.75\" y=\"-231.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">failed</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlimmediateOutputsWithInjectionz -->\n",
       "<g id=\"node27\" class=\"node\">\n",
       "<title>clusterrun_controlimmediateOutputsWithInjectionz</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"796.75\" cy=\"-291\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"796.75\" y=\"-285.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">z</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlcollectingInputsy -->\n",
       "<g id=\"node31\" class=\"node\">\n",
       "<title>clusterrun_controlcollectingInputsy</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"971.63\" cy=\"-293\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"971.63\" y=\"-287.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">y</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlimmediateOutputsWithInjectionz&#45;&gt;clusterrun_controlcollectingInputsy -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>clusterrun_controlimmediateOutputsWithInjectionz&#45;&gt;clusterrun_controlcollectingInputsy</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M824.01,-291.3C838.52,-291.47 857.52,-291.69 877.02,-291.92\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M877.02,-291.92C896.51,-292.14 916.49,-292.37 932.96,-292.56\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"932.85,-296.06 942.89,-292.68 932.93,-289.06 932.85,-296.06\"/>\n",
       "</g>\n",
       "<!-- clusterrun_controlcollectingInputsrun -->\n",
       "<g id=\"node28\" class=\"node\">\n",
       "<title>clusterrun_controlcollectingInputsrun</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"986.63,-197 944.63,-197 944.63,-173 986.63,-173 998.63,-185 986.63,-197\"/>\n",
       "<text text-anchor=\"middle\" x=\"971.63\" y=\"-179.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">run</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlcollectingOutputsWithInjectionran -->\n",
       "<g id=\"node33\" class=\"node\">\n",
       "<title>clusterrun_controlcollectingOutputsWithInjectionran</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1164.5,-197 1122.5,-197 1122.5,-173 1164.5,-173 1176.5,-185 1164.5,-197\"/>\n",
       "<text text-anchor=\"middle\" x=\"1149.5\" y=\"-179.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">ran</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlcollectingInputsrun&#45;&gt;clusterrun_controlcollectingOutputsWithInjectionran -->\n",
       "<!-- clusterrun_controlcollectingOutputsWithInjectionfailed -->\n",
       "<g id=\"node34\" class=\"node\">\n",
       "<title>clusterrun_controlcollectingOutputsWithInjectionfailed</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1164.5,-251 1122.5,-251 1122.5,-227 1164.5,-227 1176.5,-239 1164.5,-251\"/>\n",
       "<text text-anchor=\"middle\" x=\"1149.5\" y=\"-233.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">failed</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlcollectingOutputsWithInjectionz -->\n",
       "<g id=\"node35\" class=\"node\">\n",
       "<title>clusterrun_controlcollectingOutputsWithInjectionz</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"1149.5\" cy=\"-293\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"1149.5\" y=\"-287.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">z</text>\n",
       "</g>\n",
       "<!-- clusterrun_controlcollectingOutputsWithInjectionz&#45;&gt;clusterrun_controlOutputscollecting__z -->\n",
       "<g id=\"edge17\" class=\"edge\">\n",
       "<title>clusterrun_controlcollectingOutputsWithInjectionz&#45;&gt;clusterrun_controlOutputscollecting__z</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M1174.69,-286.05C1189.58,-281.46 1209.02,-274.91 1226.02,-267.35\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M1226.02,-267.35C1227.02,-266.9 1228.02,-266.45 1229,-266 1244.32,-258.95 1260.5,-249.82 1274.27,-241.48\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"1275.86,-244.61 1282.54,-236.38 1272.19,-238.65 1275.86,-244.61\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.graphs.Digraph at 0x1342f00d0>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf.draw(size=(10, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fd65369-d9c1-4f87-b79c-7e597fba8cac",
   "metadata": {},
   "source": [
    "The same signals can be wired with the following syntactic sugar (and the `>>` can be chained together):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "c52fbef3-ea9b-47db-b179-d9044659cd89",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  start\n",
      "start  immediate\n",
      "start immediate collecting\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'collecting__z': 'collecting'}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf = pwf.Workflow(\"sugar\", automate_execution=False)\n",
    "wf.start = Verbose(\"\", \"\", \"start\")\n",
    "wf.immediate = Verbose(wf.start, \"\", \"immediate\")\n",
    "wf.collecting = Verbose(wf.start, wf.immediate, \"collecting\")\n",
    "\n",
    "wf.start >> wf.immediate\n",
    "wf.collecting << (wf.start, wf.immediate)\n",
    "\n",
    "wf.starting_nodes = [wf.start]\n",
    "\n",
    "wf()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c94ec1bf-5285-43d4-9348-0539c87e17a6",
   "metadata": {},
   "source": [
    "## State behavior and the executor motivation\n",
    "\n",
    "If we look at the `__getstate__` of a child, we will notice its parent has been purged:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "e7270eef-8642-4859-982b-b3c35dda968f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'_label': 'immediate',\n",
       " '_parent': None,\n",
       " '_detached_parent_path': '/sugar',\n",
       " 'running': False,\n",
       " 'failed': False,\n",
       " 'executor': None,\n",
       " 'future': None,\n",
       " '_thread_pool_sleep_time': 1e-06,\n",
       " '_signals': <pyiron_workflow.io.Signals at 0x134379d50>,\n",
       " 'checkpoint': None,\n",
       " '_cached_inputs': {'x': 'start', 'y': '', 'z': 'immediate'},\n",
       " '_user_data': {},\n",
       " '_inputs': <pyiron_workflow.io.Inputs at 0x134352610>,\n",
       " '_outputs': <pyiron_workflow.mixin.injection.OutputsWithInjection at 0x134352d90>}"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf.immediate.__getstate__()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd1774e5-57ed-4ab2-a3f5-b624fb6b8f0e",
   "metadata": {},
   "source": [
    "And similarly the node's connections get purged:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "59cac615-02ee-478e-93a5-e6a8b38c37b3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'channel_dict': {'x': <pyiron_workflow.channels.InputData at 0x13439ac90>,\n",
       "  'y': <pyiron_workflow.channels.InputData at 0x1342fddd0>,\n",
       "  'z': <pyiron_workflow.channels.InputData at 0x134352050>}}"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf.immediate.inputs.__getstate__()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f97c490-9323-4bf0-9cf3-20b30bcd368b",
   "metadata": {},
   "source": [
    "But we see that the parent node retains state about both its children and their connections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "1642ac22-255c-4e50-9a26-a6d6b0cd203d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<__main__.Verbose at 0x1342bf010>,\n",
       " [(('immediate', 'x'), ('start', 'z')),\n",
       "  (('collecting', 'x'), ('start', 'z')),\n",
       "  (('collecting', 'y'), ('immediate', 'z'))])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parent_state = wf.__getstate__()\n",
    "parent_state[\"start\"], parent_state[\"_child_data_connections\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95ce64a2-73a8-4399-9c1d-bebda965b942",
   "metadata": {},
   "source": [
    "This is actually some important engineering. Sending a node off to a parallel process with an executor requires serializing data to send to the new process. For `concurrent.futures.ProcessPoolExecutor` and those compliant with it (our expectation for these circumstances) that involves using `__getstate__` (well, `__reduce__`, but the state comes out under the hood). When we send a `Function` node off for parallel execution, we actually only send the `Function.node_function` (remember it is a `@staticmethod`!!!) and the actual input data. But for `Macro` nodes, we necessarily send the entire node so there is something there to run the subgraph! If we sent the macro's parent along, or its connections, we'd need to serialize _the entire graph_ when we run just one piece on a separate process!\n",
    "\n",
    "This careful management of state minimizes how much data we actually need to serialize "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6a3b48f-eda6-4947-a1b2-22abfa394293",
   "metadata": {},
   "source": [
    "## Executor limitations\n",
    "\n",
    "In a similar manner, there are some things we can't serialize, namely thread locks and other executor-related objects. That means that, at present, you can't _nest_ executors. The motivated reader can see that there is room to extend this, e.g. by accepting a node _class_ (which is serializable) and some arguments for it and recreating one on-the-fly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "2784b0c2-035e-44bb-b790-0d5fe2a84331",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m \u001b[0mRunnable\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parse_executor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexecutor\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;34m'StdLibExecutor'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mSource:\u001b[0m   \n",
       "    \u001b[0;34m@\u001b[0m\u001b[0mstaticmethod\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0;32mdef\u001b[0m \u001b[0m_parse_executor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexecutor\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mStdLibExecutor\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m        \u001b[0;34m\"\"\"\u001b[0m\n",
       "\u001b[0;34m        We may want to allow users to specify how to build an executor rather than\u001b[0m\n",
       "\u001b[0;34m        actually providing an executor instance -- so here we can interpret these.\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m        NOTE:\u001b[0m\n",
       "\u001b[0;34m            `concurrent.futures.Executor` _won't_ actually work, because we need\u001b[0m\n",
       "\u001b[0;34m            stuff with :mod:`cloudpickle` support. We're leaning on this for a guaranteed\u001b[0m\n",
       "\u001b[0;34m            interface (has `submit` and returns a `Future`), and leaving it to the user\u001b[0m\n",
       "\u001b[0;34m            to provide an executor that will actually work!!!\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m        NOTE:\u001b[0m\n",
       "\u001b[0;34m            If, in the future, this parser is extended to instantiate new executors from\u001b[0m\n",
       "\u001b[0;34m            instructions, these new instances may not be caught by the\u001b[0m\n",
       "\u001b[0;34m            `executor_shutdown` method. This will require some re-engineering to make\u001b[0m\n",
       "\u001b[0;34m            sure we don't have dangling executors.\u001b[0m\n",
       "\u001b[0;34m        \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m        \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexecutor\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mStdLibExecutor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m            \u001b[0;32mreturn\u001b[0m \u001b[0mexecutor\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m        \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m            \u001b[0;32mraise\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m                \u001b[0;34mf\"Expected an instance of {StdLibExecutor}, but got {executor}.\"\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m            \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mFile:\u001b[0m      ~/work/pyiron/pyiron_workflow/pyiron_workflow/mixin/run.py\n",
       "\u001b[0;31mType:\u001b[0m      function"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from pyiron_workflow.mixin.run import Runnable\n",
    "\n",
    "Runnable._parse_executor??"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e09e6b40-6cbe-4198-817c-a9f1e75e44b3",
   "metadata": {},
   "source": [
    "## While loops\n",
    "\n",
    "While-loops involve some circular flow of data that terminates on a particular data condition. These _require_ manual specification of the execution signals, as data signals alone are not enough to resolve the oroborous of flow. Thankfully, by virtue of `Macro` nodes being walled gardens, once you have encapsulated your while-behaviour inside a macro, that macro can be embedded in a usual data DAG and the parent-level execution flow can be automated as usual.\n",
    "\n",
    "We don't have the same helper interfaces for \"while\" loops as we do for \"for\" loops discussed in the `quickstart.ipynb`, but thankfully they can just be constructed as a macro definition out of existing tools. The only \"magic\" piece we haven't discussed yet is the standard library `If` node -- the curious reader can go look at its definition, but basically it just has extra output signals other than `ran` which fire depending on the truthiness of its input condition. Otherwise we will use tools we've seen before. \n",
    "\n",
    "In the example below, we follow a pattern of breaking the while loop into `body`, `condition`, and `switch` nodes (and `history` for some state logging). This pattern can be generically followed, but the exact data connections formed between your `body` and `conditon` nodes will depend on the details of what your while-loop body is doing and what the break conditions are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "e0916c46-132c-4046-827e-a75fff6dbc5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "@pwf.as_macro_node(\"greater\")\n",
    "def AddWhileLessThan(self, a, b, cap):\n",
    "    \"\"\"\n",
    "    Add :param:`b` to :param:`a` while the sum is less than or equal to :param:`cap`.\n",
    "\n",
    "    A simple but complete demonstrator for how to construct cyclic flows, including\n",
    "    logging key outputs during the loop.\n",
    "    \"\"\"\n",
    "    # Bespoke logic\n",
    "    self.body = pwf.standard_nodes.Add(obj=a, other=b)\n",
    "    self.body.inputs.obj = self.body.outputs.add  # Higher priority connection\n",
    "    # The output is NOT_DATA on the first pass and `a` gets used, \n",
    "    # But after that the node will find and use its own output\n",
    "    self.condition = pwf.standard_nodes.LessThan(self.body, cap)\n",
    "\n",
    "    # Universal logic\n",
    "    self.switch = pwf.standard_nodes.If()\n",
    "    self.switch.inputs.condition = self.condition\n",
    "\n",
    "    self.starting_nodes = [self.body]\n",
    "    self.body >> self.condition >> self.switch\n",
    "    self.switch.signals.output.true >> self.body\n",
    "\n",
    "    # Bespoke logging\n",
    "    self.history = pwf.standard_nodes.AppendToList()\n",
    "    self.history.inputs.existing = self.history\n",
    "    self.history.inputs.new_element = self.body\n",
    "    self.body >> self.history\n",
    "\n",
    "    # Returns are pretty universal for single-value body nodes,\n",
    "    # assuming a log of the history is not desired as output,\n",
    "    # but in general return values are also bespoke\n",
    "    return self.body"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "ce8a3c1f-64e9-4da1-b29b-d16717d03b22",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 12.0.0 (0)\n",
       " -->\n",
       "<!-- Title: clusterAddWhileLessThan Pages: 1 -->\n",
       "<svg width=\"720pt\" height=\"478pt\"\n",
       " viewBox=\"0.00 0.00 720.00 477.69\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(0.578313 0.578313) rotate(0) translate(4 822)\">\n",
       "<title>clusterAddWhileLessThan</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-822 1241,-822 1241,4 -4,4\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.5\" y=\"-5.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">AddWhileLessThan: AddWhileLessThan</text>\n",
       "<g id=\"clust1\" class=\"cluster\">\n",
       "<title>clusterAddWhileLessThanInputs</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust1_l_0\" gradientUnits=\"userSpaceOnUse\" x1=\"8\" y1=\"-493.5\" x2=\"166.75\" y2=\"-493.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust1_l_0)\" stroke=\"#a5a4a5\" points=\"8,-348 8,-639 166.75,-639 166.75,-348 8,-348\"/>\n",
       "<text text-anchor=\"middle\" x=\"87.38\" y=\"-621.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">Inputs</text>\n",
       "</g>\n",
       "<g id=\"clust2\" class=\"cluster\">\n",
       "<title>clusterAddWhileLessThanOutputsWithInjection</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust2_l_1\" gradientUnits=\"userSpaceOnUse\" x1=\"690.38\" y1=\"-718.5\" x2=\"548.38\" y2=\"-718.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust2_l_1)\" stroke=\"#a5a4a5\" points=\"548.38,-627 548.38,-810 690.38,-810 690.38,-627 548.38,-627\"/>\n",
       "<text text-anchor=\"middle\" x=\"619.38\" y=\"-792.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">OutputsWithInjection</text>\n",
       "</g>\n",
       "<g id=\"clust3\" class=\"cluster\">\n",
       "<title>clusterAddWhileLessThanbody</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust3_l_2\" gradientUnits=\"userSpaceOnUse\" x1=\"178.75\" y1=\"-478\" x2=\"523.5\" y2=\"-478\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust3_l_2)\" stroke=\"#bfe2bf\" stroke-width=\"2\" points=\"178.75,-340 178.75,-616 523.5,-616 523.5,-340 178.75,-340\"/>\n",
       "<text text-anchor=\"middle\" x=\"351.13\" y=\"-598.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">body: Add</text>\n",
       "</g>\n",
       "<g id=\"clust4\" class=\"cluster\">\n",
       "<title>clusterAddWhileLessThanbodyInputs</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust4_l_3\" gradientUnits=\"userSpaceOnUse\" x1=\"186.75\" y1=\"-466.5\" x2=\"345.5\" y2=\"-466.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust4_l_3)\" stroke=\"#a5a4a5\" points=\"186.75,-348 186.75,-585 345.5,-585 345.5,-348 186.75,-348\"/>\n",
       "<text text-anchor=\"middle\" x=\"266.13\" y=\"-567.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">Inputs</text>\n",
       "</g>\n",
       "<g id=\"clust5\" class=\"cluster\">\n",
       "<title>clusterAddWhileLessThanbodyOutputsWithInjection</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust5_l_4\" gradientUnits=\"userSpaceOnUse\" x1=\"515.5\" y1=\"-439.5\" x2=\"373.5\" y2=\"-439.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust5_l_4)\" stroke=\"#a5a4a5\" points=\"373.5,-348 373.5,-531 515.5,-531 515.5,-348 373.5,-348\"/>\n",
       "<text text-anchor=\"middle\" x=\"444.5\" y=\"-513.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">OutputsWithInjection</text>\n",
       "</g>\n",
       "<g id=\"clust6\" class=\"cluster\">\n",
       "<title>clusterAddWhileLessThancondition</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust6_l_5\" gradientUnits=\"userSpaceOnUse\" x1=\"531.5\" y1=\"-169\" x2=\"884.25\" y2=\"-169\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust6_l_5)\" stroke=\"#bfe2bf\" stroke-width=\"2\" points=\"531.5,-31 531.5,-307 884.25,-307 884.25,-31 531.5,-31\"/>\n",
       "<text text-anchor=\"middle\" x=\"707.88\" y=\"-289.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">condition: LessThan</text>\n",
       "</g>\n",
       "<g id=\"clust7\" class=\"cluster\">\n",
       "<title>clusterAddWhileLessThanconditionInputs</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust7_l_6\" gradientUnits=\"userSpaceOnUse\" x1=\"539.5\" y1=\"-157.5\" x2=\"698.25\" y2=\"-157.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust7_l_6)\" stroke=\"#a5a4a5\" points=\"539.5,-39 539.5,-276 698.25,-276 698.25,-39 539.5,-39\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-258.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">Inputs</text>\n",
       "</g>\n",
       "<g id=\"clust8\" class=\"cluster\">\n",
       "<title>clusterAddWhileLessThanconditionOutputsWithInjection</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust8_l_7\" gradientUnits=\"userSpaceOnUse\" x1=\"876.25\" y1=\"-184.5\" x2=\"734.25\" y2=\"-184.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust8_l_7)\" stroke=\"#a5a4a5\" points=\"734.25,-93 734.25,-276 876.25,-276 876.25,-93 734.25,-93\"/>\n",
       "<text text-anchor=\"middle\" x=\"805.25\" y=\"-258.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">OutputsWithInjection</text>\n",
       "</g>\n",
       "<g id=\"clust9\" class=\"cluster\">\n",
       "<title>clusterAddWhileLessThanswitch</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust9_l_8\" gradientUnits=\"userSpaceOnUse\" x1=\"892.25\" y1=\"-250\" x2=\"1237\" y2=\"-250\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust9_l_8)\" stroke=\"#bfe2bf\" stroke-width=\"2\" points=\"892.25,-85 892.25,-415 1237,-415 1237,-85 892.25,-85\"/>\n",
       "<text text-anchor=\"middle\" x=\"1064.63\" y=\"-397.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">switch: If</text>\n",
       "</g>\n",
       "<g id=\"clust10\" class=\"cluster\">\n",
       "<title>clusterAddWhileLessThanswitchInputs</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust10_l_9\" gradientUnits=\"userSpaceOnUse\" x1=\"900.25\" y1=\"-184.5\" x2=\"1059\" y2=\"-184.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust10_l_9)\" stroke=\"#a5a4a5\" points=\"900.25,-93 900.25,-276 1059,-276 1059,-93 900.25,-93\"/>\n",
       "<text text-anchor=\"middle\" x=\"979.63\" y=\"-258.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">Inputs</text>\n",
       "</g>\n",
       "<g id=\"clust11\" class=\"cluster\">\n",
       "<title>clusterAddWhileLessThanswitchOutputsWithInjection</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust11_l_10\" gradientUnits=\"userSpaceOnUse\" x1=\"1229\" y1=\"-238.5\" x2=\"1087\" y2=\"-238.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust11_l_10)\" stroke=\"#a5a4a5\" points=\"1087,-93 1087,-384 1229,-384 1229,-93 1087,-93\"/>\n",
       "<text text-anchor=\"middle\" x=\"1158\" y=\"-366.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">OutputsWithInjection</text>\n",
       "</g>\n",
       "<g id=\"clust12\" class=\"cluster\">\n",
       "<title>clusterAddWhileLessThanhistory</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust12_l_11\" gradientUnits=\"userSpaceOnUse\" x1=\"531.5\" y1=\"-481\" x2=\"884.25\" y2=\"-481\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust12_l_11)\" stroke=\"#bfe2bf\" stroke-width=\"2\" points=\"531.5,-343 531.5,-619 884.25,-619 884.25,-343 531.5,-343\"/>\n",
       "<text text-anchor=\"middle\" x=\"707.88\" y=\"-601.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">history: AppendToList</text>\n",
       "</g>\n",
       "<g id=\"clust13\" class=\"cluster\">\n",
       "<title>clusterAddWhileLessThanhistoryInputs</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust13_l_12\" gradientUnits=\"userSpaceOnUse\" x1=\"539.5\" y1=\"-469.5\" x2=\"698.25\" y2=\"-469.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust13_l_12)\" stroke=\"#a5a4a5\" points=\"539.5,-351 539.5,-588 698.25,-588 698.25,-351 539.5,-351\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-570.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">Inputs</text>\n",
       "</g>\n",
       "<g id=\"clust14\" class=\"cluster\">\n",
       "<title>clusterAddWhileLessThanhistoryOutputsWithInjection</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust14_l_13\" gradientUnits=\"userSpaceOnUse\" x1=\"876.25\" y1=\"-442.5\" x2=\"734.25\" y2=\"-442.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust14_l_13)\" stroke=\"#a5a4a5\" points=\"734.25,-351 734.25,-534 876.25,-534 876.25,-351 734.25,-351\"/>\n",
       "<text text-anchor=\"middle\" x=\"805.25\" y=\"-516.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">OutputsWithInjection</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanInputsrun -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanInputsrun</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"102.38,-602 60.38,-602 60.38,-578 102.38,-578 114.38,-590 102.38,-602\"/>\n",
       "<text text-anchor=\"middle\" x=\"87.38\" y=\"-584.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">run</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanOutputsWithInjectionran -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanOutputsWithInjectionran</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"633.88,-773 591.88,-773 591.88,-749 633.88,-749 645.88,-761 633.88,-773\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-755.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">ran</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanInputsrun&#45;&gt;clusterAddWhileLessThanOutputsWithInjectionran -->\n",
       "<!-- clusterAddWhileLessThanInputsaccumulate_and_run -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanInputsaccumulate_and_run</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"146.75,-440 16,-440 16,-416 146.75,-416 158.75,-428 146.75,-440\"/>\n",
       "<text text-anchor=\"middle\" x=\"87.38\" y=\"-422.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">accumulate_and_run</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanInputsa -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanInputsa</title>\n",
       "<ellipse fill=\"none\" stroke=\"#edb22c\" stroke-width=\"2\" cx=\"87.38\" cy=\"-482\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"87.38\" y=\"-476.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">a</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanbodyInputsobj -->\n",
       "<g id=\"node11\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanbodyInputsobj</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"266.13\" cy=\"-482\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"266.13\" y=\"-476.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">obj</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanInputsa&#45;&gt;clusterAddWhileLessThanbodyInputsobj -->\n",
       "<g id=\"edge15\" class=\"edge\">\n",
       "<title>clusterAddWhileLessThanInputsa&#45;&gt;clusterAddWhileLessThanbodyInputsobj</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" stroke-dasharray=\"5,2\" d=\"M114.84,-482C129.78,-482 149.48,-482 169.67,-482\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" stroke-dasharray=\"5,2\" d=\"M169.67,-482C189.86,-482 210.55,-482 227.48,-482\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"227.26,-485.5 237.26,-482 227.26,-478.5 227.26,-485.5\"/>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanInputsb -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanInputsb</title>\n",
       "<ellipse fill=\"none\" stroke=\"#edb22c\" stroke-width=\"2\" cx=\"87.38\" cy=\"-536\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"87.38\" y=\"-530.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">b</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanbodyInputsother -->\n",
       "<g id=\"node12\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanbodyInputsother</title>\n",
       "<ellipse fill=\"none\" stroke=\"#edb22c\" stroke-width=\"2\" cx=\"266.13\" cy=\"-536\" rx=\"30.38\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"266.13\" y=\"-530.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">other</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanInputsb&#45;&gt;clusterAddWhileLessThanbodyInputsother -->\n",
       "<g id=\"edge16\" class=\"edge\">\n",
       "<title>clusterAddWhileLessThanInputsb&#45;&gt;clusterAddWhileLessThanbodyInputsother</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" stroke-dasharray=\"5,2\" d=\"M114.84,-536C129.31,-536 148.23,-536 167.75,-536\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" stroke-dasharray=\"5,2\" d=\"M167.75,-536C187.27,-536 207.37,-536 224.21,-536\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"224.02,-539.5 234.02,-536 224.02,-532.5 224.02,-539.5\"/>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanInputscap -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanInputscap</title>\n",
       "<ellipse fill=\"none\" stroke=\"#edb22c\" stroke-width=\"2\" cx=\"87.38\" cy=\"-374\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"87.38\" y=\"-368.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">cap</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanconditionInputsother -->\n",
       "<g id=\"node19\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanconditionInputsother</title>\n",
       "<ellipse fill=\"none\" stroke=\"#edb22c\" stroke-width=\"2\" cx=\"618.88\" cy=\"-65\" rx=\"30.38\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-59.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">other</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanInputscap&#45;&gt;clusterAddWhileLessThanconditionInputsother -->\n",
       "<g id=\"edge17\" class=\"edge\">\n",
       "<title>clusterAddWhileLessThanInputscap&#45;&gt;clusterAddWhileLessThanconditionInputsother</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" stroke-dasharray=\"5,2\" d=\"M105.55,-360.67C137.12,-336.45 209.3,-282.42 297.41,-225\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" stroke-dasharray=\"5,2\" d=\"M297.41,-225C369.3,-178.14 451.79,-129.02 531.5,-92 546.75,-84.92 564.35,-79.04 579.66,-74.59\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"580.19,-78.08 588.88,-72.02 578.31,-71.33 580.19,-78.08\"/>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanOutputsWithInjectionfailed -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanOutputsWithInjectionfailed</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"633.88,-719 591.88,-719 591.88,-695 633.88,-695 645.88,-707 633.88,-719\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-701.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">failed</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanOutputsWithInjectiongreater -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanOutputsWithInjectiongreater</title>\n",
       "<ellipse fill=\"none\" stroke=\"#edb22c\" stroke-width=\"2\" cx=\"618.88\" cy=\"-653\" rx=\"38.18\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-647.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">greater</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanbodyInputsrun -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanbodyInputsrun</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"281.13,-386 239.13,-386 239.13,-362 281.13,-362 293.13,-374 281.13,-386\"/>\n",
       "<text text-anchor=\"middle\" x=\"266.13\" y=\"-368.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">run</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanbodyOutputsWithInjectionran -->\n",
       "<g id=\"node13\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanbodyOutputsWithInjectionran</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"459,-386 417,-386 417,-362 459,-362 471,-374 459,-386\"/>\n",
       "<text text-anchor=\"middle\" x=\"444\" y=\"-368.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">ran</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanbodyInputsrun&#45;&gt;clusterAddWhileLessThanbodyOutputsWithInjectionran -->\n",
       "<!-- clusterAddWhileLessThanbodyInputsaccumulate_and_run -->\n",
       "<g id=\"node10\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanbodyInputsaccumulate_and_run</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"325.5,-440 194.75,-440 194.75,-416 325.5,-416 337.5,-428 325.5,-440\"/>\n",
       "<text text-anchor=\"middle\" x=\"266.13\" y=\"-422.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">accumulate_and_run</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanconditionInputsrun -->\n",
       "<g id=\"node16\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanconditionInputsrun</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"633.88,-185 591.88,-185 591.88,-161 633.88,-161 645.88,-173 633.88,-185\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-167.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">run</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanbodyOutputsWithInjectionran&#45;&gt;clusterAddWhileLessThanconditionInputsrun -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>clusterAddWhileLessThanbodyOutputsWithInjectionran&#45;&gt;clusterAddWhileLessThanconditionInputsrun</title>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M449.07,-355.53C454.76,-332.51 466.89,-291.63 488.3,-254.2\"/>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M488.3,-254.2C499.85,-234.02 514.1,-214.84 531.5,-200 545.19,-188.32 563.93,-181.69 580.45,-177.92\"/>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"580.83,-181.41 589.96,-176.04 579.47,-174.55 580.83,-181.41\"/>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanhistoryInputsrun -->\n",
       "<g id=\"node31\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanhistoryInputsrun</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"633.88,-389 591.88,-389 591.88,-365 633.88,-365 645.88,-377 633.88,-389\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-371.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">run</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanbodyOutputsWithInjectionran&#45;&gt;clusterAddWhileLessThanhistoryInputsrun -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>clusterAddWhileLessThanbodyOutputsWithInjectionran&#45;&gt;clusterAddWhileLessThanhistoryInputsrun</title>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M471.26,-374.46C485.77,-374.71 504.77,-375.04 524.27,-375.38\"/>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M524.27,-375.38C543.76,-375.71 563.74,-376.06 580.21,-376.35\"/>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"580.08,-379.84 590.14,-376.52 580.2,-372.85 580.08,-379.84\"/>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanbodyOutputsWithInjectionfailed -->\n",
       "<g id=\"node14\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanbodyOutputsWithInjectionfailed</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"459,-440 417,-440 417,-416 459,-416 471,-428 459,-440\"/>\n",
       "<text text-anchor=\"middle\" x=\"444\" y=\"-422.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">failed</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanbodyOutputsWithInjectionadd -->\n",
       "<g id=\"node15\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanbodyOutputsWithInjectionadd</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"444\" cy=\"-482\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"444\" y=\"-476.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">add</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanbodyOutputsWithInjectionadd&#45;&gt;clusterAddWhileLessThanOutputsWithInjectiongreater -->\n",
       "<g id=\"edge18\" class=\"edge\">\n",
       "<title>clusterAddWhileLessThanbodyOutputsWithInjectionadd&#45;&gt;clusterAddWhileLessThanOutputsWithInjectiongreater</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" stroke-dasharray=\"5,2\" d=\"M455.72,-498.5C467.53,-516.11 487.96,-544.99 511.13,-570.89\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" stroke-dasharray=\"5,2\" d=\"M511.13,-570.89C517.74,-578.28 524.58,-585.43 531.5,-592 547.63,-607.32 567.85,-621.81 584.67,-632.82\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"582.54,-635.61 592.85,-638.06 586.32,-629.72 582.54,-635.61\"/>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanbodyOutputsWithInjectionadd&#45;&gt;clusterAddWhileLessThanbodyInputsobj -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>clusterAddWhileLessThanbodyOutputsWithInjectionadd&#45;&gt;clusterAddWhileLessThanbodyInputsobj</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M416.78,-482C401.93,-482 382.34,-482 362.26,-482\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M362.26,-482C342.17,-482 321.57,-482 304.71,-482\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"304.97,-478.5 294.97,-482 304.97,-485.5 304.97,-478.5\"/>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanconditionInputsobj -->\n",
       "<g id=\"node18\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanconditionInputsobj</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"618.88\" cy=\"-227\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-221.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">obj</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanbodyOutputsWithInjectionadd&#45;&gt;clusterAddWhileLessThanconditionInputsobj -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>clusterAddWhileLessThanbodyOutputsWithInjectionadd&#45;&gt;clusterAddWhileLessThanconditionInputsobj</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M471.16,-480.24C488.86,-477.56 511.18,-470.98 523.5,-455 534.42,-440.83 528.98,-400.53 528.85,-371.5\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M528.85,-371.5C528.8,-361.48 529.39,-352.8 531.5,-347 545.29,-309.09 574.7,-272.51 595.35,-249.91\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"597.74,-252.47 602.02,-242.78 592.63,-247.69 597.74,-252.47\"/>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanhistoryInputsnew_element -->\n",
       "<g id=\"node34\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanhistoryInputsnew_element</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"618.88\" cy=\"-539\" rx=\"63.04\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-533.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">new_element</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanbodyOutputsWithInjectionadd&#45;&gt;clusterAddWhileLessThanhistoryInputsnew_element -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>clusterAddWhileLessThanbodyOutputsWithInjectionadd&#45;&gt;clusterAddWhileLessThanhistoryInputsnew_element</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M468.43,-490.35C481.53,-494.97 498.55,-500.92 515.32,-506.59\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M515.32,-506.59C520.79,-508.44 526.23,-510.26 531.5,-512 541.91,-515.43 553.06,-519 563.78,-522.37\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"562.7,-525.7 573.29,-525.35 564.79,-519.02 562.7,-525.7\"/>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanconditionOutputsWithInjectionran -->\n",
       "<g id=\"node20\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanconditionOutputsWithInjectionran</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"819.75,-131 777.75,-131 777.75,-107 819.75,-107 831.75,-119 819.75,-131\"/>\n",
       "<text text-anchor=\"middle\" x=\"804.75\" y=\"-113.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">ran</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanconditionInputsrun&#45;&gt;clusterAddWhileLessThanconditionOutputsWithInjectionran -->\n",
       "<!-- clusterAddWhileLessThanconditionInputsaccumulate_and_run -->\n",
       "<g id=\"node17\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanconditionInputsaccumulate_and_run</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"678.25,-131 547.5,-131 547.5,-107 678.25,-107 690.25,-119 678.25,-131\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-113.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">accumulate_and_run</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanswitchInputsrun -->\n",
       "<g id=\"node23\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanswitchInputsrun</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"994.63,-131 952.63,-131 952.63,-107 994.63,-107 1006.63,-119 994.63,-131\"/>\n",
       "<text text-anchor=\"middle\" x=\"979.63\" y=\"-113.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">run</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanconditionOutputsWithInjectionran&#45;&gt;clusterAddWhileLessThanswitchInputsrun -->\n",
       "<g id=\"edge11\" class=\"edge\">\n",
       "<title>clusterAddWhileLessThanconditionOutputsWithInjectionran&#45;&gt;clusterAddWhileLessThanswitchInputsrun</title>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M832.01,-119C846.52,-119 865.52,-119 885.02,-119\"/>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M885.02,-119C904.51,-119 924.49,-119 940.96,-119\"/>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"940.89,-122.5 950.89,-119 940.89,-115.5 940.89,-122.5\"/>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanconditionOutputsWithInjectionfailed -->\n",
       "<g id=\"node21\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanconditionOutputsWithInjectionfailed</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"819.75,-185 777.75,-185 777.75,-161 819.75,-161 831.75,-173 819.75,-185\"/>\n",
       "<text text-anchor=\"middle\" x=\"804.75\" y=\"-167.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">failed</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanconditionOutputsWithInjectionlt -->\n",
       "<g id=\"node22\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanconditionOutputsWithInjectionlt</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"804.75\" cy=\"-227\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"804.75\" y=\"-221.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">lt</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanswitchInputscondition -->\n",
       "<g id=\"node25\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanswitchInputscondition</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"979.63\" cy=\"-227\" rx=\"45.5\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"979.63\" y=\"-221.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">condition</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanconditionOutputsWithInjectionlt&#45;&gt;clusterAddWhileLessThanswitchInputscondition -->\n",
       "<g id=\"edge12\" class=\"edge\">\n",
       "<title>clusterAddWhileLessThanconditionOutputsWithInjectionlt&#45;&gt;clusterAddWhileLessThanswitchInputscondition</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M832.01,-227C843.98,-227 859.02,-227 874.87,-227\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M874.87,-227C890.72,-227 907.37,-227 922.59,-227\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"922.42,-230.5 932.42,-227 922.42,-223.5 922.42,-230.5\"/>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanswitchOutputsWithInjectionran -->\n",
       "<g id=\"node26\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanswitchOutputsWithInjectionran</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1172.5,-131 1130.5,-131 1130.5,-107 1172.5,-107 1184.5,-119 1172.5,-131\"/>\n",
       "<text text-anchor=\"middle\" x=\"1157.5\" y=\"-113.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">ran</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanswitchInputsrun&#45;&gt;clusterAddWhileLessThanswitchOutputsWithInjectionran -->\n",
       "<!-- clusterAddWhileLessThanswitchInputsaccumulate_and_run -->\n",
       "<g id=\"node24\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanswitchInputsaccumulate_and_run</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1039,-185 908.25,-185 908.25,-161 1039,-161 1051,-173 1039,-185\"/>\n",
       "<text text-anchor=\"middle\" x=\"979.63\" y=\"-167.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">accumulate_and_run</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanswitchOutputsWithInjectionfailed -->\n",
       "<g id=\"node27\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanswitchOutputsWithInjectionfailed</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1172.5,-185 1130.5,-185 1130.5,-161 1172.5,-161 1184.5,-173 1172.5,-185\"/>\n",
       "<text text-anchor=\"middle\" x=\"1157.5\" y=\"-167.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">failed</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanswitchOutputsWithInjectiontrue -->\n",
       "<g id=\"node28\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanswitchOutputsWithInjectiontrue</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1172.5,-239 1130.5,-239 1130.5,-215 1172.5,-215 1184.5,-227 1172.5,-239\"/>\n",
       "<text text-anchor=\"middle\" x=\"1157.5\" y=\"-221.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">true</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanswitchOutputsWithInjectiontrue&#45;&gt;clusterAddWhileLessThanbodyInputsrun -->\n",
       "<g id=\"edge13\" class=\"edge\">\n",
       "<title>clusterAddWhileLessThanswitchOutputsWithInjectiontrue&#45;&gt;clusterAddWhileLessThanbodyInputsrun</title>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M1130.31,-234.56C1116.8,-239.09 1100.38,-245.62 1087,-254 1072.61,-263.01 1074.2,-272.43 1059,-280 956.67,-330.97 920.07,-325 805.75,-325 731.55,-325 686.66,-325 659.49,-325\"/>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M659.49,-325C617.88,-325 617.88,-325 617.88,-325 508.94,-325 480.75,-324.9 373.5,-344 350.18,-348.15 324.61,-355.28 304.39,-361.54\"/>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"303.37,-358.19 294.9,-364.55 305.49,-364.86 303.37,-358.19\"/>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanswitchOutputsWithInjectionfalse -->\n",
       "<g id=\"node29\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanswitchOutputsWithInjectionfalse</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1172.5,-293 1130.5,-293 1130.5,-269 1172.5,-269 1184.5,-281 1172.5,-293\"/>\n",
       "<text text-anchor=\"middle\" x=\"1157.5\" y=\"-275.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">false</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanswitchOutputsWithInjectiontruth -->\n",
       "<g id=\"node30\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanswitchOutputsWithInjectiontruth</title>\n",
       "<ellipse fill=\"none\" stroke=\"#edb22c\" stroke-width=\"2\" cx=\"1157.5\" cy=\"-335\" rx=\"27.95\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"1157.5\" y=\"-329.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">truth</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanhistoryOutputsWithInjectionran -->\n",
       "<g id=\"node35\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanhistoryOutputsWithInjectionran</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"819.75,-389 777.75,-389 777.75,-365 819.75,-365 831.75,-377 819.75,-389\"/>\n",
       "<text text-anchor=\"middle\" x=\"804.75\" y=\"-371.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">ran</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanhistoryInputsrun&#45;&gt;clusterAddWhileLessThanhistoryOutputsWithInjectionran -->\n",
       "<!-- clusterAddWhileLessThanhistoryInputsaccumulate_and_run -->\n",
       "<g id=\"node32\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanhistoryInputsaccumulate_and_run</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"678.25,-443 547.5,-443 547.5,-419 678.25,-419 690.25,-431 678.25,-443\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-425.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">accumulate_and_run</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanhistoryInputsexisting -->\n",
       "<g id=\"node33\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanhistoryInputsexisting</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"618.88\" cy=\"-485\" rx=\"40.13\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"618.88\" y=\"-479.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">existing</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanhistoryOutputsWithInjectionfailed -->\n",
       "<g id=\"node36\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanhistoryOutputsWithInjectionfailed</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"819.75,-443 777.75,-443 777.75,-419 819.75,-419 831.75,-431 819.75,-443\"/>\n",
       "<text text-anchor=\"middle\" x=\"804.75\" y=\"-425.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">failed</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanhistoryOutputsWithInjectionlist -->\n",
       "<g id=\"node37\" class=\"node\">\n",
       "<title>clusterAddWhileLessThanhistoryOutputsWithInjectionlist</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"804.75\" cy=\"-485\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"804.75\" y=\"-479.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">list</text>\n",
       "</g>\n",
       "<!-- clusterAddWhileLessThanhistoryOutputsWithInjectionlist&#45;&gt;clusterAddWhileLessThanhistoryInputsexisting -->\n",
       "<g id=\"edge14\" class=\"edge\">\n",
       "<title>clusterAddWhileLessThanhistoryOutputsWithInjectionlist&#45;&gt;clusterAddWhileLessThanhistoryInputsexisting</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M777.4,-485C763.52,-485 745.48,-485 726.59,-485\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M726.59,-485C707.69,-485 687.94,-485 670.64,-485\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"670.83,-481.5 660.83,-485 670.83,-488.5 670.83,-481.5\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.graphs.Digraph at 0x134353390>"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cyclic = AddWhileLessThan()\n",
    "cyclic.draw(size=(10, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "32d1c20d-d484-434f-9b10-02ee17df4eee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'greater': 6}"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cyclic(0, 2, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90bfa6fa-6218-41c1-8dc4-630f511cffb6",
   "metadata": {},
   "source": [
    "We can examine the provenance as usual. In this case, because the graph is cyclic, the same node appears multiple times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "d44e90ad-4a96-4c0a-a4d2-0e3ed394479c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['body',\n",
       " 'history',\n",
       " 'condition',\n",
       " 'switch',\n",
       " 'body',\n",
       " 'history',\n",
       " 'condition',\n",
       " 'switch',\n",
       " 'body',\n",
       " 'history',\n",
       " 'condition',\n",
       " 'switch']"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cyclic.provenance_by_execution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "686fbf70-de7d-4040-9840-a6c8fffbd036",
   "metadata": {},
   "source": [
    "Since the nodes only store their instantaneous IO state and not its history, we've added a \"history\" node into the workflow. It's not part of the macro output in this example, but you can always dig into the node to examine its state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "5814f830-fe47-4bce-b8f4-35df63565e6b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cyclic.history.outputs.list.value"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46af7a97-57dc-4d68-886f-c6f00de97597",
   "metadata": {},
   "source": [
    "And, of course, such a macro can be (un)pickled as usual"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "4a7eece3-20dd-4f57-88f2-5a1076daeb08",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pickle\n",
    "\n",
    "reloaded = pickle.loads(pickle.dumps(cyclic))\n",
    "reloaded.outputs.greater.value"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "900d1943-c594-409f-9174-18ab89fa45dd",
   "metadata": {},
   "source": [
    "## Handling failure\n",
    "\n",
    "Sometimes a node might fail -- sometimes we might even anticipate the possibility. `pyiron_workflow` allows for this with the runtime flag  `raise_run_exceptions`. There is even an output signal `failed` to allow you to manage flow control based off of node failure (although, like cyclic graphs, this requires manual management of the execution flow).\n",
    "\n",
    "Here is an example of this feature, including chaining further execution off of a failure and having failure occur inside the context of an executor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "be3e780b-b3cb-43d9-917f-ed3b2210e521",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "exception calling callback for <Future at 0x1342899d0 state=finished raised TypeError>\n",
      "concurrent.futures.process._RemoteTraceback: \n",
      "\"\"\"\n",
      "Traceback (most recent call last):\n",
      "  File \"/Users/huber/anaconda3/envs/pyiron_311/lib/python3.11/concurrent/futures/process.py\", line 261, in _process_worker\n",
      "    r = call_item.fn(*call_item.args, **call_item.kwargs)\n",
      "        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
      "  File \"/Users/huber/work/pyiron/pyiron_workflow/pyiron_workflow/nodes/function.py\", line 317, in _on_run\n",
      "    return self.node_function(**kwargs)\n",
      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
      "  File \"/Users/huber/work/pyiron/pyiron_workflow/pyiron_workflow/nodes/standard.py\", line 518, in Add\n",
      "    return obj + other\n",
      "           ~~~~^~~~~~~\n",
      "TypeError: unsupported operand type(s) for +: 'int' and 'str'\n",
      "\"\"\"\n",
      "\n",
      "The above exception was the direct cause of the following exception:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"/Users/huber/anaconda3/envs/pyiron_311/lib/python3.11/concurrent/futures/_base.py\", line 340, in _invoke_callbacks\n",
      "    callback(self)\n",
      "  File \"/Users/huber/work/pyiron/pyiron_workflow/pyiron_workflow/mixin/run.py\", line 278, in _finish_run\n",
      "    raise e\n",
      "  File \"/Users/huber/work/pyiron/pyiron_workflow/pyiron_workflow/mixin/run.py\", line 273, in _finish_run\n",
      "    run_output = run_output.result()\n",
      "                 ^^^^^^^^^^^^^^^^^^^\n",
      "  File \"/Users/huber/anaconda3/envs/pyiron_311/lib/python3.11/concurrent/futures/_base.py\", line 449, in result\n",
      "    return self.__get_result()\n",
      "           ^^^^^^^^^^^^^^^^^^^\n",
      "  File \"/Users/huber/anaconda3/envs/pyiron_311/lib/python3.11/concurrent/futures/_base.py\", line 401, in __get_result\n",
      "    raise self._exception\n",
      "TypeError: unsupported operand type(s) for +: 'int' and 'str'\n"
     ]
    },
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 12.0.0 (0)\n",
       " -->\n",
       "<!-- Title: clustertest Pages: 1 -->\n",
       "<svg width=\"720pt\" height=\"206pt\"\n",
       " viewBox=\"0.00 0.00 720.00 205.86\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(0.314286 0.314286) rotate(0) translate(4 651)\">\n",
       "<title>clustertest</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-651 2286.91,-651 2286.91,4 -4,4\"/>\n",
       "<text text-anchor=\"middle\" x=\"1141.46\" y=\"-5.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">test: Workflow</text>\n",
       "<g id=\"clust1\" class=\"cluster\">\n",
       "<title>clustertestInputs</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust1_l_0\" gradientUnits=\"userSpaceOnUse\" x1=\"8\" y1=\"-230.5\" x2=\"247.58\" y2=\"-230.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust1_l_0)\" stroke=\"#a5a4a5\" points=\"8,-31 8,-430 247.58,-430 247.58,-31 8,-31\"/>\n",
       "<text text-anchor=\"middle\" x=\"127.79\" y=\"-412.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">Inputs</text>\n",
       "</g>\n",
       "<g id=\"clust2\" class=\"cluster\">\n",
       "<title>clustertestOutputs</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust2_l_1\" gradientUnits=\"userSpaceOnUse\" x1=\"2274.91\" y1=\"-334.5\" x2=\"2035.33\" y2=\"-334.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust2_l_1)\" stroke=\"#a5a4a5\" points=\"2035.33,-189 2035.33,-480 2274.91,-480 2274.91,-189 2035.33,-189\"/>\n",
       "<text text-anchor=\"middle\" x=\"2155.12\" y=\"-462.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">Outputs</text>\n",
       "</g>\n",
       "<g id=\"clust3\" class=\"cluster\">\n",
       "<title>clustertesta</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust3_l_2\" gradientUnits=\"userSpaceOnUse\" x1=\"259.58\" y1=\"-430\" x2=\"604.33\" y2=\"-430\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust3_l_2)\" stroke=\"#bfe2bf\" stroke-width=\"2\" points=\"259.58,-319 259.58,-541 604.33,-541 604.33,-319 259.58,-319\"/>\n",
       "<text text-anchor=\"middle\" x=\"431.96\" y=\"-523.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">a: UserInput</text>\n",
       "</g>\n",
       "<g id=\"clust4\" class=\"cluster\">\n",
       "<title>clustertestaInputs</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust4_l_3\" gradientUnits=\"userSpaceOnUse\" x1=\"267.58\" y1=\"-418.5\" x2=\"426.33\" y2=\"-418.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust4_l_3)\" stroke=\"#a5a4a5\" points=\"267.58,-327 267.58,-510 426.33,-510 426.33,-327 267.58,-327\"/>\n",
       "<text text-anchor=\"middle\" x=\"346.96\" y=\"-492.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">Inputs</text>\n",
       "</g>\n",
       "<g id=\"clust5\" class=\"cluster\">\n",
       "<title>clustertestaOutputsWithInjection</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust5_l_4\" gradientUnits=\"userSpaceOnUse\" x1=\"596.33\" y1=\"-418.5\" x2=\"454.33\" y2=\"-418.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust5_l_4)\" stroke=\"#a5a4a5\" points=\"454.33,-327 454.33,-510 596.33,-510 596.33,-327 454.33,-327\"/>\n",
       "<text text-anchor=\"middle\" x=\"525.33\" y=\"-492.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">OutputsWithInjection</text>\n",
       "</g>\n",
       "<g id=\"clust6\" class=\"cluster\">\n",
       "<title>clustertestb</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust6_l_5\" gradientUnits=\"userSpaceOnUse\" x1=\"612.33\" y1=\"-344\" x2=\"957.08\" y2=\"-344\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust6_l_5)\" stroke=\"#bfe2bf\" stroke-width=\"2\" points=\"612.33,-233 612.33,-455 957.08,-455 957.08,-233 612.33,-233\"/>\n",
       "<text text-anchor=\"middle\" x=\"784.71\" y=\"-437.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">b: UserInput</text>\n",
       "</g>\n",
       "<g id=\"clust7\" class=\"cluster\">\n",
       "<title>clustertestbInputs</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust7_l_6\" gradientUnits=\"userSpaceOnUse\" x1=\"620.33\" y1=\"-332.5\" x2=\"779.08\" y2=\"-332.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust7_l_6)\" stroke=\"#a5a4a5\" points=\"620.33,-241 620.33,-424 779.08,-424 779.08,-241 620.33,-241\"/>\n",
       "<text text-anchor=\"middle\" x=\"699.71\" y=\"-406.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">Inputs</text>\n",
       "</g>\n",
       "<g id=\"clust8\" class=\"cluster\">\n",
       "<title>clustertestbOutputsWithInjection</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust8_l_7\" gradientUnits=\"userSpaceOnUse\" x1=\"949.08\" y1=\"-332.5\" x2=\"807.08\" y2=\"-332.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust8_l_7)\" stroke=\"#a5a4a5\" points=\"807.08,-241 807.08,-424 949.08,-424 949.08,-241 807.08,-241\"/>\n",
       "<text text-anchor=\"middle\" x=\"878.08\" y=\"-406.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">OutputsWithInjection</text>\n",
       "</g>\n",
       "<g id=\"clust9\" class=\"cluster\">\n",
       "<title>clustertestc_fails</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust9_l_8\" gradientUnits=\"userSpaceOnUse\" x1=\"965.08\" y1=\"-387\" x2=\"1309.83\" y2=\"-387\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust9_l_8)\" stroke=\"#ff0000\" stroke-width=\"2\" points=\"965.08,-249 965.08,-525 1309.83,-525 1309.83,-249 965.08,-249\"/>\n",
       "<text text-anchor=\"middle\" x=\"1137.46\" y=\"-507.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">c_fails: Add</text>\n",
       "</g>\n",
       "<g id=\"clust10\" class=\"cluster\">\n",
       "<title>clustertestc_failsInputs</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust10_l_9\" gradientUnits=\"userSpaceOnUse\" x1=\"973.08\" y1=\"-375.5\" x2=\"1131.83\" y2=\"-375.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust10_l_9)\" stroke=\"#a5a4a5\" points=\"973.08,-257 973.08,-494 1131.83,-494 1131.83,-257 973.08,-257\"/>\n",
       "<text text-anchor=\"middle\" x=\"1052.46\" y=\"-476.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">Inputs</text>\n",
       "</g>\n",
       "<g id=\"clust11\" class=\"cluster\">\n",
       "<title>clustertestc_failsOutputsWithInjection</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust11_l_10\" gradientUnits=\"userSpaceOnUse\" x1=\"1301.83\" y1=\"-384.5\" x2=\"1159.83\" y2=\"-384.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust11_l_10)\" stroke=\"#a5a4a5\" points=\"1159.83,-293 1159.83,-476 1301.83,-476 1301.83,-293 1159.83,-293\"/>\n",
       "<text text-anchor=\"middle\" x=\"1230.83\" y=\"-458.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">OutputsWithInjection</text>\n",
       "</g>\n",
       "<g id=\"clust12\" class=\"cluster\">\n",
       "<title>clustertestd_if_success</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust12_l_11\" gradientUnits=\"userSpaceOnUse\" x1=\"1317.83\" y1=\"-528\" x2=\"1670.58\" y2=\"-528\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust12_l_11)\" stroke=\"#bfe2bf\" stroke-width=\"2\" points=\"1317.83,-417 1317.83,-639 1670.58,-639 1670.58,-417 1317.83,-417\"/>\n",
       "<text text-anchor=\"middle\" x=\"1494.21\" y=\"-621.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">d_if_success: UserInput</text>\n",
       "</g>\n",
       "<g id=\"clust13\" class=\"cluster\">\n",
       "<title>clustertestd_if_successInputs</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust13_l_12\" gradientUnits=\"userSpaceOnUse\" x1=\"1325.83\" y1=\"-516.5\" x2=\"1484.58\" y2=\"-516.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust13_l_12)\" stroke=\"#a5a4a5\" points=\"1325.83,-425 1325.83,-608 1484.58,-608 1484.58,-425 1325.83,-425\"/>\n",
       "<text text-anchor=\"middle\" x=\"1405.21\" y=\"-590.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">Inputs</text>\n",
       "</g>\n",
       "<g id=\"clust14\" class=\"cluster\">\n",
       "<title>clustertestd_if_successOutputsWithInjection</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust14_l_13\" gradientUnits=\"userSpaceOnUse\" x1=\"1662.58\" y1=\"-516.5\" x2=\"1520.58\" y2=\"-516.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust14_l_13)\" stroke=\"#a5a4a5\" points=\"1520.58,-425 1520.58,-608 1662.58,-608 1662.58,-425 1520.58,-425\"/>\n",
       "<text text-anchor=\"middle\" x=\"1591.58\" y=\"-590.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">OutputsWithInjection</text>\n",
       "</g>\n",
       "<g id=\"clust15\" class=\"cluster\">\n",
       "<title>clustertestd_if_failure</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust15_l_14\" gradientUnits=\"userSpaceOnUse\" x1=\"1317.83\" y1=\"-270\" x2=\"1670.58\" y2=\"-270\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust15_l_14)\" stroke=\"#bfe2bf\" stroke-width=\"2\" points=\"1317.83,-159 1317.83,-381 1670.58,-381 1670.58,-159 1317.83,-159\"/>\n",
       "<text text-anchor=\"middle\" x=\"1494.21\" y=\"-363.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">d_if_failure: UserInput</text>\n",
       "</g>\n",
       "<g id=\"clust16\" class=\"cluster\">\n",
       "<title>clustertestd_if_failureInputs</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust16_l_15\" gradientUnits=\"userSpaceOnUse\" x1=\"1325.83\" y1=\"-258.5\" x2=\"1484.58\" y2=\"-258.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust16_l_15)\" stroke=\"#a5a4a5\" points=\"1325.83,-167 1325.83,-350 1484.58,-350 1484.58,-167 1325.83,-167\"/>\n",
       "<text text-anchor=\"middle\" x=\"1405.21\" y=\"-332.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">Inputs</text>\n",
       "</g>\n",
       "<g id=\"clust17\" class=\"cluster\">\n",
       "<title>clustertestd_if_failureOutputsWithInjection</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust17_l_16\" gradientUnits=\"userSpaceOnUse\" x1=\"1662.58\" y1=\"-258.5\" x2=\"1520.58\" y2=\"-258.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust17_l_16)\" stroke=\"#a5a4a5\" points=\"1520.58,-167 1520.58,-350 1662.58,-350 1662.58,-167 1520.58,-167\"/>\n",
       "<text text-anchor=\"middle\" x=\"1591.58\" y=\"-332.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">OutputsWithInjection</text>\n",
       "</g>\n",
       "<g id=\"clust18\" class=\"cluster\">\n",
       "<title>clusterteste_fails</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust18_l_17\" gradientUnits=\"userSpaceOnUse\" x1=\"1678.58\" y1=\"-243\" x2=\"2023.33\" y2=\"-243\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#bfe2bf;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust18_l_17)\" stroke=\"#ff0000\" stroke-width=\"2\" points=\"1678.58,-105 1678.58,-381 2023.33,-381 2023.33,-105 1678.58,-105\"/>\n",
       "<text text-anchor=\"middle\" x=\"1850.96\" y=\"-363.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">e_fails: Add</text>\n",
       "</g>\n",
       "<g id=\"clust19\" class=\"cluster\">\n",
       "<title>clusterteste_failsInputs</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust19_l_18\" gradientUnits=\"userSpaceOnUse\" x1=\"1686.58\" y1=\"-231.5\" x2=\"1845.33\" y2=\"-231.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust19_l_18)\" stroke=\"#a5a4a5\" points=\"1686.58,-113 1686.58,-350 1845.33,-350 1845.33,-113 1686.58,-113\"/>\n",
       "<text text-anchor=\"middle\" x=\"1765.96\" y=\"-332.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">Inputs</text>\n",
       "</g>\n",
       "<g id=\"clust20\" class=\"cluster\">\n",
       "<title>clusterteste_failsOutputsWithInjection</title>\n",
       "<defs>\n",
       "<linearGradient id=\"clust20_l_19\" gradientUnits=\"userSpaceOnUse\" x1=\"2015.33\" y1=\"-258.5\" x2=\"1873.33\" y2=\"-258.5\" >\n",
       "<stop offset=\"0\" style=\"stop-color:#a5a4a5;stop-opacity:1.;\"/>\n",
       "<stop offset=\"1\" style=\"stop-color:#e4e3e4;stop-opacity:1.;\"/>\n",
       "</linearGradient>\n",
       "</defs>\n",
       "<polygon fill=\"url(#clust20_l_19)\" stroke=\"#a5a4a5\" points=\"1873.33,-167 1873.33,-350 2015.33,-350 2015.33,-167 1873.33,-167\"/>\n",
       "<text text-anchor=\"middle\" x=\"1944.33\" y=\"-332.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">OutputsWithInjection</text>\n",
       "</g>\n",
       "<!-- clustertestInputsrun -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>clustertestInputsrun</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"142.79,-69 100.79,-69 100.79,-45 142.79,-45 154.79,-57 142.79,-69\"/>\n",
       "<text text-anchor=\"middle\" x=\"127.79\" y=\"-51.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">run</text>\n",
       "</g>\n",
       "<!-- clustertestOutputsran -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>clustertestOutputsran</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"2170.12,-227 2128.12,-227 2128.12,-203 2170.12,-203 2182.12,-215 2170.12,-227\"/>\n",
       "<text text-anchor=\"middle\" x=\"2155.12\" y=\"-209.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">ran</text>\n",
       "</g>\n",
       "<!-- clustertestInputsrun&#45;&gt;clustertestOutputsran -->\n",
       "<!-- clustertestInputsaccumulate_and_run -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>clustertestInputsaccumulate_and_run</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"187.17,-123 56.42,-123 56.42,-99 187.17,-99 199.17,-111 187.17,-123\"/>\n",
       "<text text-anchor=\"middle\" x=\"127.79\" y=\"-105.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">accumulate_and_run</text>\n",
       "</g>\n",
       "<!-- clustertestInputsa__user_input -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>clustertestInputsa__user_input</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"127.79\" cy=\"-327\" rx=\"65.97\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"127.79\" y=\"-321.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">a__user_input</text>\n",
       "</g>\n",
       "<!-- clustertestaInputsuser_input -->\n",
       "<g id=\"node15\" class=\"node\">\n",
       "<title>clustertestaInputsuser_input</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"346.96\" cy=\"-461\" rx=\"51.35\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"346.96\" y=\"-455.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">user_input</text>\n",
       "</g>\n",
       "<!-- clustertestInputsa__user_input&#45;&gt;clustertestaInputsuser_input -->\n",
       "<g id=\"edge16\" class=\"edge\">\n",
       "<title>clustertestInputsa__user_input&#45;&gt;clustertestaInputsuser_input</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M194.12,-328.07C213.82,-331.68 233.84,-339.2 247.58,-354 256.83,-363.97 257.45,-373.93 255.92,-383.95\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M255.92,-383.95C253.39,-400.42 245.04,-417.02 259.58,-434 266.71,-442.32 276.37,-448.12 286.65,-452.14\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"285.48,-455.44 296.07,-455.25 287.67,-448.79 285.48,-455.44\"/>\n",
       "</g>\n",
       "<!-- clustertestInputsb__user_input -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>clustertestInputsb__user_input</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"127.79\" cy=\"-273\" rx=\"65.97\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"127.79\" y=\"-267.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">b__user_input</text>\n",
       "</g>\n",
       "<!-- clustertestbInputsuser_input -->\n",
       "<g id=\"node21\" class=\"node\">\n",
       "<title>clustertestbInputsuser_input</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"699.71\" cy=\"-267\" rx=\"51.35\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"699.71\" y=\"-261.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">user_input</text>\n",
       "</g>\n",
       "<!-- clustertestInputsb__user_input&#45;&gt;clustertestbInputsuser_input -->\n",
       "<g id=\"edge17\" class=\"edge\">\n",
       "<title>clustertestInputsb__user_input&#45;&gt;clustertestbInputsuser_input</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M194.17,-272.31C249.6,-271.73 333.16,-270.85 416.42,-269.97\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M416.42,-269.97C499.68,-269.1 582.63,-268.22 636.85,-267.65\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"636.75,-271.15 646.72,-267.55 636.68,-264.15 636.75,-271.15\"/>\n",
       "</g>\n",
       "<!-- clustertestInputsd_if_success__user_input -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>clustertestInputsd_if_success__user_input</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"127.79\" cy=\"-381\" rx=\"111.79\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"127.79\" y=\"-375.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">d_if_success__user_input</text>\n",
       "</g>\n",
       "<!-- clustertestd_if_successInputsuser_input -->\n",
       "<g id=\"node34\" class=\"node\">\n",
       "<title>clustertestd_if_successInputsuser_input</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"1405.21\" cy=\"-559\" rx=\"51.35\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"1405.21\" y=\"-553.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">user_input</text>\n",
       "</g>\n",
       "<!-- clustertestInputsd_if_success__user_input&#45;&gt;clustertestd_if_successInputsuser_input -->\n",
       "<g id=\"edge18\" class=\"edge\">\n",
       "<title>clustertestInputsd_if_success__user_input&#45;&gt;clustertestd_if_successInputsuser_input</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M140.8,-399.14C161.34,-428.54 206.19,-486.12 259.58,-514 365.18,-569.14 404.69,-559 523.83,-559 523.83,-559 523.83,-559 546.43,-559\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M546.43,-559C588.5,-559 708.91,-559 1053.46,-559 1154.54,-559 1272.02,-559 1342.12,-559\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"1341.87,-562.5 1351.87,-559 1341.87,-555.5 1341.87,-562.5\"/>\n",
       "</g>\n",
       "<!-- clustertestInputsd_if_failure__user_input -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>clustertestInputsd_if_failure__user_input</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"127.79\" cy=\"-219\" rx=\"103.99\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"127.79\" y=\"-213.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">d_if_failure__user_input</text>\n",
       "</g>\n",
       "<!-- clustertestd_if_failureInputsuser_input -->\n",
       "<g id=\"node40\" class=\"node\">\n",
       "<title>clustertestd_if_failureInputsuser_input</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"1405.21\" cy=\"-193\" rx=\"51.35\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"1405.21\" y=\"-187.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">user_input</text>\n",
       "</g>\n",
       "<!-- clustertestInputsd_if_failure__user_input&#45;&gt;clustertestd_if_failureInputsuser_input -->\n",
       "<g id=\"edge19\" class=\"edge\">\n",
       "<title>clustertestInputsd_if_failure__user_input&#45;&gt;clustertestd_if_failureInputsuser_input</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M226.97,-213.2C306.88,-208.98 422.6,-204 523.83,-204 523.83,-204 523.83,-204 587.21,-204\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M587.21,-204C652.45,-204 784.83,-204 1053.46,-204 1154.88,-204 1272.73,-199.35 1342.74,-196.09\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"1342.64,-199.6 1352.47,-195.64 1342.31,-192.61 1342.64,-199.6\"/>\n",
       "</g>\n",
       "<!-- clustertestInputse_fails__other -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>clustertestInputse_fails__other</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"127.79\" cy=\"-165\" rx=\"65.48\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"127.79\" y=\"-159.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">e_fails__other</text>\n",
       "</g>\n",
       "<!-- clusterteste_failsInputsother -->\n",
       "<g id=\"node47\" class=\"node\">\n",
       "<title>clusterteste_failsInputsother</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"1765.96\" cy=\"-139\" rx=\"30.38\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"1765.96\" y=\"-133.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">other</text>\n",
       "</g>\n",
       "<!-- clustertestInputse_fails__other&#45;&gt;clusterteste_failsInputsother -->\n",
       "<g id=\"edge20\" class=\"edge\">\n",
       "<title>clustertestInputse_fails__other&#45;&gt;clusterteste_failsInputsother</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M189.62,-158.76C267.13,-151.35 405.29,-140 523.83,-140 523.83,-140 523.83,-140 627.78,-140\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M627.78,-140C735.87,-140 956.38,-140 1406.21,-140 1521.37,-140 1657.32,-139.48 1723.96,-139.19\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"1723.69,-142.69 1733.68,-139.15 1723.66,-135.69 1723.69,-142.69\"/>\n",
       "</g>\n",
       "<!-- clustertestOutputsfailed -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>clustertestOutputsfailed</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"2170.12,-281 2128.12,-281 2128.12,-257 2170.12,-257 2182.12,-269 2170.12,-281\"/>\n",
       "<text text-anchor=\"middle\" x=\"2155.12\" y=\"-263.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">failed</text>\n",
       "</g>\n",
       "<!-- clustertestOutputsc_fails__add -->\n",
       "<g id=\"node10\" class=\"node\">\n",
       "<title>clustertestOutputsc_fails__add</title>\n",
       "<ellipse fill=\"none\" stroke=\"#edb22c\" stroke-width=\"2\" cx=\"2155.12\" cy=\"-377\" rx=\"59.63\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"2155.12\" y=\"-371.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">c_fails__add</text>\n",
       "</g>\n",
       "<!-- clustertestOutputsd_if_success__user_input -->\n",
       "<g id=\"node11\" class=\"node\">\n",
       "<title>clustertestOutputsd_if_success__user_input</title>\n",
       "<ellipse fill=\"none\" stroke=\"#edb22c\" stroke-width=\"2\" cx=\"2155.12\" cy=\"-431\" rx=\"111.79\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"2155.12\" y=\"-425.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">d_if_success__user_input</text>\n",
       "</g>\n",
       "<!-- clustertestOutputse_fails__add -->\n",
       "<g id=\"node12\" class=\"node\">\n",
       "<title>clustertestOutputse_fails__add</title>\n",
       "<ellipse fill=\"none\" stroke=\"#edb22c\" stroke-width=\"2\" cx=\"2155.12\" cy=\"-323\" rx=\"60.12\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"2155.12\" y=\"-317.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">e_fails__add</text>\n",
       "</g>\n",
       "<!-- clustertestaInputsrun -->\n",
       "<g id=\"node13\" class=\"node\">\n",
       "<title>clustertestaInputsrun</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"361.96,-365 319.96,-365 319.96,-341 361.96,-341 373.96,-353 361.96,-365\"/>\n",
       "<text text-anchor=\"middle\" x=\"346.96\" y=\"-347.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">run</text>\n",
       "</g>\n",
       "<!-- clustertestaOutputsWithInjectionran -->\n",
       "<g id=\"node16\" class=\"node\">\n",
       "<title>clustertestaOutputsWithInjectionran</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"539.83,-365 497.83,-365 497.83,-341 539.83,-341 551.83,-353 539.83,-365\"/>\n",
       "<text text-anchor=\"middle\" x=\"524.83\" y=\"-347.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">ran</text>\n",
       "</g>\n",
       "<!-- clustertestaInputsrun&#45;&gt;clustertestaOutputsWithInjectionran -->\n",
       "<!-- clustertestaInputsaccumulate_and_run -->\n",
       "<g id=\"node14\" class=\"node\">\n",
       "<title>clustertestaInputsaccumulate_and_run</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"406.33,-419 275.58,-419 275.58,-395 406.33,-395 418.33,-407 406.33,-419\"/>\n",
       "<text text-anchor=\"middle\" x=\"346.96\" y=\"-401.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">accumulate_and_run</text>\n",
       "</g>\n",
       "<!-- clustertestbInputsrun -->\n",
       "<g id=\"node19\" class=\"node\">\n",
       "<title>clustertestbInputsrun</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"714.71,-387 672.71,-387 672.71,-363 714.71,-363 726.71,-375 714.71,-387\"/>\n",
       "<text text-anchor=\"middle\" x=\"699.71\" y=\"-369.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">run</text>\n",
       "</g>\n",
       "<!-- clustertestaOutputsWithInjectionran&#45;&gt;clustertestbInputsrun -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>clustertestaOutputsWithInjectionran&#45;&gt;clustertestbInputsrun</title>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M552.09,-356.34C566.66,-358.2 585.77,-360.63 605.35,-363.12\"/>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M605.35,-363.12C624.94,-365.61 645,-368.17 661.48,-370.26\"/>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"660.62,-373.68 670.98,-371.47 661.51,-366.74 660.62,-373.68\"/>\n",
       "</g>\n",
       "<!-- clustertestaOutputsWithInjectionfailed -->\n",
       "<g id=\"node17\" class=\"node\">\n",
       "<title>clustertestaOutputsWithInjectionfailed</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"539.83,-419 497.83,-419 497.83,-395 539.83,-395 551.83,-407 539.83,-419\"/>\n",
       "<text text-anchor=\"middle\" x=\"524.83\" y=\"-401.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">failed</text>\n",
       "</g>\n",
       "<!-- clustertestaOutputsWithInjectionuser_input -->\n",
       "<g id=\"node18\" class=\"node\">\n",
       "<title>clustertestaOutputsWithInjectionuser_input</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"524.83\" cy=\"-461\" rx=\"51.35\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"524.83\" y=\"-455.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">user_input</text>\n",
       "</g>\n",
       "<!-- clustertestc_failsInputsobj -->\n",
       "<g id=\"node27\" class=\"node\">\n",
       "<title>clustertestc_failsInputsobj</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"1052.46\" cy=\"-445\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"1052.46\" y=\"-439.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">obj</text>\n",
       "</g>\n",
       "<!-- clustertestaOutputsWithInjectionuser_input&#45;&gt;clustertestc_failsInputsobj -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>clustertestaOutputsWithInjectionuser_input&#45;&gt;clustertestc_failsInputsobj</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M576.23,-459.47C628.66,-457.87 714.79,-455.25 799.42,-452.67\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M799.42,-452.67C884.05,-450.1 967.19,-447.57 1013.65,-446.15\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"1013.6,-449.65 1023.49,-445.85 1013.39,-442.66 1013.6,-449.65\"/>\n",
       "</g>\n",
       "<!-- clustertestbOutputsWithInjectionran -->\n",
       "<g id=\"node22\" class=\"node\">\n",
       "<title>clustertestbOutputsWithInjectionran</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"892.58,-279 850.58,-279 850.58,-255 892.58,-255 904.58,-267 892.58,-279\"/>\n",
       "<text text-anchor=\"middle\" x=\"877.58\" y=\"-261.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">ran</text>\n",
       "</g>\n",
       "<!-- clustertestbInputsrun&#45;&gt;clustertestbOutputsWithInjectionran -->\n",
       "<!-- clustertestbInputsaccumulate_and_run -->\n",
       "<g id=\"node20\" class=\"node\">\n",
       "<title>clustertestbInputsaccumulate_and_run</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"759.08,-333 628.33,-333 628.33,-309 759.08,-309 771.08,-321 759.08,-333\"/>\n",
       "<text text-anchor=\"middle\" x=\"699.71\" y=\"-315.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">accumulate_and_run</text>\n",
       "</g>\n",
       "<!-- clustertestc_failsInputsrun -->\n",
       "<g id=\"node25\" class=\"node\">\n",
       "<title>clustertestc_failsInputsrun</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1067.46,-295 1025.46,-295 1025.46,-271 1067.46,-271 1079.46,-283 1067.46,-295\"/>\n",
       "<text text-anchor=\"middle\" x=\"1052.46\" y=\"-277.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">run</text>\n",
       "</g>\n",
       "<!-- clustertestbOutputsWithInjectionran&#45;&gt;clustertestc_failsInputsrun -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>clustertestbOutputsWithInjectionran&#45;&gt;clustertestc_failsInputsrun</title>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M904.84,-269.43C919.35,-270.77 938.35,-272.53 957.85,-274.34\"/>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M957.85,-274.34C977.34,-276.14 997.32,-277.99 1013.79,-279.51\"/>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1013.45,-283 1023.73,-280.43 1014.09,-276.03 1013.45,-283\"/>\n",
       "</g>\n",
       "<!-- clustertestbOutputsWithInjectionfailed -->\n",
       "<g id=\"node23\" class=\"node\">\n",
       "<title>clustertestbOutputsWithInjectionfailed</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"892.58,-333 850.58,-333 850.58,-309 892.58,-309 904.58,-321 892.58,-333\"/>\n",
       "<text text-anchor=\"middle\" x=\"877.58\" y=\"-315.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">failed</text>\n",
       "</g>\n",
       "<!-- clustertestbOutputsWithInjectionuser_input -->\n",
       "<g id=\"node24\" class=\"node\">\n",
       "<title>clustertestbOutputsWithInjectionuser_input</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"877.58\" cy=\"-375\" rx=\"51.35\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"877.58\" y=\"-369.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">user_input</text>\n",
       "</g>\n",
       "<!-- clustertestc_failsInputsother -->\n",
       "<g id=\"node28\" class=\"node\">\n",
       "<title>clustertestc_failsInputsother</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"1052.46\" cy=\"-391\" rx=\"30.38\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"1052.46\" y=\"-385.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">other</text>\n",
       "</g>\n",
       "<!-- clustertestbOutputsWithInjectionuser_input&#45;&gt;clustertestc_failsInputsother -->\n",
       "<g id=\"edge11\" class=\"edge\">\n",
       "<title>clustertestbOutputsWithInjectionuser_input&#45;&gt;clustertestc_failsInputsother</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M927.66,-379.54C940.8,-380.76 955.37,-382.11 969.76,-383.44\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M969.76,-383.44C984.15,-384.77 998.37,-386.09 1010.81,-387.24\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"1010.25,-390.7 1020.53,-388.14 1010.9,-383.73 1010.25,-390.7\"/>\n",
       "</g>\n",
       "<!-- clustertestc_failsOutputsWithInjectionran -->\n",
       "<g id=\"node29\" class=\"node\">\n",
       "<title>clustertestc_failsOutputsWithInjectionran</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1245.33,-439 1203.33,-439 1203.33,-415 1245.33,-415 1257.33,-427 1245.33,-439\"/>\n",
       "<text text-anchor=\"middle\" x=\"1230.33\" y=\"-421.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">ran</text>\n",
       "</g>\n",
       "<!-- clustertestc_failsInputsrun&#45;&gt;clustertestc_failsOutputsWithInjectionran -->\n",
       "<!-- clustertestc_failsInputsaccumulate_and_run -->\n",
       "<g id=\"node26\" class=\"node\">\n",
       "<title>clustertestc_failsInputsaccumulate_and_run</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1111.83,-349 981.08,-349 981.08,-325 1111.83,-325 1123.83,-337 1111.83,-349\"/>\n",
       "<text text-anchor=\"middle\" x=\"1052.46\" y=\"-331.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">accumulate_and_run</text>\n",
       "</g>\n",
       "<!-- clustertestd_if_successInputsrun -->\n",
       "<g id=\"node32\" class=\"node\">\n",
       "<title>clustertestd_if_successInputsrun</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1420.21,-463 1378.21,-463 1378.21,-439 1420.21,-439 1432.21,-451 1420.21,-463\"/>\n",
       "<text text-anchor=\"middle\" x=\"1405.21\" y=\"-445.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">run</text>\n",
       "</g>\n",
       "<!-- clustertestc_failsOutputsWithInjectionran&#45;&gt;clustertestd_if_successInputsrun -->\n",
       "<g id=\"edge12\" class=\"edge\">\n",
       "<title>clustertestc_failsOutputsWithInjectionran&#45;&gt;clustertestd_if_successInputsrun</title>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M1257.59,-430.65C1272.16,-432.67 1291.27,-435.32 1310.85,-438.04\"/>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M1310.85,-438.04C1330.44,-440.76 1350.5,-443.54 1366.98,-445.83\"/>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1366.1,-449.24 1376.49,-447.15 1367.06,-442.31 1366.1,-449.24\"/>\n",
       "</g>\n",
       "<!-- clustertestc_failsOutputsWithInjectionfailed -->\n",
       "<g id=\"node30\" class=\"node\">\n",
       "<title>clustertestc_failsOutputsWithInjectionfailed</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1245.33,-331 1203.33,-331 1203.33,-307 1245.33,-307 1257.33,-319 1245.33,-331\"/>\n",
       "<text text-anchor=\"middle\" x=\"1230.33\" y=\"-313.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">failed</text>\n",
       "</g>\n",
       "<!-- clustertestd_if_failureInputsrun -->\n",
       "<g id=\"node38\" class=\"node\">\n",
       "<title>clustertestd_if_failureInputsrun</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1420.21,-313 1378.21,-313 1378.21,-289 1420.21,-289 1432.21,-301 1420.21,-313\"/>\n",
       "<text text-anchor=\"middle\" x=\"1405.21\" y=\"-295.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">run</text>\n",
       "</g>\n",
       "<!-- clustertestc_failsOutputsWithInjectionfailed&#45;&gt;clustertestd_if_failureInputsrun -->\n",
       "<g id=\"edge13\" class=\"edge\">\n",
       "<title>clustertestc_failsOutputsWithInjectionfailed&#45;&gt;clustertestd_if_failureInputsrun</title>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M1257.59,-316.27C1272.1,-314.76 1291.1,-312.78 1310.6,-310.75\"/>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M1310.6,-310.75C1330.09,-308.72 1350.07,-306.64 1366.54,-304.92\"/>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1366.9,-308.4 1376.48,-303.89 1366.17,-301.44 1366.9,-308.4\"/>\n",
       "</g>\n",
       "<!-- clustertestc_failsOutputsWithInjectionadd -->\n",
       "<g id=\"node31\" class=\"node\">\n",
       "<title>clustertestc_failsOutputsWithInjectionadd</title>\n",
       "<ellipse fill=\"none\" stroke=\"#edb22c\" stroke-width=\"2\" cx=\"1230.33\" cy=\"-373\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"1230.33\" y=\"-367.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">add</text>\n",
       "</g>\n",
       "<!-- clustertestc_failsOutputsWithInjectionadd&#45;&gt;clustertestOutputsc_fails__add -->\n",
       "<g id=\"edge21\" class=\"edge\">\n",
       "<title>clustertestc_failsOutputsWithInjectionadd&#45;&gt;clustertestOutputsc_fails__add</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M1257.39,-376.19C1316.48,-383.13 1465.19,-399 1590.08,-399 1590.08,-399 1590.08,-399 1607.34,-399\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M1607.34,-399C1627.57,-399 1671.51,-399 1766.96,-399 1879.02,-399 2009.04,-389.7 2086.28,-383.19\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"2086.58,-386.68 2096.24,-382.34 2085.98,-379.71 2086.58,-386.68\"/>\n",
       "</g>\n",
       "<!-- clustertestd_if_successOutputsWithInjectionran -->\n",
       "<g id=\"node35\" class=\"node\">\n",
       "<title>clustertestd_if_successOutputsWithInjectionran</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1606.08,-463 1564.08,-463 1564.08,-439 1606.08,-439 1618.08,-451 1606.08,-463\"/>\n",
       "<text text-anchor=\"middle\" x=\"1591.08\" y=\"-445.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">ran</text>\n",
       "</g>\n",
       "<!-- clustertestd_if_successInputsrun&#45;&gt;clustertestd_if_successOutputsWithInjectionran -->\n",
       "<!-- clustertestd_if_successInputsaccumulate_and_run -->\n",
       "<g id=\"node33\" class=\"node\">\n",
       "<title>clustertestd_if_successInputsaccumulate_and_run</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1464.58,-517 1333.83,-517 1333.83,-493 1464.58,-493 1476.58,-505 1464.58,-517\"/>\n",
       "<text text-anchor=\"middle\" x=\"1405.21\" y=\"-499.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">accumulate_and_run</text>\n",
       "</g>\n",
       "<!-- clustertestd_if_successOutputsWithInjectionfailed -->\n",
       "<g id=\"node36\" class=\"node\">\n",
       "<title>clustertestd_if_successOutputsWithInjectionfailed</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1606.08,-517 1564.08,-517 1564.08,-493 1606.08,-493 1618.08,-505 1606.08,-517\"/>\n",
       "<text text-anchor=\"middle\" x=\"1591.08\" y=\"-499.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">failed</text>\n",
       "</g>\n",
       "<!-- clustertestd_if_successOutputsWithInjectionuser_input -->\n",
       "<g id=\"node37\" class=\"node\">\n",
       "<title>clustertestd_if_successOutputsWithInjectionuser_input</title>\n",
       "<ellipse fill=\"none\" stroke=\"#edb22c\" stroke-width=\"2\" cx=\"1591.08\" cy=\"-559\" rx=\"51.35\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"1591.08\" y=\"-553.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">user_input</text>\n",
       "</g>\n",
       "<!-- clustertestd_if_successOutputsWithInjectionuser_input&#45;&gt;clustertestOutputsd_if_success__user_input -->\n",
       "<g id=\"edge22\" class=\"edge\">\n",
       "<title>clustertestd_if_successOutputsWithInjectionuser_input&#45;&gt;clustertestOutputsd_if_success__user_input</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M1634.79,-549.27C1682.11,-538.5 1762.89,-520.1 1846.83,-500.98\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M1846.83,-500.98C1930.76,-481.87 2017.85,-462.03 2077.79,-448.38\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"2078.24,-451.87 2087.22,-446.24 2076.69,-445.04 2078.24,-451.87\"/>\n",
       "</g>\n",
       "<!-- clustertestd_if_failureOutputsWithInjectionran -->\n",
       "<g id=\"node41\" class=\"node\">\n",
       "<title>clustertestd_if_failureOutputsWithInjectionran</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1606.08,-205 1564.08,-205 1564.08,-181 1606.08,-181 1618.08,-193 1606.08,-205\"/>\n",
       "<text text-anchor=\"middle\" x=\"1591.08\" y=\"-187.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">ran</text>\n",
       "</g>\n",
       "<!-- clustertestd_if_failureInputsrun&#45;&gt;clustertestd_if_failureOutputsWithInjectionran -->\n",
       "<!-- clustertestd_if_failureInputsaccumulate_and_run -->\n",
       "<g id=\"node39\" class=\"node\">\n",
       "<title>clustertestd_if_failureInputsaccumulate_and_run</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1464.58,-259 1333.83,-259 1333.83,-235 1464.58,-235 1476.58,-247 1464.58,-259\"/>\n",
       "<text text-anchor=\"middle\" x=\"1405.21\" y=\"-241.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">accumulate_and_run</text>\n",
       "</g>\n",
       "<!-- clusterteste_failsInputsrun -->\n",
       "<g id=\"node44\" class=\"node\">\n",
       "<title>clusterteste_failsInputsrun</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1780.96,-259 1738.96,-259 1738.96,-235 1780.96,-235 1792.96,-247 1780.96,-259\"/>\n",
       "<text text-anchor=\"middle\" x=\"1765.96\" y=\"-241.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">run</text>\n",
       "</g>\n",
       "<!-- clustertestd_if_failureOutputsWithInjectionran&#45;&gt;clusterteste_failsInputsrun -->\n",
       "<g id=\"edge14\" class=\"edge\">\n",
       "<title>clustertestd_if_failureOutputsWithInjectionran&#45;&gt;clusterteste_failsInputsrun</title>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M1618.34,-201.2C1632.97,-205.77 1652.19,-211.77 1671.86,-217.92\"/>\n",
       "<path fill=\"none\" stroke=\"#21bfd8\" d=\"M1671.86,-217.92C1691.53,-224.07 1711.67,-230.36 1728.16,-235.51\"/>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1726.7,-238.72 1737.29,-238.36 1728.79,-232.04 1726.7,-238.72\"/>\n",
       "</g>\n",
       "<!-- clustertestd_if_failureOutputsWithInjectionfailed -->\n",
       "<g id=\"node42\" class=\"node\">\n",
       "<title>clustertestd_if_failureOutputsWithInjectionfailed</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1606.08,-259 1564.08,-259 1564.08,-235 1606.08,-235 1618.08,-247 1606.08,-259\"/>\n",
       "<text text-anchor=\"middle\" x=\"1591.08\" y=\"-241.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">failed</text>\n",
       "</g>\n",
       "<!-- clustertestd_if_failureOutputsWithInjectionuser_input -->\n",
       "<g id=\"node43\" class=\"node\">\n",
       "<title>clustertestd_if_failureOutputsWithInjectionuser_input</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"1591.08\" cy=\"-301\" rx=\"51.35\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"1591.08\" y=\"-295.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">user_input</text>\n",
       "</g>\n",
       "<!-- clusterteste_failsInputsobj -->\n",
       "<g id=\"node46\" class=\"node\">\n",
       "<title>clusterteste_failsInputsobj</title>\n",
       "<ellipse fill=\"#edb22c\" stroke=\"#edb22c\" cx=\"1765.96\" cy=\"-301\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"1765.96\" y=\"-295.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">obj</text>\n",
       "</g>\n",
       "<!-- clustertestd_if_failureOutputsWithInjectionuser_input&#45;&gt;clusterteste_failsInputsobj -->\n",
       "<g id=\"edge15\" class=\"edge\">\n",
       "<title>clustertestd_if_failureOutputsWithInjectionuser_input&#45;&gt;clusterteste_failsInputsobj</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M1642.55,-301C1656.08,-301 1671.04,-301 1685.73,-301\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M1685.73,-301C1700.41,-301 1714.82,-301 1727.23,-301\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"1727.21,-304.5 1737.21,-301 1727.21,-297.5 1727.21,-304.5\"/>\n",
       "</g>\n",
       "<!-- clusterteste_failsOutputsWithInjectionran -->\n",
       "<g id=\"node48\" class=\"node\">\n",
       "<title>clusterteste_failsOutputsWithInjectionran</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1958.83,-205 1916.83,-205 1916.83,-181 1958.83,-181 1970.83,-193 1958.83,-205\"/>\n",
       "<text text-anchor=\"middle\" x=\"1943.83\" y=\"-187.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">ran</text>\n",
       "</g>\n",
       "<!-- clusterteste_failsInputsrun&#45;&gt;clusterteste_failsOutputsWithInjectionran -->\n",
       "<!-- clusterteste_failsInputsaccumulate_and_run -->\n",
       "<g id=\"node45\" class=\"node\">\n",
       "<title>clusterteste_failsInputsaccumulate_and_run</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1825.33,-205 1694.58,-205 1694.58,-181 1825.33,-181 1837.33,-193 1825.33,-205\"/>\n",
       "<text text-anchor=\"middle\" x=\"1765.96\" y=\"-187.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">accumulate_and_run</text>\n",
       "</g>\n",
       "<!-- clusterteste_failsOutputsWithInjectionfailed -->\n",
       "<g id=\"node49\" class=\"node\">\n",
       "<title>clusterteste_failsOutputsWithInjectionfailed</title>\n",
       "<polygon fill=\"#21bfd8\" stroke=\"#21bfd8\" points=\"1958.83,-259 1916.83,-259 1916.83,-235 1958.83,-235 1970.83,-247 1958.83,-259\"/>\n",
       "<text text-anchor=\"middle\" x=\"1943.83\" y=\"-241.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">failed</text>\n",
       "</g>\n",
       "<!-- clusterteste_failsOutputsWithInjectionadd -->\n",
       "<g id=\"node50\" class=\"node\">\n",
       "<title>clusterteste_failsOutputsWithInjectionadd</title>\n",
       "<ellipse fill=\"none\" stroke=\"#edb22c\" stroke-width=\"2\" cx=\"1943.83\" cy=\"-301\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"1943.83\" y=\"-295.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">add</text>\n",
       "</g>\n",
       "<!-- clusterteste_failsOutputsWithInjectionadd&#45;&gt;clustertestOutputse_fails__add -->\n",
       "<g id=\"edge23\" class=\"edge\">\n",
       "<title>clusterteste_failsOutputsWithInjectionadd&#45;&gt;clustertestOutputse_fails__add</title>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M1970.91,-303.74C1985.28,-305.25 2004.29,-307.25 2024.63,-309.39\"/>\n",
       "<path fill=\"none\" stroke=\"#edb22c\" d=\"M2024.63,-309.39C2044.98,-311.53 2066.65,-313.81 2086.33,-315.87\"/>\n",
       "<polygon fill=\"#edb22c\" stroke=\"#edb22c\" points=\"2085.91,-319.35 2096.22,-316.91 2086.64,-312.39 2085.91,-319.35\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.graphs.Digraph at 0x1343d54d0>"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf = pwf.Workflow(\"test\")\n",
    "wf.a = pwf.standard_nodes.UserInput(1)\n",
    "wf.b = pwf.standard_nodes.UserInput(\"two\")\n",
    "wf.c_fails = wf.a + wf.b  # Type error\n",
    "wf.d_if_success = pwf.standard_nodes.UserInput(0)\n",
    "wf.d_if_failure = pwf.standard_nodes.UserInput(\"But what's the question?\")\n",
    "wf.e_fails = pwf.standard_nodes.Add(wf.d_if_failure, 42)  # Type error\n",
    "\n",
    "wf.a >> wf.b >> wf.c_fails >> wf.d_if_success\n",
    "wf.c_fails.signals.output.failed >> wf.d_if_failure >> wf.e_fails\n",
    "wf.starting_nodes = [wf.a]\n",
    "wf.automate_execution = False\n",
    "\n",
    "with pwf.Workflow.create.ProcessPoolExecutor() as exe:\n",
    "    wf.c_fails.executor = exe\n",
    "    wf(raise_run_exceptions=False)\n",
    "\n",
    "wf.draw(size=(10, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f265a14-11fd-40e4-9862-b524ad749c0a",
   "metadata": {},
   "source": [
    "## Storage interfaces\n",
    "\n",
    "We saw in `quickstart.ipynb` how to save and load nodes to/from their default location (based on the current working directory and their semantic label), and how to use checkpointing and autoloading with the built-in `\"pickle\"` storage back end.\n",
    "\n",
    "We can also save and load using an explicit storage interface instance. This allows us to save and load at non-standard locations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "75aac7e5-7fe8-4a69-b0f3-1510cf52ef5e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'without__in': True}"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf = pwf.Workflow(\"custom_save_location\")\n",
    "wf.cant_spell = pwf.standard_nodes.UserInput(\"slaughter\")\n",
    "wf.without = wf.cant_spell.contains(\"laughter\")\n",
    "wf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "3ce9be3f-2ac9-49d1-a482-dc0c6735aa59",
   "metadata": {},
   "outputs": [],
   "source": [
    "storage = pwf.PickleStorage()\n",
    "storage.save(wf, \"../someplace_else\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "2e70af5b-9e74-4b1a-a26c-b9f427401f4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    reloaded = storage.load(filename=\"../someplace_else\")\n",
    "    assert(reloaded.outputs.without__in.value == wf.outputs.without__in.value)\n",
    "finally:\n",
    "    # Clean up\n",
    "    storage.delete(filename=\"../someplace_else\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5819af7e-0303-483a-8e4d-f02bae4cae73",
   "metadata": {},
   "source": [
    "And also to specify interface settings -- these can also be set on a per-operation level using kwargs, but for something like `checkpoint` the operations happen in a built-in way where we don't have the ability to modify the kwargs to the call, so we need to adjust the settings right in the interface.\n",
    "\n",
    "For `PickleStorage` the only setting is whether to allow a fallback to `cloudpickle`, so let's turn that off and construct an example where we'd see the failure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "8adf1d56-6d81-4b20-9efe-ae0a67348cf9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def outer_function():\n",
    "    def inner_function(x):\n",
    "        return x\n",
    "    return inner_function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "6b1f54c9-872b-40c6-9370-bd0032d5d075",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'unpickleable__x': 2}"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf = pwf.Workflow(\"doomed\")\n",
    "wf.unpickleable = pwf.function_node(outer_function())\n",
    "wf(unpickleable__x=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f2dfcd4-d753-4f75-9405-38c91bf4937c",
   "metadata": {},
   "source": [
    "There's nothing inherently wrong with the node and it runs fine, but the function comes from a `<local>` scope, so we won't be able to pickle it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "2938411c-df0a-4483-ae32-2fec2413248b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TypeNotFoundError: doomed cannot be saved with the storage interface PickleStorage because it (or one of its children) has a type that cannot be imported. Is this node defined inside <locals>? \n",
      "Import readiness report: \n",
      "doomed: NOT IMPORTABLE\n",
      "\tunpickleable: NOT IMPORTABLE\n"
     ]
    }
   ],
   "source": [
    "no_fallback = pwf.PickleStorage(cloudpickle_fallback=False)\n",
    "wf.unpickleable.checkpoint = no_fallback\n",
    "try:\n",
    "    wf.recovery = None  # We know this will fail and don't care about a recovery file\n",
    "    wf(unpickleable__x=3)\n",
    "except pwf.TypeNotFoundError as e:\n",
    "    print(\"TypeNotFoundError:\", e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d854f41-9049-413d-acb4-1a9c40ea2cf4",
   "metadata": {},
   "source": [
    "### Extensions\n",
    "\n",
    "The pickle interface inherits from a more generic `StorageInterface`, which uses abstract methods to specify what `Node` expects from an interface that sits between itself and a serialization routine. Further storage backends are possible by subclassing this base class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f40bfd6f-3fbf-4c2b-aeee-534ed4bcc970",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}