modal 1.1.1.dev41__py3-none-any.whl → 1.1.2__py3-none-any.whl

modal/_utils/blob_utils.py

@@ -444,14 +444,24 @@ def get_file_upload_spec_from_fileobj(fp: BinaryIO, mount_filename: PurePosixPat
 _FileUploadSource2 = Callable[[], ContextManager[BinaryIO]]
 
 
+@dataclasses.dataclass
+class FileUploadBlock:
+    # The start (byte offset, inclusive) of the block within the file
+    start: int
+    # The end (byte offset, exclusive) of the block, after having removed any trailing zeroes
+    end: int
+    # Raw (unencoded 32 byte) SHA256 sum of the block, not including trailing zeroes
+    contents_sha256: bytes
+
+
 @dataclasses.dataclass
 class FileUploadSpec2:
     source: _FileUploadSource2
     source_description: Union[str, Path]
 
     path: str
-    # Raw (unencoded 32 byte) SHA256 sum per 8MiB file block
-    blocks_sha256: list[bytes]
+    # 8MiB file blocks
+    blocks: list[FileUploadBlock]
     mode: int  # file permission bits (last 12 bits of st_mode)
     size: int
 
@@ -522,53 +532,102 @@ class FileUploadSpec2:
             source_fp.seek(0, os.SEEK_END)
             size = source_fp.tell()
 
-        blocks_sha256 = await hash_blocks_sha256(source, size, hash_semaphore)
+        blocks = await _gather_blocks(source, size, hash_semaphore)
 
         return FileUploadSpec2(
             source=source,
             source_description=source_description,
             path=mount_filename.as_posix(),
-            blocks_sha256=blocks_sha256,
+            blocks=blocks,
             mode=mode & 0o7777,
             size=size,
         )
 
 
-async def hash_blocks_sha256(
+async def _gather_blocks(
     source: _FileUploadSource2,
     size: int,
     hash_semaphore: asyncio.Semaphore,
-) -> list[bytes]:
+) -> list[FileUploadBlock]:
     def ceildiv(a: int, b: int) -> int:
         return -(a // -b)
 
     num_blocks = ceildiv(size, BLOCK_SIZE)
 
-    def blocking_hash_block_sha256(block_idx: int) -> bytes:
-        sha256_hash = hashlib.sha256()
-        block_start = block_idx * BLOCK_SIZE
+    async def gather_block(block_idx: int) -> FileUploadBlock:
+        async with hash_semaphore:
+            return await asyncio.to_thread(_gather_block, source, block_idx)
 
-        with source() as block_fp:
-            block_fp.seek(block_start)
+    tasks = (gather_block(idx) for idx in range(num_blocks))
+    return await asyncio.gather(*tasks)
 
-            num_bytes_read = 0
-            while num_bytes_read < BLOCK_SIZE:
-                chunk = block_fp.read(BLOCK_SIZE - num_bytes_read)
 
-                if not chunk:
-                    break
+def _gather_block(source: _FileUploadSource2, block_idx: int) -> FileUploadBlock:
+    start = block_idx * BLOCK_SIZE
+    end = _find_end_of_block(source, start, start + BLOCK_SIZE)
+    contents_sha256 = _hash_range_sha256(source, start, end)
+    return FileUploadBlock(start=start, end=end, contents_sha256=contents_sha256)
 
-                num_bytes_read += len(chunk)
-                sha256_hash.update(chunk)
 
-        return sha256_hash.digest()
+def _hash_range_sha256(source: _FileUploadSource2, start, end):
+    sha256_hash = hashlib.sha256()
+    range_size = end - start
 
-    async def hash_block_sha256(block_idx: int) -> bytes:
-        async with hash_semaphore:
-            return await asyncio.to_thread(blocking_hash_block_sha256, block_idx)
+    with source() as fp:
+        fp.seek(start)
+
+        num_bytes_read = 0
+        while num_bytes_read < range_size:
+            chunk = fp.read(range_size - num_bytes_read)
+
+            if not chunk:
+                break
+
+            num_bytes_read += len(chunk)
+            sha256_hash.update(chunk)
+
+    return sha256_hash.digest()
+
+
+def _find_end_of_block(source: _FileUploadSource2, start: int, end: int) -> Optional[int]:
+    """Finds the appropriate end of a block, which is the index of the byte just past the last non-zero byte in the
+    block.
+
+    >>> _find_end_of_block(lambda: BytesIO(b"abc123\0\0\0"), 0, 1024)
+    6
+    >>> _find_end_of_block(lambda: BytesIO(b"abc123\0\0\0"), 3, 1024)
+    6
+    >>> _find_end_of_block(lambda: BytesIO(b"abc123\0\0\0"), 0, 3)
+    4
+    >>> _find_end_of_block(lambda: BytesIO(b"abc123\0\0\0a"), 0, 9)
+    6
+    >>> _find_end_of_block(lambda: BytesIO(b"\0\0\0"), 0, 3)
+    0
+    >>> _find_end_of_block(lambda: BytesIO(b"\0\0\0\0\0\0"), 3, 6)
+    3
+    >>> _find_end_of_block(lambda: BytesIO(b""), 0, 1024)
+    0
+    """
+    size = end - start
+    new_end = start
 
-    tasks = (hash_block_sha256(idx) for idx in range(num_blocks))
-    return await asyncio.gather(*tasks)
+    with source() as block_fp:
+        block_fp.seek(start)
+
+        num_bytes_read = 0
+        while num_bytes_read < size:
+            chunk = block_fp.read(size - num_bytes_read)
+
+            if not chunk:
+                break
+
+            stripped_chunk = chunk.rstrip(b"\0")
+            if stripped_chunk:
+                new_end = start + num_bytes_read + len(stripped_chunk)
+
+            num_bytes_read += len(chunk)
+
+    return new_end
 
 
 def use_md5(url: str) -> bool:

modal/_utils/function_utils.py

@@ -392,8 +392,8 @@ async def _stream_function_call_data(
     attempt_token: Optional[str] = None,
 ) -> AsyncGenerator[Any, None]:
     """Read from the `data_in` or `data_out` stream of a function call."""
-    if function_call_id is None and attempt_token is None:
-        raise ValueError("function_call_id or attempt_token is required for data_out stream")
+    if not function_call_id and not attempt_token:
+        raise ValueError("function_call_id or attempt_token is required to read from a data stream")
 
     if stub is None:
         stub = client.stub
@@ -415,8 +415,9 @@ async def _stream_function_call_data(
         req = api_pb2.FunctionCallGetDataRequest(
             function_call_id=function_call_id,
             last_index=last_index,
-            attempt_token=attempt_token,
         )
+        if attempt_token:
+            req.attempt_token = attempt_token  # oneof clears function_call_id.
         try:
             async for chunk in stub_fn.unary_stream(req):
                 if chunk.index <= last_index:

modal/_utils/time_utils.py

@@ -1,11 +1,35 @@
 # Copyright Modal Labs 2025
-from datetime import datetime
-from typing import Optional
+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:
-    locale_tz = datetime.now().astimezone().tzinfo
-    return datetime.fromtimestamp(ts, tz=locale_tz)
+    return datetime.fromtimestamp(ts, tz=locale_tz())
 
 
 def timestamp_to_localized_str(ts: float, isotz: bool = True) -> Optional[str]:

modal/app.py

@@ -612,7 +612,7 @@ class _App:
     @warn_on_renamed_autoscaler_settings
     def function(
         self,
-        _warn_parentheses_missing: Any = None,
+        _warn_parentheses_missing=None,  # mdmd:line-hidden
         *,
         image: Optional[_Image] = None,  # The image to run as the container for the function
         schedule: Optional[Schedule] = None,  # An optional Modal Schedule for the function
@@ -641,7 +641,7 @@ class _App:
         scaledown_window: Optional[int] = None,  # Max time (in seconds) a container can remain idle while scaling down.
         proxy: Optional[_Proxy] = None,  # Reference to a Modal Proxy to use in front of this function.
         retries: Optional[Union[int, Retries]] = None,  # Number of times to retry each input in case of failure.
-        timeout: Optional[int] = None,  # Maximum execution time of the function in seconds.
+        timeout: int = 300,  # Maximum execution time in seconds.
         name: Optional[str] = None,  # Sets the Modal name of the function within the app
         is_generator: Optional[
             bool
@@ -841,7 +841,7 @@ class _App:
     @warn_on_renamed_autoscaler_settings
     def cls(
         self,
-        _warn_parentheses_missing: Optional[bool] = None,
+        _warn_parentheses_missing=None,  # mdmd:line-hidden
         *,
         image: Optional[_Image] = None,  # The image to run as the container for the function
         secrets: Sequence[_Secret] = (),  # Optional Modal Secret objects with environment variables for the container
@@ -869,7 +869,7 @@ class _App:
         scaledown_window: Optional[int] = None,  # Max time (in seconds) a container can remain idle while scaling down.
         proxy: Optional[_Proxy] = None,  # Reference to a Modal Proxy to use in front of this function.
         retries: Optional[Union[int, Retries]] = None,  # Number of times to retry each input in case of failure.
-        timeout: Optional[int] = None,  # Maximum execution time of the function in seconds.
+        timeout: int = 300,  # Maximum execution time in seconds; applies independently to startup and each input.
         cloud: Optional[str] = None,  # Cloud provider to run the function on. Possible values are aws, gcp, oci, auto.
         region: Optional[Union[str, Sequence[str]]] = None,  # Region or regions to run the function on.
         enable_memory_snapshot: bool = False,  # Enable memory checkpointing for faster cold starts.
@@ -931,13 +931,16 @@ class _App:
 
                 if wrapped_cls.flags & _PartialFunctionFlags.CLUSTERED:
                     cluster_size = wrapped_cls.params.cluster_size
+                    rdma = wrapped_cls.params.rdma
                 else:
                     cluster_size = None
+                    rdma = None
             else:
                 user_cls = wrapped_cls
                 max_concurrent_inputs = allow_concurrent_inputs
                 target_concurrent_inputs = None
                 cluster_size = None
+                rdma = None
             if not inspect.isclass(user_cls):
                 raise TypeError("The @app.cls decorator must be used on a class.")
 
@@ -1007,6 +1010,7 @@ class _App:
                 scheduler_placement=scheduler_placement,
                 i6pn_enabled=i6pn_enabled,
                 cluster_size=cluster_size,
+                rdma=rdma,
                 include_source=include_source if include_source is not None else self._include_source_default,
                 experimental_options={k: str(v) for k, v in (experimental_options or {}).items()},
                 _experimental_proxy_ip=_experimental_proxy_ip,

modal/app.pyi

@@ -387,7 +387,7 @@ class _App:
 
     def function(
         self,
-        _warn_parentheses_missing: typing.Any = None,
+        _warn_parentheses_missing=None,
         *,
         image: typing.Optional[modal.image._Image] = None,
         schedule: typing.Optional[modal.schedule.Schedule] = None,
@@ -410,7 +410,7 @@ class _App:
         scaledown_window: typing.Optional[int] = None,
         proxy: typing.Optional[modal.proxy._Proxy] = None,
         retries: typing.Union[int, modal.retries.Retries, None] = None,
-        timeout: typing.Optional[int] = None,
+        timeout: int = 300,
         name: typing.Optional[str] = None,
         is_generator: typing.Optional[bool] = None,
         cloud: typing.Optional[str] = None,
@@ -441,7 +441,7 @@ class _App:
     )
     def cls(
         self,
-        _warn_parentheses_missing: typing.Optional[bool] = None,
+        _warn_parentheses_missing=None,
         *,
         image: typing.Optional[modal.image._Image] = None,
         secrets: collections.abc.Sequence[modal.secret._Secret] = (),
@@ -463,7 +463,7 @@ class _App:
         scaledown_window: typing.Optional[int] = None,
         proxy: typing.Optional[modal.proxy._Proxy] = None,
         retries: typing.Union[int, modal.retries.Retries, None] = None,
-        timeout: typing.Optional[int] = None,
+        timeout: int = 300,
         cloud: typing.Optional[str] = None,
         region: typing.Union[str, collections.abc.Sequence[str], None] = None,
         enable_memory_snapshot: bool = False,
@@ -990,7 +990,7 @@ class App:
 
     def function(
         self,
-        _warn_parentheses_missing: typing.Any = None,
+        _warn_parentheses_missing=None,
         *,
         image: typing.Optional[modal.image.Image] = None,
         schedule: typing.Optional[modal.schedule.Schedule] = None,
@@ -1013,7 +1013,7 @@ class App:
         scaledown_window: typing.Optional[int] = None,
         proxy: typing.Optional[modal.proxy.Proxy] = None,
         retries: typing.Union[int, modal.retries.Retries, None] = None,
-        timeout: typing.Optional[int] = None,
+        timeout: int = 300,
         name: typing.Optional[str] = None,
         is_generator: typing.Optional[bool] = None,
         cloud: typing.Optional[str] = None,
@@ -1044,7 +1044,7 @@ class App:
     )
     def cls(
         self,
-        _warn_parentheses_missing: typing.Optional[bool] = None,
+        _warn_parentheses_missing=None,
         *,
         image: typing.Optional[modal.image.Image] = None,
         secrets: collections.abc.Sequence[modal.secret.Secret] = (),
@@ -1066,7 +1066,7 @@ class App:
         scaledown_window: typing.Optional[int] = None,
         proxy: typing.Optional[modal.proxy.Proxy] = None,
         retries: typing.Union[int, modal.retries.Retries, None] = None,
-        timeout: typing.Optional[int] = None,
+        timeout: int = 300,
         cloud: typing.Optional[str] = None,
         region: typing.Union[str, collections.abc.Sequence[str], None] = None,
         enable_memory_snapshot: bool = False,

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")
@@ -64,17 +63,21 @@ async def clear(name: str, *, yes: bool = YES_OPTION, env: Optional[str] = ENV_O
 
 @dict_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):
+async def delete(
+    name: str,
+    *,
+    allow_missing: bool = Option(False, "--allow-missing", help="Don't error if the Dict doesn't exist."),
+    yes: bool = YES_OPTION,
+    env: Optional[str] = ENV_OPTION,
+):
     """Delete a named Dict and all of its data."""
-    # Lookup first to validate the name, even though delete is a staticmethod
-    await _Dict.from_name(name, environment_name=env).hydrate()
     if not yes:
         typer.confirm(
             f"Are you sure you want to irrevocably delete the modal.Dict '{name}'?",
             default=False,
             abort=True,
         )
-    await _Dict.delete(name, environment_name=env)
+    await _Dict.objects.delete(name, environment_name=env, allow_missing=allow_missing)
 
 
 @dict_cli.command(name="get", rich_help_panel="Inspection")

modal/cli/entry_point.py

@@ -33,7 +33,7 @@ def version_callback(value: bool):
 
 
 entrypoint_cli_typer = typer.Typer(
-    no_args_is_help=True,
+    no_args_is_help=False,
     add_completion=False,
     rich_markup_mode="markdown",
     help="""
@@ -45,12 +45,18 @@ entrypoint_cli_typer = typer.Typer(
 )
 
 
-@entrypoint_cli_typer.callback()
+@entrypoint_cli_typer.callback(invoke_without_command=True)
 def modal(
     ctx: typer.Context,
     version: bool = typer.Option(None, "--version", callback=version_callback),
 ):
-    pass
+    # TODO: When https://github.com/fastapi/typer/pull/1240 gets shipped, then
+    # - set invoke_without_command=False in the callback decorator
+    # - set no_args_is_help=True in entrypoint_cli_typer
+    if ctx.invoked_subcommand is None:
+        console = make_console()
+        console.print(ctx.get_help())
+        raise typer.Exit()
 
 
 def check_path():

modal/cli/launch.py

@@ -3,11 +3,16 @@ import asyncio
 import inspect
 import json
 import os
+import subprocess
+import tempfile
 from pathlib import Path
 from typing import Any, Optional
 
+import rich.panel
+from rich.markdown import Markdown
 from typer import Typer
 
+from .._output import make_console
 from ..exception import _CliUserExecutionError
 from ..output import enable_output
 from ..runner import run_app
@@ -16,15 +21,25 @@ from .import_refs import ImportRef, _get_runnable_app, import_file_or_module
 launch_cli = Typer(
     name="launch",
     no_args_is_help=True,
+    rich_markup_mode="markdown",
     help="""
     Open a serverless app instance on Modal.
-
-    This command is in preview and may change in the future.
+    >⚠️  `modal launch` is **experimental** and may change in the future.
     """,
 )
 
 
-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:
+    console = make_console()
+    console.print(
+        rich.panel.Panel(
+            Markdown(f"⚠️  `modal launch {name}` is **experimental** and may change in the future."),
+            border_style="yellow",
+        ),
+    )
+
     os.environ["MODAL_LAUNCH_ARGS"] = json.dumps(args)
 
     program_path = str(Path(__file__).parent / "programs" / filename)
@@ -33,7 +48,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
@@ -61,6 +76,17 @@ def jupyter(
     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
 ):
+    console = make_console()
+    console.print(
+        rich.panel.Panel(
+            (
+                "[link=https://modal.com/notebooks]Try Modal Notebooks! "
+                "modal.com/notebooks[/link]\n"
+                "Notebooks have a new UI, saved content, real-time collaboration and more."
+            ),
+        ),
+        style="bold cyan",
+    )
     args = {
         "cpu": cpu,
         "memory": memory,
@@ -95,3 +121,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.", hidden=True)
+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.", hidden=True)
+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/cli/profile.py

@@ -19,6 +19,7 @@ profile_cli = typer.Typer(name="profile", help="Switch between Modal profiles.",
 @profile_cli.command(help="Change the active Modal profile.")
 def activate(profile: str = typer.Argument(..., help="Modal profile to activate.")):
     config_set_active_profile(profile)
+    typer.echo(f"Active profile: {profile}")
 
 
 @profile_cli.command(help="Print the currently active Modal profile.")