nextmv 0.34.0.dev0__tar.gz → 0.34.0.dev2__tar.gz

{nextmv-0.34.0.dev0 → nextmv-0.34.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextmv
-Version: 0.34.0.dev0
+Version: 0.34.0.dev2
 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.dev2/nextmv/__about__.py

@@ -0,0 +1 @@
+__version__ = "v0.34.0.dev2"

{nextmv-0.34.0.dev0 → nextmv-0.34.0.dev2}/nextmv/__init__.py

@@ -25,6 +25,7 @@ from .manifest import ManifestPythonArch as ManifestPythonArch
 from .manifest import ManifestPythonModel as ManifestPythonModel
 from .manifest import ManifestRuntime as ManifestRuntime
 from .manifest import ManifestType as ManifestType
+from .manifest import default_python_manifest as default_python_manifest
 from .model import Model as Model
 from .model import ModelConfiguration as ModelConfiguration
 from .options import Option as Option

{nextmv-0.34.0.dev0 → nextmv-0.34.0.dev2}/nextmv/local/application.py

@@ -33,13 +33,14 @@ from nextmv.local.local import (
 )
 from nextmv.local.runner import run
 from nextmv.logger import log
-from nextmv.manifest import Manifest
+from nextmv.manifest import Manifest, default_python_manifest
 from nextmv.options import Options
 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,
+    FormatInput,
     Run,
     RunConfiguration,
     RunInformation,
@@ -93,6 +94,39 @@ class Application:
 
     description: Optional[str] = None
     """Description of the application."""
+    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
+    app is initialized, and a manifest is not present, a default Python
+    manifest will be created, using the `nextmv.default_python_manifest`
+    function. If you specify this argument, and a manifest file is already
+    present in the `src` directory, the provided manifest will override the
+    existing one.
+    """
+
+    def __post_init__(self):
+        """
+        Validate the presence of the manifest in the application.
+        """
+
+        if self.manifest is not None:
+            self.manifest.to_yaml(self.src)
+
+            return
+
+        try:
+            manifest = Manifest.from_yaml(self.src)
+            self.manifest = manifest
+
+            return
+
+        except Exception:
+            manifest = default_python_manifest()
+            self.manifest = manifest
+            manifest.to_yaml(self.src)
+
+            return
 
     @classmethod
     def initialize(
@@ -293,7 +327,7 @@ class Application:
         >>> print(f"Local run completed with ID: {run_id}")
         """
 
-        self.__validate_input_dir_path_and_configuration(input_dir_path, configuration)
+        configuration = self.__validate_input_dir_path_and_configuration(input_dir_path, configuration)
 
         if self.src is None:
             raise ValueError("`src` property for the `Application` must be specified to run the application locally")
@@ -853,7 +887,7 @@ class Application:
         self,
         input_dir_path: Optional[str],
         configuration: Optional[Union[RunConfiguration, dict[str, Any]]],
-    ) -> None:
+    ) -> RunConfiguration:
         """
         Auxiliary function to validate the directory path and configuration.
         """
@@ -862,60 +896,45 @@ class Application:
             return
 
         if configuration is None:
-            raise ValueError(
-                "If dir_path is provided, a RunConfiguration must also be provided.",
-            )
+            if self.manifest.configuration is not None and self.manifest.configuration.content is not None:
+                configuration = RunConfiguration(
+                    format=Format(
+                        format_input=FormatInput(
+                            input_type=self.manifest.configuration.content.format,
+                        ),
+                    ),
+                )
+            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`.",
+                )
 
-        config_format = self.__extract_config_format(configuration)
+        # Forcefully turn the configuration into a RunConfiguration object to
+        # make it easier to deal with in the other functions.
+        if isinstance(configuration, dict):
+            configuration = RunConfiguration.from_dict(configuration)
 
+        config_format = configuration.format
         if config_format is None:
             raise ValueError(
-                "If dir_path is provided, RunConfiguration.format must also be provided.",
+                "If `dir_path` is provided, `RunConfiguration.format` must also be provided.",
             )
 
-        input_type = self.__extract_input_type(config_format)
-
-        if input_type is None or input_type in (InputFormat.JSON, InputFormat.TEXT):
+        input_type = config_format.format_input
+        if input_type is None:
             raise ValueError(
-                "If dir_path is provided, RunConfiguration.format.format_input.input_type must be set to a valid type. "
-                f"Valid types are: {[InputFormat.CSV_ARCHIVE, InputFormat.MULTI_FILE]}",
+                "If `dir_path` is provided, `RunConfiguration.format.format_input` must also be provided.",
             )
 
-    def __extract_config_format(self, configuration: Union[RunConfiguration, dict[str, Any]]) -> Any:
-        """Extract format from configuration, handling both RunConfiguration objects and dicts."""
-        if isinstance(configuration, RunConfiguration):
-            return configuration.format
-
-        if isinstance(configuration, dict):
-            config_format = configuration.get("format")
-            if config_format is not None and isinstance(config_format, dict):
-                return Format.from_dict(config_format) if hasattr(Format, "from_dict") else config_format
-
-            return config_format
-
-        raise ValueError("Configuration must be a RunConfiguration object or a dict.")
-
-    def __extract_input_type(self, config_format: Any) -> Any:
-        """Extract input type from config format."""
-        if isinstance(config_format, dict):
-            format_input = config_format.get("format_input") or config_format.get("input")
-            if format_input is None:
-                raise ValueError(
-                    "If dir_path is provided, RunConfiguration.format.format_input must also be provided.",
-                )
-
-            if isinstance(format_input, dict):
-                return format_input.get("input_type") or format_input.get("type")
-
-            return getattr(format_input, "input_type", None)
-
-        # Handle Format object
-        if config_format.format_input is None:
+        if input_type is None or input_type in (InputFormat.JSON, InputFormat.TEXT):
             raise ValueError(
-                "If dir_path is provided, RunConfiguration.format.format_input must also be provided.",
+                "If `dir_path` is provided, `RunConfiguration.format.format_input.input_type` must be set to "
+                f"a valid type. Valid types are: {[InputFormat.CSV_ARCHIVE, InputFormat.MULTI_FILE]}",
             )
 
-        return config_format.format_input.input_type
+        return configuration
 
     def __extract_input_data(
         self,
@@ -1026,7 +1045,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 = [line.rstrip("\n") for line in f.readlines()]
+            stderr_logs = f.read()
 
         # Create the tracked run object and start configuring it.
         tracked_run = TrackedRun(

{nextmv-0.34.0.dev0 → nextmv-0.34.0.dev2}/nextmv/local/executor.py

@@ -907,6 +907,9 @@ def _copy_new_or_modified_files(
     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.
+
     Parameters
     ----------
     src_dir : str
@@ -927,11 +930,12 @@ def _copy_new_or_modified_files(
     if exclusion_dirs is not None:
         exclusion_directories.extend(exclusion_dirs)
 
+    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)
-        os.makedirs(dst_root, exist_ok=True)
 
+        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):
@@ -941,7 +945,45 @@ def _copy_new_or_modified_files(
             dst_file = os.path.join(dst_root, file)
 
             if _should_copy_file(src_file, dst_file):
+                files_to_copy.append((src_file, dst_file))
+
+        # 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
+
+    # Clean up empty directories after copying
+    if files_copied:
+        _remove_empty_directories(dst_dir)
+
+
+def _remove_empty_directories(directory: str) -> None:
+    """
+    Recursively remove empty directories starting from the given directory.
+
+    This function walks the directory tree bottom-up and removes any directories
+    that are empty after all files have been processed. It preserves the root
+    directory even if it's empty.
+
+    Parameters
+    ----------
+    directory : str
+        The root directory path to start cleaning from.
+    """
+    for root, dirs, files in os.walk(directory, topdown=False):
+        # Skip the root directory itself
+        if root == directory:
+            continue
+
+        # If directory is empty (no files and no subdirectories), remove it
+        if not files and not dirs:
+            try:
+                os.rmdir(root)
+            except OSError:
+                # Directory might not be empty due to hidden files or permissions
+                pass
 
 
 def _should_copy_file(src_file: str, dst_file: str) -> bool:

{nextmv-0.34.0.dev0 → nextmv-0.34.0.dev2}/nextmv/manifest.py

@@ -357,19 +357,24 @@ class ManifestPython(BaseModel):
         validation_alias=AliasChoices("pip-requirements", "pip_requirements"),
         default=None,
     )
-    """Path to a requirements.txt file.
+    """
+    Path to a requirements.txt file.
 
     Contains (additional) Python dependencies that will be bundled with the
     app.
     """
     arch: Optional[ManifestPythonArch] = None
-    """The architecture this model is meant to run on. One of "arm64" or "amd64". Uses
-    "arm64" if not specified."""
+    """
+    The architecture this model is meant to run on. One of "arm64" or "amd64". Uses
+    "arm64" if not specified.
+    """
     version: Optional[Union[str, float]] = None
-    """The Python version this model is meant to run with. Uses "3.11" if not specified.
+    """
+    The Python version this model is meant to run with. Uses "3.11" if not specified.
     """
     model: Optional[ManifestPythonModel] = None
-    """Information about an encoded decision model.
+    """
+    Information about an encoded decision model.
 
     As handled via mlflow. This information is used to load the decision model
     from the app bundle.
@@ -1352,3 +1357,28 @@ class Manifest(BaseModel):
         )
 
         return manifest
+
+
+def default_python_manifest() -> Manifest:
+    """
+    Creates a default Python manifest as a starting point for applications
+    being executed on the Nextmv Platform.
+
+    You can import the `default_python_manifest` function directly from `nextmv`:
+
+    ```python
+    from nextmv import default_python_manifest
+    ```
+
+    Returns
+    -------
+    Manifest
+        A default Python manifest with common settings.
+    """
+
+    return Manifest(
+        files=["main.py"],
+        runtime=ManifestRuntime.PYTHON,
+        type=ManifestType.PYTHON,
+        python=ManifestPython(pip_requirements="requirements.txt"),
+    )

nextmv-0.34.0.dev0/nextmv/__about__.py

@@ -1 +0,0 @@
-__version__ = "v0.34.0.dev0"