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

modal/cli/network_file_system.py

@@ -8,18 +8,17 @@ 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 Typer
+from typer import Argument, Typer
 
 import modal
 from modal._location import display_location
-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.network_file_system import _NetworkFileSystem
@@ -28,9 +27,9 @@ from modal_proto import api_pb2
 nfs_cli = Typer(name="nfs", help="Read and edit `modal.NetworkFileSystem` file systems.", no_args_is_help=True)
 
 
-@nfs_cli.command(name="list", help="List the names of all network file systems.")
+@nfs_cli.command(name="list", help="List the names of all network file systems.", 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()
@@ -59,7 +58,7 @@ def some_func():
 """
 
 
-@nfs_cli.command(name="create", help="Create a named network file system.")
+@nfs_cli.command(name="create", help="Create a named network file system.", rich_help_panel="Management")
 def create(
     name: str,
     env: Optional[str] = ENV_OPTION,
@@ -81,7 +80,11 @@ async def _volume_from_name(deployment_name: str) -> _NetworkFileSystem:
     return network_file_system
 
 
-@nfs_cli.command(name="ls", help="List files and directories in a network file system.")
+@nfs_cli.command(
+    name="ls",
+    help="List files and directories in a network file system.",
+    rich_help_panel="File operations",
+)
 @synchronizer.create_blocking
 async def ls(
     volume_name: str,
@@ -120,8 +123,10 @@ async def ls(
 
 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(
@@ -137,19 +142,23 @@ async def put(
     console = Console()
 
     if Path(local_path).is_dir():
-        spinner = step_progress(f"Uploading directory '{local_path}' to '{remote_path}'...")
-        with Live(spinner, console=console):
-            await volume.add_local_dir(local_path, remote_path)
-        console.print(step_completed(f"Uploaded directory '{local_path}' to '{remote_path}'"))
+        progress_handler = ProgressHandler(type="upload", console=console)
+        with progress_handler.live:
+            await volume.add_local_dir(local_path, remote_path, progress_cb=progress_handler.progress)
+            progress_handler.progress(complete=True)
+        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):
-            written_bytes = await volume.add_local_file(local_path, remote_path)
+        progress_handler = ProgressHandler(type="upload", console=console)
+        with progress_handler.live:
+            written_bytes = await volume.add_local_file(local_path, remote_path, progress_cb=progress_handler.progress)
+            progress_handler.progress(complete=True)
         console.print(
-            step_completed(f"Uploaded file '{local_path}' to '{remote_path}' ({written_bytes} bytes written)")
+            OutputManager.step_completed(
+                f"Uploaded file '{local_path}' to '{remote_path}' ({written_bytes} bytes written)"
+            )
         )
 
 
@@ -158,7 +167,7 @@ class CliError(Exception):
         self.message = message
 
 
-@nfs_cli.command(name="get")
+@nfs_cli.command(name="get", rich_help_panel="File operations")
 @synchronizer.create_blocking
 async def get(
     volume_name: str,
@@ -174,7 +183,7 @@ async def get(
 
     For example, to download an entire network file system into `dump_volume`:
 
-    ```bash
+    ```
     modal nfs get <volume-name> "**" dump_volume
     ```
 
@@ -183,10 +192,16 @@ async def get(
     ensure_env(env)
     destination = Path(local_destination)
     volume = await _volume_from_name(volume_name)
-    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!"))
 
 
-@nfs_cli.command(name="rm", help="Delete a file or directory from a network file system.")
+@nfs_cli.command(
+    name="rm", help="Delete a file or directory from a network file system.", rich_help_panel="File operations"
+)
 @synchronizer.create_blocking
 async def rm(
     volume_name: str,
@@ -202,3 +217,24 @@ async def rm(
         if exc.status in (Status.NOT_FOUND, Status.INVALID_ARGUMENT):
             raise UsageError(exc.message)
         raise
+
+
+@nfs_cli.command(
+    name="delete",
+    help="Delete a named, persistent modal.NetworkFileSystem.",
+    rich_help_panel="Management",
+)
+@synchronizer.create_blocking
+async def delete(
+    nfs_name: str = Argument(help="Name of the modal.NetworkFileSystem to be deleted. Case sensitive"),
+    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.NetworkFileSystem '{nfs_name}'?",
+            default=False,
+            abort=True,
+        )
+
+    await _NetworkFileSystem.delete(nfs_name, environment_name=env)

modal/cli/profile.py

@@ -28,7 +28,7 @@ def current():
 
 @profile_cli.command(name="list", help="Show all Modal profiles and highlight the active one.")
 @synchronizer.create_blocking
-async def list(json: Optional[bool] = False):
+async def list_(json: Optional[bool] = False):
     config = Config()
     profiles = config_profiles()
     lookup_coros = [

modal/cli/programs/run_jupyter.py

@@ -8,16 +8,32 @@ import subprocess
 import threading
 import time
 import webbrowser
-from typing import Any, Dict
+from typing import Any
 
-from modal import App, Image, Queue, forward
-
-# Passed by `modal launch` locally via CLI, empty on remote runner.
-args: Dict[str, Any] = json.loads(os.environ.get("MODAL_LAUNCH_LOCAL_ARGS", "{}"))
+from modal import App, Image, Queue, Secret, Volume, forward
 
+# Passed by `modal launch` locally via CLI, plumbed to remote runner through secrets.
+args: dict[str, Any] = json.loads(os.environ.get("MODAL_LAUNCH_ARGS", "{}"))
 
 app = App()
-app.image = Image.from_registry(args.get("image"), add_python=args.get("add_python")).pip_install("jupyterlab")
+
+image = Image.from_registry(args.get("image"), add_python=args.get("add_python")).pip_install("jupyterlab")
+
+if args.get("mount"):
+    image = image.add_local_dir(
+        args.get("mount"),
+        remote_path="/root/lab/mount",
+    )
+
+volume = (
+    Volume.from_name(
+        args.get("volume"),
+        create_if_missing=True,
+    )
+    if args.get("volume")
+    else None
+)
+volumes = {"/root/lab/volume": volume} if volume else {}
 
 
 def wait_for_port(url: str, q: Queue):
@@ -33,9 +49,18 @@ def wait_for_port(url: str, q: Queue):
     q.put(url)
 
 
-@app.function(cpu=args.get("cpu"), memory=args.get("memory"), gpu=args.get("gpu"), timeout=args.get("timeout"))
+@app.function(
+    image=image,
+    cpu=args.get("cpu"),
+    memory=args.get("memory"),
+    gpu=args.get("gpu"),
+    timeout=args.get("timeout"),
+    secrets=[Secret.from_dict({"MODAL_LAUNCH_ARGS": json.dumps(args)})],
+    volumes=volumes,
+    concurrency_limit=1 if volume else None,
+)
 def run_jupyter(q: Queue):
-    os.mkdir("/lab")
+    os.makedirs("/root/lab", exist_ok=True)
     token = secrets.token_urlsafe(13)
     with forward(8888) as tunnel:
         url = tunnel.url + "/?token=" + token
@@ -48,7 +73,7 @@ def run_jupyter(q: Queue):
                 "--allow-root",
                 "--ip=0.0.0.0",
                 "--port=8888",
-                "--notebook-dir=/lab",
+                "--notebook-dir=/root/lab",
                 "--LabApp.allow_origin='*'",
                 "--LabApp.allow_remote_access=1",
             ],

modal/cli/programs/vscode.py

@@ -8,19 +8,60 @@ import subprocess
 import threading
 import time
 import webbrowser
-from typing import Any, Dict, Tuple
+from typing import Any
 
-from modal import App, Image, Queue, forward
+from modal import App, Image, Queue, Secret, Volume, forward
 
-# Passed by `modal launch` locally via CLI, empty on remote runner.
-args: Dict[str, Any] = json.loads(os.environ.get("MODAL_LAUNCH_LOCAL_ARGS", "{}"))
+# Passed by `modal launch` locally via CLI, plumbed to remote runner through secrets.
+args: dict[str, Any] = json.loads(os.environ.get("MODAL_LAUNCH_ARGS", "{}"))
+
+CODE_SERVER_INSTALLER = "https://code-server.dev/install.sh"
+CODE_SERVER_ENTRYPOINT = (
+    "https://raw.githubusercontent.com/coder/code-server/refs/tags/v4.96.1/ci/release-image/entrypoint.sh"
+)
+FIXUD_INSTALLER = "https://github.com/boxboat/fixuid/releases/download/v0.6.0/fixuid-0.6.0-linux-$ARCH.tar.gz"
 
 
 app = App()
-app.image = Image.from_registry("codercom/code-server", add_python="3.11").dockerfile_commands("ENTRYPOINT []")
+image = (
+    Image.from_registry(args.get("image"), add_python="3.11")
+    .apt_install("curl", "dumb-init", "git", "git-lfs")
+    .run_commands(
+        f"curl -fsSL {CODE_SERVER_INSTALLER} | sh",
+        f"curl -fsSL {CODE_SERVER_ENTRYPOINT}  > /code-server.sh",
+        "chmod u+x /code-server.sh",
+    )
+    .run_commands(
+        'ARCH="$(dpkg --print-architecture)"'
+        f' && curl -fsSL "{FIXUD_INSTALLER}" | tar -C /usr/local/bin -xzf - '
+        " && chown root:root /usr/local/bin/fixuid"
+        " && chmod 4755 /usr/local/bin/fixuid"
+        " && mkdir -p /etc/fixuid"
+        ' && echo "user: root" >> /etc/fixuid/config.yml'
+        ' && echo "group: root" >> /etc/fixuid/config.yml'
+    )
+    .run_commands("mkdir /home/coder")
+    .env({"ENTRYPOINTD": ""})
+)
+
+if args.get("mount"):
+    image = image.add_local_dir(
+        args.get("mount"),
+        remote_path="/home/coder/mount",
+    )
+
+volume = (
+    Volume.from_name(
+        args.get("volume"),
+        create_if_missing=True,
+    )
+    if args.get("volume")
+    else None
+)
+volumes = {"/home/coder/volume": volume} if volume else {}
 
 
-def wait_for_port(data: Tuple[str, str], q: Queue):
+def wait_for_port(data: tuple[str, str], q: Queue):
     start_time = time.monotonic()
     while True:
         try:
@@ -33,7 +74,16 @@ def wait_for_port(data: Tuple[str, str], q: Queue):
     q.put(data)
 
 
-@app.function(cpu=args.get("cpu"), memory=args.get("memory"), gpu=args.get("gpu"), timeout=args.get("timeout"))
+@app.function(
+    image=image,
+    cpu=args.get("cpu"),
+    memory=args.get("memory"),
+    gpu=args.get("gpu"),
+    timeout=args.get("timeout"),
+    secrets=[Secret.from_dict({"MODAL_LAUNCH_ARGS": json.dumps(args)})],
+    volumes=volumes,
+    concurrency_limit=1 if volume else None,
+)
 def run_vscode(q: Queue):
     os.chdir("/home/coder")
     token = secrets.token_urlsafe(13)
@@ -41,7 +91,7 @@ def run_vscode(q: Queue):
         url = tunnel.url
         threading.Thread(target=wait_for_port, args=((url, token), q)).start()
         subprocess.run(
-            ["/usr/bin/entrypoint.sh", "--bind-addr", "0.0.0.0:8080", "."],
+            ["/code-server.sh", "--bind-addr", "0.0.0.0:8080", "."],
             env={**os.environ, "SHELL": "/bin/bash", "PASSWORD": token},
         )
     q.put("done")

modal/cli/queues.py

@@ -0,0 +1,131 @@
+# Copyright Modal Labs 2024
+from typing import Optional
+
+import typer
+from rich.console import Console
+from typer import Argument, Option, Typer
+
+from modal._resolver import Resolver
+from modal._utils.async_utils import synchronizer
+from modal._utils.grpc_utils import retry_transient_errors
+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.queue import _Queue
+from modal_proto import api_pb2
+
+queue_cli = Typer(
+    name="queue",
+    no_args_is_help=True,
+    help="Manage `modal.Queue` objects and inspect their contents.",
+)
+
+PARTITION_OPTION = Option(
+    None,
+    "-p",
+    "--partition",
+    help="Name of the partition to use, otherwise use the default (anonymous) partition.",
+)
+
+
+@queue_cli.command(name="create", rich_help_panel="Management")
+@synchronizer.create_blocking
+async def create(name: str, *, env: Optional[str] = ENV_OPTION):
+    """Create a named Queue.
+
+    Note: This is a no-op when the Queue already exists.
+    """
+    q = _Queue.from_name(name, environment_name=env, create_if_missing=True)
+    client = await _Client.from_env()
+    resolver = Resolver(client=client)
+    await resolver.load(q)
+
+
+@queue_cli.command(name="delete", rich_help_panel="Management")
+@synchronizer.create_blocking
+async def delete(name: str, *, yes: bool = YES_OPTION, env: Optional[str] = ENV_OPTION):
+    """Delete a named Queue and all of its data."""
+    # Lookup first to validate the name, even though delete is a staticmethod
+    await _Queue.lookup(name, environment_name=env)
+    if not yes:
+        typer.confirm(
+            f"Are you sure you want to irrevocably delete the modal.Queue '{name}'?",
+            default=False,
+            abort=True,
+        )
+    await _Queue.delete(name, environment_name=env)
+
+
+@queue_cli.command(name="list", rich_help_panel="Management")
+@synchronizer.create_blocking
+async def list_(*, json: bool = False, env: Optional[str] = ENV_OPTION):
+    """List all named Queues."""
+    env = ensure_env(env)
+
+    max_total_size = 100_000
+    client = await _Client.from_env()
+    request = api_pb2.QueueListRequest(environment_name=env, total_size_limit=max_total_size + 1)
+    response = await retry_transient_errors(client.stub.QueueList, request)
+
+    rows = [
+        (
+            q.name,
+            timestamp_to_local(q.created_at, json),
+            str(q.num_partitions),
+            str(q.total_size) if q.total_size <= max_total_size else f">{max_total_size}",
+        )
+        for q in response.queues
+    ]
+    display_table(["Name", "Created at", "Partitions", "Total size"], rows, json)
+
+
+@queue_cli.command(name="clear", rich_help_panel="Management")
+@synchronizer.create_blocking
+async def clear(
+    name: str,
+    partition: Optional[str] = PARTITION_OPTION,
+    all: bool = Option(False, "-a", "--all", help="Clear the contents of all partitions."),
+    yes: bool = YES_OPTION,
+    *,
+    env: Optional[str] = ENV_OPTION,
+):
+    """Clear the contents of a queue by removing all of its data."""
+    q = await _Queue.lookup(name, environment_name=env)
+    if not yes:
+        typer.confirm(
+            f"Are you sure you want to irrevocably delete the contents of modal.Queue '{name}'?",
+            default=False,
+            abort=True,
+        )
+    await q.clear(partition=partition, all=all)
+
+
+@queue_cli.command(name="peek", rich_help_panel="Inspection")
+@synchronizer.create_blocking
+async def peek(
+    name: str, n: int = Argument(1), partition: Optional[str] = PARTITION_OPTION, *, env: Optional[str] = ENV_OPTION
+):
+    """Print the next N items in the queue or queue partition (without removal)."""
+    q = await _Queue.lookup(name, environment_name=env)
+    console = Console()
+    i = 0
+    async for item in q.iterate(partition=partition):
+        console.print(item)
+        i += 1
+        if i >= n:
+            break
+
+
+@queue_cli.command(name="len", rich_help_panel="Inspection")
+@synchronizer.create_blocking
+async def len(
+    name: str,
+    partition: Optional[str] = PARTITION_OPTION,
+    total: bool = Option(False, "-t", "--total", help="Compute the sum of the queue lengths across all partitions"),
+    *,
+    env: Optional[str] = ENV_OPTION,
+):
+    """Print the length of a queue partition or the total length of all partitions."""
+    q = await _Queue.lookup(name, environment_name=env)
+    console = Console()
+    console.print(await q.len(partition=partition, total=total))