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

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 Image, Queue, Stub, 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", "{}"))
 
+app = App()
 
-stub = Stub()
-stub.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)
 
 
-@stub.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",
             ],
@@ -58,7 +83,7 @@ def run_jupyter(q: Queue):
     q.put("done")
 
 
-@stub.local_entrypoint()
+@app.local_entrypoint()
 def main():
     with Queue.ephemeral() as q:
         run_jupyter.spawn(q)

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 Image, Queue, Stub, 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"
 
-stub = Stub()
-stub.image = Image.from_registry("codercom/code-server", add_python="3.11").dockerfile_commands("ENTRYPOINT []")
 
+app = App()
+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": ""})
+)
 
-def wait_for_port(data: Tuple[str, str], q: Queue):
+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):
     start_time = time.monotonic()
     while True:
         try:
@@ -33,7 +74,16 @@ def wait_for_port(data: Tuple[str, str], q: Queue):
     q.put(data)
 
 
-@stub.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,13 +91,13 @@ 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")
 
 
-@stub.local_entrypoint()
+@app.local_entrypoint()
 def main():
     with Queue.ephemeral() as q:
         run_vscode.spawn(q)

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))