nextmv 0.33.0__py3-none-any.whl → 0.34.0.dev0__py3-none-any.whl

nextmv/__about__.py

@@ -1 +1 @@
-__version__ = "v0.33.0"
+__version__ = "v0.34.0.dev0"

nextmv/__init__.py

@@ -69,6 +69,7 @@ from .run import RunResult as RunResult
 from .run import RunType as RunType
 from .run import RunTypeConfiguration as RunTypeConfiguration
 from .run import StatisticsIndicator as StatisticsIndicator
+from .run import SyncedRun as SyncedRun
 from .run import TrackedRun as TrackedRun
 from .run import TrackedRunStatus as TrackedRunStatus
 from .run import run_duration as run_duration

nextmv/cloud/application.py

@@ -58,7 +58,7 @@ from nextmv.logger import log
 from nextmv.manifest import Manifest
 from nextmv.model import Model, ModelConfiguration
 from nextmv.options import Options
-from nextmv.output import Output, OutputFormat
+from nextmv.output import ASSETS_KEY, STATISTICS_KEY, Asset, Output, OutputFormat, Statistics
 from nextmv.polling import DEFAULT_POLLING_OPTIONS, PollingOptions, poll
 from nextmv.run import (
     ExternalRunResult,
@@ -187,17 +187,20 @@ class Application:
         >>> app = Application.new(client=client, name="My New App", id="my-app")
         """
 
+        if id is None:
+            id = safe_id("app")
+
         if exist_ok and cls.exists(client=client, id=id):
             return Application(client=client, id=id)
 
         payload = {
             "name": name,
+            "id": id,
         }
 
         if description is not None:
             payload["description"] = description
-        if id is not None:
-            payload["id"] = id
+
         if is_workflow is not None:
             payload["is_pipeline"] = is_workflow
 
@@ -1790,7 +1793,7 @@ class Application:
             when the run is part of a batch experiment.
         external_result: Optional[Union[ExternalRunResult, dict[str, Any]]]
             External result to use for the run. This can be a
-            `cloud.ExternalRunResult` object or a dict. If the object is used,
+            `nextmv.ExternalRunResult` object or a dict. If the object is used,
             then the `.to_dict()` method is applied to extract the
             configuration. This is used when the run is an external run. We
             suggest that instead of specifying this parameter, you use the
@@ -1820,8 +1823,6 @@ class Application:
             not `JSON`. If the final `options` are not of type `dict[str,str]`.
         """
 
-        self.__validate_input_dir_path_and_configuration(input_dir_path, configuration)
-
         tar_file = ""
         if input_dir_path is not None and input_dir_path != "":
             if not os.path.exists(input_dir_path):
@@ -1879,6 +1880,7 @@ class Application:
         query_params = {}
         if instance_id is not None or self.default_instance_id is not None:
             query_params["instance_id"] = instance_id if instance_id is not None else self.default_instance_id
+
         response = self.client.request(
             method="POST",
             endpoint=f"{self.endpoint}/runs",
@@ -2993,6 +2995,7 @@ class Application:
             execution_duration=tracked_run.duration,
         )
 
+        # Handle the stderr logs if provided.
         if tracked_run.logs is not None:
             url_stderr = self.upload_url()
             self.upload_large_input(input=tracked_run.logs_text(), upload_url=url_stderr)
@@ -3001,6 +3004,47 @@ class Application:
         if tracked_run.error is not None and tracked_run.error != "":
             external_result.error_message = tracked_run.error
 
+        # Handle the statistics upload if provided.
+        stats = tracked_run.statistics
+        if stats is not None:
+            if isinstance(stats, Statistics):
+                stats_dict = stats.to_dict()
+                stats_dict = {STATISTICS_KEY: stats_dict}
+            elif isinstance(stats, dict):
+                stats_dict = stats
+                if STATISTICS_KEY not in stats_dict:
+                    stats_dict = {STATISTICS_KEY: stats_dict}
+            else:
+                raise ValueError("tracked_run.statistics must be either a `Statistics` or `dict` object")
+
+            url_stats = self.upload_url()
+            self.upload_large_input(input=stats_dict, upload_url=url_stats)
+            external_result.statistics_upload_id = url_stats.upload_id
+
+        # Handle the assets upload if provided.
+        assets = tracked_run.assets
+        if assets is not None:
+            if isinstance(assets, list):
+                assets_list = []
+                for ix, asset in enumerate(assets):
+                    if isinstance(asset, Asset):
+                        assets_list.append(asset.to_dict())
+                    elif isinstance(asset, dict):
+                        assets_list.append(asset)
+                    else:
+                        raise ValueError(f"tracked_run.assets, index {ix} must be an `Asset` or `dict` object")
+                assets_dict = {ASSETS_KEY: assets_list}
+            elif isinstance(assets, dict):
+                assets_dict = assets
+                if ASSETS_KEY not in assets_dict:
+                    assets_dict = {ASSETS_KEY: assets_dict}
+            else:
+                raise ValueError("tracked_run.assets must be either a `list[Asset]`, `list[dict]`, or `dict` object")
+
+            url_assets = self.upload_url()
+            self.upload_large_input(input=assets_dict, upload_url=url_assets)
+            external_result.assets_upload_id = url_assets.upload_id
+
         return self.new_run(
             upload_id=url_input.upload_id,
             external_result=external_result,
@@ -3860,49 +3904,6 @@ class Application:
 
         raise ValueError(f"Unknown scenario input type: {scenario.scenario_input.scenario_input_type}")
 
-    def __validate_input_dir_path_and_configuration(
-        self,
-        input_dir_path: Optional[str],
-        configuration: Optional[Union[RunConfiguration, dict[str, Any]]],
-    ) -> None:
-        """
-        Auxiliary function to validate the directory path and configuration.
-        """
-        input_type = self.__get_input_type(configuration)
-
-        # If no explicit input type is defined, there is nothing to validate.
-        if input_type is None:
-            return
-
-        # Validate that the input directory path is provided when explicitly required.
-        dir_types = (InputFormat.MULTI_FILE, InputFormat.CSV_ARCHIVE)
-        if input_type in dir_types and not input_dir_path:
-            raise ValueError(
-                f"If RunConfiguration.format.format_input.input_type is set to {input_type}, "
-                "then input_dir_path must be provided.",
-            )
-
-    def __get_input_type(self, config: Union[RunConfiguration, dict[str, Any]]) -> Optional[InputFormat]:
-        """
-        Auxiliary function to extract the input type from the run configuration.
-        """
-
-        if config is None:
-            return None
-
-        if isinstance(config, dict):
-            config = RunConfiguration.from_dict(config)
-
-        if (
-            isinstance(config, RunConfiguration)
-            and config.format is not None
-            and config.format.format_input is not None
-            and config.format.format_input.input_type is not None
-        ):
-            return config.format.format_input.input_type
-
-        return None
-
     def __package_inputs(self, dir_path: str) -> str:
         """
         This is an auxiliary function for packaging the inputs found in the

nextmv/local/application.py

@@ -35,9 +35,19 @@ from nextmv.local.runner import run
 from nextmv.logger import log
 from nextmv.manifest import Manifest
 from nextmv.options import Options
-from nextmv.output import OUTPUTS_KEY, SOLUTIONS_KEY, OutputFormat
+from nextmv.output import ASSETS_KEY, OUTPUTS_KEY, SOLUTIONS_KEY, STATISTICS_KEY, OutputFormat
 from nextmv.polling import DEFAULT_POLLING_OPTIONS, PollingOptions, poll
-from nextmv.run import ErrorLog, Format, Run, RunConfiguration, RunInformation, RunResult, TrackedRun, TrackedRunStatus
+from nextmv.run import (
+    ErrorLog,
+    Format,
+    Run,
+    RunConfiguration,
+    RunInformation,
+    RunResult,
+    SyncedRun,
+    TrackedRun,
+    TrackedRunStatus,
+)
 from nextmv.safe import safe_id
 from nextmv.status import StatusV2
 
@@ -995,25 +1005,10 @@ class Application:
         input_type = run_result.metadata.format.format_input.input_type
 
         # Skip runs that have already been synced.
-        already_synced = run_result.synced_run_id is not None and run_result.synced_at is not None
+        synced_run, already_synced = run_result.is_synced(app_id=target.id, instance_id=instance_id)
         if already_synced:
             if verbose:
-                log(f"   ⏭️  Skipping local run `{run_id}`, already synced at {run_result.synced_at.isoformat()}.")
-
-            return False
-
-        # Skip runs that don't have the supported type. TODO: delete this when
-        # external runs support CSV_ARCHIVE and MULTI_FILE. Right now,
-        # submitting an external result with a new run is limited to JSON and
-        # TEXT. After this if statement is removed, the rest of the code should
-        # work with CSV_ARCHIVE and MULTI_FILE as well, as using the input dir
-        # path is already considered.
-        if input_type not in {InputFormat.JSON, InputFormat.TEXT}:
-            if verbose:
-                log(
-                    f"   ⏭️  Skipping local run `{run_id}`, unsupported input type: {input_type.value}. "
-                    f"Supported types are: {[InputFormat.JSON.value, InputFormat.TEXT.value]}",
-                )
+                log(f"   ⏭️  Skipping local run `{run_id}`, already synced with {synced_run.to_dict()}.")
 
             return False
 
@@ -1031,7 +1026,7 @@ class Application:
         # Read the logs of the run and place each line as an element in a list
         run_dir = os.path.join(runs_dir, run_id)
         with open(os.path.join(run_dir, LOGS_KEY, LOGS_FILE)) as f:
-            stderr_logs = f.readlines()
+            stderr_logs = [line.rstrip("\n") for line in f.readlines()]
 
         # Create the tracked run object and start configuring it.
         tracked_run = TrackedRun(
@@ -1055,11 +1050,28 @@ class Application:
             tracked_run.input_dir_path = inputs_path
 
         # Resolve the output according to its type.
-        if run_result.metadata.format.format_output.output_type == OutputFormat.JSON:
+        output_type = run_result.metadata.format.format_output.output_type
+        if output_type == OutputFormat.JSON:
             tracked_run.output = run_result.output
         else:
             tracked_run.output_dir_path = os.path.join(run_dir, OUTPUTS_KEY, SOLUTIONS_KEY)
 
+        # Resolve the statistics according to their type and presence. If
+        # working with JSON, the statistics should be resolved from the output.
+        if output_type in {OutputFormat.CSV_ARCHIVE, OutputFormat.MULTI_FILE}:
+            stats_file_path = os.path.join(run_dir, OUTPUTS_KEY, STATISTICS_KEY, f"{STATISTICS_KEY}.json")
+            if os.path.exists(stats_file_path):
+                with open(stats_file_path) as f:
+                    tracked_run.statistics = json.load(f)
+
+        # Resolve the assets according to their type and presence. If working
+        # with JSON, the assets should be resolved from the output.
+        if output_type in {OutputFormat.CSV_ARCHIVE, OutputFormat.MULTI_FILE}:
+            assets_file_path = os.path.join(run_dir, OUTPUTS_KEY, ASSETS_KEY, f"{ASSETS_KEY}.json")
+            if os.path.exists(assets_file_path):
+                with open(assets_file_path) as f:
+                    tracked_run.assets = json.load(f)
+
         # Actually sync the run by tracking it remotely on Nextmv Cloud.
         configuration = RunConfiguration(
             format=Format(
@@ -1074,13 +1086,18 @@ class Application:
         )
 
         # Mark the local run as synced by updating the local run info.
-        run_result.synced_run_id = tracked_id
-        run_result.synced_at = datetime.now(timezone.utc)
+        synced_run = SyncedRun(
+            run_id=tracked_id,
+            synced_at=datetime.now(timezone.utc),
+            app_id=target.id,
+            instance_id=instance_id,
+        )
+        run_result.add_synced_run(synced_run)
         with open(os.path.join(run_dir, f"{run_id}.json"), "w") as f:
             json.dump(run_result.to_dict(), f, indent=2)
 
         if verbose:
-            log(f"✅ Synced local run `{run_id}` as remote run `{tracked_id}`.")
+            log(f"✅ Synced local run `{run_id}` as remote run `{synced_run.to_dict()}`.")
 
         return True
 
@@ -1116,7 +1133,15 @@ class Application:
             return False
 
         # Validate outputs
-        if not self.__validate_outputs(run_dir, run_result.metadata.format.format_output.output_type):
+        format_output = run_result.metadata.format.format_output
+        if format_output is None or not format_output:
+            return False
+
+        output_type = format_output.output_type
+        if output_type is None or output_type == "":
+            return False
+
+        if not self.__validate_outputs(run_dir, output_type):
             return False
 
         # Validate logs

nextmv/local/executor.py

@@ -16,6 +16,10 @@ process_run_input
     Function to process the run input based on the format.
 process_run_output
     Function to process the run output and handle results.
+resolve_output_format
+    Function to determine the output format from manifest or directory structure.
+process_run_information
+    Function to update run metadata including duration and status.
 process_run_logs
     Function to process and save run logs.
 process_run_statistics
@@ -26,8 +30,13 @@ process_run_solutions
     Function to process and save run solutions.
 process_run_visuals
     Function to process and save run visuals.
+resolve_stdout
+    Function to parse subprocess stdout output.
+ignore_patterns
+    Function to filter files and directories during source code copying.
 """
 
+import hashlib
 import json
 import os
 import shutil
@@ -84,25 +93,26 @@ def execute_run(
     input_data: Optional[Union[dict[str, Any], str]] = None,
 ) -> None:
     """
-    This function actually executes the decision model run, using a
-    subprocess to call the entrypoint script with the appropriate input and
-    options.
+    Executes the decision model run using a subprocess to call the entrypoint
+    script with the appropriate input and options.
 
     Parameters
     ----------
+    run_id : str
+        The unique identifier for the run.
     src : str
         The path to the application source code.
-    manifest_entrypoint : str
-        The entrypoint script as defined in the application manifest.
+    manifest_dict : dict[str, Any]
+        The manifest dictionary containing application configuration.
     run_dir : str
-        The path to the run directory.
+        The path to the run directory where outputs will be stored.
     run_config : dict[str, Any]
-        The run configuration.
+        The run configuration containing format and other settings.
     inputs_dir_path : Optional[str], optional
         The path to the directory containing input files, by default None. If
         provided, this parameter takes precedence over `input_data`.
     options : Optional[dict[str, Any]], optional
-        Additional options for the run, by default None.
+        Additional command-line options for the run, by default None.
     input_data : Optional[Union[dict[str, Any], str]], optional
         The input data for the run, by default None. If `inputs_dir_path` is
         provided, this parameter is ignored.
@@ -119,7 +129,7 @@ def execute_run(
         # place to work from, and be cleaned up afterwards.
         with tempfile.TemporaryDirectory() as temp_dir:
             temp_src = os.path.join(temp_dir, "src")
-            shutil.copytree(src, temp_src, ignore=shutil.ignore_patterns(NEXTMV_DIR))
+            shutil.copytree(src, temp_src, ignore=ignore_patterns)
 
             manifest = Manifest.from_dict(manifest_dict)
 
@@ -162,6 +172,7 @@ def execute_run(
                 temp_src=temp_src,
                 result=result,
                 run_dir=run_dir,
+                src=src,
             )
 
     except Exception as e:
@@ -290,29 +301,30 @@ def process_run_output(
     temp_src: str,
     result: subprocess.CompletedProcess[str],
     run_dir: str,
+    src: str,
 ) -> None:
     """
     Processes the result of the subprocess run. This function is in charge of
     handling the run results, including solutions, statistics, logs, assets,
-    etc.
+    and visuals.
 
     Parameters
     ----------
     manifest : Manifest
-        The application manifest.
+        The application manifest containing configuration details.
+    run_id : str
+        The unique identifier for the run.
     temp_src : str
         The path to the temporary source directory.
     result : subprocess.CompletedProcess[str]
-        The result of the subprocess run.
+        The result of the subprocess run containing stdout, stderr, and return code.
     run_dir : str
-        The path to the run directory.
+        The path to the run directory where outputs will be stored.
+    src : str
+        The path to the application source code.
     """
 
-    # Parse stdout as JSON, if possible.
-    stdout_output = {}
-    raw_output = result.stdout
-    if raw_output.strip() != "":
-        stdout_output = json.loads(raw_output)
+    stdout_output = resolve_stdout(result)
 
     # Create outputs directory.
     outputs_dir = os.path.join(run_dir, OUTPUTS_KEY)
@@ -324,7 +336,6 @@ def process_run_output(
         temp_run_outputs_dir=temp_run_outputs_dir,
         temp_src=temp_src,
     )
-
     process_run_information(
         run_id=run_id,
         run_dir=run_dir,
@@ -342,6 +353,7 @@ def process_run_output(
         stdout_output=stdout_output,
         temp_src=temp_src,
         manifest=manifest,
+        src=src,
     )
     process_run_assets(
         temp_run_outputs_dir=temp_run_outputs_dir,
@@ -349,6 +361,7 @@ def process_run_output(
         stdout_output=stdout_output,
         temp_src=temp_src,
         manifest=manifest,
+        src=src,
     )
     process_run_solutions(
         run_id=run_id,
@@ -359,6 +372,7 @@ def process_run_output(
         stdout_output=stdout_output,
         output_format=output_format,
         manifest=manifest,
+        src=src,
     )
     process_run_visuals(
         run_dir=run_dir,
@@ -381,11 +395,16 @@ def resolve_output_format(
     Parameters
     ----------
     manifest : Manifest
-        The application manifest.
+        The application manifest containing configuration details.
     temp_run_outputs_dir : str
         The path to the temporary outputs directory.
     temp_src : str
         The path to the temporary source directory.
+
+    Returns
+    -------
+    OutputFormat
+        The determined output format (JSON, CSV_ARCHIVE, or MULTI_FILE).
     """
 
     if manifest.configuration is not None and manifest.configuration.content is not None:
@@ -433,7 +452,8 @@ def process_run_information(run_id: str, run_dir: str, result: subprocess.Comple
     error = ""
     if result.returncode != 0:
         status = StatusV2.failed.value
-        error = result.stderr if result.stderr else "unknown error"
+        # Truncate error message so that Cloud does not complain.
+        error = (result.stderr.strip().replace("\n", " ") if result.stderr else "unknown error")[:60]
 
     # Update the run info file.
     info["metadata"]["duration"] = duration
@@ -448,29 +468,34 @@ def process_run_logs(
     output_format: OutputFormat,
     run_dir: str,
     result: subprocess.CompletedProcess[str],
-    stdout_output: dict[str, Any],
+    stdout_output: Union[str, dict[str, Any]],
 ) -> None:
     """
     Processes the logs of the run. Writes the logs to a logs directory.
+    For multi-file format, stdout is written to logs if present.
 
     Parameters
     ----------
     output_format : OutputFormat
-        The output format of the run.
+        The output format of the run (JSON, CSV_ARCHIVE, or MULTI_FILE).
     run_dir : str
-        The path to the run directory.
+        The path to the run directory where logs will be stored.
     result : subprocess.CompletedProcess[str]
-        The result of the subprocess run.
-    stdout_output : dict[str, Any]
-        The stdout output of the run, parsed as a dictionary.
+        The result of the subprocess run containing stderr output.
+    stdout_output : Union[str, dict[str, Any]]
+        The stdout output of the run, either as raw string or parsed dictionary.
     """
 
     logs_dir = os.path.join(run_dir, LOGS_KEY)
     os.makedirs(logs_dir, exist_ok=True)
     std_err = result.stderr
     with open(os.path.join(logs_dir, LOGS_FILE), "w") as f:
-        if output_format == OutputFormat.MULTI_FILE and stdout_output != {}:
-            f.write(json.dumps(stdout_output))
+        if output_format == OutputFormat.MULTI_FILE and bool(stdout_output):
+            if isinstance(stdout_output, dict):
+                f.write(json.dumps(stdout_output))
+            elif isinstance(stdout_output, str):
+                f.write(stdout_output)
+
             if std_err:
                 f.write("\n")
 
@@ -480,14 +505,15 @@ def process_run_logs(
 def process_run_statistics(
     temp_run_outputs_dir: str,
     outputs_dir: str,
-    stdout_output: dict[str, Any],
+    stdout_output: Union[str, dict[str, Any]],
     temp_src: str,
     manifest: Manifest,
+    src: str,
 ) -> None:
     """
-    Processes the statistics of the run. Check for an outputs/statistics folder
-    being created by the run. If it exists, copy it to the run directory. If it
-    doesn't exist, attempt to get the stats from stdout.
+    Processes the statistics of the run. Checks for an outputs/statistics folder
+    or custom statistics file location from manifest. If found, copies to run
+    directory. Otherwise, attempts to extract statistics from stdout.
 
     Parameters
     ----------
@@ -495,12 +521,15 @@ def process_run_statistics(
         The path to the temporary outputs directory.
     outputs_dir : str
         The path to the outputs directory in the run directory.
-    stdout_output : dict[str, Any]
-        The stdout output of the run, parsed as a dictionary.
+    stdout_output : Union[str, dict[str, Any]]
+        The stdout output of the run, either as raw string or parsed dictionary.
     temp_src : str
         The path to the temporary source directory.
     manifest : Manifest
-        The application manifest.
+        The application manifest containing configuration and custom paths.
+    src : str
+        The path to the original application source code, used to avoid copying
+        files that are already part of the source.
     """
 
     stats_dst = os.path.join(outputs_dir, STATISTICS_KEY)
@@ -524,7 +553,10 @@ def process_run_statistics(
 
     stats_src = os.path.join(temp_run_outputs_dir, STATISTICS_KEY)
     if os.path.exists(stats_src) and os.path.isdir(stats_src):
-        shutil.copytree(stats_src, stats_dst, dirs_exist_ok=True)
+        _copy_new_or_modified_files(stats_src, stats_dst, src)
+        return
+
+    if not isinstance(stdout_output, dict):
         return
 
     if STATISTICS_KEY not in stdout_output:
@@ -538,14 +570,15 @@ def process_run_statistics(
 def process_run_assets(
     temp_run_outputs_dir: str,
     outputs_dir: str,
-    stdout_output: dict[str, Any],
+    stdout_output: Union[str, dict[str, Any]],
     temp_src: str,
     manifest: Manifest,
+    src: str,
 ) -> None:
     """
-    Processes the assets of the run. Check for an outputs/assets folder being
-    created by the run. If it exists, copy it to the run directory. If it
-    doesn't exist, attempt to get the assets from stdout.
+    Processes the assets of the run. Checks for an outputs/assets folder or
+    custom assets file location from manifest. If found, copies to run directory.
+    Otherwise, attempts to extract assets from stdout.
 
     Parameters
     ----------
@@ -553,12 +586,15 @@ def process_run_assets(
         The path to the temporary outputs directory.
     outputs_dir : str
         The path to the outputs directory in the run directory.
-    stdout_output : dict[str, Any]
-        The stdout output of the run, parsed as a dictionary.
+    stdout_output : Union[str, dict[str, Any]]
+        The stdout output of the run, either as raw string or parsed dictionary.
     temp_src : str
         The path to the temporary source directory.
     manifest : Manifest
-        The application manifest.
+        The application manifest containing configuration and custom paths.
+    src : str
+        The path to the original application source code, used to avoid copying
+        files that are already part of the source.
     """
 
     assets_dst = os.path.join(outputs_dir, ASSETS_KEY)
@@ -582,7 +618,10 @@ def process_run_assets(
 
     assets_src = os.path.join(temp_run_outputs_dir, ASSETS_KEY)
     if os.path.exists(assets_src) and os.path.isdir(assets_src):
-        shutil.copytree(assets_src, assets_dst, dirs_exist_ok=True)
+        _copy_new_or_modified_files(assets_src, assets_dst, src)
+        return
+
+    if not isinstance(stdout_output, dict):
         return
 
     if ASSETS_KEY not in stdout_output:
@@ -599,37 +638,42 @@ def process_run_solutions(
     temp_run_outputs_dir: str,
     temp_src: str,
     outputs_dir: str,
-    stdout_output: dict[str, Any],
+    stdout_output: Union[str, dict[str, Any]],
     output_format: OutputFormat,
     manifest: Manifest,
+    src: str,
 ) -> None:
     """
-    Processes the solutions (output) of the run. This method has the handle all
-    the different formats for processing solutions. This includes looking for
-    an `output` directory (`csv-archive`), an `outputs/solutions` directory
-    (`multi-file`), or looking for solutions in the stdout output (`json` or
-    `text`). For flexibility, we copy whatever is in the `output` and
-    `outputs/solutions` directories, if they exist. If neither exist, we
-    attempt to get the solution from stdout.
+    Processes the solutions (output) of the run. Handles all different output
+    formats including CSV-archive, multi-file, JSON, and text. Looks for
+    `output` directory (csv-archive), `outputs/solutions` directory (multi-file),
+    or custom solutions path from manifest. Falls back to stdout for JSON/text.
+    Updates run metadata with output size and format information.
+
+    Only copies files that are truly new outputs, excluding files that already
+    exist in the original source code, inputs, statistics, or assets directories
+    to prevent copying application data as solutions.
 
     Parameters
     ----------
     run_id : str
-        The ID of the run.
+        The unique identifier of the run.
     run_dir : str
-        The path to the run directory.
+        The path to the run directory where outputs are stored.
     temp_run_outputs_dir : str
         The path to the temporary outputs directory.
     temp_src : str
         The path to the temporary source directory.
     outputs_dir : str
         The path to the outputs directory in the run directory.
-    stdout_output : dict[str, Any]
-        The stdout output of the run, parsed as a dictionary.
+    stdout_output : Union[str, dict[str, Any]]
+        The stdout output of the run, either as raw string or parsed dictionary.
     output_format : OutputFormat
-        The output format of the run.
+        The determined output format (JSON, CSV_ARCHIVE, MULTI_FILE, or TEXT).
     manifest : Manifest
-        The application manifest.
+        The application manifest containing configuration and custom paths.
+    src : str
+        The path to the application source code.
     """
 
     info_file = os.path.join(run_dir, f"{run_id}.json")
@@ -640,9 +684,12 @@ def process_run_solutions(
     solutions_dst = os.path.join(outputs_dir, SOLUTIONS_KEY)
     os.makedirs(solutions_dst, exist_ok=True)
 
+    # Build list of directories to exclude from copying
+    exclusion_dirs = _build_exclusion_directories(src, manifest, outputs_dir, run_dir)
+
     if output_format == OutputFormat.CSV_ARCHIVE:
         output_src = os.path.join(temp_src, OUTPUT_KEY)
-        shutil.copytree(output_src, solutions_dst, dirs_exist_ok=True)
+        _copy_new_or_modified_files(output_src, solutions_dst, src, exclusion_dirs)
     elif output_format == OutputFormat.MULTI_FILE:
         solutions_src = os.path.join(temp_run_outputs_dir, SOLUTIONS_KEY)
         if (
@@ -653,11 +700,14 @@ def process_run_solutions(
         ):
             solutions_src = os.path.join(temp_src, manifest.configuration.content.multi_file.output.solutions)
 
-        shutil.copytree(solutions_src, solutions_dst, dirs_exist_ok=True)
+        _copy_new_or_modified_files(solutions_src, solutions_dst, src, exclusion_dirs)
     else:
-        if stdout_output:
+        if bool(stdout_output):
             with open(os.path.join(solutions_dst, DEFAULT_OUTPUT_JSON_FILE), "w") as f:
-                json.dump(stdout_output, f, indent=2)
+                if isinstance(stdout_output, dict):
+                    json.dump(stdout_output, f, indent=2)
+                elif isinstance(stdout_output, str):
+                    f.write(stdout_output)
 
     # Update the run information file with the output size and type.
     calculate_files_size(run_dir, run_id, solutions_dst, metadata_key="output_size")
@@ -669,14 +719,15 @@ def process_run_solutions(
 def process_run_visuals(run_dir: str, outputs_dir: str) -> None:
     """
     Processes the visuals from the assets in the run output. This function looks
-    for Plotly assets and generates HTML files for each visual.
+    for visual assets (Plotly and GeoJSON) in the assets.json file and generates
+    HTML files for each visual. ChartJS visuals are ignored for local runs.
 
     Parameters
     ----------
     run_dir : str
-        The path to the run directory.
+        The path to the run directory where visuals will be stored.
     outputs_dir : str
-        The path to the outputs directory in the run directory.
+        The path to the outputs directory in the run directory containing assets.
     """
 
     # Get the assets.
@@ -710,5 +761,265 @@ def process_run_visuals(run_dir: str, outputs_dir: str) -> None:
         # so we ignore it for now.
 
 
+def resolve_stdout(result: subprocess.CompletedProcess[str]) -> Union[str, dict[str, Any]]:
+    """
+    Resolves the stdout output of the subprocess run. If the stdout is valid
+    JSON, it returns the parsed dictionary. Otherwise, it returns the raw
+    string output.
+
+    Parameters
+    ----------
+    result : subprocess.CompletedProcess[str]
+        The result of the subprocess run.
+
+    Returns
+    -------
+    Union[str, dict[str, Any]]
+        The parsed stdout output as a dictionary if valid JSON, otherwise the
+        raw string output.
+    """
+    raw_output = result.stdout
+    if raw_output.strip() == "":
+        return ""
+
+    try:
+        return json.loads(raw_output)
+    except json.JSONDecodeError:
+        return raw_output
+
+
+def ignore_patterns(dir_path: str, names: list[str]) -> list[str]:
+    """
+    Custom ignore function for copytree that filters files and directories
+    during source code copying. Excludes virtual environments, cache files,
+    the nextmv directory, and non-essential files while preserving Python
+    source files and application manifests.
+
+    Parameters
+    ----------
+    dir_path : str
+        The path to the directory being processed.
+    names : list[str]
+        A list of file and directory names in the current directory.
+
+    Returns
+    -------
+    list[str]
+        A list of names to ignore during the copy operation.
+    """
+    ignored = []
+    for name in names:
+        full_path = os.path.join(dir_path, name)
+
+        # Ignore nextmv directory
+        if name == NEXTMV_DIR:
+            ignored.append(name)
+            continue
+
+        # Ignore virtual environment directories
+        if name in ("venv", ".venv", "env", ".env", "virtualenv", ".virtualenv"):
+            ignored.append(name)
+            continue
+
+        # Ignore __pycache__ directories
+        if name == "__pycache__":
+            ignored.append(name)
+            continue
+
+        # If it's a file, only keep Python files and app.yaml
+        if os.path.isfile(full_path):
+            if not (name.endswith(".py") or name == "app.yaml"):
+                ignored.append(name)
+                continue
+
+        # Ignore .pyc files explicitly
+        if name.endswith(".pyc"):
+            ignored.append(name)
+            continue
+
+    return ignored
+
+
+def _build_exclusion_directories(src: str, manifest: Manifest, outputs_dir: str, run_dir: str) -> list[str]:
+    """
+    Build a list of directories to exclude when copying solution files.
+
+    Parameters
+    ----------
+    src : str
+        The path to the original application source code.
+    manifest : Manifest
+        The application manifest containing configuration.
+    outputs_dir : str
+        The path to the outputs directory in the run directory.
+    run_dir : str
+        The path to the run directory.
+
+    Returns
+    -------
+    list[str]
+        List of directory paths to exclude from copying.
+    """
+    exclusion_dirs = []
+
+    # Add inputs directory from original source
+    inputs_dir_original = os.path.join(src, INPUTS_KEY)
+    if os.path.exists(inputs_dir_original):
+        exclusion_dirs.append(inputs_dir_original)
+
+    # Add custom inputs directory if specified in manifest
+    if (
+        manifest.configuration is not None
+        and manifest.configuration.content is not None
+        and manifest.configuration.content.format == InputFormat.MULTI_FILE
+        and manifest.configuration.content.multi_file is not None
+    ):
+        custom_inputs_dir = os.path.join(src, manifest.configuration.content.multi_file.input.path)
+        if os.path.exists(custom_inputs_dir):
+            exclusion_dirs.append(custom_inputs_dir)
+
+    # Add inputs directory from run directory
+    inputs_dir_run = os.path.join(run_dir, INPUTS_KEY)
+    if os.path.exists(inputs_dir_run):
+        exclusion_dirs.append(inputs_dir_run)
+
+    # Add statistics and assets directories from run outputs
+    stats_dir = os.path.join(outputs_dir, STATISTICS_KEY)
+    if os.path.exists(stats_dir):
+        exclusion_dirs.append(stats_dir)
+
+    assets_dir = os.path.join(outputs_dir, ASSETS_KEY)
+    if os.path.exists(assets_dir):
+        exclusion_dirs.append(assets_dir)
+
+    return exclusion_dirs
+
+
+def _copy_new_or_modified_files(
+    src_dir: str, dst_dir: str, original_src_dir: Optional[str] = None, exclusion_dirs: Optional[list[str]] = None
+) -> None:
+    """
+    Copy files from source to destination only if they meet specific criteria.
+
+    This function ensures that only files that are either:
+    1. New files (not present in destination)
+    2. Existing files with different content (based on checksum comparison)
+    3. Files that are NOT present in the original source directory (if provided)
+    4. Files that are NOT present in any of the exclusion directories (if provided)
+
+    Parameters
+    ----------
+    src_dir : str
+        The source directory path to copy from.
+    dst_dir : str
+        The destination directory path to copy to.
+    original_src_dir : Optional[str], optional
+        The original source directory to check against. Files present in this
+        directory will NOT be copied, by default None.
+    exclusion_dirs : Optional[list[str]], optional
+        Additional directories to check against. Files present in any of these
+        directories will NOT be copied, by default None.
+    """
+    # Build list of all exclusion directories
+    exclusion_directories = []
+    if original_src_dir is not None:
+        exclusion_directories.append(original_src_dir)
+    if exclusion_dirs is not None:
+        exclusion_directories.extend(exclusion_dirs)
+
+    for root, _dirs, files in os.walk(src_dir):
+        rel_root = os.path.relpath(root, src_dir)
+        dst_root = dst_dir if rel_root == "." else os.path.join(dst_dir, rel_root)
+        os.makedirs(dst_root, exist_ok=True)
+
+        for file in files:
+            # Skip if file exists in any exclusion directory
+            if exclusion_directories and _file_exists_in_exclusion_dirs(file, rel_root, exclusion_directories):
+                continue
+
+            src_file = os.path.join(root, file)
+            dst_file = os.path.join(dst_root, file)
+
+            if _should_copy_file(src_file, dst_file):
+                shutil.copy2(src_file, dst_file)
+
+
+def _should_copy_file(src_file: str, dst_file: str) -> bool:
+    """
+    Determine if a file should be copied based on existence and content.
+
+    Parameters
+    ----------
+    src_file : str
+        Path to the source file.
+    dst_file : str
+        Path to the destination file.
+
+    Returns
+    -------
+    bool
+        True if the file should be copied, False otherwise.
+    """
+    if not os.path.exists(dst_file):
+        return True
+
+    try:
+        src_checksum = _calculate_file_checksum(src_file)
+        dst_checksum = _calculate_file_checksum(dst_file)
+        return src_checksum != dst_checksum
+    except OSError:
+        return True
+
+
+def _calculate_file_checksum(file_path: str) -> str:
+    """
+    Calculate MD5 checksum of a file.
+
+    Parameters
+    ----------
+    file_path : str
+        The path to the file.
+
+    Returns
+    -------
+    str
+        The MD5 checksum of the file.
+    """
+    hash_md5 = hashlib.md5()
+    with open(file_path, "rb") as f:
+        for chunk in iter(lambda: f.read(4096), b""):
+            hash_md5.update(chunk)
+    return hash_md5.hexdigest()
+
+
+def _file_exists_in_exclusion_dirs(file_name: str, rel_root: str, exclusion_dirs: list[str]) -> bool:
+    """
+    Check if a file exists in any of the exclusion directories.
+
+    Parameters
+    ----------
+    file_name : str
+        The name of the file to check.
+    rel_root : str
+        The relative root path from the source directory.
+    exclusion_dirs : list[str]
+        List of directories to check against.
+
+    Returns
+    -------
+    bool
+        True if the file exists in any exclusion directory, False otherwise.
+    """
+    for exclusion_dir in exclusion_dirs:
+        if rel_root != ".":
+            exclusion_file = os.path.join(exclusion_dir, rel_root, file_name)
+        else:
+            exclusion_file = os.path.join(exclusion_dir, file_name)
+
+        if os.path.exists(exclusion_file):
+            return True
+    return False
+
+
 if __name__ == "__main__":
     main()

nextmv/local/local.py

@@ -36,7 +36,7 @@ LOGS_KEY = "logs"
 """
 Logs key constant used for identifying logs in the run output.
 """
-LOGS_FILE = "stderr.log"
+LOGS_FILE = "logs.log"
 """
 Constant used for identifying the file used for logging.
 """

nextmv/run.py

@@ -52,7 +52,7 @@ from pydantic import AliasChoices, Field, field_validator
 from nextmv._serialization import serialize_json
 from nextmv.base_model import BaseModel
 from nextmv.input import Input, InputFormat
-from nextmv.output import Output, OutputFormat
+from nextmv.output import Asset, Output, OutputFormat, Statistics
 from nextmv.status import Status, StatusV2
 
 
@@ -687,6 +687,56 @@ class Metadata(BaseModel):
     """Deprecated: use status_v2."""
 
 
+class SyncedRun(BaseModel):
+    """
+    Information about a run that has been synced to a remote application.
+
+    You can import the `SyncedRun` class directly from `nextmv`:
+
+    ```python
+    from nextmv import SyncedRun
+    ```
+
+    Parameters
+    ----------
+    run_id : str
+        ID of the synced remote run. When the `Application.sync` method is
+        used, this field marks the association between the local run (`id`) and
+        the remote run (`synced_run.id`).
+    synced_at : datetime
+        Timestamp when the run was synced with the remote run.
+    app_id : str
+        The ID of the remote application that the local run was synced to.
+    instance_id : Optional[str], optional
+        The instance of the remote application that the local run was synced
+        to. This field is optional and may be None. If it is not specified, it
+        indicates that the run was synced against the default instance of the
+        app. Defaults to None.
+    """
+
+    run_id: str
+    """
+    ID of the synced remote run. When the `Application.sync` method is used,
+    this field marks the association between the local run (`id`) and the
+    remote run (`synced_run.id`)
+    """
+    synced_at: datetime
+    """
+    Timestamp when the run was synced with the remote run.
+    """
+    app_id: str
+    """
+    The ID of the remote application that the local run was synced to.
+    """
+
+    instance_id: Optional[str] = None
+    """
+    The instance of the remote application that the local run was synced to.
+    This field is optional and may be None. If it is not specified, it
+    indicates that the run was synced against the default instance of the app.
+    """
+
+
 class RunInformation(BaseModel):
     """
     Information of a run.
@@ -727,19 +777,18 @@ class RunInformation(BaseModel):
     """
     URL to the run in the Nextmv console.
     """
-    synced_run_id: Optional[str] = None
-    """
-    ID of the synced remote run, if applicable. When the `Application.sync`
-    method is used, this field marks the association between the local run
-    (`id`) and the remote run (`synced_run_id`). This field is None if the run
-    was not created using `Application.sync` or if the run has not been synced
-    yet.
+    synced_runs: Optional[list[SyncedRun]] = None
     """
-    synced_at: Optional[datetime] = None
-    """
-    Timestamp when the run was synced with the remote run. This field is
-    None if the run was not created using `Application.sync` or if the run
-    has not been synced yet.
+    List of synced runs associated with this run, if applicable. When the
+    `Application.sync` method is used, this field contains the associations
+    between the local run (`id`) and the remote runs (`synced_run.id`). This
+    field is None if the run was not created using `Application.sync` or if the
+    run has not been synced yet. It is possible to sync a single local run to
+    multiple remote runs. A remote run is identified by its application ID and
+    instance (if applicable). A local run cannot be synced to a remote run if
+    it is already present, this is, if there exists a record in the list with
+    the same application ID and instance. If there is not a repeated remote
+    run, a new record is added to the list.
     """
 
     def to_run(self) -> Run:
@@ -817,6 +866,83 @@ class RunInformation(BaseModel):
             input_set_id=None,
         )
 
+    def add_synced_run(self, synced_run: SyncedRun) -> bool:
+        """
+        Add a synced run to the RunInformation.
+
+        This method adds a `SyncedRun` instance to the list of synced runs
+        associated with this `RunInformation`. If the list is None, it
+        initializes it first. If the run has already been synced, then it is
+        not added to the list. A run is already synced if there exists a record
+        in the list with the same application ID. This method returns True if
+        the synced run was added, and False otherwise.
+
+        Parameters
+        ----------
+        synced_run : SyncedRun
+            The SyncedRun instance to add.
+
+        Returns
+        -------
+        bool
+            True if the synced run was added, False if it was already present.
+        """
+
+        if self.synced_runs is None:
+            self.synced_runs = [synced_run]
+
+            return True
+
+        if synced_run.instance_id is None:
+            for existing_run in self.synced_runs:
+                if existing_run.app_id == synced_run.app_id:
+                    return False
+        else:
+            for existing_run in self.synced_runs:
+                if existing_run.app_id == synced_run.app_id and existing_run.instance_id == synced_run.instance_id:
+                    return False
+
+        self.synced_runs.append(synced_run)
+
+        return True
+
+    def is_synced(self, app_id: str, instance_id: Optional[str] = None) -> tuple[SyncedRun, bool]:
+        """
+        Check if the run has been synced to a specific application and instance.
+
+        This method checks if there exists a `SyncedRun` in the list of synced
+        runs that matches the given application ID and optional instance ID.
+
+        Parameters
+        ----------
+        app_id : str
+            The application ID to check.
+        instance_id : Optional[str], optional
+            The instance ID to check. If None, only the application ID is
+            considered. Defaults to None.
+
+        Returns
+        -------
+        tuple[SyncedRun, bool]
+            A tuple containing the SyncedRun instance if found, and a boolean
+            indicating whether the run has been synced to the specified
+            application and instance.
+        """
+
+        if self.synced_runs is None:
+            return None, False
+
+        if instance_id is None:
+            for existing_run in self.synced_runs:
+                if existing_run.app_id == app_id:
+                    return existing_run, True
+        else:
+            for existing_run in self.synced_runs:
+                if existing_run.app_id == app_id and existing_run.instance_id == instance_id:
+                    return existing_run, True
+
+        return None, False
+
 
 class ErrorLog(BaseModel):
     """
@@ -1154,6 +1280,16 @@ class ExternalRunResult(BaseModel):
     """Error message of the run."""
     execution_duration: Optional[int] = None
     """Duration of the run, in milliseconds."""
+    statistics_upload_id: Optional[str] = None
+    """
+    ID of the statistics upload. Use this field when working with `CSV_ARCHIVE`
+    or `MULTI_FILE` output formats.
+    """
+    assets_upload_id: Optional[str] = None
+    """
+    ID of the assets upload. Use this field when working with `CSV_ARCHIVE`
+    or `MULTI_FILE` output formats.
+    """
 
     def __post_init_post_parse__(self):
         """
@@ -1265,6 +1401,18 @@ class TrackedRun:
         when working with `CSV_ARCHIVE` or `MULTI_FILE`. If both `output` and
         `output_dir_path` are specified, the `output` is ignored, and the files
         are saved in the directory instead. Defaults to None.
+    statistics : Statistics or dict[str, Any], optional
+        Statistics of the run being tracked. Only use this field if you want to
+        track statistics for `CSV_ARCHIVE` or `MULTI_FILE` output formats. If you
+        are working with `JSON` or `TEXT` output formats, this field will be
+        ignored, as the statistics are extracted directly from the `output`.
+        This field is optional. Defaults to None.
+    assets : list[Asset or dict[str, Any]], optional
+        Assets associated with the run being tracked. Only use this field if you
+        want to track assets for `CSV_ARCHIVE` or `MULTI_FILE` output formats.
+        If you are working with `JSON` or `TEXT` output formats, this field will
+        be ignored, as the assets are extracted directly from the `output`.
+        This field is optional. Defaults to None.
 
     Examples
     --------
@@ -1365,6 +1513,20 @@ class TrackedRun:
     `output_dir_path` are specified, the `output` is ignored, and the files
     are saved in the directory instead.
     """
+    statistics: Optional[Union[Statistics, dict[str, Any]]] = None
+    """
+    Statistics of the run being tracked. Only use this field if you want to
+    track statistics for `CSV_ARCHIVE` or `MULTI_FILE` output formats. If you
+    are working with `JSON` or `TEXT` output formats, this field will be
+    ignored, as the statistics are extracted directly from the `output`.
+    """
+    assets: Optional[list[Union[Asset, dict[str, Any]]]] = None
+    """
+    Assets associated with the run being tracked. Only use this field if you
+    want to track assets for `CSV_ARCHIVE` or `MULTI_FILE` output formats.
+    If you are working with `JSON` or `TEXT` output formats, this field will
+    be ignored, as the assets are extracted directly from the `output`.
+    """
 
     def __post_init__(self):  # noqa: C901
         """

{nextmv-0.33.0.dist-info → nextmv-0.34.0.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextmv
-Version: 0.33.0
+Version: 0.34.0.dev0
 Summary: The all-purpose Python SDK for Nextmv
 Project-URL: Homepage, https://www.nextmv.io
 Project-URL: Documentation, https://nextmv-py.docs.nextmv.io/en/latest/nextmv/

{nextmv-0.33.0.dist-info → nextmv-0.34.0.dev0.dist-info}/RECORD

@@ -1,6 +1,6 @@
-nextmv/__about__.py,sha256=VyKoqs7qvl1UtyON_wE484wOoQ1-D2LWfsRhOrha9gg,24
+nextmv/__about__.py,sha256=IEH4q3YZ3NJ8xLBOPvbdmzjvZQSBu6mlVa0ZYNf6FZ0,29
 nextmv/__entrypoint__.py,sha256=dA0iwwHtrq6Z9w9FxmxKLoBGLyhe7jWtUAU-Y3PEgHg,1094
-nextmv/__init__.py,sha256=uM80mRRs2Ht2dP60DvxR11HmunFJ7EL7XUJHtKQi2qI,3683
+nextmv/__init__.py,sha256=GYzXp81KEteniXZkNZ9IgLYnJNOBOQckOeGpTkxjjD4,3723
 nextmv/_serialization.py,sha256=JlSl6BL0M2Esf7F89GsGIZ__Pp8RnFRNM0UxYhuuYU4,2853
 nextmv/base_model.py,sha256=qmJ4AsYr9Yv01HQX_BERrn3229gyoZrYyP9tcyqNfeU,2311
 nextmv/deprecated.py,sha256=kEVfyQ-nT0v2ePXTNldjQG9uH5IlfQVy3L4tztIxwmU,1638
@@ -11,13 +11,13 @@ nextmv/model.py,sha256=vI3pSV3iTwjRPflar7nAg-6h98XRUyi9II5O2J06-Kc,15018
 nextmv/options.py,sha256=yPJu5lYMbV6YioMwAXv7ctpZUggLXKlZc9CqIbUFvE4,37895
 nextmv/output.py,sha256=HdvWYG3gIzwoXquulaEVI4LLchXJDjkbag0BkBPM0vQ,55128
 nextmv/polling.py,sha256=nfefvWI1smm-lIzaXE-4DMlojp6KXIvVi88XLJYUmo8,9724
-nextmv/run.py,sha256=lAWWkLml1C7wkXSvN8orBjudoz72Qv5ZCHCWY9e7xaY,45813
+nextmv/run.py,sha256=8B9hh-jWJpoMSJiDmgmXaqvmzTicWCn75UTJu7Nf7Cs,52401
 nextmv/safe.py,sha256=VAK4fGEurbLNji4Pg5Okga5XQSbI4aI9JJf95_68Z20,3867
 nextmv/status.py,sha256=SCDLhh2om3yeO5FxO0x-_RShQsZNXEpjHNdCGdb3VUI,2787
 nextmv/cloud/__init__.py,sha256=2wI72lhWq81BYv1OpS0OOTT5-3sivpX0H4z5ANPoLMc,5051
 nextmv/cloud/acceptance_test.py,sha256=ZEzCMrfJF-nUFr1nEr4IDgcoyavPhnanjFuPBJ79tAk,27731
 nextmv/cloud/account.py,sha256=jIdGNyI3l3dVh2PuriAwAOrEuWRM150WgzxcBMVBNRw,6058
-nextmv/cloud/application.py,sha256=zbirm_bbihnzhKsO8gAO_dJRAJV4FtXsQsSaismgt-I,139298
+nextmv/cloud/application.py,sha256=oUpw6I1r4u9Cn0pnlylWlm23hPgZKsg_vnBXbqTtU-w,139693
 nextmv/cloud/batch_experiment.py,sha256=13ciRpgBabMMTyazfdfEAymD3rTPrTAAorECsANxxuA,10397
 nextmv/cloud/client.py,sha256=E0DiUb377jvEnpXlRnfT1PGCI0Jm0lTUoX5VqeU91lk,18165
 nextmv/cloud/ensemble.py,sha256=glrRgyRFcEH12fNUhEl1FOo6xOTDEaF478dxfX0wj2Y,8604
@@ -38,13 +38,13 @@ nextmv/default_app/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 nextmv/default_app/src/main.py,sha256=WWeN_xl_mcPhICl3rSCvdEjRkFXGmAnej88FhS-fAmc,884
 nextmv/default_app/src/visuals.py,sha256=WYK_YBnLmYo3TpVev1CpoNCuW5R7hk9QIkeCmvMn1Fs,1014
 nextmv/local/__init__.py,sha256=6BsoqlK4dw6X11_uKzz9gBPfxKpdiol2FYO8R3X73SE,116
-nextmv/local/application.py,sha256=qq14ihKxymg5NHqhU56qTu6lVmMYWLGYUJC4MrhWB68,45815
-nextmv/local/executor.py,sha256=ohAUrIRohcH_qGglK1hSFR0W6bPBSuMAcMwVkW5G4vM,24338
+nextmv/local/application.py,sha256=dupLPPJ0JkMsTI-7-OoPz9JCRboJyxWy6iO3SPKdA1o,46514
+nextmv/local/executor.py,sha256=Num-VdI5rRecI1XDz__YtW7U2q02ulbwMfWxlhhzwU8,35202
 nextmv/local/geojson_handler.py,sha256=7FavJdkUonop-yskjis0x3qFGB8A5wZyoBUblw-bVhw,12540
-nextmv/local/local.py,sha256=wUHuoAXqJIZpTJBh056hmQuiPEjlZvLTR2BC6Ino-WI,2619
+nextmv/local/local.py,sha256=cp56UpI8h19Ob6Jvb_Ni0ceXH5Vv3ET_iPTDe6ftq3Y,2617
 nextmv/local/plotly_handler.py,sha256=bLb50e3AkVr_W-F6S7lXfeRdN60mG2jk3UElNmhoMWU,1930
 nextmv/local/runner.py,sha256=hwkITHrQG_J9TzxufnaP1mjLWG-iSsNQD66UFZY4pp4,8602
-nextmv-0.33.0.dist-info/METADATA,sha256=JRt0lALKQ1i0E_J2AhgozeUtC7kv_YGHsqK_-VDePsw,16008
-nextmv-0.33.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-nextmv-0.33.0.dist-info/licenses/LICENSE,sha256=ZIbK-sSWA-OZprjNbmJAglYRtl5_K4l9UwAV3PGJAPc,11349
-nextmv-0.33.0.dist-info/RECORD,,
+nextmv-0.34.0.dev0.dist-info/METADATA,sha256=lqIIWxNBN6AfvZ_Nw8hmkTyxM1lOhVQ2nvm--xoPML8,16013
+nextmv-0.34.0.dev0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+nextmv-0.34.0.dev0.dist-info/licenses/LICENSE,sha256=ZIbK-sSWA-OZprjNbmJAglYRtl5_K4l9UwAV3PGJAPc,11349
+nextmv-0.34.0.dev0.dist-info/RECORD,,