nextmv 0.40.0__py3-none-any.whl → 1.0.0.dev0__py3-none-any.whl

nextmv/cloud/package.py

@@ -6,9 +6,12 @@ import platform
 import re
 import shutil
 import subprocess
+import sys
 import tarfile
 import tempfile
 
+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
@@ -21,18 +24,19 @@ _MANDATORY_FILES_PER_TYPE = {
 }
 
 
-def _package(
+def _package(  # noqa: C901 # complexity attributed to printing.
     app_dir: str,
     manifest: Manifest,
     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."""
 
     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 "{MANIFEST_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,9 +76,22 @@ 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
 
@@ -77,6 +100,7 @@ def _run_build_command(
     app_dir: str,
     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,
@@ -120,6 +149,7 @@ def _run_pre_push_command(
     app_dir: str,
     pre_push_command: str | None = None,
     verbose: bool = False,
+    rich_print: bool = False,
 ) -> None:
     """Run the pre-push command specified in the manifest."""
 
@@ -129,7 +159,11 @@ def _run_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,
@@ -227,16 +261,23 @@ def __handle_python(
     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)
 
 

nextmv/input.py

@@ -77,8 +77,6 @@ class InputFormat(str, Enum):
     """JSON format, utf-8 encoded."""
     TEXT = "text"
     """Text format, utf-8 encoded."""
-    CSV = "csv"
-    """CSV format, utf-8 encoded."""
     CSV_ARCHIVE = "csv-archive"
     """CSV archive format: multiple CSV files."""
     MULTI_FILE = "multi-file"
@@ -376,8 +374,6 @@ class Input:
        means that the data must be JSON-deserializable, which includes dicts and
        lists.
     - `InputFormat.TEXT`: the data is `str`, and it must be utf-8 encoded.
-    - `InputFormat.CSV`: the data is `list[dict[str, Any]]`, where each dict
-       represents a row in the CSV.
     - `InputFormat.CSV_ARCHIVE`: the data is `dict[str, list[dict[str, Any]]]`,
        where each key is the name of a CSV file and the value is a list of dicts
        representing the rows in that CSV file.
@@ -466,12 +462,6 @@ class Input:
                 "input_format InputFormat.TEXT, supported type is `str`"
             )
 
-        elif self.input_format == InputFormat.CSV and not isinstance(self.data, list):
-            raise ValueError(
-                f"unsupported Input.data type: {type(self.data)} with "
-                "input_format InputFormat.CSV, supported type is `list`"
-            )
-
         elif self.input_format == InputFormat.CSV_ARCHIVE and not isinstance(self.data, dict):
             raise ValueError(
                 f"unsupported Input.data type: {type(self.data)} with "
@@ -607,8 +597,6 @@ class LocalInputLoader(InputLoader):
     >>> loader = LocalInputLoader()
     >>> # Load JSON from stdin or file
     >>> input_obj = loader.load(input_format=InputFormat.JSON, path="data.json")
-    >>> # Load CSV from a file
-    >>> input_obj = loader.load(input_format=InputFormat.CSV, path="data.csv")
     """
 
     def _read_text(path: str, _) -> str:
@@ -672,7 +660,6 @@ class LocalInputLoader(InputLoader):
     STDIN_READERS = {
         InputFormat.JSON: lambda _: json.load(sys.stdin),
         InputFormat.TEXT: lambda _: sys.stdin.read().rstrip("\n"),
-        InputFormat.CSV: lambda csv_configurations: list(csv.DictReader(sys.stdin, **csv_configurations)),
     }
     """
     Dictionary of functions to read from standard input.
@@ -687,7 +674,7 @@ class LocalInputLoader(InputLoader):
     FILE_READERS = {
         InputFormat.JSON: _read_json,
         InputFormat.TEXT: _read_text,
-        InputFormat.CSV: _read_csv,
+        "CSV": _read_csv,
     }
     """
     Dictionary of functions to read from files.
@@ -706,23 +693,23 @@ class LocalInputLoader(InputLoader):
     ) -> Input:
         """
         Load the input data. The input data can be in various formats. For
-        `InputFormat.JSON`, `InputFormat.TEXT`, and `InputFormat.CSV`, the data
-        can be streamed from stdin or read from a file. When the `path`
-        argument is provided (and valid), the input data is read from the file
-        specified by `path`, otherwise, it is streamed from stdin. For
-        `InputFormat.CSV_ARCHIVE`, the input data is read from the directory
-        specified by `path`. If the `path` is not provided, the default
-        location `input` is used. The directory should contain one or more
-        files, where each file in the directory is a CSV file.
+        `InputFormat.JSON` and `InputFormat.TEXT`, the data can be streamed
+        from stdin or read from a file. When the `path` argument is provided
+        (and valid), the input data is read from the file specified by `path`,
+        otherwise, it is streamed from stdin. For `InputFormat.CSV_ARCHIVE`,
+        the input data is read from the directory specified by `path`. If the
+        `path` is not provided, the default location `input` is used. The
+        directory should contain one or more files, where each file in the
+        directory is a CSV file.
 
         The `Input` that is returned contains the `data` attribute. This data
         can be of different types, depending on the provided `input_format`:
 
         - `InputFormat.JSON`: the data is a `dict[str, Any]`.
         - `InputFormat.TEXT`: the data is a `str`.
-        - `InputFormat.CSV`: the data is a `list[dict[str, Any]]`.
-        - `InputFormat.CSV_ARCHIVE`: the data is a `dict[str, list[dict[str, Any]]]`.
-          Each key is the name of the CSV file, minus the `.csv` extension.
+        - `InputFormat.CSV_ARCHIVE`: the data is a `dict[str, list[dict[str,
+          Any]]]`. Each key is the name of the CSV file, minus the `.csv`
+          extension.
         - `InputFormat.MULTI_FILE`: the data is a `dict[str, Any]`, where each
           key is the file name (with extension) and the value is the data read
           from the file. The data can be of any type, depending on the file
@@ -745,11 +732,11 @@ class LocalInputLoader(InputLoader):
             `input_format` is set to `InputFormat.MULTI_FILE`. Each `DataFile`
             instance should have a `name` (the file name with extension) and a
             `loader` function that reads the data from the file. The `loader`
-            function should accept the file path as its first argument and return
-            the data read from the file. The `loader` can also accept additional
-            positional and keyword arguments, which can be provided through the
-            `loader_args` and `loader_kwargs` attributes of the `DataFile`
-            instance.
+            function should accept the file path as its first argument and
+            return the data read from the file. The `loader` can also accept
+            additional positional and keyword arguments, which can be provided
+            through the `loader_args` and `loader_kwargs` attributes of the
+            `DataFile` instance.
 
         Returns
         -------
@@ -766,7 +753,7 @@ class LocalInputLoader(InputLoader):
         if csv_configurations is None:
             csv_configurations = {}
 
-        if input_format in [InputFormat.JSON, InputFormat.TEXT, InputFormat.CSV]:
+        if input_format in [InputFormat.JSON, InputFormat.TEXT]:
             data = self._load_utf8_encoded(path=path, input_format=input_format, csv_configurations=csv_configurations)
         elif input_format == InputFormat.CSV_ARCHIVE:
             data = self._load_archive(path=path, csv_configurations=csv_configurations)
@@ -785,7 +772,7 @@ class LocalInputLoader(InputLoader):
         self,
         csv_configurations: dict[str, Any] | None,
         path: str | None = None,
-        input_format: InputFormat | None = InputFormat.JSON,
+        input_format: InputFormat | str | None = InputFormat.JSON,
         use_file_reader: bool = False,
     ) -> dict[str, Any] | str | list[dict[str, Any]]:
         """
@@ -871,7 +858,7 @@ class LocalInputLoader(InputLoader):
                 stripped = file.removesuffix(csv_ext)
                 data[stripped] = self._load_utf8_encoded(
                     path=os.path.join(dir_path, file),
-                    input_format=InputFormat.CSV,
+                    input_format="CSV",
                     use_file_reader=True,
                     csv_configurations=csv_configurations,
                 )
@@ -1034,7 +1021,6 @@ def load(
 
     - `InputFormat.JSON`: the data is a `dict[str, Any]`
     - `InputFormat.TEXT`: the data is a `str`
-    - `InputFormat.CSV`: the data is a `list[dict[str, Any]]`
     - `InputFormat.CSV_ARCHIVE`: the data is a `dict[str, list[dict[str, Any]]]`
         Each key is the name of the CSV file, minus the `.csv` extension.
     - `InputFormat.MULTI_FILE`: the data is a `dict[str, Any]`
@@ -1119,8 +1105,6 @@ def load(
     >>> from nextmv.input import load, InputFormat
     >>> # Load JSON from stdin
     >>> input_obj = load(input_format=InputFormat.JSON)
-    >>> # Load CSV from a file
-    >>> input_obj = load(input_format=InputFormat.CSV, path="data.csv")
     >>> # Load CSV archive from a directory
     >>> input_obj = load(input_format=InputFormat.CSV_ARCHIVE, path="input_dir")
     """

nextmv/local/application.py

@@ -256,8 +256,7 @@ class Application:
             `nextmv.InputFormat.MULTI_FILE`, you should use the
             `input_dir_path` argument instead. This argument takes precedence
             over the `input`. If `input_dir_path` is specified, this function
-            looks for files in that directory and tars them, to later be
-            uploaded using the `upload_large_input` method. If both the
+            looks for files in that directory and tars them. If both the
             `input_dir_path` and `input` arguments are provided, the `input`
             is ignored.
 
@@ -273,9 +272,6 @@ class Application:
 
             When working with JSON or text data, use the `input` argument
             directly.
-
-            In general, if an input is too large, it will be uploaded with the
-            `upload_large_input` method.
         name: Optional[str]
             Name of the local run.
         description: Optional[str]
@@ -399,8 +395,7 @@ class Application:
             `nextmv.InputFormat.MULTI_FILE`, you should use the
             `input_dir_path` argument instead. This argument takes precedence
             over the `input`. If `input_dir_path` is specified, this function
-            looks for files in that directory and tars them, to later be
-            uploaded using the `upload_large_input` method. If both the
+            looks for files in that directory and tars them. If both the
             `input_dir_path` and `input` arguments are provided, the `input` is
             ignored.
 
@@ -416,9 +411,6 @@ class Application:
 
             When working with JSON or text data, use the `input` argument
             directly.
-
-            In general, if an input is too large, it will be uploaded with the
-            `upload_large_input` method.
         name: Optional[str]
             Name of the local run.
         description: Optional[str]
@@ -699,11 +691,7 @@ class Application:
 
         def polling_func() -> tuple[Any, bool]:
             run_information = self.run_metadata(run_id=run_id)
-            if run_information.metadata.status_v2 in {
-                StatusV2.succeeded,
-                StatusV2.failed,
-                StatusV2.canceled,
-            }:
+            if run_information.metadata.run_is_finalized():
                 return run_information, True
 
             return None, False

nextmv/polling.py

@@ -128,17 +128,49 @@ class PollingOptions:
     return True to stop the polling and False to continue. The function does
     not receive any arguments. The function is called before each poll.
     """
+    sleep_duration_func: Callable[[], float] | None = None
+    """
+    Optional function to calculate the sleep duration between polls. If provided,
+    this function will be called to determine how long to sleep instead of using
+    the default exponential backoff calculation. The function should return a
+    float representing the sleep duration in seconds. The function does not
+    receive any arguments and is called before each sleep.
+    """
 
 
 DEFAULT_POLLING_OPTIONS: PollingOptions = PollingOptions()
 """
+!!! warning
+    `DEFAULT_POLLING_OPTIONS` is a mutable global variable. Use the `default_polling_options`
+    function to obtain a fresh instance of `PollingOptions` with default settings.
+
 Default polling options to use when polling for a run result. This constant
 provides the default values for `PollingOptions` used across the module.
-Using these defaults is recommended for most use cases unless specific timing
-needs are required.
 """
 
 
+def default_polling_options() -> PollingOptions:
+    """
+    Returns a new instance of PollingOptions with default settings.
+
+    This function can be used to obtain a fresh set of default polling options
+    that can be modified as needed without affecting the global defaults.
+
+    You can import the `default_polling_options` function directly from `nextmv`:
+
+    ```python
+    from nextmv import default_polling_options
+    ```
+
+    Returns
+    -------
+    PollingOptions
+        A new instance of PollingOptions with default values.
+    """
+
+    return PollingOptions()
+
+
 def poll(  # noqa: C901
     polling_options: PollingOptions,
     polling_func: Callable[[], tuple[Any, bool]],
@@ -255,23 +287,29 @@ def poll(  # noqa: C901
             )
 
         # Calculate the delay.
-        if max_reached:
-            # If we already reached the maximum, we don't want to further calculate the
-            # delay to avoid overflows.
-            delay = polling_options.max_delay
-            delay += random.uniform(0, polling_options.jitter)  # Add jitter.
+        if polling_options.sleep_duration_func is not None:
+            # Use the custom sleep duration function if provided.
+            sleep_duration = polling_options.sleep_duration_func()
         else:
-            delay = polling_options.delay  # Base
-            delay += polling_options.backoff * (2**ix)  # Add exponential backoff.
-            delay += random.uniform(0, polling_options.jitter)  # Add jitter.
+            # Calculate delay using exponential backoff with jitter.
+            if max_reached:
+                # If we already reached the maximum, we don't want to further calculate the
+                # delay to avoid overflows.
+                delay = polling_options.max_delay
+            else:
+                delay = polling_options.delay  # Base
+                delay += polling_options.backoff * (2**ix)  # Add exponential backoff.
+
+            # We cannot exceed the max delay.
+            if delay >= polling_options.max_delay:
+                max_reached = True
+                delay = polling_options.max_delay
+
+            # Add jitter.
+            delay += random.uniform(0, polling_options.jitter)
 
-        # We cannot exceed the max delay.
-        if delay >= polling_options.max_delay:
-            max_reached = True
-            delay = polling_options.max_delay
+            sleep_duration = delay
 
-        # Sleep for the calculated delay.
-        sleep_duration = delay
         if polling_options.verbose:
             log(f"polling | sleeping for duration: {sleep_duration}")
 

nextmv/run.py

@@ -687,6 +687,23 @@ class Metadata(BaseModel):
     statistics: dict[str, Any] | None = None
     """User defined statistics of the run."""
 
+    def run_is_finalized(self) -> bool:
+        """
+        Checks if the run has reached a finalized state.
+
+        Returns
+        -------
+        bool
+            True if the run status is one of `succeeded`, `failed`, or
+            `canceled`. False otherwise.
+        """
+
+        return self.status_v2 in {
+            StatusV2.succeeded,
+            StatusV2.failed,
+            StatusV2.canceled,
+        }
+
 
 class SyncedRun(BaseModel):
     """
@@ -1031,6 +1048,43 @@ class RunLog(BaseModel):
     """Log of the run."""
 
 
+class TimestampedRunLog(BaseModel):
+    """
+    Timestamped log entry of a run.
+
+    You can import the `TimestampedRunLog` class directly from `nextmv`:
+
+    ```python
+    from nextmv import TimestampedRunLog
+    ```
+
+    Parameters
+    ----------
+    timestamp : datetime
+        Timestamp of the log entry.
+    log : str
+        Log message.
+
+    Examples
+    --------
+    >>> from nextmv import TimestampedRunLog
+    >>> from datetime import datetime
+    >>> log_entry = TimestampedRunLog(
+    ...     timestamp=datetime(2023, 1, 1, 12, 0, 0),
+    ...     log="Optimization started"
+    ... )
+    >>> log_entry.timestamp
+    datetime.datetime(2023, 1, 1, 12, 0)
+    >>> log_entry.log
+    'Optimization started'
+    """
+
+    timestamp: datetime
+    """Timestamp of the log entry."""
+    log: str
+    """Log message."""
+
+
 class RunQueuing(BaseModel):
     """
     RunQueuing configuration for a run.
@@ -1395,8 +1449,8 @@ class TrackedRun:
     output : Output or dict[str, Any] or str, optional
         The output of the run being tracked. Please note that if the output
         format is JSON, then the output data must be JSON serializable. If both
-        `output` and `output_dir_path` are specified, the `output` is ignored, and
-        the files in the directory are used instead. Defaults to None.
+        `output` and `output_dir_path` are specified, the `output` is ignored,
+        and the files in the directory are used instead. Defaults to None.
     duration : int, optional
         The duration of the run being tracked, in milliseconds. This field is
         optional. Defaults to None.
@@ -1404,39 +1458,41 @@ class TrackedRun:
         An error message if the run failed. You should only specify this if the
         run failed (the `status` is `TrackedRunStatus.FAILED`), otherwise an
         exception will be raised. This field is optional. Defaults to None.
-    logs : list[str], optional
-        The logs of the run being tracked. Each element of the list is a line in
-        the log. This field is optional. Defaults to None.
+    logs : str or list[str], optional
+        The logs of the run being tracked. If the logs are provided as a list,
+        each element of the list is a line in the log. This field is optional.
+        Defaults to None.
     name : str, optional
         Optional name for the run being tracked. Defaults to None.
     description : str, optional
         Optional description for the run being tracked. Defaults to None.
     input_dir_path : str, optional
         Path to a directory containing input files. If specified, the calling
-        function will package the files in the directory into a tar file and upload
-        it as a large input. This is useful for non-JSON input formats, such as
-        when working with `CSV_ARCHIVE` or `MULTI_FILE`. If both `input` and
-        `input_dir_path` are specified, the `input` is ignored, and the files in
-        the directory are used instead. Defaults to None.
+        function will package the files in the directory into a tar file and
+        upload it as a large input. This is useful for non-JSON input formats,
+        such as when working with `CSV_ARCHIVE` or `MULTI_FILE`. If both
+        `input` and `input_dir_path` are specified, the `input` is ignored, and
+        the files in the directory are used instead. Defaults to None.
     output_dir_path : str, optional
         Path to a directory containing output files. If specified, the calling
-        function will package the files in the directory into a tar file and upload
-        it as a large output. This is useful for non-JSON output formats, such as
-        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.
+        function will package the files in the directory into a tar file and
+        upload it as a large output. This is useful for non-JSON output
+        formats, such as 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`.
+        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.
+        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
     --------
@@ -1482,8 +1538,8 @@ class TrackedRun:
     ------
     ValueError
         If the status value is invalid, if an error message is provided for a
-        successful run, or if input/output formats are not JSON or
-        input/output dicts are not JSON serializable.
+        successful run, or if input/output formats are not JSON or input/output
+        dicts are not JSON serializable.
     """
 
     status: TrackedRunStatus
@@ -1508,8 +1564,8 @@ class TrackedRun:
     error: str | None = None
     """An error message if the run failed. You should only specify this if the
     run failed, otherwise an exception will be raised."""
-    logs: list[str] | None = None
-    """The logs of the run being tracked. Each element of the list is a line in
+    logs: str | list[str] | None = None
+    """The logs of the run being tracked. If a list, each element is a line in
     the log."""
     name: str | None = None
     """

{nextmv-0.40.0.dist-info → nextmv-1.0.0.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextmv
-Version: 0.40.0
+Version: 1.0.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/
@@ -267,20 +267,45 @@ Description-Content-Type: text/markdown
 
 Welcome to `nextmv`, the general Python SDK for the Nextmv Platform.
 
-📖 To learn more about the `nextmv`, visit the [docs][docs].
+📖 To learn more about `nextmv`, visit the [docs][docs].
 
 ## Installation
 
-Requires Python `>=3.10`. Install using `pip`:
+Requires Python `>=3.10`. Install using the Python package manager of your
+choice:
 
-```bash
-pip install nextmv
-```
+- `pip`
+
+    ```bash
+    pip install nextmv
+    ```
+
+- `pipx`
+
+    ```bash
+    pipx install nextmv
+    ```
 
-Install all optional dependencies (recommended):
+- `uv`
+
+    ```bash
+    uv tool install nextmv
+    ```
+
+Install all optional dependencies (recommended) by specifying `"nextmv[all]"`
+instead of just `"nextmv"`.
+
+## CLI
+
+The Nextmv CLI is installed automatically with the SDK. To verify installation,
+run:
 
 ```bash
-pip install "nextmv[all]"
+nextmv --help
 ```
 
+If you are contributing to the CLI, please make sure you read the [CLI
+Contributing Guide][cli-contributing].
+
 [docs]: https://nextmv-py.docs.nextmv.io/en/latest/nextmv/
+[cli-contributing]: nextmv/cli/CONTRIBUTING.md