modal 0.62.16__py3-none-any.whl → 0.72.11__py3-none-any.whl

modal/cli/utils.py

@@ -1,19 +1,74 @@
 # Copyright Modal Labs 2022
+import asyncio
+from collections.abc import Sequence
 from datetime import datetime
-from typing import List, Union
+from json import dumps
+from typing import Optional, Union
 
 import typer
+from click import UsageError
+from grpclib import GRPCError, Status
 from rich.console import Console
-from rich.json import JSON
-from rich.table import Table
+from rich.table import Column, Table
 from rich.text import Text
 
+from modal_proto import api_pb2
 
-def timestamp_to_local(ts: float) -> str:
+from .._output import OutputManager, get_app_logs_loop
+from .._utils.async_utils import synchronizer
+from ..client import _Client
+from ..environments import ensure_env
+from ..exception import NotFoundError
+
+
+@synchronizer.create_blocking
+async def stream_app_logs(
+    app_id: Optional[str] = None, task_id: Optional[str] = None, app_logs_url: Optional[str] = None
+):
+    client = await _Client.from_env()
+    output_mgr = OutputManager(status_spinner_text=f"Tailing logs for {app_id}")
+    try:
+        with output_mgr.show_status_spinner():
+            await get_app_logs_loop(client, output_mgr, app_id=app_id, task_id=task_id, app_logs_url=app_logs_url)
+    except asyncio.CancelledError:
+        pass
+    except GRPCError as exc:
+        if exc.status in (Status.INVALID_ARGUMENT, Status.NOT_FOUND):
+            raise UsageError(exc.message)
+        else:
+            raise
+    except KeyboardInterrupt:
+        pass
+
+
+@synchronizer.create_blocking
+async def get_app_id_from_name(name: str, env: Optional[str], client: Optional[_Client] = None) -> str:
+    if client is None:
+        client = await _Client.from_env()
+    env_name = ensure_env(env)
+    request = api_pb2.AppGetByDeploymentNameRequest(
+        namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE, name=name, environment_name=env_name
+    )
+    try:
+        resp = await client.stub.AppGetByDeploymentName(request)
+    except GRPCError as exc:
+        if exc.status in (Status.INVALID_ARGUMENT, Status.NOT_FOUND):
+            raise UsageError(exc.message or "")
+        raise
+    if not resp.app_id:
+        env_comment = f" in the '{env_name}' environment" if env_name else ""
+        raise NotFoundError(f"Could not find a deployed app named '{name}'{env_comment}.")
+    return resp.app_id
+
+
+def timestamp_to_local(ts: float, isotz: bool = True) -> str:
     if ts > 0:
         locale_tz = datetime.now().astimezone().tzinfo
         dt = datetime.fromtimestamp(ts, tz=locale_tz)
-        return dt.isoformat(sep=" ", timespec="seconds")
+        if isotz:
+            return dt.isoformat(sep=" ", timespec="seconds")
+        else:
+            return f"{datetime.strftime(dt, '%Y-%m-%d %H:%M')} {locale_tz.tzname(dt)}"
     else:
         return None
 
@@ -22,13 +77,25 @@ def _plain(text: Union[Text, str]) -> str:
     return text.plain if isinstance(text, Text) else text
 
 
-def display_table(column_names: List[str], rows: List[List[Union[Text, str]]], json: bool, title: str = None):
+def is_tty() -> bool:
+    return Console().is_terminal
+
+
+def display_table(
+    columns: Sequence[Union[Column, str]],
+    rows: Sequence[Sequence[Union[Text, str]]],
+    json: bool = False,
+    title: str = "",
+):
+    def col_to_str(col: Union[Column, str]) -> str:
+        return str(col.header) if isinstance(col, Column) else col
+
     console = Console()
     if json:
-        json_data = [{col: _plain(row[i]) for i, col in enumerate(column_names)} for row in rows]
-        console.print(JSON.from_data(json_data))
+        json_data = [{col_to_str(col): _plain(row[i]) for i, col in enumerate(columns)} for row in rows]
+        console.print_json(dumps(json_data))
     else:
-        table = Table(*column_names, title=title)
+        table = Table(*columns, title=title)
         for row in rows:
             table.add_row(*row)
         console.print(table)
@@ -39,4 +106,6 @@ ENV_OPTION_HELP = """Environment to interact with.
 If not specified, Modal will use the default environment of your current profile, or the `MODAL_ENVIRONMENT` variable.
 Otherwise, raises an error if the workspace has multiple environments.
 """
-ENV_OPTION = typer.Option(default=None, help=ENV_OPTION_HELP)
+ENV_OPTION = typer.Option(None, "-e", "--env", help=ENV_OPTION_HELP)
+
+YES_OPTION = typer.Option(False, "-y", "--yes", help="Run without pausing for confirmation.")

modal/cli/volume.py

@@ -1,36 +1,27 @@
 # Copyright Modal Labs 2022
 import os
-import shutil
 import sys
-from contextlib import contextmanager
-from datetime import datetime
 from pathlib import Path
-from tempfile import NamedTemporaryFile
-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 _glob_download
-from modal.cli.utils import ENV_OPTION, display_table
+from modal.cli._download import _volume_download
+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.volume import _Volume, _VolumeUploadContextManager
 from modal_proto import api_pb2
 
-FileType = api_pb2.VolumeListFilesEntry.FileType
-PIPE_PATH = Path("-")
-
 volume_cli = Typer(
     name="volume",
     no_args_is_help=True,
@@ -58,26 +49,27 @@ 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"""
-@stub.function(volumes={{"/my_vol": modal.Volume.from_name("{name}")}})
+@app.function(volumes={{"/my_vol": modal.Volume.from_name("{name}")}})
 def some_func():
     os.listdir("/my_vol")
 """
 
     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,
@@ -86,83 +78,58 @@ async def get(
     force: bool = False,
     env: Optional[str] = ENV_OPTION,
 ):
-    """Download files from a modal.Volume.
+    """Download files from a modal.Volume object.
 
-    Specifying a glob pattern (using any `*` or `**` patterns) as the `remote_path` will download all matching *files*, preserving
-    the source directory structure for the matched files.
+    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> "**" dump_volume
+    ```
+    modal volume get <volume_name> logs/april-12-1.txt
+    modal volume get <volume_name> / volume_data_dump
     ```
 
-    Use "-" (a hyphen) as LOCAL_DESTINATION to write contents of file to stdout (only for non-glob paths).
+    Use "-" as LOCAL_DESTINATION to write file contents to standard output.
     """
     ensure_env(env)
     destination = Path(local_destination)
     volume = await _Volume.lookup(volume_name, environment_name=env)
-
-    def is_file_fn(entry):
-        return entry.type == FileType.FILE
-
-    if "*" in remote_path:
-        await _glob_download(volume, is_file_fn, remote_path, destination, force)
-        return
-
-    if destination != PIPE_PATH:
-        if destination.is_dir():
-            destination = destination / remote_path.rsplit("/")[-1]
-
-        if destination.exists() and not force:
-            raise UsageError(f"'{destination}' already exists")
-        elif not destination.parent.exists():
-            raise UsageError(f"Local directory '{destination.parent}' does not exist")
-
-    @contextmanager
-    def _destination_stream():
-        if destination == PIPE_PATH:
-            yield sys.stdout.buffer
-        else:
-            with NamedTemporaryFile(delete=False) as fp:
-                yield fp
-            shutil.move(fp.name, destination)
-
-    try:
-        with _destination_stream() as fp:
-            await volume.read_file_into_fileobj(remote_path.lstrip("/"), fileobj=fp, progress=destination != PIPE_PATH)
-    except FileNotFoundError as exc:
-        raise UsageError(str(exc))
-    except GRPCError as exc:
-        raise UsageError(exc.message) if exc.status == Status.INVALID_ARGUMENT else exc
+    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))
     env_part = f" in environment '{env}'" if env else ""
     column_names = ["Name", "Created at"]
     rows = []
-    locale_tz = datetime.now().astimezone().tzinfo
     for item in response.items:
-        rows.append(
-            [
-                item.label,
-                str(datetime.fromtimestamp(item.created_at, tz=locale_tz)),
-            ]
-        )
+        rows.append([item.label, timestamp_to_local(item.created_at, json)])
     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,
     path: str = Argument(default="/"),
+    json: bool = False,
     env: Optional[str] = ENV_OPTION,
 ):
     ensure_env(env)
@@ -177,41 +144,42 @@ 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)
-
-        locale_tz = datetime.now().astimezone().tzinfo
+    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:
-            if entry.type == FileType.DIRECTORY:
+            print(entry.path)
+    else:
+        rows = []
+        for entry in entries:
+            if entry.type == api_pb2.FileEntry.FileType.DIRECTORY:
                 filetype = "dir"
-            elif entry.type == FileType.SYMLINK:
+            elif entry.type == api_pb2.FileEntry.FileType.SYMLINK:
                 filetype = "link"
             else:
                 filetype = "file"
-            table.add_row(
-                entry.path,
-                filetype,
-                str(datetime.fromtimestamp(entry.mtime, tz=locale_tz)),
-                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(
@@ -229,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,
@@ -273,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)
@@ -289,23 +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"),
-    confirm: bool = Option(default=False, help="Set this flag to delete without prompting for confirmation"),
+    yes: bool = YES_OPTION,
     env: Optional[str] = ENV_OPTION,
 ):
-    env = ensure_env(env)
-    volume = await _Volume.lookup(volume_name, environment_name=env)
-    if not isinstance(volume, _Volume):
-        raise UsageError("The specified app entity is not a modal.Volume")
-
-    if not confirm:
+    if not yes:
         typer.confirm(
             f"Are you sure you want to irrevocably delete the modal.Volume '{volume_name}'?",
             default=False,
             abort=True,
         )
 
-    await volume.delete()
+    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 rename the modal.Volume '{old_name}'?"
+            " This may break any Apps currently using it.",
+            default=False,
+            abort=True,
+        )
+
+    await _Volume.rename(old_name, new_name, environment_name=env)