nextpipe 0.3.5.dev0__tar.gz → 0.4.0.dev0__tar.gz

{nextpipe-0.3.5.dev0 → nextpipe-0.4.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextpipe
-Version: 0.3.5.dev0
+Version: 0.4.0.dev0
 Summary: Framework for Decision Pipeline modeling and execution
 Project-URL: Homepage, https://www.nextmv.io
 Project-URL: Documentation, https://nextpipe.docs.nextmv.io/en/latest/
@@ -108,7 +108,7 @@ Requires-Dist: dataclasses-json>=0.6.7
 Requires-Dist: nextmv>=0.29.4
 Requires-Dist: requests>=2.31.0
 Provides-Extra: dev
-Requires-Dist: goldie>=0.1.7; extra == 'dev'
+Requires-Dist: goldie>=0.1.8; extra == 'dev'
 Requires-Dist: ruff>=0.11.6; extra == 'dev'
 Description-Content-Type: text/markdown
 

nextpipe-0.4.0.dev0/docs/examples/multifile-workflow.md

@@ -0,0 +1,186 @@
+# multi-file Workflow Example
+
+!!! tip
+
+    This example uses the [`echo` app](../tutorials/echo.md), make sure to complete
+    that tutorial first.
+
+This example showcases how to use **multi-file** applications _within_ a
+Nextpipe workflow. A multi-file application differs from a JSON-based
+application in that it accepts a directory of files as input and produces a
+directory of files as output. Note that the workflow itself is also a multi-file
+application, however, this is a user choice (i.e., you could also create a
+JSON-based workflow that uses multi-file sub-applications).
+
+For demonstration purposes, we will use the simple [echo-multi application] as
+the sub-application, which echoes the input files as output files.
+
+Find the workflow code below (mind the comments explaining each step):
+
+```python
+import os
+import shutil
+
+import nextmv
+import nextmv.cloud
+
+from nextpipe import FlowSpec, app, log, needs, step
+
+options = nextmv.Options(
+    nextmv.Option("input", str, "inputs/", "Path to input file.", False),
+    nextmv.Option("output", str, "outputs/", "Path to output file.", False),
+)
+
+
+# >>> Workflow definition
+class Flow(FlowSpec):
+    # The first step receives the path to the input files directly (see main()) and
+    # automatically zips the directory and passes it to the 'echo-multi' sub-app.
+    @app(app_id="echo-multi")
+    @step
+    def solve1():
+        """Runs a multi-file model."""
+        pass
+
+    # The second step receives the path to the output files from the first step. This path
+    # will point to a temporary directory containing the output files from the first step.
+    @needs(predecessors=[solve1])
+    @step
+    def transform(result_path: str):
+        """Transforms the result for the next step."""
+        # Just list the content of the result directory.
+        log(f"Contents of result directory {result_path}:")
+        for file_name in os.listdir(result_path):
+            full_file_name = os.path.join(result_path, file_name)
+            if os.path.isfile(full_file_name):
+                log(f"- {file_name}")
+
+        # Add a new file to the result for demonstration purposes.
+        new_file_path = os.path.join(result_path, "additional_file.txt")
+        with open(new_file_path, "w") as f:
+            f.write("This is an additional file added in the transform step.\n")
+        log(f"Added new file: {new_file_path}")
+
+        return result_path
+
+    # The third step receives the (modified) directory from the transform step and runs
+    # another multi-file app on it.
+    @app(
+        app_id="echo-multi",
+        # We specify the content type explicitly here. This is normally done via the app's
+        # manifest, but we can do it explicitly like this too.
+        run_configuration=nextmv.RunConfiguration(
+            format=nextmv.Format(
+                format_input=nextmv.FormatInput(input_type=nextmv.InputFormat.MULTI_FILE),
+                format_output=nextmv.FormatOutput(output_type=nextmv.OutputFormat.MULTI_FILE),
+            )
+        ),
+        full_result=True,
+    )
+    @needs(predecessors=[transform])
+    @step
+    def solve2(result: nextmv.cloud.RunResult):
+        """Runs another multi-file model."""
+        pass
+
+    # The final step receives the output from 'solve2' as a full result object (see
+    # 'full_result=True' above). In this case, the path to the output files is available
+    # via 'result.output'.
+    @needs(predecessors=[solve2])
+    @step
+    def prepare_output(result: nextmv.cloud.RunResult):
+        """Transforms the result for the next step."""
+        # Extract the path to the output files.
+        result_path = result.output
+        # Simply copy the files from the given directory to the expected output directory.
+        os.makedirs(options.output, exist_ok=True)
+        for file_name in os.listdir(result_path):
+            full_file_name = os.path.join(result_path, file_name)
+            if os.path.isfile(full_file_name):
+                shutil.copy(full_file_name, options.output)
+
+
+def main():
+    # Run workflow (simply provide the path to the multi-file input)
+    flow = Flow("DecisionFlow", options.input)
+    flow.run()
+    # The last step of the flow already prepares the output in the requested directory,
+    # so no need to do anything here anymore.
+
+
+if __name__ == "__main__":
+    main()
+```
+
+Run the example:
+
+```bash
+$ python main.py
+[nextpipe] No application ID or run ID found, uplink is inactive.
+[nextpipe] Flow: Flow
+[nextpipe] nextpipe: v0.3.5
+[nextpipe] nextmv: 0.33.0
+[nextpipe] Flow graph steps:
+[nextpipe] Step:
+[nextpipe]   Definition: Step(solve1, StepRun(echo-multi, , {}, False))
+[nextpipe]   Docstring: Runs a multi-file model.
+[nextpipe] Step:
+[nextpipe]   Definition: Step(transform, StepNeeds(solve1))
+[nextpipe]   Docstring: Transforms the result for the next step.
+[nextpipe] Step:
+[nextpipe]   Definition: Step(solve2, StepNeeds(transform), StepRun(echo-multi, , {}, True))
+[nextpipe]   Docstring: Runs another multi-file model.
+[nextpipe] Step:
+[nextpipe]   Definition: Step(prepare_output, StepNeeds(solve2))
+[nextpipe]   Docstring: Transforms the result for the next step.
+[nextpipe] Mermaid diagram:
+[nextpipe] graph LR
+  solve1(solve1)
+  solve1 --> transform
+  transform(transform)
+  transform --> solve2
+  solve2(solve2)
+  solve2 --> prepare_output
+  prepare_output(prepare_output)
+
+[nextpipe] Mermaid URL: https://mermaid.ink/svg/Z3JhcGggTFIKICBzb2x2ZTEoc29sdmUxKQogIHNvbHZlMSAtLT4gdHJhbnNmb3JtCiAgdHJhbnNmb3JtKHRyYW5zZm9ybSkKICB0cmFuc2Zvcm0gLS0+IHNvbHZlMgogIHNvbHZlMihzb2x2ZTIpCiAgc29sdmUyIC0tPiBwcmVwYXJlX291dHB1dAogIHByZXBhcmVfb3V0cHV0KHByZXBhcmVfb3V0cHV0KQo=?theme=dark
+[nextpipe] Running node solve1_0
+[nextpipe] Started app step solve1_0 run, find it at https://cloud.nextmv.io/app/echo-multi/run/latest-a-JAvuFgDR?view=details
+/home/marius/.asdf/installs/python/3.13.7/lib/python3.13/shutil.py:1281: DeprecationWarning: Python 3.14 will, by default, filter extracted tar archives and reject files or modify their metadata. Use the filter argument to control this behavior.
+  tarobj.extractall(extract_dir, filter=filter)
+[nextpipe] Running node transform_0
+[transform_0] Contents of result directory /tmp/nextpipe_output_igqsibzm:
+[transform_0] - input.xlsx
+[transform_0] - data.csv
+[transform_0] Added new file: /tmp/nextpipe_output_igqsibzm/additional_file.txt
+[nextpipe] Running node solve2_0
+[nextpipe] Started app step solve2_0 run, find it at https://cloud.nextmv.io/app/echo-multi/run/latest-HIwvuFgDg?view=details
+[nextpipe] Running node prepare_output_0
+```
+
+Content of the output directory:
+
+```bash
+tree outputs/
+outputs/
+├── additional_file.txt
+├── data.csv
+└── input.xlsx
+
+1 directory, 3 files
+```
+
+The resulting Mermaid diagram for this flow looks like this:
+
+```mermaid
+graph LR
+  solve1(solve1)
+  solve1 --> transform
+  transform(transform)
+  transform --> solve2
+  solve2(solve2)
+  solve2 --> prepare_output
+  prepare_output(prepare_output)
+```
+
+[echo-multi application]: ../tutorials/echo-multi.md

nextpipe-0.4.0.dev0/docs/tutorials/echo-multi.md

@@ -0,0 +1,154 @@
+# The `echo-multi` app
+
+Several examples assume you have a Nextmv application called `echo-multi`. This
+is just a simple application created for demonstration purposes. It takes the
+input files and echoes them as output files.
+
+Let's get set up with the `echo-multi` application. Before starting:
+
+1. [Sign up][signup] for a Nextmv account.
+2. Get your API key. Go to [Team > API Key][api-key].
+
+Make sure that you have your API key set as an environment variable:
+
+```bash
+export NEXTMV_API_KEY="<YOUR-API-KEY>"
+```
+
+Now that you have a valid Nextmv account and API key, let's create the
+`echo-multi` Nextmv app (start in an empty directory).
+
+1. Create a folder `inputs/` and add some sample input files to it. For example,
+   you can create two text files `input.csv` and `input.txt` with some sample
+   content.
+1. In a new directory, create a file called `main.py` with the code for the
+   basic app that echoes the input.
+
+    ```python
+    import glob
+
+    import os
+    import time
+
+    import nextmv
+
+    def main():
+        options = nextmv.Options(
+            nextmv.Option("input", str, "inputs/", "Path to input file.", False),
+            nextmv.Option("output", str, "outputs/", "Path to output file.", False),
+            nextmv.Option("duration", float, 1.0, "Runtime duration (in seconds).", False),
+        )
+
+        # Read and prepare the input data.
+        input_data = read_input(options.input)
+
+        # Log information about the input files.
+        nextmv.log(f"Size of input files (count: {len(input_data)}):")
+        for file_path, content in input_data.items():
+            nextmv.log(f"  {file_path}: {len(content)} bytes")
+
+        # Sleep for the specified duration.
+        nextmv.log(f"Sleeping for {options.duration} seconds...")
+        time.sleep(options.duration)
+        nextmv.log("Woke up from sleep.")
+
+        # Write the output.
+        write_output(options.output, input_data)
+
+    def read_input(input_path: str) -> dict[str, bytes]:
+        """Reads the input files to memory."""
+        input_files = glob.glob(os.path.join(input_path, "**/*"), recursive=True)
+        content = {}
+        for file_path in input_files:
+            if os.path.isfile(file_path):
+                with open(file_path, "rb") as file:
+                    nextmv.log(f"Reading file: {file_path}")
+                    content[file_path] = file.read()
+        return content
+
+    def write_output(output_path: str, content: dict[str, bytes]) -> None:
+        """Writes the given output files."""
+        if not os.path.exists(output_path):
+            os.makedirs(output_path)
+
+        for file_path, data in content.items():
+            output_file_path = os.path.join(output_path, os.path.basename(file_path))
+            with open(output_file_path, "wb") as file:
+                nextmv.log(f"Writing file: {output_file_path}")
+                file.write(data)
+
+    if __name__ == "__main__":
+        main()
+    ```
+
+    Note that the application uses the [`nextmv`][nextmv-docs] library. This
+    library is a dependency of `nextpipe` and should be installed automatically
+    when you install `nextpipe`.
+
+    You may run the app locally to test it:
+
+    ```bash
+    python main.py
+    ```
+
+1. Create a `requirements.txt` file with the following requirements for running
+   the app:
+
+    ```requirements.txt
+    nextmv
+    ```
+
+1. Create an `app.yaml` file (the app manifest) with the following instructions:
+
+    ```yaml
+    type: python
+    runtime: ghcr.io/nextmv-io/runtime/python:3.11
+    files:
+        - main.py
+    python:
+        pip-requirements: requirements.txt
+    ```
+
+1. Push the application to your Nextmv account. Create a `push.py` script in
+   the same directory with the following code:
+
+    ```python
+    import os
+
+    from nextmv import cloud
+
+    client = cloud.Client(api_key=os.getenv("NEXTMV_API_KEY"))
+    app = cloud.Application.new(client=client, name="echo-multi", id="echo-multi", description="Sample echo multi-file app.", exist_ok=True)
+    app.push(verbose=True)
+    ```
+
+1. Execute the `push.py` script to push the app to your Nextmv account:
+
+    ```bash
+    $ python push.py
+    💽 Starting build for Nextmv application.
+    🐍 Bundling Python dependencies.
+    📋 Copied files listed in "app.yaml" manifest.
+    📦 Packaged application (588 files, 5.39 MiB).
+    🌟 Pushing to application: "echo-multi".
+    💥️ Successfully pushed to application: "echo-multi".
+    {
+    "app_id": "echo-multi",
+    "endpoint": "https://api.cloud.nextmv.io",
+    "instance_url": "v1/applications/echo-multi/runs?instance_id=devint"
+    }
+    ```
+
+    Alternatively, you can use the [Nextmv CLI][nextmv-cli] to create and push the app:
+
+    ```bash
+    nextmv app create -a echo-multi -n echo-multi -d "Sample echo multi-file app."
+    nextmv app push -a echo-multi
+    ```
+
+Now you are ready to run the examples.
+
+[signup]: https://cloud.nextmv.io
+[api-key]: https://cloud.nextmv.io/team/api-keys
+[nextmv-docs]: https://nextmv-py.readthedocs.io/en/latest/nextmv/
+[nextmv-cli]: https://docs.nextmv.io/docs/using-nextmv/reference/cli

{nextpipe-0.3.5.dev0 → nextpipe-0.4.0.dev0}/mkdocs.yml

@@ -12,6 +12,7 @@ nav:
           - The echo app: tutorials/echo.md
       - Examples:
           - Basic chained workflow: examples/basic-chained-workflow.md
+          - Multi-file workflow: examples/multifile-workflow.md
           - Fanout workflow: examples/fanout-workflow.md
           - Ensemble workflow: examples/ensemble-workflow.md
           - Complex workflow: examples/complex-workflow.md

nextpipe-0.4.0.dev0/nextpipe/__about__.py

@@ -0,0 +1 @@
+__version__ = "v0.4.0.dev.0"

{nextpipe-0.3.5.dev0 → nextpipe-0.4.0.dev0}/nextpipe/decorators.py

@@ -50,6 +50,7 @@ from collections.abc import Callable
 from enum import Enum
 from functools import wraps
 
+import nextmv
 from nextmv import cloud
 from nextmv.deprecated import deprecated
 
@@ -772,10 +773,10 @@ class App:
         The ID of the instance to run.
     options : dict[str, Any]
         The options to pass to the application.
-    input_type : InputType
-        The type of input to pass to the application (JSON or FILES).
     full_result : bool
         Whether to return the full result including metadata.
+    run_configuration : nextmv.RunConfiguration
+        The configuration to apply when running the app.
     polling_options : Optional[cloud.PollingOptions]
         Options for polling for the results of the app run.
     """
@@ -788,6 +789,7 @@ class App:
         parameters: dict[str, typing.Any] = None,
         options: dict[str, typing.Any] = None,
         full_result: bool = False,
+        run_configuration: nextmv.RunConfiguration = None,
         polling_options: typing.Optional[cloud.PollingOptions] = _DEFAULT_POLLING_OPTIONS,
     ):
         """
@@ -799,16 +801,22 @@ class App:
             The ID of the Nextmv Application to run.
         instance_id : str, optional
             The ID of the instance to run. Default is defined by the app on Platform.
-        input_type : InputType, optional
-            The type of input to pass to the application, by default InputType.JSON.
         options : dict[str, Any], optional
             The options to pass to the application, by default None.
         full_result : bool, optional
             Whether to return the full result including metadata, by default False.
+        run_configuration : nextmv.RunConfiguration, optional
+            The configuration to apply when running the app, by default None.
         polling_options : Optional[cloud.PollingOptions], optional
             Options for polling for the results of the app run, by default _DEFAULT_POLLING_OPTIONS.
         """
 
+        if input_type:
+            deprecated(
+                "input_type",
+                "The 'input_type' argument is deprecated and will be removed in a future release.",
+            )
+
         # Make sure only one of options or parameters is used.
         if parameters and options:
             raise ValueError("You can only use either 'parameters' or 'options', not both.")
@@ -824,6 +832,7 @@ class App:
         self.options = options if options else {}
         self.input_type = input_type
         self.full_result = full_result
+        self.run_configuration = run_configuration
         self.polling_options = polling_options
 
     def __repr__(self):
@@ -835,7 +844,7 @@ class App:
             A string representation of the app.
         """
 
-        return f"StepRun({self.app_id}, {self.instance_id}, {self.options}, {self.input_type}, {self.full_result})"
+        return f"StepRun({self.app_id}, {self.instance_id}, {self.options}, {self.full_result})"
 
 
 def app(
@@ -845,6 +854,7 @@ def app(
     options: dict[str, typing.Any] = None,
     input_type: InputType = InputType.JSON,
     full_result: bool = False,
+    run_configuration: nextmv.RunConfiguration = None,
     polling_options: typing.Optional[cloud.PollingOptions] = _DEFAULT_POLLING_OPTIONS,
 ):
     """
@@ -871,14 +881,13 @@ def app(
     options : dict[str, Any]
         The options to pass to the application. This is a dictionary of
         parameter names and values. The values must be JSON serializable.
-    input_type : InputType
-        The type of input to pass to the application. This can be either
-        JSON or FILES. Default is JSON.
     full_result : bool
         Whether to return the full result of the application run. If this is
         set to `True`, the full result (with metadata) will be returned. If
         this is set to `False`, only the output of the application will be
         returned.
+    run_configuration : nextmv.RunConfiguration
+        The configuration to apply when running the app.
     polling_options : Optional[cloud.PollingOptions]
         Options for polling for the results of the app run. This is used to
         configure the polling behavior, such as the timeout and backoff
@@ -924,6 +933,12 @@ def app(
     ```
     """
 
+    if input_type:
+        deprecated(
+            "input_type",
+            "The 'input_type' argument is deprecated and will be removed in a future release.",
+        )
+
     # Make sure only one of options or parameters is used.
     if parameters and options:
         raise ValueError("You can only use either 'parameters' or 'options', not both.")
@@ -950,6 +965,7 @@ def app(
             options=converted_options,
             input_type=input_type,
             full_result=full_result,
+            run_configuration=run_configuration,
             polling_options=polling_options,
         )
         wrapper.step.type = StepType.APP

{nextpipe-0.3.5.dev0 → nextpipe-0.4.0.dev0}/nextpipe/flow.py

@@ -27,14 +27,16 @@ import base64
 import copy
 import inspect
 import io
+import os
 import random
+import tempfile
 import threading
 import time
 from importlib.metadata import version
 from itertools import product
 from typing import Any, Optional, Union
 
-from nextmv.cloud import Application, Client
+from nextmv.cloud import Application, Client, RunResult
 
 from . import config, decorators, graph, schema, threads, uplink, utils
 from .__about__ import __version__
@@ -907,6 +909,7 @@ class Runner:
         # Run the step
         if node.parent.definition.is_app():
             app_step: decorators.App = node.parent.definition.app
+
             # Prepare the input for the app
             # TODO: We only support one predecessor for app steps for now. This may
             # change in the future. We may want to support multiple predecessors for
@@ -923,12 +926,23 @@ class Runner:
                 # Merge the options from the app decorator with the options from the
                 # AppRunConfig. AppRunConfig options take precedence.
                 options = app_step.options | app_run_options
+            elif isinstance(inputs[0], RunResult):
+                # If the input is a RunResult, we use its output as input.
+                run_result: RunResult = inputs[0]
+                input = run_result.output
+                options = app_step.options
+                name = node.id
             else:
                 # If the input is not AppRunConfig, we use it directly.
                 input = inputs[0]
                 options = app_step.options
                 name = node.id
 
+            # Detect dir mode / multi-file direct input
+            is_dir_mode = False
+            if isinstance(input, str) and os.path.isdir(input):
+                is_dir_mode = True
+
             # Modify the polling options set for the step (by default or by the
             # user) so that the initial delay is randomized and the stopping
             # callback is configured as the node being cancelled if the user
@@ -942,13 +956,22 @@ class Runner:
             run_args = (
                 [],  # No nameless arguments
                 {  # We use the named arguments to pass the user arguments to the run function
-                    "input": input,
-                    "run_options": options,
-                    "polling_options": polling_options,
+                    "options": options,
                     "name": name,
                 },
             )
 
+            # Prepare input argument. We need to use 'input_dir_path' when dealing with a
+            # directory input (e.g., multi-file input).
+            if is_dir_mode:
+                run_args[1]["input_dir_path"] = input
+            else:
+                run_args[1]["input"] = input
+
+            # Apply run configuration if given.
+            if app_step.run_configuration is not None:
+                run_args[1]["configuration"] = app_step.run_configuration
+
             # Prepare the application itself.
             app = Application(
                 client=client,
@@ -957,18 +980,35 @@ class Runner:
             if app_step.instance_id is not None and app_step.instance_id != "":
                 app.default_instance_id = app_step.instance_id
 
-            # Run the application
-            result = app.new_run_with_result(
-                *run_args[0],
-                **run_args[1],
-            )
-            run_id = result.id
-            node.run_id = run_id
-            utils.log_internal(f"Finished app step {node.id} run, find it at {result.console_url}")
+            # We always supply an output directory path in case of implicit multi-file output
+            temp_dir = tempfile.mkdtemp(prefix="nextpipe_output_")
 
-            # Return result (do not unwrap if full result is requested)
+            # Run the application
+            try:
+                run_id = app.new_run(*run_args[0], **run_args[1])
+                console_url = f"{client.console_url}/app/{app_step.app_id}/run/{run_id}?view=details"
+                utils.log_internal(f"Started app step {node.id} run, find it at {console_url}")
+                result = app.run_result_with_polling(
+                    run_id=run_id, polling_options=polling_options, output_dir_path=temp_dir
+                )
+                node.run_id = run_id
+            finally:  # Make sure we clean up temp dir on failure too
+                # If the temp dir is empty, remove it
+                dir_result = False
+                if not os.listdir(temp_dir):
+                    os.rmdir(temp_dir)
+                else:
+                    dir_result = True
+
+            # Return result
+            #  - Do not unwrap if full result is requested
+            #  - If the output came in a directory, return the directory path
             if app_step.full_result:
+                if dir_result:
+                    result.output = temp_dir
                 return result
+            if dir_result:
+                return temp_dir
             return result.output
 
         else:

{nextpipe-0.3.5.dev0 → nextpipe-0.4.0.dev0}/nextpipe/schema.py

@@ -70,8 +70,10 @@ class AppRunConfig:
 
     Parameters
     ----------
-    input : dict[str, Any], optional
-        Input data for the app, by default None.
+    input : Union[dict[str, Any], str, Any]
+        Input data for the app. A JSON app can take a dictionary, multi-file apps can take
+        a directory path as a string. Other types will be passed to the underlying Python
+        SDK as-is (e.g., nextmv.Input).
     options : Union[list[AppOption], dict[str, Any]], optional
         Options for running the app, by default empty. These can be provided as a list of
         `AppOption` instances, or, simply as a dictionary of key-value pairs.
@@ -88,8 +90,10 @@ class AppRunConfig:
     ... )
     """
 
-    input: dict[str, Any] = None
-    """Input for the app."""
+    input: Union[dict[str, Any], str, Any]
+    """Input for the app. A JSON app can take a dictionary, multi-file apps can take a
+    directory path as a string. Other types will be passed to the underlying Python SDK
+    as-is (e.g., nextmv.Input)."""
     options: Union[list[AppOption], dict[str, Any]] = field(default_factory=list)
     """Options for running the app."""
     name: Optional[str] = None

{nextpipe-0.3.5.dev0 → nextpipe-0.4.0.dev0}/pyproject.toml

@@ -71,5 +71,5 @@ path = "nextpipe/__about__.py"
 [project.optional-dependencies]
 dev = [
     "ruff>=0.11.6",
-    "goldie>=0.1.7",
+    "goldie>=0.1.8",
 ]

{nextpipe-0.3.5.dev0 → nextpipe-0.4.0.dev0}/tests/.gitignore

@@ -1,3 +1,4 @@
 go-nextroute/
 python-pyvroom-routing/
 python-ortools-routing/
+outputs/

{nextpipe-0.3.5.dev0 → nextpipe-0.4.0.dev0}/tests/README.md

@@ -12,6 +12,11 @@ cd apps/echo
 nextmv app create -a echo -n "Echo" || true
 nextmv app push -a echo
 cd ../..
+# Setup echo-multi app
+cd apps/echo-multi
+nextmv app create -a echo-multi -n "Echo Multi" || true
+nextmv app push -a echo-multi
+cd ../..
 ```
 
 Furthermore, subscribe to the following marketplace apps and name them as follows:

nextpipe-0.4.0.dev0/tests/apps/echo-multi/.gitignore

@@ -0,0 +1 @@
+outputs/

nextpipe-0.4.0.dev0/tests/apps/echo-multi/README.md

@@ -0,0 +1,19 @@
+# JSON echo
+
+This is a sample app that reads input files and echoes them as output. This app
+is meant to be used for the `multi-file` I/O format.
+
+This app is used for testing.
+
+## Usage
+
+```bash
+python main.py -threads 10 -duration 10
+```
+
+## Push to Nextmv
+
+```bash
+nextmv app create -a echo-multi -n "JSON echo multi-file" -d "This is a sample app that reads input files and echoes them as output."
+nextmv app push -a echo-multi
+```