nextmv 0.34.0.dev3__py3-none-any.whl → 0.34.1__py3-none-any.whl

nextmv/__about__.py

@@ -1 +1 @@
-__version__ = "v0.34.0.dev3"
+__version__ = "v0.34.1"

nextmv/local/application.py

@@ -892,9 +892,6 @@ class Application:
         Auxiliary function to validate the directory path and configuration.
         """
 
-        if input_dir_path is None or input_dir_path == "":
-            return
-
         if configuration is None:
             if self.manifest.configuration is not None and self.manifest.configuration.content is not None:
                 configuration = RunConfiguration(
@@ -904,18 +901,21 @@ class Application:
                         ),
                     ),
                 )
-            else:
-                raise ValueError(
-                    "If `dir_path` is provided, either a `RunConfiguration` must also be provided or "
-                    "the application's manifest (app.yaml) must include the format under "
-                    "`configuration.content.format`.",
-                )
-
-        # Forcefully turn the configuration into a RunConfiguration object to
-        # make it easier to deal with in the other functions.
-        if isinstance(configuration, dict):
+        elif isinstance(configuration, dict):
+            # Forcefully turn the configuration into a RunConfiguration object to
+            # make it easier to deal with in the other functions.
             configuration = RunConfiguration.from_dict(configuration)
 
+        if input_dir_path is None or input_dir_path == "":
+            return configuration
+
+        if configuration is None:
+            raise ValueError(
+                "If `dir_path` is provided, either a `RunConfiguration` must also be provided or "
+                "the application's manifest (app.yaml) must include the format under "
+                "`configuration.content.format`.",
+            )
+
         config_format = configuration.format
         if config_format is None:
             raise ValueError(

nextmv/local/executor.py

@@ -32,13 +32,12 @@ 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 re
 import shutil
 import subprocess
 import sys
@@ -129,7 +128,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=ignore_patterns)
+            shutil.copytree(src, temp_src, ignore=_ignore_patterns)
 
             manifest = Manifest.from_dict(manifest_dict)
 
@@ -353,7 +352,6 @@ 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,
@@ -361,7 +359,6 @@ def process_run_output(
         stdout_output=stdout_output,
         temp_src=temp_src,
         manifest=manifest,
-        src=src,
     )
     process_run_solutions(
         run_id=run_id,
@@ -508,7 +505,6 @@ def process_run_statistics(
     stdout_output: Union[str, dict[str, Any]],
     temp_src: str,
     manifest: Manifest,
-    src: str,
 ) -> None:
     """
     Processes the statistics of the run. Checks for an outputs/statistics folder
@@ -527,9 +523,6 @@ def process_run_statistics(
         The path to the temporary source directory.
     manifest : 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)
@@ -553,7 +546,7 @@ 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):
-        _copy_new_or_modified_files(stats_src, stats_dst, src)
+        shutil.copytree(stats_src, stats_dst, dirs_exist_ok=True)
         return
 
     if not isinstance(stdout_output, dict):
@@ -573,7 +566,6 @@ def process_run_assets(
     stdout_output: Union[str, dict[str, Any]],
     temp_src: str,
     manifest: Manifest,
-    src: str,
 ) -> None:
     """
     Processes the assets of the run. Checks for an outputs/assets folder or
@@ -592,9 +584,6 @@ def process_run_assets(
         The path to the temporary source directory.
     manifest : 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)
@@ -618,7 +607,7 @@ 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):
-        _copy_new_or_modified_files(assets_src, assets_dst, src)
+        shutil.copytree(assets_src, assets_dst, dirs_exist_ok=True)
         return
 
     if not isinstance(stdout_output, dict):
@@ -684,12 +673,9 @@ 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)
-        _copy_new_or_modified_files(output_src, solutions_dst, src, exclusion_dirs)
+        shutil.copytree(output_src, solutions_dst, dirs_exist_ok=True)
     elif output_format == OutputFormat.MULTI_FILE:
         solutions_src = os.path.join(temp_run_outputs_dir, SOLUTIONS_KEY)
         if (
@@ -700,7 +686,16 @@ def process_run_solutions(
         ):
             solutions_src = os.path.join(temp_src, manifest.configuration.content.multi_file.output.solutions)
 
-        _copy_new_or_modified_files(solutions_src, solutions_dst, src, exclusion_dirs)
+        _copy_new_or_modified_files(
+            runtime_dir=solutions_src,
+            dst_dir=solutions_dst,
+            original_src_dir=src,
+            exclusion_dirs=[
+                os.path.join(outputs_dir, STATISTICS_KEY),
+                os.path.join(outputs_dir, ASSETS_KEY),
+                os.path.join(run_dir, INPUTS_KEY),
+            ],
+        )
     else:
         if bool(stdout_output):
             with open(os.path.join(solutions_dst, DEFAULT_OUTPUT_JSON_FILE), "w") as f:
@@ -788,7 +783,7 @@ def resolve_stdout(result: subprocess.CompletedProcess[str]) -> Union[str, dict[
         return raw_output
 
 
-def ignore_patterns(dir_path: str, names: list[str]) -> list[str]:
+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,
@@ -817,7 +812,7 @@ def ignore_patterns(dir_path: str, names: list[str]) -> list[str]:
             continue
 
         # Ignore virtual environment directories
-        if name in ("venv", ".venv", "env", ".env", "virtualenv", ".virtualenv"):
+        if re.match(r"^\.?(venv|env|virtualenv).*$", name):
             ignored.append(name)
             continue
 
@@ -840,123 +835,127 @@ def ignore_patterns(dir_path: str, names: list[str]) -> list[str]:
     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
+def _copy_new_or_modified_files(  # noqa: C901
+    runtime_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.
+    Copy only new or modified files from runtime directory to destination directory.
 
-    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)
-
-    Empty directories are not created or are removed after copying to avoid
-    cluttering the output with empty folders.
+    This function identifies files that are either new (not present in the original
+    source) or have been modified (different content, checksum, or modification time)
+    compared to the original source. It excludes files that exist in specified
+    exclusion directories to avoid copying input data, statistics, or assets as
+    solution outputs.
 
     Parameters
     ----------
-    src_dir : str
-        The source directory path to copy from.
+    runtime_dir : str
+        The path to the runtime directory containing files to potentially copy.
     dst_dir : str
-        The destination directory path to copy to.
+        The destination directory where new or modified files will be copied.
     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.
+        The path to the original source directory for comparison, by default None.
+        If None, all files from runtime_dir are considered new.
     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 = []
+        List of directory paths containing files to exclude from copying,
+        by default None. Files matching those in exclusion directories will
+        not be copied even if they are new or modified.
+    """
+
+    # Gather a list of the files that are created/modified in the runtime dir,
+    # this is, the directory where the actual executable code is run from.
+    runtime_files_rel = []
+    runtime_files_abs = []
+    for root, _, files in os.walk(runtime_dir):
+        # Skip __pycache__ directories
+        if "__pycache__" in root:
+            continue
+
+        for rel_file in files:
+            # Skip .pyc files
+            if rel_file.endswith(".pyc"):
+                continue
+
+            file_path = os.path.join(root, rel_file)
+            runtime_files_rel.append(os.path.relpath(file_path, runtime_dir))
+            runtime_files_abs.append(file_path)
+
+    # Gather a list of the files that exist in the original source dir. Given
+    # that the source dir is copied to the runtime dir before execution, we can
+    # use this to determine which files are new or modified.
+    original_src_files_rel = set()
     if original_src_dir is not None:
-        exclusion_directories.append(original_src_dir)
+        for root, _, files in os.walk(original_src_dir):
+            for rel_file in files:
+                file_path = os.path.join(root, rel_file)
+                original_src_files_rel.add(os.path.relpath(file_path, original_src_dir))
+
+    # Gather a list of the files that exist in the exclusion dirs. This is used
+    # to avoid copying files that are part of this special exclusion set.
+    exclusion_files_rel = set()
     if exclusion_dirs is not None:
-        exclusion_directories.extend(exclusion_dirs)
+        for exclusion_dir in exclusion_dirs:
+            for root, _, files in os.walk(exclusion_dir):
+                for rel_file in files:
+                    file_path = os.path.join(root, rel_file)
+                    exclusion_files_rel.add(os.path.relpath(file_path, exclusion_dir))
+
+    # Now we filter the runtime files to only keep those that are new or
+    # modified compared to the original source files.
+    files_before_exclusion = []
+    for ix, rel_file in enumerate(runtime_files_rel):
+        abs_file = runtime_files_abs[ix]
+
+        # If the file is net new, we keep it.
+        if rel_file not in original_src_files_rel:
+            files_before_exclusion.append(abs_file)
+            continue
+
+        # If content of the file is different, we keep it.
+        runtime_checksum = _calculate_file_checksum(abs_file)
+        original_abs_file = os.path.join(original_src_dir, rel_file)
+        original_checksum = _calculate_file_checksum(original_abs_file)
+        if runtime_checksum != original_checksum:
+            files_before_exclusion.append(abs_file)
+            continue
 
-    files_copied = False
-    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)
+        # If content of the file is the same, but the date is newer, we keep it.
+        src_mtime = os.path.getmtime(abs_file)
+        original_mtime = os.path.getmtime(original_abs_file)
+        if src_mtime > original_mtime:
+            files_before_exclusion.append(abs_file)
+            continue
 
-        files_to_copy = []
-        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):
+    # Now we filter out any files that are part of the exclusion set.
+    final_files = []
+    if exclusion_dirs is not None:
+        for file in files_before_exclusion:
+            rel_file = os.path.relpath(file, runtime_dir)
+            if rel_file in exclusion_files_rel:
                 continue
 
-            src_file = os.path.join(root, file)
-            dst_file = os.path.join(dst_root, file)
+            final_files.append(file)
+    else:
+        final_files = files_before_exclusion
+
+    # Now that we have a clean list of files that we are going to copy, we
+    # proceed to copy them over to the destination directory.
+    for file in final_files:
+        rel_file = os.path.relpath(file, runtime_dir)
+        dst_file = os.path.join(dst_dir, rel_file)
 
-            if _should_copy_file(src_file, dst_file):
-                files_to_copy.append((src_file, dst_file))
+        # Create the directory structure if it doesn't exist
+        dst_file_dir = os.path.dirname(dst_file)
+        os.makedirs(dst_file_dir, exist_ok=True)
 
-        # Only create directory if there are files to copy
-        if files_to_copy:
-            os.makedirs(dst_root, exist_ok=True)
-            for src_file, dst_file in files_to_copy:
-                shutil.copy2(src_file, dst_file)
-                files_copied = True
+        # Copy the file
+        shutil.copy2(file, dst_file)
 
-    # Clean up empty directories after copying
-    if files_copied:
-        _remove_empty_directories(dst_dir)
+    # Finally, we remove any empty directories that might have been created.
+    _remove_empty_directories(dst_dir)
 
 
 def _remove_empty_directories(directory: str) -> None:
@@ -986,33 +985,6 @@ def _remove_empty_directories(directory: str) -> None:
                 pass
 
 
-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.
@@ -1034,34 +1006,5 @@ def _calculate_file_checksum(file_path: str) -> str:
     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/manifest.py

@@ -11,6 +11,8 @@ ManifestType
     Enum for application types based on programming language.
 ManifestRuntime
     Enum for runtime environments where apps run on Nextmv.
+ManifestPythonArch
+    Enum for target architecture for bundling Python apps.
 ManifestBuild
     Class for build-specific attributes in the manifest.
 ManifestPythonModel
@@ -38,6 +40,11 @@ ManifestConfiguration
 Manifest
     Main class representing an app manifest for Nextmv.
 
+Functions
+---------
+default_python_manifest
+    Creates a default Python manifest as a starting point for applications.
+
 Constants
 --------
 MANIFEST_FILE_NAME
@@ -331,7 +338,7 @@ class ManifestPython(BaseModel):
 
     Parameters
     ----------
-    pip_requirements : Optional[str], default=None
+    pip_requirements : Optional[Union[str, list[str]]], default=None
         Path to a requirements.txt file containing (additional) Python
         dependencies that will be bundled with the app. Alternatively, you can provide a
         list of strings, each representing a package to install, e.g.,
@@ -358,10 +365,11 @@ class ManifestPython(BaseModel):
         default=None,
     )
     """
-    Path to a requirements.txt file.
+    Path to a requirements.txt file or list of packages.
 
     Contains (additional) Python dependencies that will be bundled with the
-    app.
+    app. Can be either a string path to a requirements.txt file or a list
+    of package specifications.
     """
     arch: Optional[ManifestPythonArch] = None
     """
@@ -383,6 +391,31 @@ class ManifestPython(BaseModel):
     @field_validator("version", mode="before")
     @classmethod
     def validate_version(cls, v: Optional[Union[str, float]]) -> Optional[str]:
+        """
+        Validate and convert the Python version field to a string.
+
+        This validator allows the version to be specified as either a float or string
+        in the manifest for convenience, but ensures it's stored internally as a string.
+
+        Parameters
+        ----------
+        v : Optional[Union[str, float]]
+            The version value to validate. Can be None, a string, or a float.
+
+        Returns
+        -------
+        Optional[str]
+            The version as a string, or None if the input was None.
+
+        Examples
+        --------
+        >>> ManifestPython.validate_version(3.11)
+        '3.11'
+        >>> ManifestPython.validate_version("3.11")
+        '3.11'
+        >>> ManifestPython.validate_version(None) is None
+        True
+        """
         # We allow the version to be a float in the manifest for convenience, but we want
         # to store it as a string internally.
         if v is None:
@@ -917,7 +950,23 @@ class ManifestContent(BaseModel):
     """Configuration for multi-file content format."""
 
     def model_post_init(self, __context) -> None:
-        """Post-initialization to validate fields."""
+        """
+        Post-initialization validation to ensure format field contains valid values.
+
+        This method is automatically called by Pydantic after the model is initialized
+        to validate that the format field contains one of the acceptable values.
+
+        Parameters
+        ----------
+        __context : Any
+            Pydantic context (unused in this implementation).
+
+        Raises
+        ------
+        ValueError
+            If the format field contains an invalid value that is not one of the
+            acceptable formats (JSON, MULTI_FILE, or CSV_ARCHIVE).
+        """
         acceptable_formats = [InputFormat.JSON, InputFormat.MULTI_FILE, InputFormat.CSV_ARCHIVE]
         if self.format not in acceptable_formats:
             raise ValueError(f"Invalid format: {self.format}. Must be one of {acceptable_formats}.")
@@ -1084,6 +1133,26 @@ class Manifest(BaseModel):
     """
 
     def model_post_init(self, __context) -> None:
+        """
+        Post-initialization to set default entrypoint based on runtime if not specified.
+
+        This method is automatically called by Pydantic after the model is initialized.
+        If no entrypoint is provided, it sets a default entrypoint based on the runtime:
+        - Python runtimes (PYTHON, HEXALY, PYOMO, CUOPT): "./main.py"
+        - DEFAULT runtime: "./main"
+        - JAVA runtime: "./main.jar"
+
+        Parameters
+        ----------
+        __context : Any
+            Pydantic context (unused in this implementation).
+
+        Raises
+        ------
+        ValueError
+            If no entrypoint is provided and the runtime cannot be resolved to
+            establish a default entrypoint.
+        """
         if self.entrypoint is None:
             if self.runtime in (
                 ManifestRuntime.PYTHON,

nextmv/run.py

@@ -682,9 +682,10 @@ class Metadata(BaseModel):
     """Format of the input and output of the run."""
     status_v2: StatusV2
     """Status of the run."""
-
     status: Optional[Status] = None
     """Deprecated: use status_v2."""
+    statistics: Optional[dict[str, Any]] = None
+    """User defined statistics of the run."""
 
 
 class SyncedRun(BaseModel):
@@ -1560,9 +1561,9 @@ class TrackedRun:
 
         if isinstance(self.output, Output):
             try:
-                _ = serialize_json(self.output.data)
+                _ = serialize_json(self.output.solution)
             except (TypeError, OverflowError) as e:
-                raise ValueError("Output.data is not JSON serializable") from e
+                raise ValueError("`Output.solution` is not JSON serializable") from e
         elif isinstance(self.output, dict):
             try:
                 _ = serialize_json(self.output)

{nextmv-0.34.0.dev3.dist-info → nextmv-0.34.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextmv
-Version: 0.34.0.dev3
+Version: 0.34.1
 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.34.0.dev3.dist-info → nextmv-0.34.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-nextmv/__about__.py,sha256=DsLmieJeEYDa6llfj0-ywyjDq25tl2JnmYHkfnN9tbY,29
+nextmv/__about__.py,sha256=EUse0zN7HR8nM-KxKO37c1BrPbYediyzvlZFeAsg5ng,24
 nextmv/__entrypoint__.py,sha256=dA0iwwHtrq6Z9w9FxmxKLoBGLyhe7jWtUAU-Y3PEgHg,1094
 nextmv/__init__.py,sha256=C2f8MteVvvOX1Wj-0GFjfUt-0RzCT0zpLpLI2yyZQw8,3796
 nextmv/_serialization.py,sha256=JlSl6BL0M2Esf7F89GsGIZ__Pp8RnFRNM0UxYhuuYU4,2853
@@ -6,12 +6,12 @@ nextmv/base_model.py,sha256=qmJ4AsYr9Yv01HQX_BERrn3229gyoZrYyP9tcyqNfeU,2311
 nextmv/deprecated.py,sha256=kEVfyQ-nT0v2ePXTNldjQG9uH5IlfQVy3L4tztIxwmU,1638
 nextmv/input.py,sha256=m9sVfO9ZL3F5i1l8amEtlWlbkekyUP4C3y9DduHWGFs,40211
 nextmv/logger.py,sha256=kNIbu46MisrzYe4T0hNMpWfRTKKacDVvbtQcNys_c_E,2513
-nextmv/manifest.py,sha256=N4Te82rKgcqzlXIpFGH-JX8JHDVW9sd7NoDvy9zZI6U,46859
+nextmv/manifest.py,sha256=vo4GJk2yF6-6cA1M5YrynlXKqupH2vQE7HByph6ne4k,49256
 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=8B9hh-jWJpoMSJiDmgmXaqvmzTicWCn75UTJu7Nf7Cs,52401
+nextmv/run.py,sha256=DcVM67ot961RDeuP-jFqNj0Xq4uxXIap_hRNIdCAT_I,52504
 nextmv/safe.py,sha256=VAK4fGEurbLNji4Pg5Okga5XQSbI4aI9JJf95_68Z20,3867
 nextmv/status.py,sha256=SCDLhh2om3yeO5FxO0x-_RShQsZNXEpjHNdCGdb3VUI,2787
 nextmv/cloud/__init__.py,sha256=2wI72lhWq81BYv1OpS0OOTT5-3sivpX0H4z5ANPoLMc,5051
@@ -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=ZANcQFa8x-hBeCAQmFRAVZcEUXRqnGOPYqmJLV5GdaE,46982
-nextmv/local/executor.py,sha256=7rxVkpyZ4GyTH7hjJX7rdM0hCo7_fSqX4EiA8YHZpC8,36624
+nextmv/local/application.py,sha256=yJDlbQB_mh29Y541Mt6a6zyT3XutdtzjqSd0mlOeteo,47002
+nextmv/local/executor.py,sha256=c0R6Pr2Lawx08YguxMydsXSGAc0PgMR3iTxpNnPpaqY,35459
 nextmv/local/geojson_handler.py,sha256=7FavJdkUonop-yskjis0x3qFGB8A5wZyoBUblw-bVhw,12540
 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.34.0.dev3.dist-info/METADATA,sha256=6K9eoJKvAufPITu_j0f0dlfMIMUNSKu0KEUcS_OJhk8,16013
-nextmv-0.34.0.dev3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-nextmv-0.34.0.dev3.dist-info/licenses/LICENSE,sha256=ZIbK-sSWA-OZprjNbmJAglYRtl5_K4l9UwAV3PGJAPc,11349
-nextmv-0.34.0.dev3.dist-info/RECORD,,
+nextmv-0.34.1.dist-info/METADATA,sha256=1f7yKaCgvQuaFl97AfIYo4xbI9ncWM5s1Z7xLwEIHfE,16008
+nextmv-0.34.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+nextmv-0.34.1.dist-info/licenses/LICENSE,sha256=ZIbK-sSWA-OZprjNbmJAglYRtl5_K4l9UwAV3PGJAPc,11349
+nextmv-0.34.1.dist-info/RECORD,,