modal 1.5.4.dev2__tar.gz → 1.5.4.dev4__tar.gz

{modal-1.5.4.dev2 → modal-1.5.4.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.5.4.dev2
+Version: 1.5.4.dev4
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0

{modal-1.5.4.dev2 → modal-1.5.4.dev4}/modal/_tunnel.py

@@ -1,7 +1,7 @@
 # Copyright Modal Labs 2023
 """Client for Modal relay servers, allowing users to expose TLS."""
 
-from collections.abc import AsyncIterator
+from collections.abc import AsyncGenerator
 from dataclasses import dataclass
 
 from synchronicity.async_wrap import asynccontextmanager
@@ -60,7 +60,7 @@ class Tunnel:
 @asynccontextmanager
 async def _forward(
     port: int, *, unencrypted: bool = False, h2_enabled: bool = False, client: _Client | None = None
-) -> AsyncIterator[Tunnel]:
+) -> AsyncGenerator[Tunnel, None]:
     """Expose a port publicly from inside a running Modal container, with TLS.
 
     If `unencrypted` is set, this also exposes the TCP socket without encryption on a random port

{modal-1.5.4.dev2 → modal-1.5.4.dev4}/modal/_watcher.py

@@ -79,6 +79,8 @@ def _watch_args_from_mounts(mounts: list[_Mount]) -> tuple[set[Path], AppFilesFi
     paths = set()
     dir_filters: dict[Path, set[Path] | None] = defaultdict(set)
     for mount in mounts:
+        if mount._entries is None:
+            continue
         # TODO(elias): Make this part of the mount class instead, since it uses so much internals
         for entry in mount._entries:
             path, filter_file = entry.watch_entry()
@@ -86,8 +88,8 @@ def _watch_args_from_mounts(mounts: list[_Mount]) -> tuple[set[Path], AppFilesFi
             paths.add(path)
             if filter_file is None:
                 dir_filters[path] = None
-            elif dir_filters[path] is not None:
-                dir_filters[path].add(filter_file.absolute().resolve())
+            elif (filters := dir_filters[path]) is not None:
+                filters.add(filter_file.absolute().resolve())
 
     watch_filter = AppFilesFilter(dir_filters=dict(dir_filters))
     return paths, watch_filter

{modal-1.5.4.dev2 → modal-1.5.4.dev4}/modal/app.py

@@ -1310,7 +1310,7 @@ class _App:
         include_source: bool | None = None,  # Whether to add source to container
         # Experimental options
         experimental_options: dict[str, Any] | None = None,
-    ) -> Callable[[CLS_T | _PartialFunction], _Server]:
+    ) -> Callable[[type[Any] | _PartialFunction], _Server]:
         """
         Decorator to register a new Modal Server with this App.
 
@@ -1403,7 +1403,7 @@ class _App:
         if env:
             secrets_list.append(_Secret.from_dict(env))
 
-        def wrapper(wrapped_user_cls: CLS_T | _PartialFunction | Callable) -> _Server:
+        def wrapper(wrapped_user_cls: type[Any] | _PartialFunction | Callable) -> _Server:
             _Server._validate_wrapped_user_cls_decorators(wrapped_user_cls, enable_memory_snapshot)
 
             # Validate the server class

{modal-1.5.4.dev2 → modal-1.5.4.dev4}/modal/app.pyi

@@ -766,7 +766,7 @@ class _App:
         include_source: typing.Optional[bool] = None,
         experimental_options: typing.Optional[dict[str, typing.Any]] = None,
     ) -> collections.abc.Callable[
-        [typing.Union[CLS_T, modal._partial_function._PartialFunction]], modal._server._Server
+        [typing.Union[type[typing.Any], modal._partial_function._PartialFunction]], modal._server._Server
     ]:
         """Decorator to register a new Modal Server with this App.
 
@@ -1771,7 +1771,9 @@ class App:
         enable_memory_snapshot: bool = False,
         include_source: typing.Optional[bool] = None,
         experimental_options: typing.Optional[dict[str, typing.Any]] = None,
-    ) -> collections.abc.Callable[[typing.Union[CLS_T, modal.partial_function.PartialFunction]], modal.server.Server]:
+    ) -> collections.abc.Callable[
+        [typing.Union[type[typing.Any], modal.partial_function.PartialFunction]], modal.server.Server
+    ]:
         """Decorator to register a new Modal Server with this App.
 
         Servers run HTTP servers that are started in a `@modal.enter()` method.

{modal-1.5.4.dev2 → modal-1.5.4.dev4}/modal/cli/_download.py

@@ -24,14 +24,9 @@ async def _volume_download(
     remote_path: str,
     local_destination: Path,
     overwrite: bool,
+    progress_cb: Callable,
     concurrency: int | None = None,
-    progress_cb: Callable | None = None,
 ):
-    if progress_cb is None:
-
-        def progress_cb(*_, **__):
-            pass
-
     if concurrency is None:
         concurrency = max(128, 2 * multiprocessing.cpu_count())
 
@@ -91,6 +86,8 @@ async def _volume_download(
 
                         file_progress_cb(complete=True)
                 else:
+                    # When not streaming to a pipe, the producer always enqueues a real output path.
+                    assert output_path is not None
                     if entry.type == FileEntryType.FILE:
                         progress_task_id = progress_cb(name=entry.path, size=entry.size)
                         output_path.parent.mkdir(parents=True, exist_ok=True)

{modal-1.5.4.dev2 → modal-1.5.4.dev4}/modal/cli/app.py

@@ -27,12 +27,12 @@ from .._logs import _FETCH_LIMIT, _MAX_FETCH_RANGE, LogsFilters
 from .._utils.time_utils import locale_tz, timestamp_to_localized_str
 from ._help import ModalGroup
 from .utils import (
+    _fetch_app_logs,
+    _stream_app_logs,
+    _tail_app_logs,
     confirm_or_suggest_yes,
     display_table,
     env_option,
-    fetch_app_logs,
-    stream_app_logs,
-    tail_app_logs,
     yes_option,
 )
 
@@ -117,7 +117,7 @@ async def list_(env: str | None = None, json: bool = False):
         "Created at",
         "Stopped at",
     ]
-    rows: list[list[Text | str]] = []
+    rows: list[list[Text | str | None]] = []
     for app_stats in resp.apps:
         state = APP_STATE_TO_MESSAGE.get(app_stats.state, Text("unknown", style="gray"))
         rows.append(
@@ -305,7 +305,7 @@ async def logs(
     )
 
     if follow:
-        await stream_app_logs.aio(
+        await _stream_app_logs(
             app_id,
             task_id=container_id or "",
             show_timestamps=timestamps,
@@ -326,9 +326,9 @@ async def logs(
             if effective_until - since_dt > _MAX_FETCH_RANGE:
                 raise UsageError(f"Log fetch time range cannot exceed {_MAX_FETCH_RANGE.days} days.")
 
-        if since and tail is None:
+        if since_dt and tail is None:
             # Range mode: --since without --tail fetches everything in the range.
-            await fetch_app_logs.aio(
+            await _fetch_app_logs(
                 app_id,
                 since_dt,
                 until_dt or now,
@@ -340,7 +340,7 @@ async def logs(
             # Tail mode: single fetch with limit.
             # --since is a hard floor, --until shifts the anchor.
             effective_tail = tail if tail is not None else _DEFAULT_LOGS_TAIL
-            await tail_app_logs.aio(
+            await _tail_app_logs(
                 app_id,
                 effective_tail,
                 show_timestamps=timestamps,
@@ -586,9 +586,16 @@ async def history(
     for idx, app_stats in enumerate(resp.app_deployment_histories):
         style = "bold green" if idx == 0 else ""
 
+        if app_stats.deployed_at:
+            ts = timestamp_to_localized_str(app_stats.deployed_at, json)
+            assert ts is not None
+            deployed_at = Text(ts, style=style)
+        else:
+            deployed_at = None
+
         row = [
             Text(f"v{app_stats.version}", style=style),
-            Text(timestamp_to_localized_str(app_stats.deployed_at, json), style=style),
+            deployed_at,
             Text(app_stats.client_version, style=style),
             Text(app_stats.deployed_by, style=style),
         ]

{modal-1.5.4.dev2 → modal-1.5.4.dev4}/modal/cli/container.py

@@ -1,5 +1,4 @@
 # Copyright Modal Labs 2022
-import uuid
 import warnings
 from datetime import datetime, timezone
 
@@ -11,27 +10,23 @@ from rich.text import Text
 from modal._environments import ensure_env
 from modal._logs import _FETCH_LIMIT, _MAX_FETCH_RANGE, LogsFilters
 from modal._object import _get_environment_name
-from modal._output.pty import get_pty_info
 from modal._utils.async_utils import synchronizer
-from modal._utils.task_command_router_client import TaskCommandRouterClient
 from modal._utils.time_utils import timestamp_to_localized_str
 from modal.cli.app import _DEFAULT_LOGS_TAIL, _SOURCE_OPTIONS, _parse_time_arg
 from modal.cli.utils import (
+    _fetch_app_logs,
+    _stream_app_logs,
+    _tail_app_logs,
     confirm_or_suggest_yes,
     display_table,
     env_option,
-    fetch_app_logs,
     is_tty,
-    stream_app_logs,
-    tail_app_logs,
     yes_option,
 )
 from modal.client import _Client
-from modal.config import config
-from modal.container_process import _ContainerProcess
 from modal.exception import InvalidError
-from modal.stream_type import StreamType
-from modal_proto import api_pb2, task_command_router_pb2 as sr_pb2
+from modal.sandbox import _container_exec
+from modal_proto import api_pb2
 
 from ._help import ModalGroup
 
@@ -70,7 +65,7 @@ async def list_(
                 task_stats.task_id,
                 task_stats.app_id,
                 task_stats.app_description,
-                timestamp_to_localized_str(task_stats.started_at, json) if task_stats.started_at else "Pending",
+                timestamp_to_localized_str(task_stats.started_at, json) or "Pending",
             ]
         )
 
@@ -184,7 +179,7 @@ async def logs(
     )
 
     if follow:
-        await stream_app_logs.aio(
+        await _stream_app_logs(
             task_id=task_id,
             sandbox_id=sandbox_id,
             show_timestamps=timestamps,
@@ -199,6 +194,7 @@ async def logs(
             sb_resp = await client.stub.SandboxGetTaskId(api_pb2.SandboxGetTaskIdRequest(sandbox_id=sandbox_id))
             task_id = sb_resp.task_id
 
+        assert task_id
         task_info_resp = await client.stub.TaskGetInfo(api_pb2.TaskGetInfoRequest(task_id=task_id))
         app_id = task_info_resp.app_id
 
@@ -236,14 +232,13 @@ async def logs(
             warnings.warn("--until time is before the Container started, no logs to fetch.", UserWarning)
             return
 
-        if since_dt is not None:
-            effective_until = until_dt or now
-            if effective_until - since_dt > _MAX_FETCH_RANGE:
-                raise UsageError(f"Log fetch time range cannot exceed {_MAX_FETCH_RANGE.days} days.")
+        effective_until = until_dt or now
+        if effective_until - since_dt > _MAX_FETCH_RANGE:
+            raise UsageError(f"Log fetch time range cannot exceed {_MAX_FETCH_RANGE.days} days.")
 
         if all_logs or (since and tail is None):
             # Range mode: --since without --tail fetches everything in the range.
-            await fetch_app_logs.aio(
+            await _fetch_app_logs(
                 app_id,
                 since_dt,
                 until_dt or now,
@@ -254,7 +249,7 @@ async def logs(
             # Tail mode: single fetch with limit.
             # --since is a hard floor, --until shifts the anchor.
             effective_tail = tail if tail is not None else _DEFAULT_LOGS_TAIL
-            await tail_app_logs.aio(
+            await _tail_app_logs(
                 app_id,
                 effective_tail,
                 show_timestamps=timestamps,
@@ -264,67 +259,6 @@ async def logs(
             )
 
 
-@synchronizer.create_blocking
-async def _exec_impl(
-    pty: bool | None = None,
-    container_id: str = "",
-    command: tuple[str, ...] = (),
-    object_id_for_v2: str | None = None,
-):
-    """Execute a command in a container (implementation).
-
-    For tasks belonging to V2 sandboxes, `object_id_for_v2` must be set to the
-    sandbox ID.
-    """
-
-    if pty is None:
-        pty = is_tty()
-
-    client = await _Client.from_env()
-
-    if object_id_for_v2 is not None:
-        command_router_client = await TaskCommandRouterClient.init_v2(client, object_id_for_v2, container_id)
-    else:
-        command_router_client = await TaskCommandRouterClient.init(client, container_id)
-
-    process_id = str(uuid.uuid4())
-
-    start_req = sr_pb2.TaskExecStartRequest(
-        task_id=container_id,
-        exec_id=process_id,
-        command_args=command,
-        stdout_config=sr_pb2.TaskExecStdoutConfig.TASK_EXEC_STDOUT_CONFIG_PIPE,
-        stderr_config=sr_pb2.TaskExecStderrConfig.TASK_EXEC_STDERR_CONFIG_PIPE,
-        pty_info=get_pty_info(shell=True) if pty else None,
-        runtime_debug=config.get("function_runtime_debug"),
-    )
-    await command_router_client.exec_start(start_req)
-
-    if pty:
-        # PTY output is raw terminal bytes (control sequences, mouse events,
-        # glyphs in non-UTF-8 locales, etc.) — not text. Strict UTF-8 decode on
-        # this stream crashes the shell as soon as anything emits a byte that
-        # isn't valid UTF-8, e.g. vim drawing a Latin-1 file under LC_CTYPE=C.
-        # Pass bytes through unmodified; `attach()` writes them straight to the
-        # local fd.
-        await _ContainerProcess(
-            process_id,
-            container_id,
-            client,
-            command_router_client=command_router_client,
-            text=False,
-        ).attach()
-    else:
-        await _ContainerProcess(
-            process_id,
-            container_id,
-            client,
-            command_router_client=command_router_client,
-            stdout=StreamType.STDOUT,
-            stderr=StreamType.STDOUT,
-        ).wait()
-
-
 @container_cli.command("exec", no_args_is_help=True)
 @click.option("--pty/--no-pty", default=None, help="Run the command using a PTY.")
 @click.argument("container_id")
@@ -335,7 +269,9 @@ def exec(
     command: tuple[str, ...] = (),
 ):
     """Execute a command in a container."""
-    _exec_impl(pty=pty, container_id=container_id, command=command)
+    if pty is None:
+        pty = is_tty()
+    _container_exec(pty=pty, container_id=container_id, command=command)
 
 
 @container_cli.command("stop", no_args_is_help=True)

{modal-1.5.4.dev2 → modal-1.5.4.dev4}/modal/cli/run.py

@@ -252,7 +252,7 @@ def _make_click_function(app, signature: CliRunnableSignature, inner: Callable[[
 def _get_signature(func: typing.Any) -> inspect.Signature:
     """Returns signature with the original source annotations."""
     kwargs: dict[str, typing.Any] = {}
-    if sys.version_info[:2] >= (3, 14):
+    if sys.version_info >= (3, 14):
         import annotationlib
 
         kwargs["annotation_format"] = annotationlib.Format.STRING
@@ -263,6 +263,7 @@ def _get_click_command_for_function(app: App, function: Function, ctx: click.Con
     if function.is_generator:
         raise InvalidError("`modal run` is not supported for generator functions")
 
+    assert function.info.raw_f
     sig: inspect.Signature = _get_signature(function.info.raw_f)
     type_hints = safe_get_type_hints(function.info.raw_f)
     signature: CliRunnableSignature = _get_cli_runnable_signature(sig, type_hints)
@@ -344,6 +345,8 @@ def _get_click_command_for_cls(app: App, method_ref: MethodReference, ctx: click
 
 def _get_click_command_for_local_entrypoint(app: App, entrypoint: LocalEntrypoint):
     func = entrypoint.info.raw_f
+    assert func
+
     isasync = inspect.iscoroutinefunction(func)
 
     signature = _get_cli_runnable_signature(_get_signature(func), safe_get_type_hints(func))
@@ -378,7 +381,10 @@ def _get_click_command_for_local_entrypoint(app: App, entrypoint: LocalEntrypoin
                 else:
                     res = func(*args, **kwargs)
             except Exception as exc:
-                raise _CliUserExecutionError(inspect.getsourcefile(func)) from exc
+                user_source = inspect.getsourcefile(func)
+                if user_source is None:
+                    raise exc
+                raise _CliUserExecutionError(user_source) from exc
 
         if result_path := ctx.obj["result_path"]:
             _write_local_result(result_path, res)
@@ -405,13 +411,15 @@ def _get_runnable_list(all_usable_commands: list[CLICommand]) -> str:
 class RunGroup(ModalGroup):
     """Click group that resolves subcommands dynamically from a file/module ref."""
 
-    def get_command(self, ctx, func_ref):
+    def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command | None:
         # note: get_command here is run before the "group logic" in the `run` logic below
         # so to ensure that `env` has been globally populated before user code is loaded, it
         # needs to be handled here, and not in the `run` logic below
         ctx.ensure_object(dict)
         ctx.obj["env"] = ensure_env(ctx.params["env"])
 
+        func_ref = cmd_name
+
         import_ref = parse_import_ref(func_ref, use_module_mode=ctx.params["m"], command="modal run")
         runnable, all_usable_commands = import_and_filter(
             import_ref, base_cmd="modal run", accept_local_entrypoint=True, accept_webhook=False
@@ -553,6 +561,7 @@ def deploy(
     import_ref = parse_import_ref(app_ref, use_module_mode=use_module_mode, command="modal deploy")
 
     OutputManager.get().set_timestamps(timestamps)
+    # Keep the app import on the main thread; user code must not run on the synchronizer thread.
     app = import_app_from_ref(import_ref, base_cmd="modal deploy")
 
     name = name or app.name or ""
@@ -569,7 +578,8 @@ def deploy(
     res = deploy_app(app, name=name, environment_name=env or "", tag=tag, deployment_strategy=strategy)
 
     if stream_logs:
-        stream_app_logs(
+        # stream_app_logs is defined in cli/utils.py, which does not get type stubs
+        stream_app_logs(  # pyright: ignore[reportCallIssue]
             app_id=res.app_id,
             app_logs_url=res.app_logs_url,
             show_timestamps=timestamps,

{modal-1.5.4.dev2 → modal-1.5.4.dev4}/modal/cli/shell.py

@@ -17,12 +17,11 @@ from ..functions import Function
 from ..image import Image
 from ..mount import _Mount
 from ..runner import interactive_shell
-from ..sandbox import _MAIN_CONTAINER_NAME, Sandbox, _is_v2_sandbox_id
+from ..sandbox import _MAIN_CONTAINER_NAME, Sandbox, _container_exec, _is_v2_sandbox_id
 from ..secret import Secret
 from ..stream_type import StreamType
 from ..volume import Volume
 from ._help import ModalCommand
-from .container import _exec_impl
 from .import_refs import (
     MethodReference,
     import_and_filter,
@@ -115,7 +114,7 @@ def _start_shell_in_sidecar_container(sandbox_id: str, container_name: str, cmd:
         if pty:
             # PTY output is raw terminal bytes, not text; strict UTF-8 decode
             # crashes on the first non-UTF-8 byte (e.g. vim drawing a Latin-1
-            # file under LC_CTYPE=C). See the matching call in `_exec_impl`.
+            # file under LC_CTYPE=C). See the matching call in `_container_exec`.
             process = sandbox_container.exec(*shlex.split(cmd), pty=True, text=False)
             process.attach()
         else:
@@ -150,7 +149,7 @@ def _start_shell_in_running_container(ref: str, cmd: str, pty: bool) -> None:
 
     assert _is_valid_modal_id(ref, "ta-")
     try:
-        _ = _exec_impl(container_id=ref, command=tuple(shlex.split(cmd)), pty=pty, object_id_for_v2=object_id_for_v2)
+        _container_exec(pty, container_id=ref, command=tuple(shlex.split(cmd)), object_id_for_v2=object_id_for_v2)
     except NotFoundError:
         raise ClickException(f"Container '{ref}' not found (is it still running?)")
     except Exception as e:

{modal-1.5.4.dev2 → modal-1.5.4.dev4}/modal/cli/utils.py

@@ -21,8 +21,7 @@ from ..exception import InvalidError
 from ..output import OutputManager
 
 
-@synchronizer.create_blocking
-async def stream_app_logs(
+async def _stream_app_logs(
     app_id: str | None = None,
     task_id: str | None = None,
     sandbox_id: str | None = None,
@@ -66,6 +65,11 @@ async def stream_app_logs(
         pass
 
 
+# Blocking variant just used by the `modal deploy` handler,
+# which must run on synchronizer thread.
+stream_app_logs = synchronizer.create_blocking(_stream_app_logs)
+
+
 async def _drain_batches(output_mgr, batches, prefixes, search_text=""):
     """Iterate over log batches and display them via the output manager."""
     last_data = ""
@@ -84,8 +88,7 @@ async def _drain_batches(output_mgr, batches, prefixes, search_text=""):
         output_mgr.print("")
 
 
-@synchronizer.create_blocking
-async def tail_app_logs(
+async def _tail_app_logs(
     app_id: str,
     n: int,
     show_timestamps: bool = False,
@@ -104,8 +107,7 @@ async def tail_app_logs(
     await _drain_batches(output_mgr, batches, prefix_fields or [], filters.search_text)
 
 
-@synchronizer.create_blocking
-async def fetch_app_logs(
+async def _fetch_app_logs(
     app_id: str,
     since: datetime,
     until: datetime,

{modal-1.5.4.dev2 → modal-1.5.4.dev4}/modal/cli/volume.py

@@ -33,17 +33,13 @@ volume_cli = ModalGroup(
 def humanize_filesize(value: int) -> str:
     if value < 0:
         raise ValueError("value should be >= 0")
-    suffix = (" KiB", " MiB", " GiB", " TiB", " PiB", " EiB", " ZiB")
-    format = "%.1f"
     base = 1024
-    bytes_ = float(value)
-    if bytes_ < base:
-        return f"{bytes_:0.0f} B"
-    for i, s in enumerate(suffix):
-        unit = base ** (i + 2)
-        if bytes_ < unit:
-            break
-    return format % (base * bytes_ / unit) + s
+    size = float(value)
+    for unit in ("B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"):
+        if size < base:
+            return f"{size:.0f} {unit}" if unit == "B" else f"{size:.1f} {unit}"
+        size /= base
+    return f"{size:.1f} ZiB"
 
 
 @volume_cli.command("create", help="Create a named, persistent modal.Volume.", panel="Management", no_args_is_help=True)
@@ -198,6 +194,7 @@ async def put(
     """
     ensure_env(env)
     vol = await _Volume.from_name(volume_name, environment_name=env).hydrate()
+    assert vol._metadata
 
     if remote_path.endswith("/"):
         remote_path = remote_path + os.path.basename(local_path)

{modal-1.5.4.dev2 → modal-1.5.4.dev4}/modal/client.pyi

@@ -37,7 +37,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.4.dev2",
+        version: str = "1.5.4.dev4",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -207,7 +207,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.4.dev2",
+        version: str = "1.5.4.dev4",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.5.4.dev2 → modal-1.5.4.dev4}/modal/functions.pyi

@@ -546,7 +546,7 @@ class Function(
 
     _call_generator: ___call_generator_spec
 
-    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER:
             """Calls the function remotely, executing it with the given arguments and returning the execution's result.
 
@@ -571,7 +571,7 @@ class Function(
             """
             ...
 
-    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P]
+    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType]
 
     class __remote_gen_spec(typing_extensions.Protocol):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -621,7 +621,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """[Experimental] Calls the function with the given arguments, without waiting for the results.
 
@@ -654,7 +654,7 @@ class Function(
             """
             ...
 
-    _experimental_spawn: ___experimental_spawn_spec[modal._functions.ReturnType, modal._functions.P]
+    _experimental_spawn: ___experimental_spawn_spec[modal._functions.P, modal._functions.ReturnType]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> None: ...
@@ -662,7 +662,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P]
 
-    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """Calls the function with the given arguments, without waiting for the results.
 
@@ -695,7 +695,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P]
+    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]:
         """Return the inner Python object wrapped by this Modal Function.

{modal-1.5.4.dev2 → modal-1.5.4.dev4}/modal/mount.py

@@ -94,7 +94,7 @@ class _MountEntry(metaclass=abc.ABCMeta):
     def get_files_to_upload(self) -> typing.Iterator[tuple[Path, str]]: ...
 
     @abc.abstractmethod
-    def watch_entry(self) -> tuple[Path, Path]: ...
+    def watch_entry(self) -> tuple[Path, Path | None]: ...
 
     @abc.abstractmethod
     def top_level_paths(self) -> list[tuple[Path, PurePosixPath]]: ...
@@ -270,7 +270,7 @@ class _MountedPythonModule(_MountEntry):
         for entry in self._proxy_entries():
             yield from entry.get_files_to_upload()
 
-    def watch_entry(self) -> tuple[Path, Path]:
+    def watch_entry(self) -> tuple[Path, Path | None]:
         for entry in self._proxy_entries():
             # TODO: fix watch for mounts of multi-path packages
             return entry.watch_entry()

{modal-1.5.4.dev2 → modal-1.5.4.dev4}/modal/mount.pyi

@@ -23,7 +23,7 @@ def python_standalone_mount_name(version: str) -> str:
 class _MountEntry:
     def description(self) -> str: ...
     def get_files_to_upload(self) -> typing.Iterator[tuple[pathlib.Path, str]]: ...
-    def watch_entry(self) -> tuple[pathlib.Path, pathlib.Path]: ...
+    def watch_entry(self) -> tuple[pathlib.Path, typing.Optional[pathlib.Path]]: ...
     def top_level_paths(self) -> list[tuple[pathlib.Path, pathlib.PurePosixPath]]: ...
 
 def _select_files(entries: list[_MountEntry]) -> list[tuple[pathlib.Path, pathlib.PurePosixPath]]: ...
@@ -105,7 +105,7 @@ class _MountedPythonModule(_MountEntry):
     def description(self) -> str: ...
     def _proxy_entries(self) -> list[_MountEntry]: ...
     def get_files_to_upload(self) -> typing.Iterator[tuple[pathlib.Path, str]]: ...
-    def watch_entry(self) -> tuple[pathlib.Path, pathlib.Path]: ...
+    def watch_entry(self) -> tuple[pathlib.Path, typing.Optional[pathlib.Path]]: ...
     def top_level_paths(self) -> list[tuple[pathlib.Path, pathlib.PurePosixPath]]: ...
     def __init__(
         self,