runnable 0.12.2__py3-none-any.whl → 0.12.3__py3-none-any.whl

runnable/sdk.py

@@ -61,11 +61,9 @@ class Catalog(BaseModel):
         put (List[str]): List of glob patterns to put into central catalog from the compute data folder.
 
     Examples:
-        >>> from runnable import Catalog, Task
+        >>> from runnable import Catalog
         >>> catalog = Catalog(compute_data_folder="/path/to/data", get=["*.csv"], put=["*.csv"])
 
-        >>> task = Task(name="task", catalog=catalog, command="echo 'hello'")
-
     """
 
     model_config = ConfigDict(extra="forbid")  # Need to be for command, would be validated later
@@ -143,50 +141,7 @@ class BaseTraversal(ABC, BaseModel):
 
 class BaseTask(BaseTraversal):
     """
-    An execution node of the pipeline.
-    Please refer to [concepts](concepts/task.md) for more information.
-
-    Attributes:
-        name (str): The name of the node.
-        command (str): The command to execute.
-
-            - For python functions, [dotted path](concepts/task.md/#python_functions) to the function.
-            - For shell commands: command to execute in the shell.
-            - For notebooks: path to the notebook.
-        command_type (str): The type of command to execute.
-            Can be one of "shell", "python", or "notebook".
-        catalog (Optional[Catalog]): The catalog to sync data from/to.
-            Please see Catalog about the structure of the catalog.
-        overrides (Dict[str, Any]): Any overrides to the command.
-            Individual tasks can override the global configuration config by referring to the
-            specific override.
-
-            For example,
-            ### Global configuration
-            ```yaml
-            executor:
-              type: local-container
-              config:
-                docker_image: "runnable/runnable:latest"
-                overrides:
-                  custom_docker_image:
-                    docker_image: "runnable/runnable:custom"
-            ```
-            ### Task specific configuration
-            ```python
-            task = Task(name="task", command="echo 'hello'", command_type="shell",
-                    overrides={'local-container': custom_docker_image})
-            ```
-        notebook_output_path (Optional[str]): The path to save the notebook output.
-            Only used when command_type is 'notebook', defaults to command+_out.ipynb
-        optional_ploomber_args (Optional[Dict[str, Any]]): Any optional ploomber args.
-            Only used when command_type is 'notebook', defaults to {}
-        output_cell_tag (Optional[str]): The tag of the output cell.
-            Only used when command_type is 'notebook', defaults to "runnable_output"
-        terminate_with_failure (bool): Whether to terminate the pipeline with a failure after this node.
-        terminate_with_success (bool): Whether to terminate the pipeline with a success after this node.
-        on_failure (str): The name of the node to execute if the step fails.
-
+    Base task type which has catalog, overrides, returns and secrets.
     """
 
     catalog: Optional[Catalog] = Field(default=None, alias="catalog")
@@ -220,12 +175,50 @@ class BaseTask(BaseTraversal):
 class PythonTask(BaseTask):
     """
     An execution node of the pipeline of python functions.
+    Please refer to [concepts](concepts/task.md/#python_functions) for more information.
 
     Attributes:
         name (str): The name of the node.
         function (callable): The function to execute.
-        catalog (Optional[Catalog]): The catalog to sync data from/to.
-            Please see Catalog about the structure of the catalog.
+
+        terminate_with_success (bool): Whether to terminate the pipeline with a success after this node.
+                Defaults to False.
+        terminate_with_failure (bool): Whether to terminate the pipeline with a failure after this node.
+                Defaults to False.
+
+        on_failure (str): The name of the node to execute if the step fails.
+
+        returns List[Union[str, TaskReturns]] : A list of the names of variables to return from the task.
+            The names should match the order of the variables returned by the function.
+
+            ```TaskReturns```: can be JSON friendly variables, objects or metrics.
+
+            By default, all variables are assumed to be JSON friendly and will be serialized to JSON.
+            Pydantic models are readily supported and will be serialized to JSON.
+
+            To return a python object, please use ```pickled(<name>)```.
+            It is advised to use ```pickled(<name>)``` for big JSON friendly variables.
+
+            For example,
+            ```python
+            from runnable import pickled
+
+            def f():
+                ...
+                x = 1
+                return x, df # A simple JSON friendly variable and a python object.
+
+            task = PythonTask(name="task", function=f, returns=["x", pickled(df)]))
+            ```
+
+            To mark any JSON friendly variable as a ```metric```, please use ```metric(x)```.
+            Metric variables should be JSON friendly and can be treated just like any other parameter.
+
+        catalog Optional[Catalog]: The files sync data from/to, refer to Catalog.
+
+        secrets List[str]: List of secrets to pass to the task. They are exposed as environment variables
+            and removed after execution.
+
         overrides (Dict[str, Any]): Any overrides to the command.
             Individual tasks can override the global configuration config by referring to the
             specific override.
@@ -246,11 +239,6 @@ class PythonTask(BaseTask):
             task = PythonTask(name="task", function="function'",
                     overrides={'local-container': custom_docker_image})
             ```
-
-        terminate_with_failure (bool): Whether to terminate the pipeline with a failure after this node.
-        terminate_with_success (bool): Whether to terminate the pipeline with a success after this node.
-        on_failure (str): The name of the node to execute if the step fails.
-
     """
 
     function: Callable = Field(exclude=True)
@@ -269,15 +257,52 @@ class PythonTask(BaseTask):
 
 class NotebookTask(BaseTask):
     """
-    An execution node of the pipeline of type notebook.
-    Please refer to [concepts](concepts/task.md) for more information.
+    An execution node of the pipeline of notebook.
+    Please refer to [concepts](concepts/task.md/#notebooks) for more information.
+
+    We internally use [Ploomber engine](https://github.com/ploomber/ploomber-engine) to execute the notebook.
 
     Attributes:
         name (str): The name of the node.
-        notebook: The path to the notebook
-        catalog (Optional[Catalog]): The catalog to sync data from/to.
-            Please see Catalog about the structure of the catalog.
-        returns: A list of the names of variables to return from the notebook.
+        notebook (str): The path to the notebook relative the project root.
+        optional_ploomber_args (Dict[str, Any]): Any optional ploomber args, please refer to
+            [Ploomber engine](https://github.com/ploomber/ploomber-engine) for more information.
+
+        terminate_with_success (bool): Whether to terminate the pipeline with a success after this node.
+                Defaults to False.
+        terminate_with_failure (bool): Whether to terminate the pipeline with a failure after this node.
+                Defaults to False.
+
+        on_failure (str): The name of the node to execute if the step fails.
+
+        returns List[Union[str, TaskReturns]] : A list of the names of variables to return from the task.
+            The names should match the order of the variables returned by the function.
+
+            ```TaskReturns```: can be JSON friendly variables, objects or metrics.
+
+            By default, all variables are assumed to be JSON friendly and will be serialized to JSON.
+            Pydantic models are readily supported and will be serialized to JSON.
+
+            To return a python object, please use ```pickled(<name>)```.
+            It is advised to use ```pickled(<name>)``` for big JSON friendly variables.
+
+            For example,
+            ```python
+            from runnable import pickled
+
+            # assume, example.ipynb is the notebook with df and x as variables in some cells.
+
+            task = Notebook(name="task", notebook="example.ipynb", returns=["x", pickled(df)]))
+            ```
+
+            To mark any JSON friendly variable as a ```metric```, please use ```metric(x)```.
+            Metric variables should be JSON friendly and can be treated just like any other parameter.
+
+        catalog Optional[Catalog]: The files sync data from/to, refer to Catalog.
+
+        secrets List[str]: List of secrets to pass to the task. They are exposed as environment variables
+        and removed after execution.
+
         overrides (Dict[str, Any]): Any overrides to the command.
             Individual tasks can override the global configuration config by referring to the
             specific override.
@@ -295,18 +320,9 @@ class NotebookTask(BaseTask):
             ```
             ### Task specific configuration
             ```python
-            task = NotebookTask(name="task", notebook="evaluation.ipynb",
+            task = NotebookTask(name="task", notebook="example.ipynb",
                     overrides={'local-container': custom_docker_image})
             ```
-        notebook_output_path (Optional[str]): The path to save the notebook output.
-            Only used when command_type is 'notebook', defaults to command+_out.ipynb
-        optional_ploomber_args (Optional[Dict[str, Any]]): Any optional ploomber args.
-            Only used when command_type is 'notebook', defaults to {}
-
-        terminate_with_failure (bool): Whether to terminate the pipeline with a failure after this node.
-        terminate_with_success (bool): Whether to terminate the pipeline with a success after this node.
-        on_failure (str): The name of the node to execute if the step fails.
-
     """
 
     notebook: str = Field(serialization_alias="command")
@@ -319,15 +335,33 @@ class NotebookTask(BaseTask):
 
 class ShellTask(BaseTask):
     """
-    An execution node of the pipeline of type shell.
-    Please refer to [concepts](concepts/task.md) for more information.
+    An execution node of the pipeline of shell script.
+    Please refer to [concepts](concepts/task.md/#shell) for more information.
+
 
     Attributes:
         name (str): The name of the node.
-        command: The shell command to execute.
-        catalog (Optional[Catalog]): The catalog to sync data from/to.
-            Please see Catalog about the structure of the catalog.
-        returns: A list of the names of variables to capture from environment variables of shell.
+        command (str): The path to the notebook relative the project root.
+        terminate_with_success (bool): Whether to terminate the pipeline with a success after this node.
+                Defaults to False.
+        terminate_with_failure (bool): Whether to terminate the pipeline with a failure after this node.
+                Defaults to False.
+
+        on_failure (str): The name of the node to execute if the step fails.
+
+        returns List[str] : A list of the names of environment variables to collect from the task.
+
+            The names should match the order of the variables returned by the function.
+            Shell based tasks can only return JSON friendly variables.
+
+            To mark any JSON friendly variable as a ```metric```, please use ```metric(x)```.
+            Metric variables should be JSON friendly and can be treated just like any other parameter.
+
+        catalog Optional[Catalog]: The files sync data from/to, refer to Catalog.
+
+        secrets List[str]: List of secrets to pass to the task. They are exposed as environment variables
+        and removed after execution.
+
         overrides (Dict[str, Any]): Any overrides to the command.
             Individual tasks can override the global configuration config by referring to the
             specific override.
@@ -345,14 +379,10 @@ class ShellTask(BaseTask):
             ```
             ### Task specific configuration
             ```python
-            task = ShellTask(name="task", command="exit 0",
+            task = ShellTask(name="task", command="export x=1",
                     overrides={'local-container': custom_docker_image})
             ```
 
-        terminate_with_failure (bool): Whether to terminate the pipeline with a failure after this node.
-        terminate_with_success (bool): Whether to terminate the pipeline with a success after this node.
-        on_failure (str): The name of the node to execute if the step fails.
-
     """
 
     command: str = Field(alias="command")
@@ -364,16 +394,20 @@ class ShellTask(BaseTask):
 
 class Stub(BaseTraversal):
     """
-    A node that does nothing.
+    A node that passes through the pipeline with no action. Just like ```pass``` in Python.
+    Please refer to [concepts](concepts/task.md/#stub) for more information.
 
     A stub node can tak arbitrary number of arguments.
-    Please refer to [concepts](concepts/stub.md) for more information.
 
     Attributes:
         name (str): The name of the node.
-        terminate_with_failure (bool): Whether to terminate the pipeline with a failure after this node.
+        command (str): The path to the notebook relative the project root.
         terminate_with_success (bool): Whether to terminate the pipeline with a success after this node.
+                Defaults to False.
+        terminate_with_failure (bool): Whether to terminate the pipeline with a failure after this node.
+                Defaults to False.
 
+        on_failure (str): The name of the node to execute if the step fails.
     """
 
     model_config = ConfigDict(extra="ignore")
@@ -422,12 +456,13 @@ class Map(BaseTraversal):
     Please refer to [concepts](concepts/map.md) for more information.
 
     Attributes:
-        branch: The pipeline to execute for each item.
+        branch (Pipeline): The pipeline to execute for each item.
 
-        iterate_on: The name of the parameter to iterate over.
+        iterate_on (str): The name of the parameter to iterate over.
             The parameter should be defined either by previous steps or statically at the start of execution.
 
-        iterate_as: The name of the iterable to be passed to functions.
+        iterate_as (str): The name of the iterable to be passed to functions.
+        reducer (Callable): The function to reduce the results of the branches.
 
 
         overrides (Dict[str, Any]): Any overrides to the command.
@@ -510,29 +545,44 @@ class Fail(BaseModel):
 
 class Pipeline(BaseModel):
     """
-    A Pipeline is a directed acyclic graph of Steps that define a workflow.
+    A Pipeline is a sequence of Steps.
 
     Attributes:
-        steps (List[Stub | PythonTask | NotebookTask | ShellTask | Parallel | Map | Success | Fail]):
+        steps (List[Stub | PythonTask | NotebookTask | ShellTask | Parallel | Map]]):
             A list of Steps that make up the Pipeline.
-        start_at (Stub | Task | Parallel | Map): The name of the first Step in the Pipeline.
+
+            The order of steps is important as it determines the order of execution.
+            Any on failure behavior should the first step in ```on_failure``` pipelines.
+
+
+
+        on_failure (List[List[Pipeline], optional): A list of Pipelines to execute in case of failure.
+
+            For example, for the below pipeline:
+                step1 >> step2
+                and step1 to reach step3 in case of failure.
+
+                failure_pipeline = Pipeline(steps=[step1, step3])
+
+                pipeline = Pipeline(steps=[step1, step2, on_failure=[failure_pipeline])
+
         name (str, optional): The name of the Pipeline. Defaults to "".
         description (str, optional): A description of the Pipeline. Defaults to "".
-        add_terminal_nodes (bool, optional): Whether to add terminal nodes to the Pipeline. Defaults to True.
 
-    The default behavior is to add "success" and "fail" nodes to the Pipeline.
-    To add custom success and fail nodes, set add_terminal_nodes=False and create success
-    and fail nodes manually.
+    The pipeline implicitly add success and fail nodes.
 
     """
 
-    steps: List[Union[StepType, List[StepType]]]
+    steps: List[Union[StepType, List["Pipeline"]]]
     name: str = ""
     description: str = ""
-    add_terminal_nodes: bool = True  # Adds "success" and "fail" nodes
 
     internal_branch_name: str = ""
 
+    @property
+    def add_terminal_nodes(self) -> bool:
+        return True
+
     _dag: graph.Graph = PrivateAttr()
     model_config = ConfigDict(extra="forbid")
 
@@ -590,6 +640,7 @@ class Pipeline(BaseModel):
                 Any definition of pipeline should have one node that terminates with success.
         """
         # TODO: Bug with repeat names
+        # TODO: https://github.com/AstraZeneca/runnable/issues/156
 
         success_path: List[StepType] = []
         on_failure_paths: List[List[StepType]] = []
@@ -598,7 +649,7 @@ class Pipeline(BaseModel):
             if isinstance(step, (Stub, PythonTask, NotebookTask, ShellTask, Parallel, Map)):
                 success_path.append(step)
                 continue
-            on_failure_paths.append(step)
+            # on_failure_paths.append(step)
 
         if not success_path:
             raise Exception("There should be some success path")
@@ -654,21 +705,19 @@ class Pipeline(BaseModel):
 
         Traverse and execute all the steps of the pipeline, eg. [local execution](configurations/executors/local.md).
 
-        Or create the ```yaml``` representation of the pipeline for other executors.
+        Or create the representation of the pipeline for other executors.
 
         Please refer to [concepts](concepts/executor.md) for more information.
 
         Args:
             configuration_file (str, optional): The path to the configuration file. Defaults to "".
-                The configuration file can be overridden by the environment variable runnable_CONFIGURATION_FILE.
+                The configuration file can be overridden by the environment variable RUNNABLE_CONFIGURATION_FILE.
 
             run_id (str, optional): The ID of the run. Defaults to "".
             tag (str, optional): The tag of the run. Defaults to "".
                 Use to group multiple runs.
 
             parameters_file (str, optional): The path to the parameters file. Defaults to "".
-            use_cached (str, optional): Whether to use cached results. Defaults to "".
-                Provide the run_id of the older execution to recover.
 
             log_level (str, optional): The log level. Defaults to defaults.LOG_LEVEL.
         """

runnable-0.12.3.dist-info/METADATA

@@ -0,0 +1,270 @@
+Metadata-Version: 2.1
+Name: runnable
+Version: 0.12.3
+Summary: A Compute agnostic pipelining software
+Home-page: https://github.com/vijayvammi/runnable
+License: Apache-2.0
+Author: Vijay Vammi
+Author-email: mesanthu@gmail.com
+Requires-Python: >=3.9,<3.13
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: database
+Provides-Extra: docker
+Provides-Extra: notebook
+Requires-Dist: click
+Requires-Dist: click-plugins (>=1.1.1,<2.0.0)
+Requires-Dist: dill (>=0.3.8,<0.4.0)
+Requires-Dist: docker ; extra == "docker"
+Requires-Dist: mlflow-skinny
+Requires-Dist: ploomber-engine (>=0.0.31,<0.0.32) ; extra == "notebook"
+Requires-Dist: pydantic (>=2.5,<3.0)
+Requires-Dist: rich (>=13.5.2,<14.0.0)
+Requires-Dist: ruamel.yaml
+Requires-Dist: ruamel.yaml.clib
+Requires-Dist: sqlalchemy ; extra == "database"
+Requires-Dist: stevedore (>=3.5.0,<4.0.0)
+Requires-Dist: typing-extensions ; python_version < "3.8"
+Project-URL: Documentation, https://github.com/vijayvammi/runnable
+Project-URL: Repository, https://github.com/vijayvammi/runnable
+Description-Content-Type: text/markdown
+
+
+
+
+
+
+</p>
+<hr style="border:2px dotted orange">
+
+<p align="center">
+<a href="https://pypi.org/project/runnable/"><img alt="python:" src="https://img.shields.io/badge/python-3.8%20%7C%203.9%20%7C%203.10-blue.svg"></a>
+<a href="https://pypi.org/project/runnable/"><img alt="Pypi" src="https://badge.fury.io/py/runnable.svg"></a>
+<a href="https://github.com/vijayvammi/runnable/blob/main/LICENSE"><img alt"License" src="https://img.shields.io/badge/license-Apache%202.0-blue.svg"></a>
+<a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
+<a href="https://github.com/python/mypy"><img alt="MyPy Checked" src="https://www.mypy-lang.org/static/mypy_badge.svg"></a>
+<a href="https://github.com/vijayvammi/runnable/actions/workflows/release.yaml"><img alt="Tests:" src="https://github.com/vijayvammi/runnable/actions/workflows/release.yaml/badge.svg">
+</p>
+<hr style="border:2px dotted orange">
+
+
+[Please check here for complete documentation](https://astrazeneca.github.io/runnable/)
+
+## Example
+
+The below data science flavored code is a well-known
+[iris example from scikit-learn](https://scikit-learn.org/stable/auto_examples/linear_model/plot_iris_logistic.html).
+
+
+```python
+"""
+Example of Logistic regression using scikit-learn
+https://scikit-learn.org/stable/auto_examples/linear_model/plot_iris_logistic.html
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+from sklearn import datasets
+from sklearn.inspection import DecisionBoundaryDisplay
+from sklearn.linear_model import LogisticRegression
+
+
+def load_data():
+    # import some data to play with
+    iris = datasets.load_iris()
+    X = iris.data[:, :2]  # we only take the first two features.
+    Y = iris.target
+
+    return X, Y
+
+
+def model_fit(X: np.ndarray, Y: np.ndarray, C: float = 1e5):
+    logreg = LogisticRegression(C=C)
+    logreg.fit(X, Y)
+
+    return logreg
+
+
+def generate_plots(X: np.ndarray, Y: np.ndarray, logreg: LogisticRegression):
+    _, ax = plt.subplots(figsize=(4, 3))
+    DecisionBoundaryDisplay.from_estimator(
+        logreg,
+        X,
+        cmap=plt.cm.Paired,
+        ax=ax,
+        response_method="predict",
+        plot_method="pcolormesh",
+        shading="auto",
+        xlabel="Sepal length",
+        ylabel="Sepal width",
+        eps=0.5,
+    )
+
+    # Plot also the training points
+    plt.scatter(X[:, 0], X[:, 1], c=Y, edgecolors="k", cmap=plt.cm.Paired)
+
+    plt.xticks(())
+    plt.yticks(())
+
+    plt.savefig("iris_logistic.png")
+
+    # TODO: What is the right value?
+    return 0.6
+
+
+## Without any orchestration
+def main():
+    X, Y = load_data()
+    logreg = model_fit(X, Y, C=1.0)
+    generate_plots(X, Y, logreg)
+
+
+## With runnable orchestration
+def runnable_pipeline():
+    # The below code can be anywhere
+    from runnable import Catalog, Pipeline, PythonTask, metric, pickled
+
+    # X, Y = load_data()
+    load_data_task = PythonTask(
+        function=load_data,
+        name="load_data",
+        returns=[pickled("X"), pickled("Y")],  # (1)
+    )
+
+    # logreg = model_fit(X, Y, C=1.0)
+    model_fit_task = PythonTask(
+        function=model_fit,
+        name="model_fit",
+        returns=[pickled("logreg")],
+    )
+
+    # generate_plots(X, Y, logreg)
+    generate_plots_task = PythonTask(
+        function=generate_plots,
+        name="generate_plots",
+        terminate_with_success=True,
+        catalog=Catalog(put=["iris_logistic.png"]),  # (2)
+        returns=[metric("score")],
+    )
+
+    pipeline = Pipeline(
+        steps=[load_data_task, model_fit_task, generate_plots_task],
+    )  # (4)
+
+    pipeline.execute()
+
+    return pipeline
+
+
+if __name__ == "__main__":
+    # main()
+    runnable_pipeline()
+
+```
+
+
+1. Return two serialized objects X and Y.
+2. Store the file `iris_logistic.png` for future reference.
+3. Define the sequence of tasks.
+4. Define a pipeline with the tasks
+
+The difference between native driver and runnable orchestration:
+
+!!! tip inline end "Notebooks and Shell scripts"
+
+    You can execute notebooks and shell scripts too!!
+
+    They can be written just as you would want them, *plain old notebooks and scripts*.
+
+
+
+
+<div class="annotate" markdown>
+
+```diff
+
+- X, Y = load_data()
++load_data_task = PythonTask(
++    function=load_data,
++     name="load_data",
++     returns=[pickled("X"), pickled("Y")], (1)
++    )
+
+-logreg = model_fit(X, Y, C=1.0)
++model_fit_task = PythonTask(
++   function=model_fit,
++   name="model_fit",
++   returns=[pickled("logreg")],
++   )
+
+-generate_plots(X, Y, logreg)
++generate_plots_task = PythonTask(
++   function=generate_plots,
++   name="generate_plots",
++   terminate_with_success=True,
++   catalog=Catalog(put=["iris_logistic.png"]), (2)
++   )
+
+
++pipeline = Pipeline(
++   steps=[load_data_task, model_fit_task, generate_plots_task], (3)
+
+```
+</div>
+
+
+---
+
+- [x] ```Domain``` code remains completely independent of ```driver``` code.
+- [x] The ```driver``` function has an equivalent and intuitive runnable expression
+- [x] Reproducible by default, runnable stores metadata about code/data/config for every execution.
+- [x] The pipeline is `runnable` in any environment.
+
+
+## Documentation
+
+[More details about the project and how to use it available here](https://astrazeneca.github.io/runnable/).
+
+<hr style="border:2px dotted orange">
+
+## Installation
+
+The minimum python version that runnable supports is 3.8
+
+```shell
+pip install runnable
+```
+
+Please look at the [installation guide](https://astrazeneca.github.io/runnable-core/usage)
+for more information.
+
+
+## Pipelines can be:
+
+### Linear
+
+A simple linear pipeline with tasks either
+[python functions](https://astrazeneca.github.io/runnable-core/concepts/task/#python_functions),
+[notebooks](https://astrazeneca.github.io/runnable-core/concepts/task/#notebooks), or [shell scripts](https://astrazeneca.github.io/runnable-core/concepts/task/#shell)
+
+[![](https://mermaid.ink/img/pako:eNpl0bFuwyAQBuBXQVdZTqTESpxMDJ0ytkszhgwnOCcoNo4OaFVZfvcSx20tGSQ4fn0wHB3o1hBIyLJOWGeDFJ3Iq7r90lfkkA9HHfmTUpnX1hFyLvrHzDLl_qB4-1BOOZGGD3TfSikvTDSNFqdj2sT2vBTr9euQlXNWjqycsN2c7UZWFMUE7udwP0L3y6JenNKiyfvz8t8_b-gavT9QJYY0PcDtjeTLptrAChriBq1JzeoeWkG4UkMKZCoN8k2Bcn1yGEN7_HYaZOBIK4h3g4EOFi-MDcgKa59SMja0_P7s_vAJ_Q_YOH6o?type=png)](https://mermaid.live/edit#pako:eNpl0bFuwyAQBuBXQVdZTqTESpxMDJ0ytkszhgwnOCcoNo4OaFVZfvcSx20tGSQ4fn0wHB3o1hBIyLJOWGeDFJ3Iq7r90lfkkA9HHfmTUpnX1hFyLvrHzDLl_qB4-1BOOZGGD3TfSikvTDSNFqdj2sT2vBTr9euQlXNWjqycsN2c7UZWFMUE7udwP0L3y6JenNKiyfvz8t8_b-gavT9QJYY0PcDtjeTLptrAChriBq1JzeoeWkG4UkMKZCoN8k2Bcn1yGEN7_HYaZOBIK4h3g4EOFi-MDcgKa59SMja0_P7s_vAJ_Q_YOH6o)
+
+### [Parallel branches](https://astrazeneca.github.io/runnable-core/concepts/parallel)
+
+Execute branches in parallel
+
+[![](https://mermaid.ink/img/pako:eNp9k01rwzAMhv-K8S4ZtJCzDzuMLmWwwkh2KMQ7eImShiZ2sB1KKf3vs52PpsWNT7LySHqlyBeciRwwwUUtTtmBSY2-YsopR8MpQUfAdCdBBekWNBpvv6-EkFICzGAtWcUTDW3wYy20M7lr5QGBK2j-anBAkH4M1z6grnjpy17xAiTwDII07jj6HK8-VnVZBspITnpjztyoVkLLJOy3Qfrdm6gQEu2370Io7WLORo84PbRoA_oOl9BBg4UHbHR58UkMWq_fxjrOnhLRx1nH0SgkjlBjh7ekxNKGc0NelDLknhePI8qf7MVNr_31nm1wwNTeM2Ao6pmf-3y3Mp7WlqA7twOnXfKs17zt-6azmim1gQL1A0NKS3EE8hKZE4Yezm3chIVFiFe4AdmwKjdv7mIjKNYHaIBiYsycySPFlF8NxzotkjPPMNGygxXu2pxp2FSslKzBpGC1Ml7IKy3krn_E7i1f_wEayTcn?type=png)](https://mermaid.live/edit#pako:eNp9k01rwzAMhv-K8S4ZtJCzDzuMLmWwwkh2KMQ7eImShiZ2sB1KKf3vs52PpsWNT7LySHqlyBeciRwwwUUtTtmBSY2-YsopR8MpQUfAdCdBBekWNBpvv6-EkFICzGAtWcUTDW3wYy20M7lr5QGBK2j-anBAkH4M1z6grnjpy17xAiTwDII07jj6HK8-VnVZBspITnpjztyoVkLLJOy3Qfrdm6gQEu2370Io7WLORo84PbRoA_oOl9BBg4UHbHR58UkMWq_fxjrOnhLRx1nH0SgkjlBjh7ekxNKGc0NelDLknhePI8qf7MVNr_31nm1wwNTeM2Ao6pmf-3y3Mp7WlqA7twOnXfKs17zt-6azmim1gQL1A0NKS3EE8hKZE4Yezm3chIVFiFe4AdmwKjdv7mIjKNYHaIBiYsycySPFlF8NxzotkjPPMNGygxXu2pxp2FSslKzBpGC1Ml7IKy3krn_E7i1f_wEayTcn)
+
+### [loops or map](https://astrazeneca.github.io/runnable-core/concepts/map)
+
+Execute a pipeline over an iterable parameter.
+
+[![](https://mermaid.ink/img/pako:eNqVlF1rwjAUhv9KyG4qKNR-3AS2m8nuBgN3Z0Sy5tQG20SSdE7E_76kVVEr2CY3Ied9Tx6Sk3PAmeKACc5LtcsKpi36nlGZFbXciHwfLN79CuWiBLMcEULWGkBSaeosA2OCxbxdXMd89Get2bZASsLiSyuvQE2mJZXIjW27t2rOmQZ3Gp9rD6UjatWnwy7q6zPPukd50WTydmemEiS_QbQ79RwxGoQY9UaMuojRA8TCXexzyHgQZNwbMu5Cxl3IXNX6OWMyiDHpzZh0GZMHjOK3xz2mgxjT3oxplzG9MPp5_nVOhwJjteDwOg3HyFj3L1dCcvh7DUc-iftX18n6Waet1xX8cG908vpKHO6OW7cvkeHm5GR2b3drdvaSGTODHLW37mxabYC8fLgRhlfxpjNdwmEets-Dx7gCXTHBXQc8-D2KbQEVUEzckjO9oZjKo9Ox2qr5XmaYWF3DGNdbzizMBHOVVWGSs9K4XeDCKv3ZttSmsx7_AYa341E?type=png)](https://mermaid.live/edit#pako:eNqVlF1rwjAUhv9KyG4qKNR-3AS2m8nuBgN3Z0Sy5tQG20SSdE7E_76kVVEr2CY3Ied9Tx6Sk3PAmeKACc5LtcsKpi36nlGZFbXciHwfLN79CuWiBLMcEULWGkBSaeosA2OCxbxdXMd89Get2bZASsLiSyuvQE2mJZXIjW27t2rOmQZ3Gp9rD6UjatWnwy7q6zPPukd50WTydmemEiS_QbQ79RwxGoQY9UaMuojRA8TCXexzyHgQZNwbMu5Cxl3IXNX6OWMyiDHpzZh0GZMHjOK3xz2mgxjT3oxplzG9MPp5_nVOhwJjteDwOg3HyFj3L1dCcvh7DUc-iftX18n6Waet1xX8cG908vpKHO6OW7cvkeHm5GR2b3drdvaSGTODHLW37mxabYC8fLgRhlfxpjNdwmEets-Dx7gCXTHBXQc8-D2KbQEVUEzckjO9oZjKo9Ox2qr5XmaYWF3DGNdbzizMBHOVVWGSs9K4XeDCKv3ZttSmsx7_AYa341E)
+
+### [Arbitrary nesting](https://astrazeneca.github.io/runnable-core/concepts/nesting/)
+Any nesting of parallel within map and so on.
+

{runnable-0.12.2.dist-info → runnable-0.12.3.dist-info}/RECORD

@@ -53,12 +53,12 @@ runnable/names.py,sha256=vn92Kv9ANROYSZX6Z4z1v_WA3WiEdIYmG6KEStBFZug,8134
 runnable/nodes.py,sha256=UqR-bJx0Hi7uLSUw_saB7VsNdFh3POKtdgsEPsasHfE,16576
 runnable/parameters.py,sha256=yZkMDnwnkdYXIwQ8LflBzn50Y0xRGxEvLlxwno6ovvs,5163
 runnable/pickler.py,sha256=5SDNf0miMUJ3ZauhQdzwk8_t-9jeOqaTjP5bvRnu9sU,2685
-runnable/sdk.py,sha256=pmxGO5HSrcEGYR_VmVk6ObfddFHo5slxiaDI6LuIdKM,27852
+runnable/sdk.py,sha256=sZWiyGVIqaAmmJuc4p1OhuqLBSqS7svN1VuSOqeZ_xA,29254
 runnable/secrets.py,sha256=dakb7WRloWVo-KpQp6Vy4rwFdGi58BTlT4OifQY106I,2324
 runnable/tasks.py,sha256=7sAtFMu6ELD3PJoisNbm47rY2wPKVzz5_h4s_QMep0k,22043
 runnable/utils.py,sha256=fXOLoFZKYqh3wQgzA2V-VZOu-dSgLPGqCZIbMmsNzOw,20016
-runnable-0.12.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-runnable-0.12.2.dist-info/METADATA,sha256=8u2DRuU-gQvmW66oAqKABw5BYsCB0sJde6E_u-coEiE,17020
-runnable-0.12.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-runnable-0.12.2.dist-info/entry_points.txt,sha256=-csEf-FCAqtOboXaBSzpgaTffz1HwlylYPxnppndpFE,1494
-runnable-0.12.2.dist-info/RECORD,,
+runnable-0.12.3.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+runnable-0.12.3.dist-info/METADATA,sha256=spjKwm0NQ2n_MEfz1c0kqe2NkxpFq6nFQwyJ91xfAso,10436
+runnable-0.12.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+runnable-0.12.3.dist-info/entry_points.txt,sha256=-csEf-FCAqtOboXaBSzpgaTffz1HwlylYPxnppndpFE,1494
+runnable-0.12.3.dist-info/RECORD,,

runnable-0.12.2.dist-info/METADATA

@@ -1,453 +0,0 @@
-Metadata-Version: 2.1
-Name: runnable
-Version: 0.12.2
-Summary: A Compute agnostic pipelining software
-Home-page: https://github.com/vijayvammi/runnable
-License: Apache-2.0
-Author: Vijay Vammi
-Author-email: mesanthu@gmail.com
-Requires-Python: >=3.9,<3.13
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Provides-Extra: database
-Provides-Extra: docker
-Provides-Extra: notebook
-Requires-Dist: click
-Requires-Dist: click-plugins (>=1.1.1,<2.0.0)
-Requires-Dist: dill (>=0.3.8,<0.4.0)
-Requires-Dist: docker ; extra == "docker"
-Requires-Dist: mlflow-skinny
-Requires-Dist: ploomber-engine (>=0.0.31,<0.0.32) ; extra == "notebook"
-Requires-Dist: pydantic (>=2.5,<3.0)
-Requires-Dist: rich (>=13.5.2,<14.0.0)
-Requires-Dist: ruamel.yaml
-Requires-Dist: ruamel.yaml.clib
-Requires-Dist: sqlalchemy ; extra == "database"
-Requires-Dist: stevedore (>=3.5.0,<4.0.0)
-Requires-Dist: typing-extensions ; python_version < "3.8"
-Project-URL: Documentation, https://github.com/vijayvammi/runnable
-Project-URL: Repository, https://github.com/vijayvammi/runnable
-Description-Content-Type: text/markdown
-
-
-
-
-
-<p align="center">
-
-                                                      ,////,
-                                                      /// 6|
-                                                      //  _|
-                                                    _/_,-'
-                                                _.-/'/   \   ,/;,
-                                            ,-' /'  \_   \ / _/
-                                            `\ /     _/\  ` /
-                                               |     /,  `\_/
-                                               |     \'
-                                    /\_        /`      /\
-                                  /' /_``--.__/\  `,. /  \
-                                  |_/`  `-._     `\/  `\   `.
-                                            `-.__/'     `\   |
-                                                        `\  \
-                                                          `\ \
-                                                            \_\__
-                                                              \___)
-
-</p>
-<hr style="border:2px dotted orange">
-
-<p align="center">
-<a href="https://pypi.org/project/runnable/"><img alt="python:" src="https://img.shields.io/badge/python-3.8%20%7C%203.9%20%7C%203.10-blue.svg"></a>
-<a href="https://pypi.org/project/runnable/"><img alt="Pypi" src="https://badge.fury.io/py/runnable.svg"></a>
-<a href="https://github.com/vijayvammi/runnable/blob/main/LICENSE"><img alt"License" src="https://img.shields.io/badge/license-Apache%202.0-blue.svg"></a>
-<a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
-<a href="https://github.com/python/mypy"><img alt="MyPy Checked" src="https://www.mypy-lang.org/static/mypy_badge.svg"></a>
-<a href="https://github.com/vijayvammi/runnable/actions/workflows/release.yaml"><img alt="Tests:" src="https://github.com/vijayvammi/runnable/actions/workflows/release.yaml/badge.svg">
-<a href="https://github.com/vijayvammi/runnable/actions/workflows/docs.yaml"><img alt="Docs:" src="https://github.com/vijayvammi/runnable/actions/workflows/docs.yaml/badge.svg">
-</p>
-<hr style="border:2px dotted orange">
-
-runnable is a simplified workflow definition language that helps in:
-
-- **Streamlined Design Process:** runnable enables users to efficiently plan their pipelines with
-[stubbed nodes](https://astrazeneca.github.io/runnable-core/concepts/stub), along with offering support for various structures such as
-[tasks](https://astrazeneca.github.io/runnable-core/concepts/task), [parallel branches](https://astrazeneca.github.io/runnable-core/concepts/parallel), and [loops or map branches](https://astrazeneca.github.io/runnable-core/concepts/map)
-in both [yaml](https://astrazeneca.github.io/runnable-core/concepts/pipeline) or a [python SDK](https://astrazeneca.github.io/runnable-core/sdk) for maximum flexibility.
-
-- **Incremental Development:** Build your pipeline piece by piece with runnable, which allows for the
-implementation of tasks as [python functions](https://astrazeneca.github.io/runnable-core/concepts/task/#python_functions),
-[notebooks](https://astrazeneca.github.io/runnable-core/concepts/task/#notebooks), or [shell scripts](https://astrazeneca.github.io/runnable-core/concepts/task/#shell),
-adapting to the developer's preferred tools and methods.
-
-- **Robust Testing:** Ensure your pipeline performs as expected with the ability to test using sampled data. runnable
-also provides the capability to [mock and patch tasks](https://astrazeneca.github.io/runnable-core/configurations/executors/mocked)
-for thorough evaluation before full-scale deployment.
-
-- **Seamless Deployment:** Transition from the development stage to production with ease.
-runnable simplifies the process by requiring [only configuration changes](https://astrazeneca.github.io/runnable-core/configurations/overview)
-to adapt to different environments, including support for [argo workflows](https://astrazeneca.github.io/runnable-core/configurations/executors/argo).
-
-- **Efficient Debugging:** Quickly identify and resolve issues in pipeline execution with runnable's local
-debugging features. Retrieve data from failed tasks and [retry failures](https://astrazeneca.github.io/runnable-core/concepts/run-log/#retrying_failures)
-using your chosen debugging tools to maintain a smooth development experience.
-
-Along with the developer friendly features, runnable also acts as an interface to production grade concepts
-such as [data catalog](https://astrazeneca.github.io/runnable-core/concepts/catalog), [reproducibility](https://astrazeneca.github.io/runnable-core/concepts/run-log),
-[experiment tracking](https://astrazeneca.github.io/runnable-core/concepts/experiment-tracking)
-and secure [access to secrets](https://astrazeneca.github.io/runnable-core/concepts/secrets).
-
-<hr style="border:2px dotted orange">
-
-## What does it do?
-
-
-![works](assets/work.png)
-
-<hr style="border:2px dotted orange">
-
-## Documentation
-
-[More details about the project and how to use it available here](https://astrazeneca.github.io/runnable-core/).
-
-<hr style="border:2px dotted orange">
-
-## Installation
-
-The minimum python version that runnable supports is 3.8
-
-```shell
-pip install runnable
-```
-
-Please look at the [installation guide](https://astrazeneca.github.io/runnable-core/usage)
-for more information.
-
-<hr style="border:2px dotted orange">
-
-## Example
-
-Your application code. Use pydantic models as DTO.
-
-Assumed to be present at ```functions.py```
-```python
-from pydantic import BaseModel
-
-class InnerModel(BaseModel):
-    """
-    A pydantic model representing a group of related parameters.
-    """
-
-    foo: int
-    bar: str
-
-
-class Parameter(BaseModel):
-    """
-    A pydantic model representing the parameters of the whole pipeline.
-    """
-
-    x: int
-    y: InnerModel
-
-
-def return_parameter() -> Parameter:
-    """
-    The annotation of the return type of the function is not mandatory
-    but it is a good practice.
-
-    Returns:
-        Parameter: The parameters that should be used in downstream steps.
-    """
-    # Return type of a function should be a pydantic model
-    return Parameter(x=1, y=InnerModel(foo=10, bar="hello world"))
-
-
-def display_parameter(x: int, y: InnerModel):
-    """
-    Annotating the arguments of the function is important for
-    runnable to understand the type of parameters you want.
-
-    Input args can be a pydantic model or the individual attributes.
-    """
-    print(x)
-    # >>> prints 1
-    print(y)
-    # >>> prints InnerModel(foo=10, bar="hello world")
-```
-
-### Application code using driver functions.
-
-The code is runnable without any orchestration framework.
-
-```python
-from functions import return_parameter, display_parameter
-
-my_param = return_parameter()
-display_parameter(my_param.x, my_param.y)
-```
-
-### Orchestration using runnable
-
-<table>
-<tr>
-    <th>python SDK</th>
-    <th>yaml</th>
-</tr>
-<tr>
-<td valign="top"><p>
-
-Example present at: ```examples/python-tasks.py```
-
-Run it as: ```python examples/python-tasks.py```
-
-```python
-from runnable import Pipeline, Task
-
-def main():
-    step1 = Task(
-        name="step1",
-        command="examples.functions.return_parameter",
-    )
-    step2 = Task(
-        name="step2",
-        command="examples.functions.display_parameter",
-        terminate_with_success=True,
-    )
-
-    step1 >> step2
-
-    pipeline = Pipeline(
-        start_at=step1,
-        steps=[step1, step2],
-        add_terminal_nodes=True,
-    )
-
-    pipeline.execute()
-
-
-if __name__ == "__main__":
-    main()
-```
-
-</p></td>
-
-<td valign="top"><p>
-
-Example present at: ```examples/python-tasks.yaml```
-
-
-Execute via the cli: ```runnable execute -f examples/python-tasks.yaml```
-
-```yaml
-dag:
-  description: |
-    This is a simple pipeline that does 3 steps in sequence.
-    In this example:
-      1. First step: returns a "parameter" x as a Pydantic model
-      2. Second step: Consumes that parameter and prints it
-
-    This pipeline demonstrates one way to pass small data from one step to another.
-
-  start_at: step 1
-  steps:
-    step 1:
-      type: task
-      command_type: python # (2)
-      command: examples.functions.return_parameter # (1)
-      next: step 2
-    step 2:
-      type: task
-      command_type: python
-      command: examples.functions.display_parameter
-      next: success
-    success:
-      type: success
-    fail:
-      type: fail
-```
-
-</p></td>
-
-</tr>
-</table>
-
-### Transpile to argo workflows
-
-No code change, just change the configuration.
-
-```yaml
-executor:
-  type: "argo"
-  config:
-    image: runnable:demo
-    persistent_volumes:
-      - name: runnable-volume
-        mount_path: /mnt
-
-run_log_store:
-  type: file-system
-  config:
-    log_folder: /mnt/run_log_store
-```
-
-More details can be found in [argo configuration](https://astrazeneca.github.io/runnable-core/configurations/executors/argo).
-
-Execute the code as ```runnable execute -f examples/python-tasks.yaml -c examples/configs/argo-config.yam```
-
-<details>
-  <summary>Expand</summary>
-
-```yaml
-apiVersion: argoproj.io/v1alpha1
-kind: Workflow
-metadata:
-  generateName: runnable-dag-
-  annotations: {}
-  labels: {}
-spec:
-  activeDeadlineSeconds: 172800
-  entrypoint: runnable-dag
-  podGC:
-    strategy: OnPodCompletion
-  retryStrategy:
-    limit: '0'
-    retryPolicy: Always
-    backoff:
-      duration: '120'
-      factor: 2
-      maxDuration: '3600'
-  serviceAccountName: default-editor
-  templates:
-    - name: runnable-dag
-      failFast: true
-      dag:
-        tasks:
-          - name: step-1-task-uvdp7h
-            template: step-1-task-uvdp7h
-            depends: ''
-          - name: step-2-task-772vg3
-            template: step-2-task-772vg3
-            depends: step-1-task-uvdp7h.Succeeded
-          - name: success-success-igzq2e
-            template: success-success-igzq2e
-            depends: step-2-task-772vg3.Succeeded
-    - name: step-1-task-uvdp7h
-      container:
-        image: runnable:demo
-        command:
-          - runnable
-          - execute_single_node
-          - '{{workflow.parameters.run_id}}'
-          - step%1
-          - --log-level
-          - WARNING
-          - --file
-          - examples/python-tasks.yaml
-          - --config-file
-          - examples/configs/argo-config.yaml
-        volumeMounts:
-          - name: executor-0
-            mountPath: /mnt
-        imagePullPolicy: ''
-        resources:
-          limits:
-            memory: 1Gi
-            cpu: 250m
-          requests:
-            memory: 1Gi
-            cpu: 250m
-    - name: step-2-task-772vg3
-      container:
-        image: runnable:demo
-        command:
-          - runnable
-          - execute_single_node
-          - '{{workflow.parameters.run_id}}'
-          - step%2
-          - --log-level
-          - WARNING
-          - --file
-          - examples/python-tasks.yaml
-          - --config-file
-          - examples/configs/argo-config.yaml
-        volumeMounts:
-          - name: executor-0
-            mountPath: /mnt
-        imagePullPolicy: ''
-        resources:
-          limits:
-            memory: 1Gi
-            cpu: 250m
-          requests:
-            memory: 1Gi
-            cpu: 250m
-    - name: success-success-igzq2e
-      container:
-        image: runnable:demo
-        command:
-          - runnable
-          - execute_single_node
-          - '{{workflow.parameters.run_id}}'
-          - success
-          - --log-level
-          - WARNING
-          - --file
-          - examples/python-tasks.yaml
-          - --config-file
-          - examples/configs/argo-config.yaml
-        volumeMounts:
-          - name: executor-0
-            mountPath: /mnt
-        imagePullPolicy: ''
-        resources:
-          limits:
-            memory: 1Gi
-            cpu: 250m
-          requests:
-            memory: 1Gi
-            cpu: 250m
-  templateDefaults:
-    activeDeadlineSeconds: 7200
-    timeout: 10800s
-  arguments:
-    parameters:
-      - name: run_id
-        value: '{{workflow.uid}}'
-  volumes:
-    - name: executor-0
-      persistentVolumeClaim:
-        claimName: runnable-volume
-
-```
-
-</details>
-
-## Pipelines can be:
-
-### Linear
-
-A simple linear pipeline with tasks either
-[python functions](https://astrazeneca.github.io/runnable-core/concepts/task/#python_functions),
-[notebooks](https://astrazeneca.github.io/runnable-core/concepts/task/#notebooks), or [shell scripts](https://astrazeneca.github.io/runnable-core/concepts/task/#shell)
-
-[![](https://mermaid.ink/img/pako:eNpl0bFuwyAQBuBXQVdZTqTESpxMDJ0ytkszhgwnOCcoNo4OaFVZfvcSx20tGSQ4fn0wHB3o1hBIyLJOWGeDFJ3Iq7r90lfkkA9HHfmTUpnX1hFyLvrHzDLl_qB4-1BOOZGGD3TfSikvTDSNFqdj2sT2vBTr9euQlXNWjqycsN2c7UZWFMUE7udwP0L3y6JenNKiyfvz8t8_b-gavT9QJYY0PcDtjeTLptrAChriBq1JzeoeWkG4UkMKZCoN8k2Bcn1yGEN7_HYaZOBIK4h3g4EOFi-MDcgKa59SMja0_P7s_vAJ_Q_YOH6o?type=png)](https://mermaid.live/edit#pako:eNpl0bFuwyAQBuBXQVdZTqTESpxMDJ0ytkszhgwnOCcoNo4OaFVZfvcSx20tGSQ4fn0wHB3o1hBIyLJOWGeDFJ3Iq7r90lfkkA9HHfmTUpnX1hFyLvrHzDLl_qB4-1BOOZGGD3TfSikvTDSNFqdj2sT2vBTr9euQlXNWjqycsN2c7UZWFMUE7udwP0L3y6JenNKiyfvz8t8_b-gavT9QJYY0PcDtjeTLptrAChriBq1JzeoeWkG4UkMKZCoN8k2Bcn1yGEN7_HYaZOBIK4h3g4EOFi-MDcgKa59SMja0_P7s_vAJ_Q_YOH6o)
-
-### [Parallel branches](https://astrazeneca.github.io/runnable-core/concepts/parallel)
-
-Execute branches in parallel
-
-[![](https://mermaid.ink/img/pako:eNp9k01rwzAMhv-K8S4ZtJCzDzuMLmWwwkh2KMQ7eImShiZ2sB1KKf3vs52PpsWNT7LySHqlyBeciRwwwUUtTtmBSY2-YsopR8MpQUfAdCdBBekWNBpvv6-EkFICzGAtWcUTDW3wYy20M7lr5QGBK2j-anBAkH4M1z6grnjpy17xAiTwDII07jj6HK8-VnVZBspITnpjztyoVkLLJOy3Qfrdm6gQEu2370Io7WLORo84PbRoA_oOl9BBg4UHbHR58UkMWq_fxjrOnhLRx1nH0SgkjlBjh7ekxNKGc0NelDLknhePI8qf7MVNr_31nm1wwNTeM2Ao6pmf-3y3Mp7WlqA7twOnXfKs17zt-6azmim1gQL1A0NKS3EE8hKZE4Yezm3chIVFiFe4AdmwKjdv7mIjKNYHaIBiYsycySPFlF8NxzotkjPPMNGygxXu2pxp2FSslKzBpGC1Ml7IKy3krn_E7i1f_wEayTcn?type=png)](https://mermaid.live/edit#pako:eNp9k01rwzAMhv-K8S4ZtJCzDzuMLmWwwkh2KMQ7eImShiZ2sB1KKf3vs52PpsWNT7LySHqlyBeciRwwwUUtTtmBSY2-YsopR8MpQUfAdCdBBekWNBpvv6-EkFICzGAtWcUTDW3wYy20M7lr5QGBK2j-anBAkH4M1z6grnjpy17xAiTwDII07jj6HK8-VnVZBspITnpjztyoVkLLJOy3Qfrdm6gQEu2370Io7WLORo84PbRoA_oOl9BBg4UHbHR58UkMWq_fxjrOnhLRx1nH0SgkjlBjh7ekxNKGc0NelDLknhePI8qf7MVNr_31nm1wwNTeM2Ao6pmf-3y3Mp7WlqA7twOnXfKs17zt-6azmim1gQL1A0NKS3EE8hKZE4Yezm3chIVFiFe4AdmwKjdv7mIjKNYHaIBiYsycySPFlF8NxzotkjPPMNGygxXu2pxp2FSslKzBpGC1Ml7IKy3krn_E7i1f_wEayTcn)
-
-### [loops or map](https://astrazeneca.github.io/runnable-core/concepts/map)
-
-Execute a pipeline over an iterable parameter.
-
-[![](https://mermaid.ink/img/pako:eNqVlF1rwjAUhv9KyG4qKNR-3AS2m8nuBgN3Z0Sy5tQG20SSdE7E_76kVVEr2CY3Ied9Tx6Sk3PAmeKACc5LtcsKpi36nlGZFbXciHwfLN79CuWiBLMcEULWGkBSaeosA2OCxbxdXMd89Get2bZASsLiSyuvQE2mJZXIjW27t2rOmQZ3Gp9rD6UjatWnwy7q6zPPukd50WTydmemEiS_QbQ79RwxGoQY9UaMuojRA8TCXexzyHgQZNwbMu5Cxl3IXNX6OWMyiDHpzZh0GZMHjOK3xz2mgxjT3oxplzG9MPp5_nVOhwJjteDwOg3HyFj3L1dCcvh7DUc-iftX18n6Waet1xX8cG908vpKHO6OW7cvkeHm5GR2b3drdvaSGTODHLW37mxabYC8fLgRhlfxpjNdwmEets-Dx7gCXTHBXQc8-D2KbQEVUEzckjO9oZjKo9Ox2qr5XmaYWF3DGNdbzizMBHOVVWGSs9K4XeDCKv3ZttSmsx7_AYa341E?type=png)](https://mermaid.live/edit#pako:eNqVlF1rwjAUhv9KyG4qKNR-3AS2m8nuBgN3Z0Sy5tQG20SSdE7E_76kVVEr2CY3Ied9Tx6Sk3PAmeKACc5LtcsKpi36nlGZFbXciHwfLN79CuWiBLMcEULWGkBSaeosA2OCxbxdXMd89Get2bZASsLiSyuvQE2mJZXIjW27t2rOmQZ3Gp9rD6UjatWnwy7q6zPPukd50WTydmemEiS_QbQ79RwxGoQY9UaMuojRA8TCXexzyHgQZNwbMu5Cxl3IXNX6OWMyiDHpzZh0GZMHjOK3xz2mgxjT3oxplzG9MPp5_nVOhwJjteDwOg3HyFj3L1dCcvh7DUc-iftX18n6Waet1xX8cG908vpKHO6OW7cvkeHm5GR2b3drdvaSGTODHLW37mxabYC8fLgRhlfxpjNdwmEets-Dx7gCXTHBXQc8-D2KbQEVUEzckjO9oZjKo9Ox2qr5XmaYWF3DGNdbzizMBHOVVWGSs9K4XeDCKv3ZttSmsx7_AYa341E)
-
-### [Arbitrary nesting](https://astrazeneca.github.io/runnable-core/concepts/nesting/)
-Any nesting of parallel within map and so on.
-