Rename Task.process to Task.run

esrftaskgraph/esrftaskgraph/methodtask.py

@@ -3,7 +3,7 @@ from esrftaskgraph.utils import import_method
 
 
 class MethodExecutorTask(Task, input_names=["method"], output_names=["return_value"]):
-    def process(self):
+    def run(self):
         method_kwargs = self.input_values
         fullname = method_kwargs.pop("method")
         method = import_method(fullname)

esrftaskgraph/esrftaskgraph/ppftasks.py

@@ -13,7 +13,7 @@ class PpfMethodExecutorTask(
     arguments and passed to the method.
     """
 
-    def process(self):
+    def run(self):
         method_kwargs = self.input_values
         fullname = method_kwargs.pop("method")
         method = import_method(fullname)
@@ -32,7 +32,7 @@ class PpfPortTask(
 ):
     """A ppfmethod which represents the identity mapping"""
 
-    def process(self):
+    def run(self):
         method_kwargs = self.input_values
         method_kwargs.pop("ppfport")  # not used
         ppfdict = method_kwargs.pop("ppfdict", None)

esrftaskgraph/esrftaskgraph/scripttask.py

@@ -4,7 +4,7 @@ from esrftaskgraph.task import Task
 
 
 class ScriptExecutorTask(Task, input_names=["script"], output_names=["returncode"]):
-    def process(self):
+    def run(self):
         fullname = self.inputs.script
         if not isinstance(fullname, str):
             raise TypeError(fullname, type(fullname))

esrftaskgraph/esrftaskgraph/task.py

@@ -202,13 +202,13 @@ class Task(Registered, hashing.UniversalHashable, register=False):
             if self.done:
                 return
             self.assert_ready_to_execute()
-            self.process()
+            self.run()
             self._outputs.dump()
         except Exception as e:
             self._exception = e
             if raise_on_error:
                 raise
 
-    def process(self):
+    def run(self):
         """To be implemented by the derived classes"""
         raise NotImplementedError

esrftaskgraph/esrftaskgraph/variable.py

@@ -194,7 +194,7 @@ class Variable(hashing.UniversalHashable):
 
     def force_non_existing(self):
         while self.exists:
-            super().uhash_randomize()
+            self.uhash_randomize()
 
 
 class VariableContainer(Mapping, Variable):

examples/taskgraph_representation.ipynb

 %% Cell type:markdown id:dominican-grave tags:
 
 # Load an run a task graph
 
 %% Cell type:code id:explicit-stake tags:
 
 ``` python
 import networkx
 import matplotlib.pyplot as plt
 from esrftaskgraph import load_graph
 from taskgraphlib import acyclic_graph1
 
 varinfo = {"root_uri": "/tmp/myresults"}
 
 persistent_taskgraph, expected_results = acyclic_graph1()
 
 runtime_taskgraph = load_graph(persistent_taskgraph)
 
 runtime_taskgraph.execute(varinfo=varinfo)
 
 networkx.draw(runtime_taskgraph.graph, with_labels=True)
 plt.show()
 ```
 
 %%%% Output: display_data
 
     ![](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAb4AAAEuCAYAAADx63eqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAA0H0lEQVR4nO3deVRU5eMG8GcYYAZlU3YBwdzQVFxAaTGwMpWi0rC+foVM8ksqkmUelSztV1rZaiK4laYo5gKKJiSiYGiSqCzmggKprIogsjiDMDO/PzDKXBIC7szc53NO5xj3zvDco/L4vvPe+0o0Go0GREREImEgdAAiIqL2xOIjIiJRYfEREZGosPiIiEhUWHxERCQqLD4iIhIVFh8REYkKi4+IiESFxUdERKLC4iMiIlFh8RERkaiw+IiISFRYfEREJCosPiIiEhUWHxERiQqLj4iIRIXFR0REosLiIyIiUWHxERGRqLD4iIhIVFh8REQkKiw+IiISFUOhAxARke65WlOH7ccLcba0ClXKBpjLDeFmb47xQ5xgZSoTOt59STQajUboEEREpBuyCioRkZKLg+fKAAB1DeqmY3JDA2gA+PS2wXTvHnB3thQm5D9g8RER0QPZmHYBi+PPQtmgwv2aQyIB5IZSzPd1Q4CXa7vle1D8jI+IiP5RY+mdgaL+7qWnvJiNwohJAACNBlDUq7A4/gw2pl1o36APgMVHRCRyrq6uSEpKuufxrIJKLI4/C0W9+p7n3I2iXo3F8WeRXViJGzduYPr06bC2toaFhQWeeOKJfxu7xbi4hYiI7isiJRfKBlWLXqtsUCEyJRc1Py1FQ0MDzpw5g86dOyMzM7N1QzYDi4+ISMQCAwNx6dIl+Pn5QSqVYsGCBUhPT0dqaioUCgX69uuPkv4BQCdnAIAiLx3XDqxFQ/VVGBibwMzzRVgMG3fH+1Yd24WajATYvvIR9h4uwtVdu1BUWAhzc3MAwJAhQ9r1Ov+KU51ERCIWFRWFrl27Yvfu3aipqcGcOXMwZswYnD9/HleuXIGJQ0+U7vy86fzy+GXoPDoEXWdtg8OUSMhdBtzxnpWHNqP25H7YTfwUhubWUBafg7m1AxYuXAhra2v0798fMTEx7XmZt2HxERHRbYKCgmBmZgaZTIbevpNRdzkfamVt40GpIeqvFkBddwNSuSlk9j3+fKFGg4r9a6C8kAG7CR9D2sECAKCsLEPx7+dgYWGB4uJiLF++HJMmTcKZM2cEuDoWHxER/YVKpcK8efPQvXt3mJubY+2MZxu/rqgCANiMDYMi7xiKIiejdNM81BX9WV7qulrUZO6Fudd4GMg7Nn1dYmgMA6kh3nvvPRgbG8Pb2xsjRoxAYmJi+17cLSw+IiKRk0gkTb+Ojo5GXFwckpKScP36dQQt33PrSOM9DDKHXrD1fx9Ob25Ch55eKNu5pOm1BnJT2PovQHn8UigLTzd93cjW9b7fs72x+IiIRM7Ozg55eXm4dOkSSktLYWxsDCsrK9y4cQOnd61qOk+jqkfNqWSolbWQSA0hkXVovFv9L+QuA2DtNxtlsR+jrjgHAGDZbQCs7Lvgk08+QUNDAw4fPozk5GSMGjWqXa/zDyw+IiKRCwsLw//93//BxcUFYWFhyM7OhoWFBUxNTfHEoL63nVv7WzKKVgTh0lfjUZORAGu/2Xe8n0m3QbDynYkr2z9CXWkuIDXEjh07ER8fDwsLC/zvf//Dhg0b4Obm1l6XeBs+soyIiKDRaODq6opLly4BAAwMDDB8+HAkJyfjjY3Hse/M5fs+puxeJBJgVF87rAzwaOXELccRHxGRiKnVauzduxd+fn4oLy+HkZERjIyMMHjwYCQmJkIikSDEpwfkhtIWvb/cUIrpPj3++cR2xOIjIhKhqqoqhIeHo0+fPpgzZw5efPFFXLx4ETKZDLa2tvjpp59gbGwMAHB3tsR8XzeYGDWvMkyMDDDf1w0DnCzb4Apajk9uISISkZycHCxfvhybNm3CU089hTVr1mD48OFNqyy3bt2K3r17w8rK6rbX/bHLgj7szsDP+IiI9JxarUZ8fDzCw8ORmZmJKVOmYOrUqXB2dm72e2UXViIyJRfJOWWQAFDeZT++Eb1tMN2nh9aN9P7A4iMi0lOVlZVYu3YtIiIi0KlTJ4SGhuKVV16BXC7/1+9dXlOH7ScKcbakGlXKepjLjeDmYAb/wdyBnYiI2tmpU6cQHh6OLVu2YMyYMQgNDYWXl5egN41rE37GR0SkB1QqFXbt2oXw8HCcOXMGb7zxBk6fPg0HBweho2kdFh8RkQ4rLy/Ht99+i8jISHTp0gWhoaHw9/dvWpFJd2LxERHpoKysLISHhyMmJgbPP/88YmJi4OGhPTeJazMWHxGRjqivr8fOnTsRHh6O/Px8TJ06FTk5ObC1tRU6mk5h8RERabmysjKsXr0aK1euhKurK0JDQzF27FgYGRkJHU0nsfiIiLTUsWPHEB4ejl27dmHcuHHYvXs3Bg4cKHQsncfbGYiItMjNmzexfft2hIeHo7i4GNOnT8eUKVPueJIKtRyLj4hIC5SWlmLVqlVYtWoV3NzcEBoaCj8/PxgacmKutfEh1UREAtFoNEhLS8PEiRPRp08flJSUIDExEQcOHMDYsWNZem2EIz4ionZWV1eHLVu2IDw8HBUVFQgJCcHkyZPRqVMnoaOJAouPiKidFBYWYuXKlVizZg0GDhyI0NBQjBkzBlJpy/a6o5bhVCcRURvSaDRITU3Fyy+/jAEDBuD69es4ePAg9u7di+eee46lJwCO+IiI2oBCoUB0dDTCw8OhUCgwY8YMTJo0Cebm5kJHEz0WHxFRK7p48SIiIyOxdu1aDB06FKGhoXjmmWdgYMAJNm3B3wkion9Jo9E0rcQcPHgwbt68iSNHjmDPnj0YPXo0S0/LcK0sEVEL1dbWIioqCsuXL4dGo8GMGTMQFRUFU1NToaPRfXCqk4iomfLz8xEREYH169fj8ccfR2hoKJ588klu9KojOP4mInoAarUaiYmJ8PPzw7BhwyCVSnHs2DHs3LkTTz31FEtPh3Cqk4joPqqrq7F+/XosX74cMpkMoaGh2LJlCzp06CB0NGohFh8R0V2cO3cOy5cvx8aNG/HUU09h9erVGD58OEd2eoDFR0R0i1qtRkJCAsLDw5GRkYEpU6YgKysLzs7OQkejVsTiIyLRq6ysxLp16xAREQFLS0uEhoZi586dkMvlQkejNsDiIyLROn36NMLDw/HDDz9g9OjRiIqKgpeXF6cz9RyLj4hERaVSYffu3QgPD8fp06cRHByMU6dOoUuXLkJHo3bC4iMiUaioqMC3336LyMhI2NvbIzQ0FOPHj4exsbHQ0aidsfiISK9lZWUhPDwcMTEx8PPzw7Zt2+Dp6Sl0LBIQi4+I9E5DQwN27tyJZcuWIT8/H1OnTkVOTg5sbW2FjkZagMVHRHqjrKwMa9aswYoVK+Dq6orQ0FCMHTsWRkZGQkcjLcLiIyKdd/z4cYSHhyMuLg7jxo3Drl27MGjQIKFjkZbiQ6qJSCfdvHkTMTExCA8PR1FREaZPn44pU6bAyspK6Gik5Vh8RKRTSktLsWrVKqxatQpubm4IDQ2Fn58fDA05gUUPhrszEJHW02g0SEtLw8SJE9GnTx+UlJQgMTGxafNXlh41B0d8RKS16urqsGXLFoSHh6O8vBwhISEICgpCp06dhI5GOozFR0Rap6ioCCtWrMCaNWvg7u6O0NBQ+Pr6QiqVCh2N9ACnOolIK2g0GqSmpuLll19G//79UVlZiYMHDzZt/srSo9bCER8RCUqhUCA6OhrLly9HbW0tZsyYgddeew3m5uZCRyM9xeIjon90taYO248X4mxpFaqUDTCXG8LN3hzjhzjBylTWove8ePEiVqxYge+++w5Dhw5FaGgonnnmGRgYcCKK2haLj4juKaugEhEpuTh4rgwAUNegbjomNzSABoBPbxtM9+4Bd2fLf3w/jUaDlJQUhIeH4+DBg3j11VcREhKCHj16tNEVEN2JxUdEd7Ux7QIWx5+FskGF+/2UkEgAuaEU833dEODletdzamtrsXHjRixfvhwqlQqhoaEIDAyEqalp24Qnug/OKRDRHRpL7wwU9fcuPeXFbBRGTIJGAyjqVVgcfwYb0y7cdk5+fj7eeecduLi4ICEhAUuXLsWpU6cwbdo0lh4JhsVHJEKurq5ISkq667Gsgkosjj8LRb36rsfvRVGvxuL4s8gquIYNGzZAIpGge/fuCA8Ph0KhwJAhQ/DUU09xd3MSHB93QES3iUjJhbJB1aLXKhtUeOn91TBMWwcAuH79OldnktZh8RGJTGBgIC5dutR0b9yCBQuQnp6O1NRU3FAo0GDhDMtnpsPYxgUAoMhLx7UDa9FQfRUGxiYw83wRFsPG3fG+Vcd2oSYjAY7/XYSt2+MwpL8bOnTo0N6XR/SPONVJJDJRUVHo2rUrdu/ejZqaGsyZMwdjxozB+fPnsXj7EcgceuDq7i+azi+PX4bOo0PQddY2OEyJhNxlwB3vWXloM2pP7ofdxE8hs7BBwqlSAICLiwucnJwwefJkXL16td2ukeh+WHxEhKCgIJiZmSGvog5mj05A/ZXfoVbWNh6UGqL+agHUdTcglZtCZv+XWw80GlTsXwPlhQzYTfgY0g4WUDaoUaw0Qnp6Oi5evIjjx4+juroaEydOFObiiP6GU51EIqdSqTB//nxs27YNBcWX0XBrFadKUQUDeUfYjA3D9cNbUJnyPYxsu6GTzyTIHPsAANR1tajJ3AvrF+bCQN6x6T2VMIKHhwcAwM7ODsuXL4eDgwOqq6thZmbW7tdI9Fcc8RGJ0F9XVkZHRyMuLg5JSUmYtu5nOE377taRxgaUOfSCrf/7cHpzEzr09ELZziVNrzWQm8LWfwHK45dCWXi66evmcqO7fj+1unkrRYnaAouPSITs7OyQn58PAKiuroZMJoOVlRUesjRCVWpU03kaVT1qTiVDrayFRGoIiaxD4x3rfyF3GQBrv9koi/0YdcU5kBsaQHYtDzk5OVCr1SgvL8ebb74JHx8fWFhYtOt1Et0Ni49IhMLCwrBo0SJYWlqioqICLi4ucHR0xBfBz8LE0e22c2t/S0bRiiBc+mo8ajISYO03+473M+k2CFa+M3Fl+0dQlOTiIVktRo8eDTMzM/Tr1w8ymQybN29ur8sjui8+soyIbhMcdQz7zly+72PK7kUiAUb1tcPKAI/WD0bUSri4hUjE6uvrcfLkSZw7dw5nz55FUlISrmo6Qv7U21DUN/8mdrmhFNN9+MBp0m4sPiIR27hxI15//XV07NgRNTU1AIBRo0YhwNft1rM6H3wxiomRAeb7umGAk2UbpSVqHZzqJBKxuro69OzZEwUFBQAAExMTXLhwAba2tq26OwORNuGIj0ik1Go1IiMjUV1dDWNjY0gkEsyePRu2trYAgAAvVwxwskRkSi6Sc8ogAaC8y358tqoyfBPki8Gu1sJcCFEzccRHJEIFBQV47bXXoFQqERUVhdjYWHz66ae4ePEiOnbseMf55TV12H6iEGdLqlGlrIe53AhuDmZ4pqcFHupig4cffhgHDx6ElZWVAFdD1DwsPiKR2bx5M2bOnIm33noLc+fOhVQqhUajQU1NTbOfqlJSUoKuXbtCpVLBzs4OiYmJ6N+/fxslJ2odnOokEolr164hJCQEGRkZSEhIwJAhQ5qOSSSSFj1K7MaNG5DJZKitrUVpaSk8PDxw6NAheHp6tmZ0olbFG9iJRODAgQNwd3eHtbU1jh8/flvp/Ru1tbVQq9WQSqWQSqXw9/dH165dW+W9idoKi49IjymVSsyaNQuvvvoq1qxZg2XLlrXqHnkymQwmJiYIDg6GqakpwsPDYWdn12rvT9QWONVJpKeysrIwceJE9OnTB1lZWW2y8KR3794oLy8H0Dj6W7VqFcLCwlr9+xC1Ji5uIdIzKpUKX375JT7//HN89dVXCAgIuG03hraSnZ2N0aNH4/fff4dMJmvz70fUUhzxEemRixcv4tVXXwUAHDt2DC4uLu32vQcMGIB+/fph8+bNeO2119rt+xI1Fz/jI9IDGo0GUVFR8PT0xLPPPosDBw60a+n9Yfbs2fjyyy/BiSTSZhzxEem48vJyTJs2DadPn0ZiYiIGDhwoWJaRI0dCIpEgMTERo0aNEiwH0f1wxEekwxITE+Hu7g4nJyccO3ZM0NIDGu8HfOedd/DFF18ImoPofri4hUgHKRQKzJ07Fzt37sS6devw1FNPCR2pyc2bN9GtWzfEx8fD3d1d6DhEd+CIj0jHnDhxAoMHD8bVq1eRlZWlVaUHAMbGxggNDcWXX34pdBSiu+KIj0hHqFQqLFmyBEuXLsU333yDCRMmCB3pnq5du4bu3bsjOzsbTk5OQschug2Lj0gH5OfnIzAwEDKZDOvXr4ezs7PQkf7RzJkzIZfLsWTJEqGjEN2GU51EWkyj0WDt2rUYNmwY/P39kZSUpBOlBwBvvfUWvv32W1RXVwsdheg2HPERaamysjIEBwcjPz8fmzZtQr9+/YSO1Gwvv/wyHn30Ubz11ltCRyFqwhEfkRaKj4/HwIED0bNnTxw9elQnSw8A3nnnHSxduhQNDQ1CRyFqwuIj0iK1tbWYNm0apk+fjujoaHz22Wc6/dzLYcOGwdnZGTExMUJHIWrC4iPSEkePHsXgwYNRW1uLrKwseHt7Cx2pVfxxQzs/VSFtweIjElhDQwM+/PBD+Pn5YdGiRdiwYQMsLCyEjtVq/Pz8cP36daSmpgodhQgAn9VJJKjz588jMDAQFhYWOHHiBBwdHYWO1OqkUinefvttfPHFF3jiiSeEjkPEER+REDQaDVavXo1HH30UEydOREJCgl6W3h8mTZqEtLQ05OTkCB2FiLczELW3y5cvY8qUKSgqKsLGjRvRt29foSO1i4ULF6K0tBSrVq0SOgqJHEd8RO1o165dGDhwIPr374+0tDTRlB4AhISEYOvWrbhy5YrQUUjkOOIjagc1NTV4++23sX//fmzYsAGPP/640JEEERwcjC5duuCDDz4QOgqJGEd8RG3syJEjGDhwINRqNTIzM0VbegAwa9YsrFixAgqFQugoJGIsPqI2Ul9fj/fffx9jx47F559/ju+++w7m5uZCxxKUm5sbhg4dig0bNggdhUSMU51EbSAnJwcBAQGwsbHB2rVrYW9vL3QkrZGSkoI33ngDZ86cgYEB/+1N7Y9/6ohakUajQUREBB577DEEBQVhz549LL2/8fb2hpmZGX788Ueho5BIccRH1EpKSkoQFBSE8vJyREVFoXfv3kJH0lqbN2/GypUrcfDgQaGjkAhxxEfUCmJjYzFo0CAMHToUhw8fZun9A39/f1y4cAHp6elCRyER4oiP6F+oqqrCzJkzcejQIURFRcHLy0voSDrj66+/xq+//ooffvhB6CgkMhzxEbVQamoq3N3dYWxsjIyMDJZeM73++uvYt28fLly4IHQUEhmO+Iia6ebNm1i4cCG+//57rF69Gn5+fkJH0llz5sxBfX09vv76a6GjkIiw+Iia4dSpUwgICICzszO+/fZb2NraCh1JpxUWFmLAgAHIz8+HpaWl0HFIJDjVSfQA1Go1vvnmG/j4+CAkJARxcXEsvVbg5OSEZ599FqtXrxY6CokIR3xE/6CoqAiTJ09GdXU1oqKi0KNHD6Ej6ZXMzEw899xzyM/Ph7GxsdBxSAQ44iO6j61bt2Lw4MEYPnw4UlNTWXptYODAgXBzc8OWLVuEjkIiwREf0V1UVlYiNDQUR48excaNG+Hp6Sl0JL32008/Ye7cucjMzIREIhE6Duk5jviI/iYlJQXu7u4wNzdHRkYGS68djBo1CiqVCklJSUJHIRHgiI/olrq6Orz33nuIjo7Gt99+izFjxggdSVTWrVuHLVu24KeffhI6Cuk5jviIAJw8eRKenp7Iy8tDVlYWS08A//3vf5GdnY2TJ08KHYX0HIuPRE2tVuPLL7/Ek08+iVmzZiEmJgbW1tZCxxIlmUyGGTNm4KuvvhI6Cuk5TnWSaF26dAmvvfYabt68iaioKHTr1k3oSKJXUVGB7t2749SpU+jSpYvQcUhPccRHohQdHQ0PDw8888wzOHjwIEtPS3Tu3BkBAQFYvny50FFIj3HER6Jy7do1TJ8+HVlZWdi0aRMGDRokdCT6m7y8PAwbNgwXLlyAqamp0HFIDxkKHYCovSQlJWHy5MkYN24cjh8/DhMTE6Ej0V10794dPj4+WLduHSZMDsb244U4W1qFKmUDzOWGcLM3x/ghTrAylQkdlXQUR3yk9xQKBcLCwrB9+3asW7cOI0eOFDoS/YPovYfxSdwJ3LRqfFJOXYO66Zjc0AAaAD69bTDduwfcnS2FCUk6i5/xkV7LzMyEh4cHiouLkZ2dzdLTARvTLuCjw9WosXwIdQ3q20oPAJS3vpZ4+jL+syYNG9MuCBOUdBaLj/SSSqXCkiVLMHLkSISFhWHLli3o3Lmz0LHoH2xMu4DF8WegqFfhXnNRyovZKIyYBI0GUNSrsDj+DMuPmoXFR3rnwoULGDFiBBISEnDs2DEEBATw+Y9awtXV9Z6PJcsqqMTi+LNQ1KvvevxeFPVqLI4/i+zCSpw+fRoeHh7o1KkTOnXqhKeffhqnT59ujeikR1h8pDc0Gg3Wr18PT09PPP/889i/fz9cXFyEjkUPKCIlF8oGVYteq2xQITIlF126dMH27dtRUVGBq1ev4vnnn8d//vOfVk5Kuo6rOkkvlJeX44033kBOTg7279+PAQMGCB2J/iYwMBCXLl2Cn58fpFIpFixYgPT0dKSmpuKGQoEGC2dYPjMdxjaN/1hR5KXj2oG1aKi+CgNjE5h5vgiLYePueN+qY7tQk5GAxImLsfjF/nB1tQTQ+A8hqVSK3Nzc9rxM0gEc8ZHO27t3L9zd3eHi4oL09HSWnpaKiopC165dsXv3btTU1GDOnDkYM2YMzp8/j8Xbj0Dm0ANXd3/RdH55/DJ0Hh2CrrO2wWFKJOQud/6+Vh7ajNqT+2E38VMYm1tj+4lCAIClpSXkcjlCQ0Px7rvvtts1km7giI901o0bNzB37lzExcVhw4YNePLJJ4WORM0UFBQEAMirqIPZoxNQeTQOamUtDOQdAakh6q8WwNj2IUjlppDa/2UTYI0GFfvX4GbJedhN+BgG8o5QNqhxtqQaQON+irW1tVi/fj2nu+kOLD7SScePH0dAQAAGDx6MrKwsdOrUSehI1EwqlQrz58/Htm3bUFB8GQ23VnGqFFUwkHeEzdgwXD+8BZUp38PIths6+UyCzLEPAEBdV4uazL2wfmFuY0neUqWsb/p1x44dMXXqVNjY2ODMmTOwtbVt1+sj7cWpTtIpDQ0NWLx4McaMGYOFCxdi06ZNLD0d8tfVtdHR0YiLi0NSUhKmrfsZTtO+u3WksQFlDr1g6/8+nN7chA49vVC2c0nTaw3kprD1X4Dy+KVQFv65atNcbnTb91Or1bhx4waKiora7qJI57D4SGfk5eXB29sbBw4cwPHjx7laTwfZ2dkhPz8fAFBdXQ2ZTAYrKys8ZGmEqtSopvM0qnrUnEqGWlkLidQQElkH4G+3pMhdBsDabzbKYj9GXXEO5IYGUBdmISMjAyqVClVVVZg1axY6deqEPn36tOt1knZj8ZHW02g0+O677+Dl5YXx48dj3759cHZ2FjoWtUBYWBgWLVoES0tLVFRUwMXFBY6Ojvgi+FmYOLrddm7tb8koWhGES1+NR01GAqz9Zt/xfibdBsHKdyaubP8IipJcuNsaYcKECbCwsED37t2Rl5eHn376CXK5vL0ukXQAn9VJWq2srAzBwcH4/fffsXHjRvTr10/oSNRGgqOOYd+Zy/d8Ysv9SCTAqL52WBng0frBSO9wxEdaa8+ePXB3d0evXr3w66+/svT0XIhPD8gNpS16rdxQiuk+Pf75RCJwxEdaqLa2FrNnz0ZCQgI2bNiAJ554QuhI1E7+fFbngz+2zMTIAPN9+yDAy7XtgpFe4YiPtMrRo0cxaNAg3LhxA1lZWSw9kQnwcsV83z4wMZL+fS3LHSQSwMRIytKjZuOIj7TCH7cpREZGIiIiAv7+/kJHIgFlF1YiMiUXyTllkKBxK6I//LEf34jeNpju0wMDnCyFikk6ijewk+DOnz+PgIAAWFpaIiMjA126dBE6Egmsv6MFLkUvwBvPvoiO/Z/C2ZJqVCnrYS43gpuDGfwHcwd2ajkWHwlGo9Fg9erVeO+997Bw4UKEhIRw+yCCRqPBjBkzkJCQABsbG6wPCRY6EukZFh8J4vLly5gyZQqKi4vx888/8wZjAtBYerNmzcLatWsBAIWFhQInIn3ExS3U7uLi4jBw4EC4u7vjyJEjLD1qsmTJEoSHh0OpVAIAzp07J3Ai0kcc8VG7qa6uxttvv43k5GRs374djz32mNCRSMt4eXnBx8cHBw4cgFwuR0lJCVQqFaTSlt3fR3Q3LD5qF0eOHEFgYCC8vb2RmZkJMzMzoSORFvLx8YGtrS1GjhyJr7/+GocOHQIXnlNr4+0M1Kbq6+vx4YcfYs2aNVi5ciVefPFFoSORllu0aBGuXLmCZcuWCR2F9BRHfNRmzp49i4CAANjZ2SEzMxP29vZCRyIdEBMTg6VLlwodg/QYF7dQq9NoNIiIiMDw4cMxZcoU/Pjjjyw9eiD5+fkoLi7G448/LnQU0mMc8dE9Xa2pw/bjhThbWoUqZQPM5YZwszfH+CH3vnm4uLgYQUFBqKiowOHDh9GrV692Tk26LDY2Fi+88AIXs1Cb4md8dIesgkpEpOTi4LkyAEDdXR4X5dPbBtO9e8Dd2bLpWExMDKZPn46pU6fivffeg5GREYia45FHHsEHH3yAUaNGCR2F9BiLj27T+HT8s1A2qO67L5pE0rgVzHxfNzzftzPefPNNHD58GFFRUfDy8mq/wKQ3ioqK0L9/f5SWlsLY2FjoOKTH+BkfNflzS5h7l57yYjYKIyZBowEU9Sosjj8DjwlvQyaTISMjg6VHLbZjxw4899xzLD1qcyw+EXF1dUVSUtJdj2UVVGJx/Nlm7YMGAIp6NQwG+yPk/SUwNTVt+vqHH34IiURyz+9H9HcxMTF46aWXhI5BIsDiIwBAREoulA2qFr22TqVGZEpu0//n5eVh27ZtcHBwaK14pOfKyspw4sQJPPPMM0JHIRFg8YlEYGAgLl26BD8/P5iamuKzzz7D+PHjYW9vD3MLC2yc/xrqrlxsOl+Rl47iNdNw6avxKFz+Kq7/GnvX9606tgtFq6chMf0MymvqAAAhISFYsmQJp6zogcXFxWHUqFEwMTEROgqJAItPJKKiotC1a1fs3r0bNTU1mDNnDsaMGYPz589j8fYjkDn0wNXdXzSdXx6/DJ1Hh6DrrG1wmBIJucuAO96z8tBm1J7cD7uJn8LY3BrbTxRi27ZtkMlk8PX1bc/LIx3HaU5qT7yPT8SCgoIAAHkVdTB7dAIqj8ZBrayFgbwjIDVE/dUCGNs+BKncFFL7Hn++UKNBxf41uFlyHnYTPoaBvCOUDWpk55cicfG72Ldvn0BXRLqosrIShw8fxtatW4WOQiLB4hMplUqF+fPnY9u2bSgovoyGW6s4VYoqGMg7wmZsGK4f3oLKlO9hZNsNnXwmQebYuH2Quq4WNZl7Yf3C3MaSvOXgD5EIDAyEq6urAFdEuurHH3+Ej48PH1xO7YZTnSLy193No6OjERcXh6SkJExb9zOcpn1360hjA8ocesHW/304vbkJHXp6oWznkqbXGshNYeu/AOXxS6EsPN309ctnj2HZsmWwt7eHvb09CgoK8PLLL2PJkj9fS/R3nOak9sbiExE7Ozvk5+cDaNwbTyaTwcrKCg9ZGqEqNarpPI2qHjWnkqFW1kIiNYRE1qHxjvW/kLsMgLXfbJTFfoy64hzIDQ0wL3wTfvvtN2RmZiIzMxNdunTBqlWrEBIS0q7XSbqjtrYW+/fvh5+fn9BRSERYfCISFhaGRYsWwdLSEhUVFXBxcYGjoyO+CH4WJo5ut51b+1syilYE4dJX41GTkQBrv9l3vJ9Jt0Gw8p2JK9s/gqIkF6+N6N802rO3t4dUKkWnTp1uu7+P6K8SEhLg5eWFzp07Cx2FRISPLCMAQHDUMew7c/m+jym7F4kEGNXXDisDPFo/GOm1CRMmwMfHB2+88YbQUUhEWHwiVlZWhvT0dCQnJ2Nr0q+QPzsPdarm/3EwMZJiS7AXBjhZtn5I0ltKpRL29vbIycmBnZ2d0HFIRLiqU4Sqq6vRr1+/pocB19TUwNjYGCu+6YHPk/Ka9dgyEyMDzPd1Y+lRsyUlJWHAgAEsPWp3/IxPhExNTTFkyBBoNJqm0lu4cCGCnuiF+b59YGIk/ftaljtIJI0jvfm+fRDg5douuUm/cDUnCYVTnSKkUqkwd+5cfPPNN1CpVDAxMUFxcTEsLCwAANmFlYhMyUVyThkkAJR32Y9vRG8bTPfpwZEetUh9fT0cHByQkZEBZ2dnoeOQyHCqU2QqKiowYcIENDQ0IC0tDd7e3ggODm4qPQAY4GSJlQEeKK+pw/YThThbUo0qZT3M5UZwczCD/+B778BO9CAOHjyIhx56iKVHgmDxiUhWVhbGjRuHsWPH4tNPP4WhoSGys7Nhb29/1/OtTGV444nu7ZySxCA2NpbTnCQYTnWKxObNm/Hmm28iPDwc//nPf4SOQyKmVqvh6OiIn3/+GT179hQ6DokQR3x6rqGhAfPmzcOOHTuQlJQEd3d3oSORyP3yyy+wsbFh6ZFgWHx67OrVq3jllVdgaGiI9PR0Ph2DtAKnOUlovJ1BT504cQIeHh4YOnQo4uPjWXqkFTQaDYuPBMcRnx6KiorCrFmzsGLFCvj7+wsdh6jJ8ePHYWxsjIcffljoKCRiLD49Ul9fj9mzZyM+Ph7Jycno16+f0JGIbvPHaE/yT09IIGpDLD49cfnyZbz88sswNTVFeno6LC0thY5EdBuNRoOYmBhs2rRJ6CgkcvyMTw+kp6fD09MT3t7e2L17N0uPtNKpU6egVCoxZMgQoaOQyHHEp+PWrl2LefPmYfXq1XjxxReFjkN0T7GxsRg3bhynOUlwLD4ddfPmTbz11ls4cOAADh48iD59+ggdiei+YmJiEBERIXQMIhafLiopKYG/vz+sra1x9OhRmJubCx2J6L5yc3Nx+fJlPPLII0JHIeJnfLrmyJEj8PT0xOjRo7Fjxw6WHumE2NhYjB07FlKpVOgoRCw+XbJq1Sq88MILWLlyJd5//30YGPC3j3QD994jbcKpTh1QV1eHGTNm4JdffsGhQ4fQq1cvoSMRPbCCggLk5eXB29tb6ChEADji03pFRUXw9vbGtWvXkJaWxtIjnbNjxw74+fnByMhI6ChEAFh8Wi01NRWenp544YUXsG3bNpiZmQkdiajZOM1J2ob78WkhjUaDyMhIfPjhh1i/fj1Gjx4tdCSiFrl8+TJ69+6N0tJSyOVyoeMQAeBnfFpHoVBg2rRpOHHiBH755Rd0784d0El3xcXFYcyYMSw90iqc6tQily5dwvDhw1FXV4cjR46w9EjncZqTtBGLT0skJydj2LBhmDBhAqKjo9GxY0ehIxH9K38syOJUPWkbTnUKTKPRYOnSpViyZAk2btyIp59+WuhIRK1i9+7dePLJJ2Fqaip0FKLbsPgEdOPGDfzvf//D6dOnkZaWBldXV6EjEbWamJgYboRMWolTnQL5/fff8dhjj8HAwACHDx9m6ZFeqampQXJyMvz8/ISOQnQHFp8A9u3bh0ceeQSTJ0/Ghg0b0KFDB6EjEbWq+Ph4PPbYY9wbkrQSpzrbkUajweeff46vv/4aP/zwA3x8fISORNQmuJqTtBlvYG8ntbW1CAoKQn5+PmJjY+Hs7Cx0JKI2oVQqYW9vj/Pnz8PGxkboOER34FRnO8jNzYWXlxc6dOiA1NRUlh7ptcTERAwaNIilR1qLxdfGEhIS8Nhjj2HatGlYu3Ytn2BBei8mJgbjxo0TOgbRPXGqs41oNBp88skniIiIwJYtW/D4448LHYmozdXX18Pe3h7Z2dlwdHQUOg7RXXFxSxuorq7GpEmTUFJSgqNHj/IHAIlGcnIyevXqxT/zpNU41dnKcnJyMGzYMNjY2CAlJYU/AEhUOM1JuoBTna1o9+7deP3117Fo0SIEBwcLHYeoXalUKnTp0gVHjhzBQw89JHQconviVGcrUKvV+Oijj7BmzRrExcXhkUceEToSUbs7fPgwunTpwtIjrcfi+5euX7+OwMBAVFRU4NixY7C3txc6EpEgYmNjOc1JOoGf8f0Lp0+fxtChQ9G1a1ccOHCApUeipdFoEBsby6e1kE5g8bVQbGwsvL29MW/ePCxfvhzGxsZCRyISTHp6Ojp27Ii+ffsKHYXoH3Gqs5lUKhUWLlyIDRs2ID4+Hp6enkJHIhIcpzlJl7D4muHatWuYOHEibty4gWPHjsHW1lboSESC02g0iImJwZYtW4SOQvRAONX5gH777Td4enqid+/e2LdvH0uP6JaTJ0+ioaEBgwYNEjoK0QNh8T2ArVu3YsSIEfjggw/w9ddfw8jISOhIRFrjj2lOiUQidBSiB8KpzvtQqVR49913sXXr1qYnzhPR7WJiYrBq1SqhYxA9MBbfPZSXl2PChAlQq9VIT0+HtbW10JGItM65c+dQXl4OLy8voaMQPTBOdd5FZmYmPD09MXDgQPz0008sPaJ7iI2NxdixY2FgwB8lpDv4p/VvoqOjMXLkSHz88cf47LPPYGjIQTHRvcTExPCmddI5/Kl+S0NDA+bMmYO4uDjs378fAwYMEDoSkVa7ePEiLly4gCeeeELoKETNwuIDUFZWhldeeQXGxsZIT09H586dhY5EpPV27NiB559/nrMipHNEP9V5/PhxeHh4wMvLC3v27GHpET0gTnOSrhL1fnzr16/H7NmzsXLlSv4FJmqG0tJS9OnTB6WlpZDJZELHIWoWUc5R1NfXY9asWdi7dy9SUlLw8MMPCx2JSKfs3LkTvr6+LD3SSaIrvsuXL2P8+PEwNzfH0aNHYWlpKXQkIp0TExODadOmCR2DqEVE9Rnfr7/+Cg8PD4wYMQK7du1i6RG1QEVFBY4ePYpRo0YJHYWoRUQz4vvuu+8QFhaGNWvW4IUXXhA6DpHO2rVrF55++ml07NhR6ChELaL3xVdXV4eZM2fi4MGD+Pnnn+Hm5iZ0JCKdFhMTgwkTJggdg6jF9HpVZ3FxMfz9/WFnZ4f169fD3Nxc6EhEOq26uhqOjo4oKCiAhYWF0HGIWkRnRnxXa+qw/XghzpZWoUrZAHO5IdzszTF+iBOsTO9cWXb48GG88sormDp1Kt59910+S5CoFezZswfDhw9n6ZFO0/riyyqoRERKLg6eKwMA1DWom47JDUvxddI5+PS2wXTvHnB3toRGo8GqVauwYMECfP/99/D19RUqOpHeiYmJwbhx44SOQfSvaPVU58a0C1gcfxbKBhXul1IiAeSGUsx5pgcOrfsEv/76K3bs2IGePXu2X1giPadQKGBvb4+8vDzuWEI6TWvn/xpL7wwU9XcvPeXFbBRGTAIAaDSAol6FD3edRC7skZaWxtIjamV79+6Fh4cHS490niDF5+rqiqSkpHsezyqoxOL4s1DUq+95zt1opMa44jgcOw8cwciRI9G5c2fY2Nhg/PjxKCkp+bexiUSN05ykL7RyxBeRkgtlg6pFr1U2qBCdehrBwcG4cOECLl68CDMzM0yePLmVUxKJx82bN7Fnzx6MHTtW6ChE/1q7L24JDAzEpUuX4OfnB6lUigULFiA9PR2pqalQKBTo268/SvoHAJ2cAQCKvHRcO7AWDdVXYWBsAjPPF2Ex7M5/dVYd24WajATYvvIR8jr3wpNjnoT5rdWeM2bMgLe3d7teJ5E+OXDgAPr06YMuXboIHYXoX2v3EV9UVBS6du2K3bt3o6amBnPmzMGYMWNw/vx5XLlyBSYOPVG68/Om88vjl6Hz6BB0nbUNDlMiIXe5c4PYykObUXtyP+wmfgpDc2tIAGw/Udh0/Oeff+aDqIn+hdjYWE5zkt7QitsZgoKCmn7d23cykmO+h1pZCwN5R0BqiPqrBTC2fQhSuSmk9j3+fKFGg4r9a3Cz5DzsJnzceD4AZYMaZ0uqAQDZ2dn48MMPERcX167XRKQvVCoV4uLikJaWJnQUolYh+Gd8KpUK8+bNQ/fu3WFubo61M55t/LqiCgBgMzYMirxjKIqcjNJN81BXdKbpteq6WtRk7oW51/im0vtDlbIeubm5GDNmDL755hsMHz68/S6KSI+kpqbCyckJ3bp1EzoKUasQpPgkEknTr6OjoxEXF4ekpCRcv34dQcv33DrSeA+DzKEXbP3fh9Obm9ChpxfKdi5peq2B3BS2/gtQHr8UysLTt3+T6jI8/fTTeP/99xEYGNjWl0SktzjNSfpGkOKzs7NDfn4+gMZn/8lkMlhZWeHGjRs4vWtV03kaVT1qTiVDrayFRGoIiaxD493qfyF3GQBrv9koi/0YdcU5AADpjQrs+mQqZsyYgalTp7bfhRHpGbVajdjYWLz00ktCRyFqNYIUX1hYGBYtWgRLS0tUVFTAxcUFjo6O6Nu3L172ffK2c2t/S0bRiiBc+mo8ajISYO03+473M+k2CFa+M3Fl+0eoK83F9cy9uFpcgA8++ACmpqZN/xFR8xw9ehQWFhbc1YT0ilY+siw46hj2nbl838eU3YtEAozqa4eVAR6tH4xIZObMmQOZTIaPPvpI6ChErUbwxS13E+LTA3JDaYteKzeUYrpPj38+kYjuS6PRICYmhtOcpHe0svjcnS0x39cNJkbNi2diZID5vm4Y4GTZNsGIRCQrKwsajQbu7u5CRyFqVVpxH9/dBHi5AkCzdmeY7+vW9DoienB32++y8sJpvPTfSbetwibSB1r5Gd9fZRdWIjIlF8k5ZZCg8eb0P8gNDaABMKK3Dab79OBIj6iZ7r/fZePfr7/ud0mkD7S++P5QXlOH7ScKcbakGlXKepjLjeDmYAb/wXffgZ2I7q+5+11yRoX0hc4UHxG1nj/3u7z31l/Ki9m4+uOXcApZD+CPz9D7sPxI52nl4hYi+nfut+dlS/e7VNSrsTj+LLILK3Hz5k34+/vD1dUVEokEKSkprZCaqH2w+IhE5t/udxmZkgsAePzxx7Fx40bY29u3ZjyiNqe1qzqJqGXut+flDYUCDRbOsHxmOoxtXAA0f8/LxImLUf1if7z11lsAAKm0ZffcEgmFIz4iPXO/PS8Xbz8CmUMPXN39RdP5zd3z0tjc+rb9Lol0DYuPSASCgoJgZmaGvIo6mD06AfVXfodaWdt48Nael+q6G5DKTSG7y56XygsZsJvwMaQdLG7b75JIF3Gqk0jPqVQqzJ8/H9u2bUNB8WU03FrHrVJUwUDeETZjw3D98BZUpnwPI9tu6OQzCTLHPgD+3PPS+oW5t+15WaWsF+JSiFoFR3xEeuhee15OW/cznKZ9d+tIy/e8NJcbtct1ELUFFh+RHrrXnpcPWRqhKjWq6byW7HkpNzSAm4MZ6urqoFQqAQA3b96EUqkEbwsmXcDiI9JD99rz8ovgZ2HiePvees3d81JRkgv/wU7o3bs3TExMUFRUhFGjRsHExAQXL15sr0skajE+uYVIZLjfJYkdR3xEIsP9LknsWHxEIsP9LknseDsDkQhxv0sSM37GRyRi3O+SxIjFR0Tc75JEhcVHRESiwsUtREQkKiw+IiISFRYfERGJCouPiIhEhcVHRESiwuIjIiJRYfEREZGosPiIiEhUWHxERCQqLD4iIhIVFh8REYkKi4+IiESFxUdERKLC4iMiIlFh8RERkaiw+IiISFRYfEREJCosPiIiEhUWHxERiQqLj4iIRIXFR0REovL/aUMj5pxbDRgAAAAASUVORK5CYII=)
 
 %% Cell type:markdown id:academic-rebound tags:
 
 # Instantiating a task
 
 A task can always be instantiated and executed from the runtime representation of a task graph. No results from upstream tasks need to be provided explicitely. The runtime representation can be instantiated from the persistent representation with `load_graph`.
 
 %% Cell type:code id:liked-belly tags:
 
 ``` python
 import inspect
 
 
 def print_task_sourcecode(task):
     lines, line_nb = inspect.getsourcelines(type(task))
     print(" \nSource code:\n" + " ".join(lines))
 
 
 def print_task_info(name, task):
     print(f"{name}: ")
     print(f" attributes = {runtime_taskgraph.graph.nodes[name]}")
     print(f" uhash = {task.uhash}")
     print(f" done = {task.done}")
     if task.done:
         print(f" result = {task.outputs.result}")
     else:
         print(" result = <not available>")
 
 
 def instantiate_task(name):
     task = runtime_taskgraph.instantiate_task_static(name, varinfo=varinfo)
     print_task_info(name, task)
     return task
 
 
 task = instantiate_task("task6")
 print_task_sourcecode(task)
 ```
 
 %%%% Output: stream
 
     task6:
      attributes = {'inputs': {'b': 6}, 'class': 'tasklib.tasks.SumTask'}
      uhash = 6273c01a95d490123dc64bc2b8acc852c2a64244552d073029b8e0a5597a4395
      done = True
      result = 16
     
     Source code:
     class SumTask(
          Task, input_names=["a"], optional_input_names=["b"], output_names=["result"]
      ):
-         def process(self):
+         def run(self):
              result = self.inputs.a
              if self.inputs.b:
                  result += self.inputs.b
              self.outputs.result = result
     
 
 %% Cell type:markdown id:bronze-wellington tags:
 
 # Modify and rerun task graphs
 
 When modifying an input, re-running the task graph will only execute that tasks that are affected by this modification
 
 %% Cell type:code id:permanent-processing tags:
 
 ``` python
 modify_name = "task1"
 dependent_name = "task6"
 independent_name = "task4"
 
 upstream = runtime_taskgraph.graph.nodes[modify_name]
 upstream["inputs"]["a"] += 1
 
 print("Modify inputs:")
 task = instantiate_task(modify_name)
 
 print("\nIndependent task:")
 task = instantiate_task(independent_name)
 
 print("\nDependent task:")
 task = instantiate_task(dependent_name)
 
 print("\nRun the new graph instance ...")
 runtime_taskgraph.execute(varinfo)
 
 print("\nDependent task is a different instance:")
 task = instantiate_task(dependent_name)
 
 print("\nIndependent task is still the same instance:")
 task = instantiate_task(independent_name)
 ```
 
 %%%% Output: stream
 
     Modify inputs:
     task1:
      attributes = {'inputs': {'a': 2}, 'class': 'tasklib.tasks.SumTask'}
      uhash = 3da320c1b5d863b447d1c3388d113cd1adbeeffc3e5f8125d225b95ac9ec852f
      done = True
      result = 2
     
     Independent task:
     task4:
      attributes = {'inputs': {'b': 4}, 'class': 'tasklib.tasks.SumTask'}
      uhash = f3d6c17410499f2bfca9e056a5c50a72d5682614fe905ba3afd0136ac5bc35cf
      done = True
      result = 6
     
     Dependent task:
     task6:
      attributes = {'inputs': {'b': 6}, 'class': 'tasklib.tasks.SumTask'}
      uhash = ab34985766dd54a4cb45c24865e926d06793b09c4afc0684cc7ae792f303b436
      done = True
      result = 17
     
     Run the new graph instance ...
     
     Dependent task is a different instance:
     task6:
      attributes = {'inputs': {'b': 6}, 'class': 'tasklib.tasks.SumTask'}
      uhash = ab34985766dd54a4cb45c24865e926d06793b09c4afc0684cc7ae792f303b436
      done = True
      result = 17
     
     Independent task is still the same instance:
     task4:
      attributes = {'inputs': {'b': 4}, 'class': 'tasklib.tasks.SumTask'}
      uhash = f3d6c17410499f2bfca9e056a5c50a72d5682614fe905ba3afd0136ac5bc35cf
      done = True
      result = 6
 
 %% Cell type:markdown id:armed-virgin tags:
 
 # Task graph as a hash tree
 
 Create a dictionary of all runtime representations of tasks
 
 %% Cell type:code id:technical-agreement tags:
 
 ``` python
 tasks = dict()
 for name in runtime_taskgraph.graph.nodes:
     runtime_taskgraph.instantiate_task_static(name, tasks=tasks, varinfo=varinfo)
 ```
 
 %% Cell type:markdown id:chinese-correlation tags:
 
 The same python object of a task represents a different task instance when modifying upstream input as a result of hash linking
 
 %% Cell type:code id:undefined-rebound tags:
 
 ``` python
 modify_name = "task1"
 dependent_name = "task6"
 
 task = tasks[dependent_name]
 
 print("Task represented by the python object:")
 print_task_info(dependent_name, task)
 
 print("\nModify upstream input:")
 tasks[modify_name].input_variables["a"].value += 1
 print_task_info(dependent_name, task)
 
 print("\nReset upstream input:")
 tasks[modify_name].input_variables["a"].value -= 1
 print_task_info(dependent_name, task)
 ```
 
 %%%% Output: stream
 
     Task represented by the python object:
     task6:
      attributes = {'inputs': {'b': 6}, 'class': 'tasklib.tasks.SumTask'}
      uhash = ab34985766dd54a4cb45c24865e926d06793b09c4afc0684cc7ae792f303b436
      done = True
      result = 17
     
     Modify upstream input:
     task6:
      attributes = {'inputs': {'b': 6}, 'class': 'tasklib.tasks.SumTask'}
      uhash = 67ba60d3a7f4a986bb55b937bdde080c464aba2bf506f381b0150b8a49e95b74
      done = False
      result = <not available>
     
     Reset upstream input:
     task6:
      attributes = {'inputs': {'b': 6}, 'class': 'tasklib.tasks.SumTask'}
      uhash = ab34985766dd54a4cb45c24865e926d06793b09c4afc0684cc7ae792f303b436
      done = True
      result = 17

tasklib/tasklib/tasks.py

@@ -7,7 +7,7 @@ __all__ = ["SumTask", "CondSumTask"]
 class SumTask(
     Task, input_names=["a"], optional_input_names=["b"], output_names=["result"]
 ):
-    def process(self):
+    def run(self):
         result = self.inputs.a
         if self.inputs.b:
             result += self.inputs.b
@@ -15,15 +15,15 @@ class SumTask(
 
 
 class CondSumTask(SumTask, output_names=["too_small"]):
-    def process(self):
-        super().process()
+    def run(self):
+        super().run()
         self.outputs.too_small = self.outputs.result < 10
 
 
 class ErrorSumTask(
     Task, optional_input_names=["a", "b", "raise_error"], output_names=["result"]
 ):
-    def process(self):
+    def run(self):
         result = self.inputs.a
         if result is self.MISSING_DATA:
             result = 0