modal 1.0.1.dev4__py3-none-any.whl → 1.0.2__py3-none-any.whl

modal/_functions.py

@@ -99,6 +99,7 @@ if TYPE_CHECKING:
     import modal.cls
     import modal.partial_function
 
+MAX_INTERNAL_FAILURE_COUNT = 8
 
 @dataclasses.dataclass
 class _RetryContext:
@@ -348,10 +349,14 @@ class _InputPlaneInvocation:
         stub: ModalClientModal,
         attempt_token: str,
         client: _Client,
+        input_item: api_pb2.FunctionPutInputsItem,
+        function_id: str,
     ):
         self.stub = stub
         self.client = client  # Used by the deserializer.
         self.attempt_token = attempt_token
+        self.input_item = input_item
+        self.function_id = function_id
 
     @staticmethod
     async def create(
@@ -365,36 +370,55 @@ class _InputPlaneInvocation:
         stub = await client.get_stub(input_plane_url)
 
         function_id = function.object_id
-        item = await _create_input(args, kwargs, stub, method_name=function._use_method_name)
+        input_item = await _create_input(args, kwargs, stub, method_name=function._use_method_name)
 
         request = api_pb2.AttemptStartRequest(
             function_id=function_id,
             parent_input_id=current_input_id() or "",
-            input=item,
+            input=input_item,
         )
         response = await retry_transient_errors(stub.AttemptStart, request)
         attempt_token = response.attempt_token
 
-        return _InputPlaneInvocation(stub, attempt_token, client)
+        return _InputPlaneInvocation(stub, attempt_token, client, input_item, function_id)
 
     async def run_function(self) -> Any:
-        # TODO(nathan): add retry logic
+        # This will retry when the server returns GENERIC_STATUS_INTERNAL_FAILURE, i.e. lost inputs or worker preemption
+        # TODO(ryan): add logic to retry for user defined retry policy
+        internal_failure_count = 0
         while True:
-            request = api_pb2.AttemptAwaitRequest(
+            await_request = api_pb2.AttemptAwaitRequest(
                 attempt_token=self.attempt_token,
                 timeout_secs=OUTPUTS_TIMEOUT,
                 requested_at=time.time(),
             )
-            response: api_pb2.AttemptAwaitResponse = await retry_transient_errors(
+            await_response: api_pb2.AttemptAwaitResponse = await retry_transient_errors(
                 self.stub.AttemptAwait,
-                request,
+                await_request,
                 attempt_timeout=OUTPUTS_TIMEOUT + ATTEMPT_TIMEOUT_GRACE_PERIOD,
             )
 
-            if response.HasField("output"):
-                return await _process_result(
-                    response.output.result, response.output.data_format, self.stub, self.client
+            try:
+                if await_response.HasField("output"):
+                    return await _process_result(
+                        await_response.output.result, await_response.output.data_format, self.stub, self.client
+                    )
+            except InternalFailure as e:
+                internal_failure_count += 1
+                # Limit the number of times we retry
+                if internal_failure_count >= MAX_INTERNAL_FAILURE_COUNT:
+                    raise e
+                # For system failures on the server, we retry immediately,
+                # and the failure does not count towards the retry policy.
+                retry_request = api_pb2.AttemptRetryRequest(
+                    function_id=self.function_id,
+                    parent_input_id=current_input_id() or "",
+                    input=self.input_item,
+                    attempt_token=self.attempt_token,
                 )
+                # TODO(ryan): Add exponential backoff?
+                retry_response = await retry_transient_errors(self.stub.AttemptRetry, retry_request)
+                self.attempt_token = retry_response.attempt_token
 
 
 # Wrapper type for api_pb2.FunctionStats
@@ -791,6 +815,11 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 if app and app.name:
                     app_name = app.name
 
+                # on builder > 2024.10 we mount client dependencies at runtime
+                mount_client_dependencies = False
+                if image._metadata is not None:
+                    mount_client_dependencies = image._metadata.image_builder_version > "2024.10"
+
                 # Relies on dicts being ordered (true as of Python 3.6).
                 volume_mounts = [
                     api_pb2.VolumeMount(
@@ -860,6 +889,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     schedule=schedule.proto_message if schedule is not None else None,
                     snapshot_debug=config.get("snapshot_debug"),
                     experimental_options=experimental_options or {},
+                    mount_client_dependencies=mount_client_dependencies,
                     # ---
                     _experimental_group_size=cluster_size or 0,  # Experimental: Clustered functions
                     _experimental_concurrent_cancellations=True,

modal/_output.py

@@ -32,6 +32,7 @@ from rich.progress import (
 from rich.spinner import Spinner
 from rich.text import Text
 
+from modal._utils.time_utils import timestamp_to_local
 from modal_proto import api_pb2
 
 from ._utils.grpc_utils import RETRYABLE_GRPC_STATUS_CODES, retry_transient_errors
@@ -81,22 +82,27 @@ def download_progress_bar() -> Progress:
     )
 
 
-class LineBufferedOutput(io.StringIO):
+class LineBufferedOutput:
     """Output stream that buffers lines and passes them to a callback."""
 
     LINE_REGEX = re.compile("(\r\n|\r|\n)")
 
-    def __init__(self, callback: Callable[[str], None]):
+    def __init__(self, callback: Callable[[str], None], show_timestamps: bool):
         self._callback = callback
         self._buf = ""
+        self._show_timestamps = show_timestamps
 
-    def write(self, data: str):
-        chunks = self.LINE_REGEX.split(self._buf + data)
+    def write(self, log: api_pb2.TaskLogs):
+        chunks = self.LINE_REGEX.split(self._buf + log.data)
 
         # re.split("(<exp>)") returns the matched groups, and also the separators.
         # e.g. re.split("(+)", "a+b") returns ["a", "+", "b"].
         # This means that chunks is guaranteed to be odd in length.
 
+        if self._show_timestamps:
+            for i in range(0, len(chunks) - 1, 2):
+                chunks[i] = f"{timestamp_to_local(log.timestamp)} {chunks[i]}"
+
         completed_lines = "".join(chunks[:-1])
         remainder = chunks[-1]
 
@@ -136,12 +142,14 @@ class OutputManager:
     _app_page_url: str | None
     _show_image_logs: bool
     _status_spinner_live: Live | None
+    _show_timestamps: bool
 
     def __init__(
         self,
         *,
         stdout: io.TextIOWrapper | None = None,
         status_spinner_text: str = "Running app...",
+        show_timestamps: bool = False,
     ):
         self._stdout = stdout or sys.stdout
         self._console = Console(file=stdout, highlight=False)
@@ -156,6 +164,7 @@ class OutputManager:
         self._app_page_url = None
         self._show_image_logs = False
         self._status_spinner_live = None
+        self._show_timestamps = show_timestamps
 
     @classmethod
     def disable(cls):
@@ -355,9 +364,9 @@ class OutputManager:
     async def put_log_content(self, log: api_pb2.TaskLogs):
         stream = self._line_buffers.get(log.file_descriptor)
         if stream is None:
-            stream = LineBufferedOutput(functools.partial(self._print_log, log.file_descriptor))
+            stream = LineBufferedOutput(functools.partial(self._print_log, log.file_descriptor), self._show_timestamps)
             self._line_buffers[log.file_descriptor] = stream
-        stream.write(log.data)
+        stream.write(log)
 
     def flush_lines(self):
         for stream in self._line_buffers.values():

modal/_utils/bytes_io_segment_payload.py

@@ -8,14 +8,14 @@ from typing import BinaryIO, Callable, Optional
 # Note: this module needs to import aiohttp in global scope
 # This takes about 50ms and isn't needed in many cases for Modal execution
 # To avoid this, we import it in local scope when needed (blob_utils.py)
-from aiohttp import BytesIOPayload
+from aiohttp import Payload
 from aiohttp.abc import AbstractStreamWriter
 
 # read ~16MiB chunks by default
 DEFAULT_SEGMENT_CHUNK_SIZE = 2**24
 
 
-class BytesIOSegmentPayload(BytesIOPayload):
+class BytesIOSegmentPayload(Payload):
     """Modified bytes payload for concurrent sends of chunks from the same file.
 
     Adds:
@@ -26,6 +26,8 @@ class BytesIOSegmentPayload(BytesIOPayload):
     Feels like this should be in some standard lib...
     """
 
+    _value: BinaryIO
+
     def __init__(
         self,
         bytes_io: BinaryIO,  # should *not* be shared as IO position modification is not locked
@@ -36,6 +38,7 @@ class BytesIOSegmentPayload(BytesIOPayload):
     ):
         # not thread safe constructor!
         super().__init__(bytes_io)
+        self._size = segment_length
         self.initial_seek_pos = bytes_io.tell()
         self.segment_start = segment_start
         self.segment_length = segment_length
@@ -46,18 +49,26 @@ class BytesIOSegmentPayload(BytesIOPayload):
         self.progress_report_cb = progress_report_cb or (lambda *_, **__: None)
         self.reset_state()
 
+    def decode(self, encoding: str = "utf-8", errors: str = "strict") -> str:
+        self._value.seek(self.initial_seek_pos)
+        return self._value.read().decode(encoding, errors)
+
     def reset_state(self):
         self._md5_checksum = hashlib.md5()
         self.num_bytes_read = 0
         self._value.seek(self.initial_seek_pos)
 
     @contextmanager
-    def reset_on_error(self):
+    def reset_on_error(self, subtract_progress: bool = False):
         try:
             yield
         except Exception as exc:
             try:
-                self.progress_report_cb(reset=True)
+                if subtract_progress:
+                    negative_progress = -self.num_bytes_read
+                    self.progress_report_cb(advance=negative_progress)
+                else:
+                    self.progress_report_cb(reset=True)
             except Exception as cb_exc:
                 raise cb_exc from exc
             raise exc
@@ -72,14 +83,21 @@ class BytesIOSegmentPayload(BytesIOPayload):
         return self._md5_checksum
 
     async def write(self, writer: "AbstractStreamWriter"):
+        # On aiohttp < 3.12.0 - this is the method that's being called on a custom payload,
+        # but on aiohttp 3.12+ `write_with_length` is called directly.
+        await self.write_with_length(writer, None)
+
+    async def write_with_length(self, writer: AbstractStreamWriter, content_length: Optional[int]):
         loop = asyncio.get_event_loop()
 
         async def safe_read():
             read_start = self.initial_seek_pos + self.segment_start + self.num_bytes_read
             self._value.seek(read_start)
             num_bytes = min(self.chunk_size, self.remaining_bytes())
-            chunk = await loop.run_in_executor(None, self._value.read, num_bytes)
+            if content_length is not None:
+                num_bytes = min(num_bytes, content_length)
 
+            chunk = await loop.run_in_executor(None, self._value.read, num_bytes)
             await loop.run_in_executor(None, self._md5_checksum.update, chunk)
             self.num_bytes_read += len(chunk)
             return chunk

modal/_utils/time_utils.py

@@ -0,0 +1,15 @@
+# Copyright Modal Labs 2025
+from datetime import datetime
+from typing import Optional
+
+
+def timestamp_to_local(ts: float, isotz: bool = True) -> Optional[str]:
+    if ts > 0:
+        locale_tz = datetime.now().astimezone().tzinfo
+        dt = datetime.fromtimestamp(ts, tz=locale_tz)
+        if isotz:
+            return dt.isoformat(sep=" ", timespec="seconds")
+        else:
+            return f"{datetime.strftime(dt, '%Y-%m-%d %H:%M')} {locale_tz.tzname(dt)}"
+    else:
+        return None

modal/cli/app.py

@@ -15,7 +15,8 @@ from modal.client import _Client
 from modal.environments import ensure_env
 from modal_proto import api_pb2
 
-from .utils import ENV_OPTION, display_table, get_app_id_from_name, stream_app_logs, timestamp_to_local
+from .._utils.time_utils import timestamp_to_local
+from .utils import ENV_OPTION, display_table, get_app_id_from_name, stream_app_logs
 
 APP_IDENTIFIER = Argument("", help="App name or ID")
 NAME_OPTION = typer.Option("", "-n", "--name", help="Deprecated: Pass App name as a positional argument")
@@ -84,6 +85,7 @@ def logs(
     app_identifier: str = APP_IDENTIFIER,
     *,
     env: Optional[str] = ENV_OPTION,
+    timestamps: bool = typer.Option(False, "--timestamps", help="Show timestamps for each log line"),
 ):
     """Show App logs, streaming while active.
 
@@ -103,7 +105,7 @@ def logs(
 
     """
     app_id = get_app_id(app_identifier, env)
-    stream_app_logs(app_id)
+    stream_app_logs(app_id, show_timestamps=timestamps)
 
 
 @app_cli.command("rollback", no_args_is_help=True, context_settings={"ignore_unknown_options": True})

modal/cli/cluster.py

@@ -8,7 +8,8 @@ from rich.text import Text
 from modal._object import _get_environment_name
 from modal._pty import get_pty_info
 from modal._utils.async_utils import synchronizer
-from modal.cli.utils import ENV_OPTION, display_table, is_tty, timestamp_to_local
+from modal._utils.time_utils import timestamp_to_local
+from modal.cli.utils import ENV_OPTION, display_table, is_tty
 from modal.client import _Client
 from modal.config import config
 from modal.container_process import _ContainerProcess

modal/cli/container.py

@@ -8,7 +8,8 @@ from modal._object import _get_environment_name
 from modal._pty import get_pty_info
 from modal._utils.async_utils import synchronizer
 from modal._utils.grpc_utils import retry_transient_errors
-from modal.cli.utils import ENV_OPTION, display_table, is_tty, stream_app_logs, timestamp_to_local
+from modal._utils.time_utils import timestamp_to_local
+from modal.cli.utils import ENV_OPTION, display_table, is_tty, stream_app_logs
 from modal.client import _Client
 from modal.config import config
 from modal.container_process import _ContainerProcess

modal/cli/dict.py

@@ -8,7 +8,8 @@ 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._utils.time_utils import timestamp_to_local
+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

modal/cli/network_file_system.py

@@ -17,8 +17,9 @@ from modal._location import display_location
 from modal._output import OutputManager, ProgressHandler
 from modal._utils.async_utils import synchronizer
 from modal._utils.grpc_utils import retry_transient_errors
+from modal._utils.time_utils import timestamp_to_local
 from modal.cli._download import _volume_download
-from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table, timestamp_to_local
+from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table
 from modal.client import _Client
 from modal.environments import ensure_env
 from modal.network_file_system import _NetworkFileSystem

modal/cli/queues.py

@@ -8,7 +8,8 @@ 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._utils.time_utils import timestamp_to_local
+from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table
 from modal.client import _Client
 from modal.environments import ensure_env
 from modal.queue import _Queue

modal/cli/secret.py

@@ -13,7 +13,8 @@ from typer import Argument
 
 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._utils.time_utils import timestamp_to_local
+from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table
 from modal.client import _Client
 from modal.environments import ensure_env
 from modal.secret import _Secret

modal/cli/utils.py

@@ -1,7 +1,6 @@
 # Copyright Modal Labs 2022
 import asyncio
 from collections.abc import Sequence
-from datetime import datetime
 from json import dumps
 from typing import Optional, Union
 
@@ -23,10 +22,13 @@ from ..exception import NotFoundError
 
 @synchronizer.create_blocking
 async def stream_app_logs(
-    app_id: Optional[str] = None, task_id: Optional[str] = None, app_logs_url: Optional[str] = None
+    app_id: Optional[str] = None,
+    task_id: Optional[str] = None,
+    app_logs_url: Optional[str] = None,
+    show_timestamps: bool = False,
 ):
     client = await _Client.from_env()
-    output_mgr = OutputManager(status_spinner_text=f"Tailing logs for {app_id}")
+    output_mgr = OutputManager(status_spinner_text=f"Tailing logs for {app_id}", show_timestamps=show_timestamps)
     try:
         with output_mgr.show_status_spinner():
             await get_app_logs_loop(client, output_mgr, app_id=app_id, task_id=task_id, app_logs_url=app_logs_url)
@@ -61,18 +63,6 @@ async def get_app_id_from_name(name: str, env: Optional[str], client: Optional[_
     return resp.app_id
 
 
-def timestamp_to_local(ts: float, isotz: bool = True) -> str:
-    if ts > 0:
-        locale_tz = datetime.now().astimezone().tzinfo
-        dt = datetime.fromtimestamp(ts, tz=locale_tz)
-        if isotz:
-            return dt.isoformat(sep=" ", timespec="seconds")
-        else:
-            return f"{datetime.strftime(dt, '%Y-%m-%d %H:%M')} {locale_tz.tzname(dt)}"
-    else:
-        return None
-
-
 def _plain(text: Union[Text, str]) -> str:
     return text.plain if isinstance(text, Text) else text
 

modal/cli/volume.py

@@ -15,8 +15,9 @@ import modal
 from modal._output import OutputManager, ProgressHandler
 from modal._utils.async_utils import synchronizer
 from modal._utils.grpc_utils import retry_transient_errors
+from modal._utils.time_utils import timestamp_to_local
 from modal.cli._download import _volume_download
-from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table, timestamp_to_local
+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
@@ -203,7 +204,7 @@ async def put(
                     vol.object_id,
                     vol._client,
                     progress_cb=progress_handler.progress,
-                    force=force
+                    force=force,
                 ) as batch:
                     batch.put_directory(local_path, remote_path)
             except FileExistsError as exc:
@@ -219,7 +220,7 @@ async def put(
                     vol.object_id,
                     vol._client,
                     progress_cb=progress_handler.progress,
-                    force=force
+                    force=force,
                 ) as batch:
                     batch.put_file(local_path, remote_path)
 

modal/client.pyi

@@ -27,11 +27,7 @@ class _Client:
     _snapshotted: bool
 
     def __init__(
-        self,
-        server_url: str,
-        client_type: int,
-        credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.0.1.dev4",
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "1.0.2"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -90,11 +86,7 @@ class Client:
     _snapshotted: bool
 
     def __init__(
-        self,
-        server_url: str,
-        client_type: int,
-        credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.0.1.dev4",
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "1.0.2"
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/exception.py

@@ -161,6 +161,8 @@ def simulate_preemption(wait_seconds: int, jitter_seconds: int = 0):
     See https://modal.com/docs/guide/preemption for more details on preemption
     handling.
     """
+    if wait_seconds <= 0:
+        raise ValueError("Time to wait must be greater than 0")
     signal.signal(signal.SIGALRM, _simulate_preemption_interrupt)
     jitter = random.randrange(0, jitter_seconds) if jitter_seconds else 0
     signal.alarm(wait_seconds + jitter)

modal/functions.pyi

@@ -227,11 +227,11 @@ class Function(
 
     _call_generator: ___call_generator_spec[typing_extensions.Self]
 
-    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER: ...
         async def aio(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER: ...
 
-    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
+    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
 
     class __remote_gen_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]: ...
@@ -246,12 +246,12 @@ class Function(
         self, *args: modal._functions.P.args, **kwargs: modal._functions.P.kwargs
     ) -> modal._functions.OriginalReturnType: ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
         async def aio(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
 
     _experimental_spawn: ___experimental_spawn_spec[
-        modal._functions.ReturnType, modal._functions.P, typing_extensions.Self
+        modal._functions.P, modal._functions.ReturnType, typing_extensions.Self
     ]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER, SUPERSELF]):
@@ -260,11 +260,11 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P, typing_extensions.Self]
 
-    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
         async def aio(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
 
-    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
+    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]: ...
 

modal/image.py

@@ -1442,7 +1442,9 @@ class _Image(_Object, type_prefix="im"):
             if version > "2024.10":
                 # for convenience when launching in a sandbox: sleep for 48h
                 commands.append(f'CMD ["sleep", "{48 * 3600}"]')
-            context_files = {CONTAINER_REQUIREMENTS_PATH: _get_modal_requirements_path(version, python_version)}
+            context_files = {}
+            if version <= "2024.10":
+                context_files = {CONTAINER_REQUIREMENTS_PATH: _get_modal_requirements_path(version, python_version)}
             return DockerfileSpec(commands=commands, context_files=context_files)
 
         return _Image._from_args(
@@ -1517,12 +1519,15 @@ class _Image(_Object, type_prefix="im"):
 
         # Note: this change is because we install dependencies with uv in 2024.10+
         requirements_prefix = "python -m " if builder_version < "2024.10" else ""
-        modal_requirements_commands = [
-            f"COPY {CONTAINER_REQUIREMENTS_PATH} {CONTAINER_REQUIREMENTS_PATH}",
-            f"RUN python -m pip install --upgrade {_base_image_config('package_tools', builder_version)}",
-            f"RUN {requirements_prefix}{_get_modal_requirements_command(builder_version)}",
-        ]
-        if builder_version > "2023.12":
+        modal_requirements_commands = []
+        if builder_version <= "2024.10":
+            # past 2024.10, client dependencies are mounted at runtime
+            modal_requirements_commands.extend([
+                f"COPY {CONTAINER_REQUIREMENTS_PATH} {CONTAINER_REQUIREMENTS_PATH}",
+                f"RUN python -m pip install --upgrade {_base_image_config('package_tools', builder_version)}",
+                f"RUN {requirements_prefix}{_get_modal_requirements_command(builder_version)}",
+            ])
+        if  "2024.10" >= builder_version > "2023.12":
             modal_requirements_commands.append(f"RUN rm {CONTAINER_REQUIREMENTS_PATH}")
 
         return [
@@ -1585,7 +1590,9 @@ class _Image(_Object, type_prefix="im"):
 
         def build_dockerfile(version: ImageBuilderVersion) -> DockerfileSpec:
             commands = _Image._registry_setup_commands(tag, version, setup_dockerfile_commands, add_python)
-            context_files = {CONTAINER_REQUIREMENTS_PATH: _get_modal_requirements_path(version, add_python)}
+            context_files = {}
+            if version <= "2024.10":
+                context_files = {CONTAINER_REQUIREMENTS_PATH: _get_modal_requirements_path(version, add_python)}
             return DockerfileSpec(commands=commands, context_files=context_files)
 
         return _Image._from_args(
@@ -1792,8 +1799,10 @@ class _Image(_Object, type_prefix="im"):
 
         def build_dockerfile_python(version: ImageBuilderVersion) -> DockerfileSpec:
             commands = _Image._registry_setup_commands("base", version, [], add_python)
-            requirements_path = _get_modal_requirements_path(version, add_python)
-            context_files = {CONTAINER_REQUIREMENTS_PATH: requirements_path}
+            context_files = {}
+            if version <= "2024.10":
+                requirements_path = _get_modal_requirements_path(version, add_python)
+                context_files = {CONTAINER_REQUIREMENTS_PATH: requirements_path}
             return DockerfileSpec(commands=commands, context_files=context_files)
 
         return _Image._from_args(
@@ -1810,22 +1819,35 @@ class _Image(_Object, type_prefix="im"):
             raise TypeError("The `python_version` argument should be a string, not a float.")
 
         def build_dockerfile(version: ImageBuilderVersion) -> DockerfileSpec:
-            requirements_path = _get_modal_requirements_path(version, python_version)
-            context_files = {CONTAINER_REQUIREMENTS_PATH: requirements_path}
+            context_files = {}
+            if version <= "2024.10":
+                requirements_path = _get_modal_requirements_path(version, python_version)
+                context_files = {CONTAINER_REQUIREMENTS_PATH: requirements_path}
             full_python_version = _dockerhub_python_version(version, python_version)
             debian_codename = _base_image_config("debian", version)
 
             commands = [
                 f"FROM python:{full_python_version}-slim-{debian_codename}",
-                f"COPY {CONTAINER_REQUIREMENTS_PATH} {CONTAINER_REQUIREMENTS_PATH}",
+            ]
+            if version <= "2024.10":
+                commands.extend([
+                    f"COPY {CONTAINER_REQUIREMENTS_PATH} {CONTAINER_REQUIREMENTS_PATH}",
+                ])
+            commands.extend([
                 "RUN apt-get update",
                 "RUN apt-get install -y gcc gfortran build-essential",
                 f"RUN pip install --upgrade {_base_image_config('package_tools', version)}",
-                f"RUN {_get_modal_requirements_command(version)}",
+            ])
+            if version <= "2024.10":
+                # after 2024.10, modal requirements are mounted at runtime
+                commands.extend([
+                    f"RUN {_get_modal_requirements_command(version)}",
+                ])
+            commands.extend([
                 # Set debian front-end to non-interactive to avoid users getting stuck with input prompts.
                 "RUN echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections",
-            ]
-            if version > "2023.12":
+            ])
+            if "2024.10" >= version > "2023.12":
                 commands.append(f"RUN rm {CONTAINER_REQUIREMENTS_PATH}")
             if version > "2024.10":
                 # for convenience when launching in a sandbox: sleep for 48h

modal/sandbox.py

@@ -252,7 +252,8 @@ class _Sandbox(_Object, type_prefix="sb"):
         client: Optional[_Client] = None,
     ) -> "_Sandbox":
         """
-        Create a new Sandbox to run untrusted, arbitrary code.
+        Create a new Sandbox to run untrusted, arbitrary code. The Sandbox's corresponding container
+        will be created asynchronously.
 
         **Usage**