modal 1.1.2.dev11__tar.gz → 1.1.2.dev13__tar.gz

{modal-1.1.2.dev11 → modal-1.1.2.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.1.2.dev11
+Version: 1.1.2.dev13
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0
@@ -22,7 +22,7 @@ Requires-Dist: click~=8.1
 Requires-Dist: grpclib<0.4.9,>=0.4.7
 Requires-Dist: protobuf!=4.24.0,<7.0,>=3.19
 Requires-Dist: rich>=12.0.0
-Requires-Dist: synchronicity~=0.10.1
+Requires-Dist: synchronicity~=0.10.2
 Requires-Dist: toml
 Requires-Dist: typer>=0.9
 Requires-Dist: types-certifi

{modal-1.1.2.dev11 → modal-1.1.2.dev13}/modal/_runtime/container_io_manager.py

@@ -39,7 +39,6 @@ from modal.exception import ClientClosed, InputCancellation, InvalidError, Seria
 from modal_proto import api_pb2
 
 if TYPE_CHECKING:
-    import modal._runtime.asgi
     import modal._runtime.user_code_imports
 
 

modal-1.1.2.dev13/modal/_utils/time_utils.py

@@ -0,0 +1,43 @@
+# Copyright Modal Labs 2025
+from datetime import datetime, tzinfo
+from typing import Optional, Union
+
+
+def locale_tz() -> tzinfo:
+    return datetime.now().astimezone().tzinfo
+
+
+def as_timestamp(arg: Optional[Union[datetime, str]]) -> float:
+    """Coerce a user-provided argument to a timestamp.
+
+    An argument provided without timezone information will be treated as local time.
+
+    When the argument is null, returns the current time.
+    """
+    if arg is None:
+        dt = datetime.now().astimezone()
+    elif isinstance(arg, str):
+        dt = datetime.fromisoformat(arg)
+    elif isinstance(arg, datetime):
+        dt = arg
+    else:
+        raise TypeError(f"Invalid argument: {arg}")
+
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=locale_tz())
+    return dt.timestamp()
+
+
+def timestamp_to_localized_dt(ts: float) -> datetime:
+    return datetime.fromtimestamp(ts, tz=locale_tz())
+
+
+def timestamp_to_localized_str(ts: float, isotz: bool = True) -> Optional[str]:
+    if ts > 0:
+        dt = timestamp_to_localized_dt(ts)
+        if isotz:
+            return dt.isoformat(sep=" ", timespec="seconds")
+        else:
+            return f"{dt:%Y-%m-%d %H:%M %Z}"
+    else:
+        return None

{modal-1.1.2.dev11 → modal-1.1.2.dev13}/modal/cli/dict.py

@@ -7,13 +7,11 @@ from typer import Argument, Option, Typer
 from modal._output import make_console
 from modal._resolver import Resolver
 from modal._utils.async_utils import synchronizer
-from modal._utils.grpc_utils import retry_transient_errors
 from modal._utils.time_utils import timestamp_to_localized_str
 from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table
 from modal.client import _Client
 from modal.dict import _Dict
 from modal.environments import ensure_env
-from modal_proto import api_pb2
 
 dict_cli = Typer(
     name="dict",
@@ -40,12 +38,13 @@ async def create(name: str, *, env: Optional[str] = ENV_OPTION):
 async def list_(*, json: bool = False, env: Optional[str] = ENV_OPTION):
     """List all named Dicts."""
     env = ensure_env(env)
-    client = await _Client.from_env()
-    request = api_pb2.DictListRequest(environment_name=env)
-    response = await retry_transient_errors(client.stub.DictList, request)
+    dicts = await _Dict.objects.list(environment_name=env)
+    rows = []
+    for obj in dicts:
+        info = await obj.info()
+        rows.append((info.name, timestamp_to_localized_str(info.created_at.timestamp(), json), info.created_by))
 
-    rows = [(d.name, timestamp_to_localized_str(d.created_at, json)) for d in response.dicts]
-    display_table(["Name", "Created at"], rows, json)
+    display_table(["Name", "Created at", "Created by"], rows, json)
 
 
 @dict_cli.command("clear", rich_help_panel="Management")

{modal-1.1.2.dev11 → modal-1.1.2.dev13}/modal/cli/launch.py

@@ -3,6 +3,8 @@ import asyncio
 import inspect
 import json
 import os
+import subprocess
+import tempfile
 from pathlib import Path
 from typing import Any, Optional
 
@@ -26,7 +28,9 @@ launch_cli = Typer(
 )
 
 
-def _launch_program(name: str, filename: str, detach: bool, args: dict[str, Any]) -> None:
+def _launch_program(
+    name: str, filename: str, detach: bool, args: dict[str, Any], *, description: Optional[str] = None
+) -> None:
     os.environ["MODAL_LAUNCH_ARGS"] = json.dumps(args)
 
     program_path = str(Path(__file__).parent / "programs" / filename)
@@ -35,7 +39,7 @@ def _launch_program(name: str, filename: str, detach: bool, args: dict[str, Any]
     entrypoint = module.main
 
     app = _get_runnable_app(entrypoint)
-    app.set_description(base_cmd)
+    app.set_description(description if description else base_cmd)
 
     # `launch/` scripts must have a `local_entrypoint()` with no args, for simplicity here.
     func = entrypoint.info.raw_f
@@ -108,3 +112,75 @@ def vscode(
         "volume": volume,
     }
     _launch_program("vscode", "vscode.py", detach, args)
+
+
+@launch_cli.command(name="machine", help="Start an instance on Modal, with direct SSH access.")
+def machine(
+    name: str,  # Name of the machine App.
+    cpu: int = 8,  # Reservation of CPU cores (can burst above this value).
+    memory: int = 32768,  # Reservation of memory in MiB (can burst above this value).
+    gpu: Optional[str] = None,  # GPU type and count, e.g. "t4" or "h100:2".
+    image: Optional[str] = None,  # Image tag to use from registry. Defaults to the notebook base image.
+    timeout: int = 3600 * 24,  # Timeout in seconds for the instance.
+    volume: str = "machine-vol",  # Attach a persisted `modal.Volume` at /workspace (created if missing).
+):
+    tempdir = Path(tempfile.gettempdir())
+    key_path = tempdir / "modal-machine-keyfile.pem"
+    # Generate a new SSH key pair for this machine instance.
+    if not key_path.exists():
+        subprocess.run(
+            ["ssh-keygen", "-t", "ed25519", "-f", str(key_path), "-N", ""],
+            check=True,
+            stdout=subprocess.DEVNULL,
+        )
+    # Add the key with expiry 1d to ssh agent.
+    subprocess.run(
+        ["ssh-add", "-t", "1d", str(key_path)],
+        check=True,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+    os.environ["SSH_PUBLIC_KEY"] = Path(str(key_path) + ".pub").read_text()
+    os.environ["MODAL_LOGS_TIMEOUT"] = "0"  # hack to work with --detach
+
+    args = {
+        "cpu": cpu,
+        "memory": memory,
+        "gpu": gpu,
+        "image": image,
+        "timeout": timeout,
+        "volume": volume,
+    }
+    _launch_program(
+        "machine",
+        "launch_instance_ssh.py",
+        True,
+        args,
+        description=name,
+    )
+
+
+@launch_cli.command(name="marimo", help="Start a remote Marimo notebook on Modal.")
+def marimo(
+    cpu: int = 8,
+    memory: int = 32768,
+    gpu: Optional[str] = None,
+    image: str = "debian:12",
+    timeout: int = 3600,
+    add_python: Optional[str] = "3.12",
+    mount: Optional[str] = None,  # Create a `modal.Mount` from a local directory.
+    volume: Optional[str] = None,  # Attach a persisted `modal.Volume` by name (creating if missing).
+    detach: bool = False,  # Run the app in "detached" mode to persist after local client disconnects
+):
+    args = {
+        "cpu": cpu,
+        "memory": memory,
+        "gpu": gpu,
+        "timeout": timeout,
+        "image": image,
+        "add_python": add_python,
+        "mount": mount,
+        "volume": volume,
+    }
+    _launch_program("marimo", "run_marimo.py", detach, args)

modal-1.1.2.dev13/modal/cli/programs/launch_instance_ssh.py

@@ -0,0 +1,94 @@
+# Copyright Modal Labs 2023
+# type: ignore
+import json
+import os
+import sys
+from typing import Any
+
+import rich
+import rich.panel
+import rich.rule
+
+import modal
+import modal.experimental
+
+# Passed by `modal launch` locally via CLI.
+args: dict[str, Any] = json.loads(os.environ.get("MODAL_LAUNCH_ARGS", "{}"))
+
+app = modal.App()
+
+image: modal.Image
+if args.get("image"):
+    image = modal.Image.from_registry(args.get("image"))
+else:
+    # Must be set to the same image builder version as the notebook base image.
+    os.environ["MODAL_IMAGE_BUILDER_VERSION"] = "2024.10"
+    image = modal.experimental.notebook_base_image(python_version="3.12")
+
+volume = (
+    modal.Volume.from_name(
+        args.get("volume"),
+        create_if_missing=True,
+    )
+    if args.get("volume")
+    else None
+)
+volumes = {"/workspace": volume} if volume else {}
+
+
+startup_script = """
+set -eu
+mkdir -p /run/sshd
+
+# Check if sshd is installed, install if not
+test -x /usr/sbin/sshd || (apt-get update && apt-get install -y openssh-server)
+
+# Change default working directory to /workspace
+echo "cd /workspace" >> /root/.profile
+
+mkdir -p /root/.ssh
+echo "$SSH_PUBLIC_KEY" >> /root/.ssh/authorized_keys
+/usr/sbin/sshd -D -e
+"""
+
+
+@app.local_entrypoint()
+def main():
+    if not os.environ.get("SSH_PUBLIC_KEY"):
+        raise ValueError("SSH_PUBLIC_KEY environment variable is not set")
+
+    sb = modal.Sandbox.create(
+        *("sh", "-c", startup_script),
+        app=app,
+        image=image,
+        cpu=args.get("cpu"),
+        memory=args.get("memory"),
+        gpu=args.get("gpu"),
+        timeout=args.get("timeout"),
+        volumes=volumes,
+        unencrypted_ports=[22],  # Forward SSH port
+        secrets=[modal.Secret.from_dict({"SSH_PUBLIC_KEY": os.environ.get("SSH_PUBLIC_KEY")})],
+    )
+    hostname, port = sb.tunnels()[22].tcp_socket
+    connection_cmd = f"ssh -A -p {port} root@{hostname}"
+
+    rich.print(
+        rich.rule.Rule(style="yellow"),
+        rich.panel.Panel(
+            f"""Your instance is ready! You can SSH into it using the following command:
+
+  [dim gray]>[/dim gray] [bold cyan]{connection_cmd}[/bold cyan]
+
+[italic]Details:[/italic]
+  • Name:    [magenta]{app.description}[/magenta]
+  • CPU:     [yellow]{args.get("cpu")} cores[/yellow]
+  • Memory:  [yellow]{args.get("memory")} MiB[/yellow]
+  • Timeout: [yellow]{args.get("timeout")} seconds[/yellow]
+  • GPU:     [green]{(args.get("gpu") or "N/A").upper()}[/green]""",
+            title="SSH Connection",
+            expand=False,
+        ),
+        rich.rule.Rule(style="yellow"),
+    )
+
+    sys.exit(0)  # Exit immediately to prevent "Timed out waiting for final apps log."

modal-1.1.2.dev13/modal/cli/programs/run_marimo.py

@@ -0,0 +1,95 @@
+# Copyright Modal Labs 2025
+# type: ignore
+import json
+import os
+import secrets
+import socket
+import subprocess
+import threading
+import time
+import webbrowser
+from typing import Any
+
+from modal import App, Image, Queue, Secret, Volume, forward
+
+# Args injected by `modal launch` CLI.
+args: dict[str, Any] = json.loads(os.environ.get("MODAL_LAUNCH_ARGS", "{}"))
+
+app = App()
+
+image = Image.from_registry(args.get("image"), add_python=args.get("add_python")).uv_pip_install("marimo")
+
+# Optional host-filesystem mount (read-only snapshot of your project, useful for editing)
+if args.get("mount"):
+    image = image.add_local_dir(args["mount"], remote_path="/root/marimo/mount")
+
+# Optional persistent Modal volume
+volume = Volume.from_name(args["volume"], create_if_missing=True) if args.get("volume") else None
+volumes = {"/root/marimo/volume": volume} if volume else {}
+
+
+def _wait_for_port(url: str, q: Queue) -> None:
+    start = time.monotonic()
+    while True:
+        try:
+            with socket.create_connection(("localhost", 8888), timeout=30):
+                break
+        except OSError as exc:
+            if time.monotonic() - start > 30:
+                raise TimeoutError("marimo server did not start within 30 s") from exc
+            time.sleep(0.05)
+    q.put(url)
+
+
+@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,
+    max_containers=1 if volume else None,
+)
+def run_marimo(q: Queue):
+    os.makedirs("/root/marimo", exist_ok=True)
+
+    # marimo supports token-based auth; generate one so only you can connect
+    token = secrets.token_urlsafe(12)
+
+    with forward(8888) as tunnel:
+        url = f"{tunnel.url}/?access_token={token}"
+        threading.Thread(target=_wait_for_port, args=(url, q), daemon=True).start()
+
+        print("\nmarimo on Modal, opening in browser …")
+        print(f"   -> {url}\n")
+
+        # Launch the headless edit server
+        subprocess.run(
+            [
+                "marimo",
+                "edit",
+                "--headless",  # don't open browser in container
+                "--host",
+                "0.0.0.0",  # bind all interfaces
+                "--port",
+                "8888",
+                "--token-password",
+                token,  # enable session-based auth
+                "--skip-update-check",
+                "/root/marimo",  # workspace directory
+            ],
+            env={**os.environ, "SHELL": "/bin/bash"},
+        )
+
+    q.put("done")
+
+
+@app.local_entrypoint()
+def main():
+    with Queue.ephemeral() as q:
+        run_marimo.spawn(q)
+        url = q.get()  # first message = connect URL
+        time.sleep(1)  # give server a heartbeat
+        webbrowser.open(url)
+        assert q.get() == "done"

{modal-1.1.2.dev11 → modal-1.1.2.dev13}/modal/cli/queues.py

@@ -1,4 +1,5 @@
 # Copyright Modal Labs 2024
+from datetime import datetime
 from typing import Optional
 
 import typer
@@ -62,22 +63,46 @@ async def delete(name: str, *, yes: bool = YES_OPTION, env: Optional[str] = ENV_
 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_localized_str(q.created_at, json),
-            str(q.num_partitions),
-            str(q.total_size) if q.total_size <= max_total_size else f">{max_total_size}",
+    max_total_size = 100_000  # Limit on the *Queue size* that we report
+
+    items: list[api_pb2.QueueListResponse.QueueInfo] = []
+
+    # Note that we need to continue using the gRPC API directly here rather than using Queue.objects.list.
+    # There is some metadata that historically appears in the CLI output (num_partitions, total_size) that
+    # doesn't make sense to transmit as hydration metadata, because the values can change over time and
+    # the metadata retrieved at hydration time could get stale. Alternatively, we could rewrite this using
+    # only public API by sequentially retrieving the queues and then querying their dynamic metadata, but
+    # that would require multiple round trips and would add lag to the CLI.
+    async def retrieve_page(created_before: float) -> bool:
+        max_page_size = 100
+        pagination = api_pb2.ListPagination(max_objects=max_page_size, created_before=created_before)
+        req = api_pb2.QueueListRequest(environment_name=env, pagination=pagination, total_size_limit=max_total_size)
+        resp = await retry_transient_errors(client.stub.QueueList, req)
+        items.extend(resp.queues)
+        return len(resp.queues) < max_page_size
+
+    finished = await retrieve_page(datetime.now().timestamp())
+    while True:
+        if finished:
+            break
+        finished = await retrieve_page(items[-1].metadata.creation_info.created_at)
+
+    queues = [_Queue._new_hydrated(item.queue_id, client, item.metadata, is_another_app=True) for item in items]
+
+    rows = []
+    for obj, resp_data in zip(queues, items):
+        info = await obj.info()
+        rows.append(
+            (
+                obj.name,
+                timestamp_to_localized_str(info.created_at.timestamp(), json),
+                info.created_by,
+                str(resp_data.num_partitions),
+                str(resp_data.total_size) if resp_data.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)
+    display_table(["Name", "Created at", "Created by", "Partitions", "Total size"], rows, json)
 
 
 @queue_cli.command(name="clear", rich_help_panel="Management")
@@ -119,7 +144,7 @@ async def peek(
 
 @queue_cli.command(name="len", rich_help_panel="Inspection")
 @synchronizer.create_blocking
-async def len(
+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"),

{modal-1.1.2.dev11 → modal-1.1.2.dev13}/modal/cli/secret.py

@@ -3,6 +3,7 @@ import json
 import os
 import platform
 import subprocess
+from datetime import datetime
 from pathlib import Path
 from tempfile import NamedTemporaryFile
 from typing import Optional
@@ -30,20 +31,45 @@ secret_cli = typer.Typer(name="secret", help="Manage secrets.", no_args_is_help=
 async def list_(env: Optional[str] = ENV_OPTION, json: bool = False):
     env = ensure_env(env)
     client = await _Client.from_env()
-    response = await retry_transient_errors(client.stub.SecretList, api_pb2.SecretListRequest(environment_name=env))
-    column_names = ["Name", "Created at", "Last used at"]
-    rows = []
 
-    for item in response.items:
+    items: list[api_pb2.SecretListItem] = []
+
+    # Note that we need to continue using the gRPC API directly here rather than using Secret.objects.list.
+    # There is some metadata that historically appears in the CLI output (last_used_at) that
+    # doesn't make sense to transmit as hydration metadata, because the value can change over time and
+    # the metadata retrieved at hydration time could get stale. Alternatively, we could rewrite this using
+    # only public API by sequentially retrieving the secrets and then querying their dynamic metadata, but
+    # that would require multiple round trips and would add lag to the CLI.
+    async def retrieve_page(created_before: float) -> bool:
+        max_page_size = 100
+        pagination = api_pb2.ListPagination(max_objects=max_page_size, created_before=created_before)
+        req = api_pb2.SecretListRequest(environment_name=env, pagination=pagination)
+        resp = await retry_transient_errors(client.stub.SecretList, req)
+        items.extend(resp.items)
+        return len(resp.items) < max_page_size
+
+    finished = await retrieve_page(datetime.now().timestamp())
+    while True:
+        if finished:
+            break
+        finished = await retrieve_page(items[-1].metadata.creation_info.created_at)
+
+    secrets = [_Secret._new_hydrated(item.secret_id, client, item.metadata, is_another_app=True) for item in items]
+
+    rows = []
+    for obj, resp_data in zip(secrets, items):
+        info = await obj.info()
         rows.append(
             [
-                item.label,
-                timestamp_to_localized_str(item.created_at, json),
-                timestamp_to_localized_str(item.last_used_at, json) if item.last_used_at else "-",
+                obj.name,
+                timestamp_to_localized_str(info.created_at.timestamp(), json),
+                info.created_by,
+                timestamp_to_localized_str(resp_data.last_used_at, json) if resp_data.last_used_at else "-",
             ]
         )
 
     env_part = f" in environment '{env}'" if env else ""
+    column_names = ["Name", "Created at", "Created by", "Last used at"]
     display_table(column_names, rows, json, title=f"Secrets{env_part}")
 
 

{modal-1.1.2.dev11 → modal-1.1.2.dev13}/modal/cli/volume.py

@@ -13,11 +13,9 @@ from typer import Argument, Option, Typer
 import modal
 from modal._output import OutputManager, ProgressHandler, make_console
 from modal._utils.async_utils import synchronizer
-from modal._utils.grpc_utils import retry_transient_errors
 from modal._utils.time_utils import timestamp_to_localized_str
 from modal.cli._download import _volume_download
 from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table
-from modal.client import _Client
 from modal.environments import ensure_env
 from modal.volume import _AbstractVolumeUploadContextManager, _Volume
 from modal_proto import api_pb2
@@ -110,14 +108,13 @@ async def get(
 @synchronizer.create_blocking
 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"]
+    volumes = await _Volume.objects.list(environment_name=env)
     rows = []
-    for item in response.items:
-        rows.append([item.label, timestamp_to_localized_str(item.created_at, json)])
-    display_table(column_names, rows, json, title=f"Volumes{env_part}")
+    for obj in volumes:
+        info = await obj.info()
+        rows.append((info.name, timestamp_to_localized_str(info.created_at.timestamp(), json), info.created_by))
+
+    display_table(["Name", "Created at", "Created by"], rows, json)
 
 
 @volume_cli.command(

{modal-1.1.2.dev11 → modal-1.1.2.dev13}/modal/client.pyi

@@ -33,7 +33,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.1.2.dev11",
+        version: str = "1.1.2.dev13",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -164,7 +164,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.1.2.dev11",
+        version: str = "1.1.2.dev13",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.