nextmv 0.18.0__py3-none-any.whl → 1.0.0.dev2__py3-none-any.whl

nextmv/cloud/package.py

@@ -6,33 +6,37 @@ import platform
 import re
 import shutil
 import subprocess
+import sys
 import tarfile
 import tempfile
-from typing import Optional
 
-from nextmv.cloud.manifest import FILE_NAME, Manifest, ManifestBuild, ManifestType
+import rich
+
 from nextmv.logger import log
+from nextmv.manifest import MANIFEST_FILE_NAME, Manifest, ManifestBuild, ManifestType
 from nextmv.model import Model, ModelConfiguration, _cleanup_python_model
 
 _MANDATORY_FILES_PER_TYPE = {
     ManifestType.PYTHON: ["main.py"],
     ManifestType.GO: ["main"],
+    ManifestType.BINARY: ["main"],
     ManifestType.JAVA: ["main.jar"],
 }
 
 
-def _package(
+def _package(  # noqa: C901 # complexity attributed to printing.
     app_dir: str,
     manifest: Manifest,
-    model: Optional[Model] = None,
-    model_configuration: Optional[ModelConfiguration] = None,
+    model: Model | None = None,
+    model_configuration: ModelConfiguration | None = None,
     verbose: bool = False,
+    rich_print: bool = False,
 ) -> tuple[str, str]:
-    """Package the app into a tarball.."""
+    """Package the app into a tarball."""
 
     with tempfile.TemporaryDirectory(prefix="nextmv-temp-") as temp_dir:
         if manifest.type == ManifestType.PYTHON:
-            __handle_python(app_dir, temp_dir, manifest, model, model_configuration, verbose)
+            __handle_python(app_dir, temp_dir, manifest, model, model_configuration, verbose, rich_print)
 
         found, missing, files = __find_files(app_dir, manifest.files)
         __confirm_mandatory_files(manifest, found)
@@ -55,7 +59,13 @@ def _package(
                 raise Exception(f"error copying asset files {file['absolute_path']}: {e}") from e
 
         if verbose:
-            log(f'📋 Copied files listed in "{FILE_NAME}" manifest.')
+            if rich_print:
+                rich.print(
+                    f":clipboard: Copied files listed in [magenta]{MANIFEST_FILE_NAME}[/magenta] manifest.",
+                    file=sys.stderr,
+                )
+            else:
+                log(f'📋 Copied files listed in "{MANIFEST_FILE_NAME}" manifest.')
 
         if manifest.type == ManifestType.PYTHON:
             _cleanup_python_model(app_dir, model_configuration, verbose)
@@ -66,17 +76,31 @@ def _package(
         if verbose:
             try:
                 size = __human_friendly_file_size(tar_file)
-                log(f"📦 Packaged application ({file_count_msg}, {size}).")
+                if rich_print:
+                    rich.print(
+                        ":package: Packaged application "
+                        f"([magenta]{file_count_msg}[/magenta], [magenta]{size}[/magenta]).",
+                        file=sys.stderr,
+                    )
+                else:
+                    log(f"📦 Packaged application ({file_count_msg}, {size}).")
             except Exception:
-                log(f"📦 Packaged application ({file_count_msg}).")
+                if rich_print:
+                    rich.print(
+                        f":package: Packaged application ([magenta]{file_count_msg}[/magenta]).",
+                        file=sys.stderr,
+                    )
+                else:
+                    log(f"📦 Packaged application ({file_count_msg}).")
 
         return tar_file, output_dir
 
 
 def _run_build_command(
     app_dir: str,
-    manifest_build: Optional[ManifestBuild] = None,
+    manifest_build: ManifestBuild | None = None,
     verbose: bool = False,
+    rich_print: bool = False,
 ) -> None:
     """Run the build command specified in the manifest."""
 
@@ -85,7 +109,12 @@ def _run_build_command(
 
     elements = manifest_build.command.split(" ")
     command_str = " ".join(elements)
-    log(f'🚧 Running build command: "{command_str}"')
+
+    if verbose:
+        if rich_print:
+            rich.print(f":construction: Running build command: [magenta]{command_str}[/magenta]", file=sys.stderr)
+        else:
+            log(f'🚧 Running build command: "{command_str}"')
     try:
         result = subprocess.run(
             elements,
@@ -103,22 +132,38 @@ def _run_build_command(
         log(result.stdout)
 
 
+def _get_shell_command_elements(pre_push_command):
+    """Get the shell command elements based on the operating system."""
+    # Check if we're in a Unix-like shell (including MINGW on Windows)
+    if "SHELL" in os.environ and shutil.which("bash"):
+        return ["bash", "-c", pre_push_command]
+    # Default to cmd on Windows
+    elif platform.system() == "Windows":
+        return ["cmd", "/c", pre_push_command]
+    # Default to sh on Unix-like systems (Linux, macOS)
+    else:
+        return ["sh", "-c", pre_push_command]
+
+
 def _run_pre_push_command(
     app_dir: str,
-    pre_push_command: Optional[str] = None,
+    pre_push_command: str | None = None,
     verbose: bool = False,
+    rich_print: bool = False,
 ) -> None:
     """Run the pre-push command specified in the manifest."""
 
     if pre_push_command is None or pre_push_command == "":
         return
 
-    elements = ["bash", "-c", pre_push_command]
-    if platform.system() == "Windows":
-        elements = ["cmd", "/c", pre_push_command]
+    elements = _get_shell_command_elements(pre_push_command)
 
     command_str = " ".join(elements)
-    log(f'🔨 Running pre-push command: "{command_str}"')
+    if verbose:
+        if rich_print:
+            rich.print(f":hammer: Running pre-push command: [magenta]{command_str}[/magenta]", file=sys.stderr)
+        else:
+            log(f'🔨 Running pre-push command: "{command_str}"')
     try:
         result = subprocess.run(
             elements,
@@ -194,8 +239,15 @@ 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:
@@ -206,23 +258,30 @@ def __handle_python(
     app_dir: str,
     temp_dir: str,
     manifest: Manifest,
-    model: Optional[Model] = None,
-    model_configuration: Optional[ModelConfiguration] = None,
+    model: Model | None = None,
+    model_configuration: ModelConfiguration | None = None,
     verbose: bool = False,
+    rich_print: bool = False,
 ) -> None:
     """Handles the Python-specific packaging logic."""
 
     if model is not None and model_configuration is not None:
         if verbose:
-            log("🔮 Encoding Python model.")
+            if rich_print:
+                rich.print(":crystal_ball: Encoding Python model.", file=sys.stderr)
+            else:
+                log("🔮 Encoding Python model.")
         model.save(app_dir, model_configuration)
 
     if verbose:
-        log("🐍 Bundling Python dependencies.")
+        if rich_print:
+            rich.print(":snake: Bundling Python dependencies.", file=sys.stderr)
+        else:
+            log("🐍 Bundling Python dependencies.")
     __install_dependencies(manifest, app_dir, temp_dir)
 
 
-def __install_dependencies(
+def __install_dependencies(  # noqa: C901 # complexity
     manifest: Manifest,
     app_dir: str,
     temp_dir: str,
@@ -233,46 +292,91 @@ def __install_dependencies(
         return
 
     pip_requirements = manifest.python.pip_requirements
+
     if pip_requirements is None or pip_requirements == "":
+        # If no pip requirements are specified, we do not install any dependencies.
         return
 
-    if not os.path.isfile(os.path.join(app_dir, pip_requirements)):
-        raise FileNotFoundError(f"pip requirements file '{pip_requirements}' not found in '{app_dir}'")
+    if isinstance(pip_requirements, list):
+        # If pip_requirements is a list, we write it to a temporary file so that we can
+        # pass it to pip.
+        pip_requirements_file = os.path.join(temp_dir, "requirements.txt")
+        with open(pip_requirements_file, "w") as f:
+            for requirement in pip_requirements:
+                f.write(requirement + "\n")
+        pip_requirements = pip_requirements_file
+    elif isinstance(pip_requirements, str):
+        # If pip_requirements is a string, we expect it to be a file path to a
+        # requirements file.
+        pip_requirements = pip_requirements.strip()
+        if not os.path.isfile(os.path.join(app_dir, pip_requirements)):
+            raise FileNotFoundError(f"pip requirements file '{pip_requirements}' not found in '{app_dir}'")
+
+    platform_filter = []
+    if not manifest.python.arch or manifest.python.arch == "arm64":
+        platform_filter.extend(
+            [
+                "--platform=manylinux2014_aarch64",
+                "--platform=manylinux_2_17_aarch64",
+                "--platform=manylinux_2_24_aarch64",
+                "--platform=manylinux_2_26_aarch64",
+                "--platform=manylinux_2_28_aarch64",
+                "--platform=manylinux_2_34_aarch64",
+                "--platform=linux_aarch64",
+            ]
+        )
+    elif manifest.python.arch == "amd64":
+        platform_filter.extend(
+            [
+                "--platform=manylinux2014_x86_64",
+                "--platform=manylinux_2_17_x86_64",
+                "--platform=manylinux_2_24_x86_64",
+                "--platform=manylinux_2_26_x86_64",
+                "--platform=manylinux_2_28_x86_64",
+                "--platform=manylinux_2_34_x86_64",
+                "--platform=linux_x86_64",
+            ]
+        )
+    else:
+        raise Exception(f"unknown architecture '{manifest.python.arch}' specified in manifest")
+
+    version_filter = ["--python-version=3.11"]
+    if manifest.python.version:
+        __confirm_python_bundling_version(manifest.python.version)
+        version_filter = [f"--python-version={manifest.python.version}"]
 
     py_cmd = __get_python_command()
     dep_dir = os.path.join(".nextmv", "python", "deps")
-    command = [
-        py_cmd,
-        "-m",
-        "pip",
-        "install",
-        "-r",
-        pip_requirements,
-        "--platform=manylinux2014_aarch64",
-        "--platform=manylinux_2_17_aarch64",
-        "--platform=manylinux_2_24_aarch64",
-        "--platform=manylinux_2_28_aarch64",
-        "--platform=linux_aarch64",
-        "--only-binary=:all:",
-        "--python-version=3.11",
-        "--implementation=cp",
-        "--upgrade",
-        "--no-warn-conflicts",
-        "--target",
-        os.path.join(temp_dir, dep_dir),
-        "--no-user",  # We explicitly avoid user mode (mainly to fix issues with Windows store Python installations)
-        "--no-input",
-        "--quiet",
-    ]
+    command = (
+        [
+            py_cmd,
+            "-m",
+            "pip",
+            "install",
+            "-r",
+            pip_requirements,
+            "--only-binary=:all:",
+            "--implementation=cp",
+            "--upgrade",
+            "--no-warn-conflicts",
+            "--target",
+            os.path.join(temp_dir, dep_dir),
+            "--no-user",  # We explicitly avoid user mode (mainly to fix issues with Windows store Python installations)
+            "--no-input",
+            "--quiet",
+        ]
+        + platform_filter
+        + version_filter
+    )
     result = subprocess.run(
         command,
         cwd=app_dir,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,  # Merge stderr into stdout
         text=True,
-        capture_output=True,
-        check=True,
     )
     if result.returncode != 0:
-        raise Exception(f"error installing dependencies: {result.stderr}")
+        raise Exception(f"error installing dependencies: {os.linesep}{result.stdout}")
 
 
 def __run_command(binary: str, dir: str, redirect_out_err: bool, *arguments: str) -> str:
@@ -361,10 +465,21 @@ def __confirm_python_version(output: str) -> None:
         except ValueError:
             major, minor = map(int, version.split("."))
 
-        if major == 3 and minor >= 9:
+        if major == 3 and minor >= 10:
             return
 
-    raise Exception("python version 3.9 or higher is required")
+    raise Exception("python version 3.10 or higher is required")
+
+
+def __confirm_python_bundling_version(version: str) -> None:
+    # Only accept versions in the form "major.minor" where both are integers
+    re_version = re.compile(r"^(\d+)\.(\d+)$")
+    match = re_version.fullmatch(version)
+    if match:
+        major, minor = int(match.group(1)), int(match.group(2))
+        if major == 3 and minor >= 10:
+            return
+    raise Exception(f"python version 3.10 or higher is required for bundling, got {version}")
 
 
 def __compress_tar(source: str, target: str) -> tuple[str, int]: