modal 0.62.115__py3-none-any.whl → 0.72.13__py3-none-any.whl

modal/cli/volume.py

@@ -2,26 +2,23 @@
 import os
 import sys
 from pathlib import Path
-from typing import List, Optional
+from typing import Optional
 
 import typer
 from click import UsageError
 from grpclib import GRPCError, Status
 from rich.console import Console
-from rich.live import Live
 from rich.syntax import Syntax
-from rich.table import Table
 from typer import Argument, Option, Typer
 
 import modal
-from modal._output import step_completed, step_progress
+from modal._output import OutputManager, ProgressHandler
 from modal._utils.async_utils import synchronizer
 from modal._utils.grpc_utils import retry_transient_errors
 from modal.cli._download import _volume_download
-from modal.cli.utils import ENV_OPTION, display_table, timestamp_to_local
+from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table, timestamp_to_local
 from modal.client import _Client
 from modal.environments import ensure_env
-from modal.exception import deprecation_warning
 from modal.volume import _Volume, _VolumeUploadContextManager
 from modal_proto import api_pb2
 
@@ -52,13 +49,14 @@ def humanize_filesize(value: int) -> str:
     return format % (base * bytes_ / unit) + s
 
 
-@volume_cli.command(name="create", help="Create a named, persistent modal.Volume.")
+@volume_cli.command(name="create", help="Create a named, persistent modal.Volume.", rich_help_panel="Management")
 def create(
     name: str,
     env: Optional[str] = ENV_OPTION,
+    version: Optional[int] = Option(default=None, help="VolumeFS version. (Experimental)"),
 ):
     env_name = ensure_env(env)
-    modal.Volume.create_deployed(name, environment_name=env)
+    modal.Volume.create_deployed(name, environment_name=env, version=version)
     usage_code = f"""
 @app.function(volumes={{"/my_vol": modal.Volume.from_name("{name}")}})
 def some_func():
@@ -66,12 +64,12 @@ def some_func():
 """
 
     console = Console()
-    console.print(f"Created volume '{name}' in environment '{env_name}'. \n\nCode example:\n")
+    console.print(f"Created Volume '{name}' in environment '{env_name}'. \n\nCode example:\n")
     usage = Syntax(usage_code, "python")
     console.print(usage)
 
 
-@volume_cli.command(name="get")
+@volume_cli.command(name="get", rich_help_panel="File operations")
 @synchronizer.create_blocking
 async def get(
     volume_name: str,
@@ -80,14 +78,14 @@ async def get(
     force: bool = False,
     env: Optional[str] = ENV_OPTION,
 ):
-    """Download files from a Volume object.
+    """Download files from a modal.Volume object.
 
     If a folder is passed for REMOTE_PATH, the contents of the folder will be downloaded
     recursively, including all subdirectories.
 
     **Example**
 
-    ```bash
+    ```
     modal volume get <volume_name> logs/april-12-1.txt
     modal volume get <volume_name> / volume_data_dump
     ```
@@ -97,12 +95,20 @@ async def get(
     ensure_env(env)
     destination = Path(local_destination)
     volume = await _Volume.lookup(volume_name, environment_name=env)
-    await _volume_download(volume, remote_path, destination, force)
+    console = Console()
+    progress_handler = ProgressHandler(type="download", console=console)
+    with progress_handler.live:
+        await _volume_download(volume, remote_path, destination, force, progress_cb=progress_handler.progress)
+    console.print(OutputManager.step_completed("Finished downloading files to local!"))
 
 
-@volume_cli.command(name="list", help="List the details of all modal.Volume volumes in an environment.")
+@volume_cli.command(
+    name="list",
+    help="List the details of all modal.Volume volumes in an Environment.",
+    rich_help_panel="Management",
+)
 @synchronizer.create_blocking
-async def list(env: Optional[str] = ENV_OPTION, json: Optional[bool] = False):
+async def list_(env: Optional[str] = ENV_OPTION, json: Optional[bool] = False):
     env = ensure_env(env)
     client = await _Client.from_env()
     response = await retry_transient_errors(client.stub.VolumeList, api_pb2.VolumeListRequest(environment_name=env))
@@ -114,7 +120,11 @@ async def list(env: Optional[str] = ENV_OPTION, json: Optional[bool] = False):
     display_table(column_names, rows, json, title=f"Volumes{env_part}")
 
 
-@volume_cli.command(name="ls", help="List files and directories in a modal.Volume volume.")
+@volume_cli.command(
+    name="ls",
+    help="List files and directories in a modal.Volume volume.",
+    rich_help_panel="File operations",
+)
 @synchronizer.create_blocking
 async def ls(
     volume_name: str,
@@ -134,13 +144,12 @@ async def ls(
             raise UsageError(exc.message)
         raise
 
-    if sys.stdout.isatty():
-        console = Console()
-        console.print(f"Directory listing of '{path}' in '{volume_name}'")
-        table = Table()
-        for name in ["filename", "type", "created/modified", "size"]:
-            table.add_column(name)
-
+    if not json and not sys.stdout.isatty():
+        # Legacy behavior -- I am not sure why exactly we did this originally but I don't want to break it
+        for entry in entries:
+            print(entry.path)
+    else:
+        rows = []
         for entry in entries:
             if entry.type == api_pb2.FileEntry.FileType.DIRECTORY:
                 filetype = "dir"
@@ -148,26 +157,29 @@ async def ls(
                 filetype = "link"
             else:
                 filetype = "file"
-            table.add_row(
-                entry.path,
-                filetype,
-                timestamp_to_local(entry.mtime, False),
-                humanize_filesize(entry.size),
+            rows.append(
+                (
+                    entry.path.encode("unicode_escape").decode("utf-8"),
+                    filetype,
+                    timestamp_to_local(entry.mtime, False),
+                    humanize_filesize(entry.size),
+                )
             )
-        console.print(table)
-    else:
-        for entry in entries:
-            print(entry.path)
+        columns = ["Filename", "Type", "Created/Modified", "Size"]
+        title = f"Directory listing of '{path}' in '{volume_name}'"
+        display_table(columns, rows, json, title)
 
 
 @volume_cli.command(
     name="put",
-    help="""Upload a file or directory to a volume.
+    help="""Upload a file or directory to a modal.Volume.
 
 Remote parent directories will be created as needed.
 
-Ending the REMOTE_PATH with a forward slash (/), it's assumed to be a directory and the file will be uploaded with its current name under that directory.
+Ending the REMOTE_PATH with a forward slash (/), it's assumed to be a directory
+and the file will be uploaded with its current name under that directory.
 """,
+    rich_help_panel="File operations",
 )
 @synchronizer.create_blocking
 async def put(
@@ -185,30 +197,36 @@ async def put(
     if remote_path.endswith("/"):
         remote_path = remote_path + os.path.basename(local_path)
     console = Console()
+    progress_handler = ProgressHandler(type="upload", console=console)
 
     if Path(local_path).is_dir():
-        spinner = step_progress(f"Uploading directory '{local_path}' to '{remote_path}'...")
-        with Live(spinner, console=console):
+        with progress_handler.live:
             try:
-                async with _VolumeUploadContextManager(vol.object_id, vol._client, force=force) as batch:
+                async with _VolumeUploadContextManager(
+                    vol.object_id, vol._client, progress_cb=progress_handler.progress, force=force
+                ) as batch:
                     batch.put_directory(local_path, remote_path)
             except FileExistsError as exc:
                 raise UsageError(str(exc))
-        console.print(step_completed(f"Uploaded directory '{local_path}' to '{remote_path}'"))
+        console.print(OutputManager.step_completed(f"Uploaded directory '{local_path}' to '{remote_path}'"))
     elif "*" in local_path:
         raise UsageError("Glob uploads are currently not supported")
     else:
-        spinner = step_progress(f"Uploading file '{local_path}' to '{remote_path}'...")
-        with Live(spinner, console=console):
+        with progress_handler.live:
             try:
-                async with _VolumeUploadContextManager(vol.object_id, vol._client, force=force) as batch:
+                async with _VolumeUploadContextManager(
+                    vol.object_id, vol._client, progress_cb=progress_handler.progress, force=force
+                ) as batch:
                     batch.put_file(local_path, remote_path)
+
             except FileExistsError as exc:
                 raise UsageError(str(exc))
-        console.print(step_completed(f"Uploaded file '{local_path}' to '{remote_path}'"))
+        console.print(OutputManager.step_completed(f"Uploaded file '{local_path}' to '{remote_path}'"))
 
 
-@volume_cli.command(name="rm", help="Delete a file or directory from a volume.")
+@volume_cli.command(
+    name="rm", help="Delete a file or directory from a modal.Volume.", rich_help_panel="File operations"
+)
 @synchronizer.create_blocking
 async def rm(
     volume_name: str,
@@ -229,12 +247,17 @@ async def rm(
 
 
 @volume_cli.command(
-    name="cp", help="Copy source file to destination file or multiple source files to destination directory."
+    name="cp",
+    help=(
+        "Copy within a modal.Volume. "
+        "Copy source file to destination file or multiple source files to destination directory."
+    ),
+    rich_help_panel="File operations",
 )
 @synchronizer.create_blocking
 async def cp(
     volume_name: str,
-    paths: List[str],  # accepts multiple paths, last path is treated as destination path
+    paths: list[str],  # accepts multiple paths, last path is treated as destination path
     env: Optional[str] = ENV_OPTION,
 ):
     ensure_env(env)
@@ -245,27 +268,45 @@ async def cp(
     await volume.copy_files(src_paths, dst_path)
 
 
-@volume_cli.command(name="delete", help="Delete a named, persistent modal.Volume.")
+@volume_cli.command(
+    name="delete",
+    help="Delete a named, persistent modal.Volume.",
+    rich_help_panel="Management",
+)
 @synchronizer.create_blocking
 async def delete(
     volume_name: str = Argument(help="Name of the modal.Volume to be deleted. Case sensitive"),
-    yes: bool = Option(default=False, help="Delete without prompting for confirmation."),
-    confirm: bool = Option(default=False, help="DEPRECATED: See `--yes` option"),
+    yes: bool = YES_OPTION,
     env: Optional[str] = ENV_OPTION,
 ):
-    if confirm:
-        deprecation_warning(
-            (2024, 4, 24),
-            "The `--confirm` option is deprecated; use `--yes` to delete without prompting.",
-            show_source=False,
+    if not yes:
+        typer.confirm(
+            f"Are you sure you want to irrevocably delete the modal.Volume '{volume_name}'?",
+            default=False,
+            abort=True,
         )
-        yes = True
 
+    await _Volume.delete(volume_name, environment_name=env)
+
+
+@volume_cli.command(
+    name="rename",
+    help="Rename a modal.Volume.",
+    rich_help_panel="Management",
+)
+@synchronizer.create_blocking
+async def rename(
+    old_name: str,
+    new_name: str,
+    yes: bool = YES_OPTION,
+    env: Optional[str] = ENV_OPTION,
+):
     if not yes:
         typer.confirm(
-            f"Are you sure you want to irrevocably delete the modal.Volume '{volume_name}'?",
+            f"Are you sure you want rename the modal.Volume '{old_name}'?"
+            " This may break any Apps currently using it.",
             default=False,
             abort=True,
         )
 
-    await _Volume.delete(label=volume_name, environment_name=env)
+    await _Volume.rename(old_name, new_name, environment_name=env)