nextmv 0.35.0__py3-none-any.whl → 0.35.0.dev1__py3-none-any.whl

nextmv/cloud/client.py

@@ -16,7 +16,7 @@ get_size(obj)
 
 import os
 from dataclasses import dataclass, field
-from typing import IO, Any
+from typing import IO, Any, Optional, Union
 from urllib.parse import urljoin
 
 import requests
@@ -98,7 +98,7 @@ class Client:
     >>> print(response.json())
     """
 
-    api_key: str | None = None
+    api_key: Optional[str] = None
     """API key to use for authenticating with the Nextmv Cloud API. If not
     provided, the client will look for the NEXTMV_API_KEY environment
     variable."""
@@ -117,7 +117,7 @@ class Client:
     seconds."""
     configuration_file: str = "~/.nextmv/config.yaml"
     """Path to the configuration file used by the Nextmv CLI."""
-    headers: dict[str, str] | None = None
+    headers: Optional[dict[str, str]] = None
     """Headers to use for requests to the Nextmv Cloud API."""
     max_retries: int = 10
     """Maximum number of retries to use for requests to the Nextmv Cloud
@@ -196,11 +196,11 @@ class Client:
         self,
         method: str,
         endpoint: str,
-        data: Any | None = None,
-        headers: dict[str, str] | None = None,
-        payload: dict[str, Any] | None = None,
-        query_params: dict[str, Any] | None = None,
-        json_configurations: dict[str, Any] | None = None,
+        data: Optional[Any] = None,
+        headers: Optional[dict[str, str]] = None,
+        payload: Optional[dict[str, Any]] = None,
+        query_params: Optional[dict[str, Any]] = None,
+        json_configurations: Optional[dict[str, Any]] = None,
     ) -> requests.Response:
         """
         Makes a request to the Nextmv Cloud API.
@@ -324,10 +324,10 @@ class Client:
 
     def upload_to_presigned_url(
         self,
-        data: dict[str, Any] | str | None,
+        data: Optional[Union[dict[str, Any], str]],
         url: str,
-        json_configurations: dict[str, Any] | None = None,
-        tar_file: str | None = None,
+        json_configurations: Optional[dict[str, Any]] = None,
+        tar_file: Optional[str] = None,
     ) -> None:
         """
         Uploads data to a presigned URL.
@@ -369,7 +369,7 @@ class Client:
         >>> client.upload_to_presigned_url(data=input_data, url="PRE_SIGNED_URL") # doctest: +SKIP
         """
 
-        upload_data: str | None = None
+        upload_data: Optional[str] = None
         if data is not None:
             if isinstance(data, dict):
                 upload_data = deflated_serialize_json(data, json_configurations=json_configurations)
@@ -433,7 +433,7 @@ class Client:
         }
 
 
-def get_size(obj: dict[str, Any] | IO[bytes] | str, json_configurations: dict[str, Any] | None = None) -> int:
+def get_size(obj: Union[dict[str, Any], IO[bytes], str], json_configurations: Optional[dict[str, Any]] = None) -> int:
     """
     Finds the size of an object in bytes.
 

nextmv/cloud/ensemble.py

@@ -22,6 +22,7 @@ EnsembleDefinition
 
 from datetime import datetime
 from enum import Enum
+from typing import Optional
 
 from nextmv.base_model import BaseModel
 
@@ -55,9 +56,9 @@ class RunGroup(BaseModel):
     """The unique identifier of the run group."""
     instance_id: str
     """ID of the app instance that this run group executes on."""
-    options: dict | None = None
+    options: Optional[dict] = None
     """Runtime options/parameters for the application."""
-    repetitions: int | None = None
+    repetitions: Optional[int] = None
     """The number of times the run is to be repeated on the instance and with
     the options defined in the run group"""
 

nextmv/cloud/input_set.py

@@ -11,6 +11,7 @@ InputSet
 """
 
 from datetime import datetime
+from typing import Optional
 
 from nextmv.base_model import BaseModel
 from nextmv.run import Format
@@ -58,19 +59,19 @@ class ManagedInput(BaseModel):
     id: str
     """ID of the input."""
 
-    name: str | None = None
+    name: Optional[str] = None
     """Name of the input."""
-    description: str | None = None
+    description: Optional[str] = None
     """Description of the input."""
-    run_id: str | None = None
+    run_id: Optional[str] = None
     """ID of the run that created the input."""
-    upload_id: str | None = None
+    upload_id: Optional[str] = None
     """ID of the upload that created the input."""
-    format: Format | None = None
+    format: Optional[Format] = None
     """Format of the input."""
-    created_at: datetime | None = None
+    created_at: Optional[datetime] = None
     """Creation time of the input."""
-    updated_at: datetime | None = None
+    updated_at: Optional[datetime] = None
     """Last update time of the input."""
 
 

nextmv/cloud/instance.py

@@ -13,6 +13,7 @@ Instance
 """
 
 from datetime import datetime
+from typing import Optional
 
 from nextmv.base_model import BaseModel
 
@@ -47,11 +48,11 @@ class InstanceConfiguration(BaseModel):
     ... )
     """
 
-    execution_class: str | None = None
+    execution_class: Optional[str] = None
     """Execution class for the instance."""
-    options: dict | None = None
+    options: Optional[dict] = None
     """Options of the app that the instance uses."""
-    secrets_collection_id: str | None = None
+    secrets_collection_id: Optional[str] = None
     """ID of the secrets collection that the instance uses."""
 
 

nextmv/cloud/package.py

@@ -8,6 +8,7 @@ import shutil
 import subprocess
 import tarfile
 import tempfile
+from typing import Optional
 
 from nextmv.logger import log
 from nextmv.manifest import MANIFEST_FILE_NAME, Manifest, ManifestBuild, ManifestType
@@ -23,8 +24,8 @@ _MANDATORY_FILES_PER_TYPE = {
 def _package(
     app_dir: str,
     manifest: Manifest,
-    model: Model | None = None,
-    model_configuration: ModelConfiguration | None = None,
+    model: Optional[Model] = None,
+    model_configuration: Optional[ModelConfiguration] = None,
     verbose: bool = False,
 ) -> tuple[str, str]:
     """Package the app into a tarball."""
@@ -74,7 +75,7 @@ def _package(
 
 def _run_build_command(
     app_dir: str,
-    manifest_build: ManifestBuild | None = None,
+    manifest_build: Optional[ManifestBuild] = None,
     verbose: bool = False,
 ) -> None:
     """Run the build command specified in the manifest."""
@@ -117,7 +118,7 @@ def _get_shell_command_elements(pre_push_command):
 
 def _run_pre_push_command(
     app_dir: str,
-    pre_push_command: str | None = None,
+    pre_push_command: Optional[str] = None,
     verbose: bool = False,
 ) -> None:
     """Run the pre-push command specified in the manifest."""
@@ -204,15 +205,8 @@ def __find_files(
 def __confirm_mandatory_files(manifest: Manifest, present_files: list[str]) -> None:
     """Confirm that all mandatory files are present in the given list of files."""
 
+    mandatory_files = _MANDATORY_FILES_PER_TYPE[manifest.type]
     found_files = {os.path.normpath(file): True for file in present_files}
-
-    # Check for mandatory files (if a custom execution config is provided we check the
-    # custom entrypoint instead)
-    mandatory_files = []
-    if manifest.execution is None or manifest.execution.entrypoint is None:
-        mandatory_files = _MANDATORY_FILES_PER_TYPE[manifest.type]
-    else:
-        mandatory_files.append(os.path.normpath(manifest.execution.entrypoint))
     missing_files = [file for file in mandatory_files if file not in found_files]
 
     if missing_files:
@@ -223,8 +217,8 @@ def __handle_python(
     app_dir: str,
     temp_dir: str,
     manifest: Manifest,
-    model: Model | None = None,
-    model_configuration: ModelConfiguration | None = None,
+    model: Optional[Model] = None,
+    model_configuration: Optional[ModelConfiguration] = None,
     verbose: bool = False,
 ) -> None:
     """Handles the Python-specific packaging logic."""
@@ -419,10 +413,10 @@ def __confirm_python_version(output: str) -> None:
         except ValueError:
             major, minor = map(int, version.split("."))
 
-        if major == 3 and minor >= 10:
+        if major == 3 and minor >= 9:
             return
 
-    raise Exception("python version 3.10 or higher is required")
+    raise Exception("python version 3.9 or higher is required")
 
 
 def __confirm_python_bundling_version(version: str) -> None:
@@ -431,9 +425,9 @@ def __confirm_python_bundling_version(version: str) -> None:
     match = re_version.fullmatch(version)
     if match:
         major, minor = int(match.group(1)), int(match.group(2))
-        if major == 3 and minor >= 10:
+        if major == 3 and minor >= 9:
             return
-    raise Exception(f"python version 3.10 or higher is required for bundling, got {version}")
+    raise Exception(f"python version 3.9 or higher is required for bundling, got {version}")
 
 
 def __compress_tar(source: str, target: str) -> tuple[str, int]:

nextmv/cloud/scenario.py

@@ -15,7 +15,7 @@ Scenario
 import itertools
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any
+from typing import Any, Optional, Union
 
 
 @dataclass
@@ -158,7 +158,11 @@ class ScenarioInput:
     Type of input for the scenario. This is used to determine how the input
     should be processed.
     """
-    scenario_input_data: str | list[str] | list[dict[str, Any]]
+    scenario_input_data: Union[
+        str,  # Input set ID
+        list[str],  # List of Input IDs
+        list[dict[str, Any]],  # Raw data
+    ]
     """
     Input data for the scenario. This can be a single input set ID (`str`), a
     list of input IDs (`list[str]`), or raw data (`list[dict[str, Any]]`).
@@ -248,12 +252,12 @@ class Scenario:
     instance_id: str
     """ID of the instance to be used for the scenario."""
 
-    scenario_id: str | None = None
+    scenario_id: Optional[str] = None
     """
     Optional ID of the scenario. The default value will be set as
     `scenario-<index>` if not set.
     """
-    configuration: list[ScenarioConfiguration] | None = None
+    configuration: Optional[list[ScenarioConfiguration]] = None
     """Optional configuration for the scenario. Use this attribute to configure
     variation of options for the scenario.
     """
@@ -296,8 +300,8 @@ class Scenario:
         if self.configuration is None or len(self.configuration) == 0:
             return [{}]
 
-        keys, value_lists = zip(*((config.name, config.values) for config in self.configuration), strict=False)
-        combinations = [dict(zip(keys, values, strict=False)) for values in itertools.product(*value_lists)]
+        keys, value_lists = zip(*((config.name, config.values) for config in self.configuration))
+        combinations = [dict(zip(keys, values)) for values in itertools.product(*value_lists)]
 
         return combinations
 

nextmv/input.py

@@ -35,7 +35,7 @@ import sys
 from collections.abc import Callable
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any
+from typing import Any, Optional, Union
 
 from nextmv._serialization import serialize_json
 from nextmv.deprecated import deprecated
@@ -155,17 +155,17 @@ class DataFile:
 
     The `loader` function should return the data that will be used in the model.
     """
-    loader_kwargs: dict[str, Any] | None = None
+    loader_kwargs: Optional[dict[str, Any]] = None
     """
     Optional keyword arguments to pass to the loader function. This can be used
     to customize the behavior of the loader.
     """
-    loader_args: list[Any] | None = None
+    loader_args: Optional[list[Any]] = None
     """
     Optional positional arguments to pass to the loader function. This can be
     used to customize the behavior of the loader.
     """
-    input_data_key: str | None = None
+    input_data_key: Optional[str] = None
     """
     Use this parameter to set a custom key to represent your file.
 
@@ -180,8 +180,8 @@ class DataFile:
 
 def json_data_file(
     name: str,
-    json_configurations: dict[str, Any] | None = None,
-    input_data_key: str | None = None,
+    json_configurations: Optional[dict[str, Any]] = None,
+    input_data_key: Optional[str] = None,
 ) -> DataFile:
     """
     This is a convenience function to create a `DataFile` that reads JSON data.
@@ -231,7 +231,7 @@ def json_data_file(
 
     json_configurations = json_configurations or {}
 
-    def loader(file_path: str) -> dict[str, Any] | Any:
+    def loader(file_path: str) -> Union[dict[str, Any], Any]:
         with open(file_path, encoding="utf-8") as f:
             return json.load(f, **json_configurations)
 
@@ -244,8 +244,8 @@ def json_data_file(
 
 def csv_data_file(
     name: str,
-    csv_configurations: dict[str, Any] | None = None,
-    input_data_key: str | None = None,
+    csv_configurations: Optional[dict[str, Any]] = None,
+    input_data_key: Optional[str] = None,
 ) -> DataFile:
     """
     This is a convenience function to create a `DataFile` that reads CSV data.
@@ -306,7 +306,7 @@ def csv_data_file(
     )
 
 
-def text_data_file(name: str, input_data_key: str | None = None) -> DataFile:
+def text_data_file(name: str, input_data_key: Optional[str] = None) -> DataFile:
     """
     This is a convenience function to create a `DataFile` that reads utf-8
     encoded text data.
@@ -408,7 +408,13 @@ class Input:
         If the `input_format` is not one of the supported formats.
     """
 
-    data: dict[str, Any] | Any | str | list[dict[str, Any]] | dict[str, list[dict[str, Any]]] | dict[str, Any]
+    data: Union[
+        Union[dict[str, Any], Any],  # JSON
+        str,  # TEXT
+        list[dict[str, Any]],  # CSV
+        dict[str, list[dict[str, Any]]],  # CSV_ARCHIVE
+        dict[str, Any],  # MULTI_FILE
+    ]
     """
     The actual data.
 
@@ -421,14 +427,14 @@ class Input:
     - For `MULTI_FILE`: `dict[str, Any]`
     """
 
-    input_format: InputFormat | None = InputFormat.JSON
+    input_format: Optional[InputFormat] = InputFormat.JSON
     """
     Format of the input data.
 
     Default is `InputFormat.JSON`.
     """
 
-    options: Options | None = None
+    options: Optional[Options] = None
     """
     Options that the `Input` was created with.
 
@@ -552,7 +558,7 @@ class InputLoader:
     def load(
         self,
         input_format: InputFormat = InputFormat.JSON,
-        options: Options | None = None,
+        options: Optional[Options] = None,
         *args,
         **kwargs,
     ) -> Input:
@@ -630,7 +636,7 @@ class LocalInputLoader(InputLoader):
         with open(path, encoding="utf-8") as f:
             return f.read().rstrip("\n")
 
-    def _read_csv(path: str, csv_configurations: dict[str, Any] | None) -> list[dict[str, Any]]:
+    def _read_csv(path: str, csv_configurations: Optional[dict[str, Any]]) -> list[dict[str, Any]]:
         """
         Read a CSV file and return its contents as a list of dictionaries.
 
@@ -649,7 +655,7 @@ class LocalInputLoader(InputLoader):
         with open(path, encoding="utf-8") as f:
             return list(csv.DictReader(f, **csv_configurations))
 
-    def _read_json(path: str, _) -> dict[str, Any] | Any:
+    def _read_json(path: str, _) -> Union[dict[str, Any], Any]:
         """
         Read a JSON file and return its parsed contents.
 
@@ -698,11 +704,11 @@ class LocalInputLoader(InputLoader):
 
     def load(
         self,
-        input_format: InputFormat | None = InputFormat.JSON,
-        options: Options | None = None,
-        path: str | None = None,
-        csv_configurations: dict[str, Any] | None = None,
-        data_files: list[DataFile] | None = None,
+        input_format: Optional[InputFormat] = InputFormat.JSON,
+        options: Optional[Options] = None,
+        path: Optional[str] = None,
+        csv_configurations: Optional[dict[str, Any]] = None,
+        data_files: Optional[list[DataFile]] = None,
     ) -> Input:
         """
         Load the input data. The input data can be in various formats. For
@@ -783,11 +789,11 @@ class LocalInputLoader(InputLoader):
 
     def _load_utf8_encoded(
         self,
-        csv_configurations: dict[str, Any] | None,
-        path: str | None = None,
-        input_format: InputFormat | None = InputFormat.JSON,
+        csv_configurations: Optional[dict[str, Any]],
+        path: Optional[str] = None,
+        input_format: Optional[InputFormat] = InputFormat.JSON,
         use_file_reader: bool = False,
-    ) -> dict[str, Any] | str | list[dict[str, Any]]:
+    ) -> Union[dict[str, Any], str, list[dict[str, Any]]]:
         """
         Load a utf-8 encoded file from stdin or filesystem.
 
@@ -825,8 +831,8 @@ class LocalInputLoader(InputLoader):
 
     def _load_archive(
         self,
-        csv_configurations: dict[str, Any] | None,
-        path: str | None = None,
+        csv_configurations: Optional[dict[str, Any]],
+        path: Optional[str] = None,
     ) -> dict[str, list[dict[str, Any]]]:
         """
         Load CSV files from a directory.
@@ -881,7 +887,7 @@ class LocalInputLoader(InputLoader):
     def _load_multi_file(
         self,
         data_files: list[DataFile],
-        path: str | None = None,
+        path: Optional[str] = None,
     ) -> dict[str, Any]:
         """
         Load multiple files from a directory.
@@ -955,10 +961,10 @@ class LocalInputLoader(InputLoader):
 
 
 def load_local(
-    input_format: InputFormat | None = InputFormat.JSON,
-    options: Options | None = None,
-    path: str | None = None,
-    csv_configurations: dict[str, Any] | None = None,
+    input_format: Optional[InputFormat] = InputFormat.JSON,
+    options: Optional[Options] = None,
+    path: Optional[str] = None,
+    csv_configurations: Optional[dict[str, Any]] = None,
 ) -> Input:
     """
     !!! warning
@@ -1010,12 +1016,12 @@ _LOCAL_INPUT_LOADER = LocalInputLoader()
 
 
 def load(
-    input_format: InputFormat | None = InputFormat.JSON,
-    options: Options | None = None,
-    path: str | None = None,
-    csv_configurations: dict[str, Any] | None = None,
-    loader: InputLoader | None = _LOCAL_INPUT_LOADER,
-    data_files: list[DataFile] | None = None,
+    input_format: Optional[InputFormat] = InputFormat.JSON,
+    options: Optional[Options] = None,
+    path: Optional[str] = None,
+    csv_configurations: Optional[dict[str, Any]] = None,
+    loader: Optional[InputLoader] = _LOCAL_INPUT_LOADER,
+    data_files: Optional[list[DataFile]] = None,
 ) -> Input:
     """
     Load input data using the specified loader.

nextmv/local/application.py

@@ -17,7 +17,7 @@ import tempfile
 import webbrowser
 from dataclasses import dataclass
 from datetime import datetime, timezone
-from typing import Any
+from typing import Any, Optional, Union
 
 from nextmv import cloud
 from nextmv._serialization import deflated_serialize_json
@@ -92,9 +92,9 @@ class Application:
     manifest.
     """
 
-    description: str | None = None
+    description: Optional[str] = None
     """Description of the application."""
-    manifest: Manifest | None = None
+    manifest: Optional[Manifest] = None
     """
     Manifest of the application. A manifest is a file named `app.yaml` that
     must be present at the root of the application's `src` directory. If the
@@ -131,9 +131,9 @@ class Application:
     @classmethod
     def initialize(
         cls,
-        src: str | None = None,
-        description: str | None = None,
-        destination: str | None = None,
+        src: Optional[str] = None,
+        description: Optional[str] = None,
+        destination: Optional[str] = None,
     ) -> "Application":
         """
         Initialize a sample Nextmv application, locally.
@@ -224,13 +224,13 @@ class Application:
 
     def new_run(
         self,
-        input: Input | dict[str, Any] | BaseModel | str = None,
-        name: str | None = None,
-        description: str | None = None,
-        options: Options | dict[str, str] | None = None,
-        configuration: RunConfiguration | dict[str, Any] | None = None,
-        json_configurations: dict[str, Any] | None = None,
-        input_dir_path: str | None = None,
+        input: Union[Input, dict[str, Any], BaseModel, str] = None,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        options: Optional[Union[Options, dict[str, str]]] = None,
+        configuration: Optional[Union[RunConfiguration, dict[str, Any]]] = None,
+        json_configurations: Optional[dict[str, Any]] = None,
+        input_dir_path: Optional[str] = None,
     ) -> str:
         """
         Run the application locally with the provided input.
@@ -361,15 +361,15 @@ class Application:
 
     def new_run_with_result(
         self,
-        input: Input | dict[str, Any] | BaseModel | str = None,
-        name: str | None = None,
-        description: str | None = None,
-        run_options: Options | dict[str, str] | None = None,
+        input: Union[Input, dict[str, Any], BaseModel, str] = None,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        run_options: Optional[Union[Options, dict[str, str]]] = None,
         polling_options: PollingOptions = DEFAULT_POLLING_OPTIONS,
-        configuration: RunConfiguration | dict[str, Any] | None = None,
-        json_configurations: dict[str, Any] | None = None,
-        input_dir_path: str | None = None,
-        output_dir_path: str | None = ".",
+        configuration: Optional[Union[RunConfiguration, dict[str, Any]]] = None,
+        json_configurations: Optional[dict[str, Any]] = None,
+        input_dir_path: Optional[str] = None,
+        output_dir_path: Optional[str] = ".",
     ) -> RunResult:
         """
         Submit an input to start a new local run of the application and poll
@@ -594,7 +594,7 @@ class Application:
 
         return info
 
-    def run_result(self, run_id: str, output_dir_path: str | None = ".") -> RunResult:
+    def run_result(self, run_id: str, output_dir_path: Optional[str] = ".") -> RunResult:
         """
         Get the local result of a run.
 
@@ -644,7 +644,7 @@ class Application:
         self,
         run_id: str,
         polling_options: PollingOptions = DEFAULT_POLLING_OPTIONS,
-        output_dir_path: str | None = ".",
+        output_dir_path: Optional[str] = ".",
     ) -> RunResult:
         """
         Get the result of a local run with polling.
@@ -761,9 +761,9 @@ class Application:
     def sync(  # noqa: C901
         self,
         target: cloud.Application,
-        run_ids: list[str] | None = None,
-        instance_id: str | None = None,
-        verbose: bool | None = False,
+        run_ids: Optional[list[str]] = None,
+        instance_id: Optional[str] = None,
+        verbose: Optional[bool] = False,
     ) -> None:
         """
         Sync the local application to a Nextmv Cloud application target.
@@ -867,7 +867,7 @@ class Application:
         self,
         run_id: str,
         run_information: RunInformation,
-        output_dir_path: str | None = ".",
+        output_dir_path: Optional[str] = ".",
     ) -> RunResult:
         """
         Get the result of a local run.
@@ -931,8 +931,8 @@ class Application:
 
     def __validate_input_dir_path_and_configuration(
         self,
-        input_dir_path: str | None,
-        configuration: RunConfiguration | dict[str, Any] | None,
+        input_dir_path: Optional[str],
+        configuration: Optional[Union[RunConfiguration, dict[str, Any]]],
     ) -> RunConfiguration:
         """
         Auxiliary function to validate the directory path and configuration.
@@ -984,8 +984,8 @@ class Application:
 
     def __extract_input_data(
         self,
-        input: Input | dict[str, Any] | BaseModel | str = None,
-    ) -> dict[str, Any] | str | None:
+        input: Union[Input, dict[str, Any], BaseModel, str] = None,
+    ) -> Optional[Union[dict[str, Any], str]]:
         """
         Auxiliary function to extract the input data from the input, based on
         its type.
@@ -1003,8 +1003,8 @@ class Application:
 
     def __extract_options_dict(
         self,
-        options: Options | dict[str, str] | None = None,
-        json_configurations: dict[str, Any] | None = None,
+        options: Optional[Union[Options, dict[str, str]]] = None,
+        json_configurations: Optional[dict[str, Any]] = None,
     ) -> dict[str, str]:
         """
         Auxiliary function to extract the options that will be sent to the
@@ -1026,9 +1026,9 @@ class Application:
 
     def __extract_run_config(
         self,
-        input: Input | dict[str, Any] | BaseModel | str = None,
-        configuration: RunConfiguration | dict[str, Any] | None = None,
-        dir_path: str | None = None,
+        input: Union[Input, dict[str, Any], BaseModel, str] = None,
+        configuration: Optional[Union[RunConfiguration, dict[str, Any]]] = None,
+        dir_path: Optional[str] = None,
     ) -> dict[str, Any]:
         """
         Auxiliary function to extract the run configuration that will be sent
@@ -1053,8 +1053,8 @@ class Application:
         run_id: str,
         runs_dir: str,
         temp_dir: str,
-        instance_id: str | None = None,
-        verbose: bool | None = False,
+        instance_id: Optional[str] = None,
+        verbose: Optional[bool] = False,
     ) -> bool:
         """
         Syncs a local run to a Nextmv Cloud target application. Returns True if