modal 1.2.5.dev10__tar.gz → 1.2.7.dev11__tar.gz

{modal-1.2.5.dev10 → modal-1.2.7.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.2.5.dev10
+Version: 1.2.7.dev11
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0
@@ -13,7 +13,7 @@ Classifier: Topic :: System :: Distributed Computing
 Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Requires-Python: <3.14,>=3.9
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp
@@ -51,7 +51,7 @@ a [user guide](https://modal.com/docs/guide), and the detailed
 
 ## Installation
 
-**This library requires Python 3.9 – 3.13.**
+**This library requires Python 3.10 – 3.13.**
 
 Install the package with `uv` or `pip`:
 

{modal-1.2.5.dev10 → modal-1.2.7.dev11}/README.md

@@ -17,7 +17,7 @@ a [user guide](https://modal.com/docs/guide), and the detailed
 
 ## Installation
 
-**This library requires Python 3.9 – 3.13.**
+**This library requires Python 3.10 – 3.13.**
 
 Install the package with `uv` or `pip`:
 

{modal-1.2.5.dev10 → modal-1.2.7.dev11}/modal/__init__.py

@@ -1,8 +1,8 @@
 # Copyright Modal Labs 2022
 import sys
 
-if sys.version_info[:2] < (3, 9):
-    raise RuntimeError("This version of Modal requires at least Python 3.9")
+if sys.version_info[:2] < (3, 10):
+    raise RuntimeError("This version of Modal requires at least Python 3.10")
 if sys.version_info[:2] >= (3, 14):
     raise RuntimeError("This version of Modal does not support Python 3.14+")
 

{modal-1.2.5.dev10 → modal-1.2.7.dev11}/modal/__main__.py

@@ -35,37 +35,12 @@ def main():
         ):
             raise
 
-        from grpclib import GRPCError, Status
         from rich.panel import Panel
 
-        if isinstance(exc, GRPCError):
-            status_map = {
-                Status.ABORTED: "Aborted",
-                Status.ALREADY_EXISTS: "Already exists",
-                Status.CANCELLED: "Cancelled",
-                Status.DATA_LOSS: "Data loss",
-                Status.DEADLINE_EXCEEDED: "Deadline exceeded",
-                Status.FAILED_PRECONDITION: "Failed precondition",
-                Status.INTERNAL: "Internal",
-                Status.INVALID_ARGUMENT: "Invalid",
-                Status.NOT_FOUND: "Not found",
-                Status.OUT_OF_RANGE: "Out of range",
-                Status.PERMISSION_DENIED: "Permission denied",
-                Status.RESOURCE_EXHAUSTED: "Resource exhausted",
-                Status.UNAUTHENTICATED: "Unauthenticaed",
-                Status.UNAVAILABLE: "Unavailable",
-                Status.UNIMPLEMENTED: "Unimplemented",
-                Status.UNKNOWN: "Unknown",
-            }
-            title = f"Error: {status_map.get(exc.status, 'Unknown')}"
-            content = str(exc.message)
-            if exc.details:
-                content += f"\n\nDetails: {exc.details}"
-        else:
-            title = "Error"
-            content = str(exc)
-            if notes := getattr(exc, "__notes__", []):
-                content = f"{content}\n\nNote: {' '.join(notes)}"
+        title = "Error"
+        content = str(exc)
+        if notes := getattr(exc, "__notes__", []):
+            content = f"{content}\n\nNote: {' '.join(notes)}"
 
         console = make_console(stderr=True)
         panel = Panel(content, title=title, title_align="left", border_style="red")

{modal-1.2.5.dev10 → modal-1.2.7.dev11}/modal/_container_entrypoint.py

@@ -43,7 +43,6 @@ from ._runtime.container_io_manager import (
 )
 
 if TYPE_CHECKING:
-    import modal._object
     import modal._runtime.container_io_manager
     import modal._runtime.user_code_imports
 

{modal-1.2.5.dev10 → modal-1.2.7.dev11}/modal/_functions.py

@@ -13,7 +13,7 @@ from typing import TYPE_CHECKING, Any, AsyncIterator, Callable, Optional, Union
 
 import typing_extensions
 from google.protobuf.message import Message
-from grpclib import GRPCError, Status
+from grpclib import Status
 from synchronicity.combined_types import MethodWithAio
 
 from modal_proto import api_pb2
@@ -694,7 +694,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         # Experimental: Clustered functions
         cluster_size: Optional[int] = None,
         rdma: Optional[bool] = None,
-        max_inputs: Optional[int] = None,
+        single_use_containers: bool = False,
         ephemeral_disk: Optional[int] = None,
         include_source: bool = True,
         experimental_options: Optional[dict[str, str]] = None,
@@ -810,14 +810,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 if arg.default is not inspect.Parameter.empty:
                     raise InvalidError(f"Modal batched function {func_name} does not accept default arguments.")
 
-        if max_inputs is not None:
-            if not isinstance(max_inputs, int):
-                raise InvalidError(f"`max_inputs` must be an int, not {type(max_inputs).__name__}")
-            if max_inputs <= 0:
-                raise InvalidError("`max_inputs` must be positive")
-            if max_inputs > 1:
-                raise InvalidError("Only `max_inputs=1` is currently supported")
-
         # Validate volumes
         validated_volumes = validate_volumes(volumes)
         cloud_bucket_mounts = [(k, v) for k, v in validated_volumes if isinstance(v, _CloudBucketMount)]
@@ -988,6 +980,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 function_definition = api_pb2.Function(
                     module_name=info.module_name or "",
                     function_name=info.function_name,
+                    implementation_name=info.implementation_name,
                     mount_ids=loaded_mount_ids,
                     secret_ids=[secret.object_id for secret in secrets],
                     image_id=(image.object_id if image else ""),
@@ -1023,7 +1016,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     object_dependencies=object_dependencies,
                     block_network=block_network,
                     untrusted=restrict_modal_access,
-                    max_inputs=max_inputs or 0,
+                    single_use_containers=single_use_containers,
+                    max_inputs=int(single_use_containers),  # TODO(michael) remove after worker rollover
                     cloud_bucket_mounts=cloud_bucket_mounts_to_proto(cloud_bucket_mounts),
                     scheduler_placement=scheduler_placement,
                     is_class=info.is_service_class(),
@@ -1054,6 +1048,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     function_data = api_pb2.FunctionData(
                         module_name=function_definition.module_name,
                         function_name=function_definition.function_name,
+                        implementation_name=function_definition.implementation_name,
                         function_type=function_definition.function_type,
                         warm_pool_size=function_definition.warm_pool_size,
                         concurrency_limit=function_definition.concurrency_limit,
@@ -1124,12 +1119,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 )
                 try:
                     response: api_pb2.FunctionCreateResponse = await load_context.client.stub.FunctionCreate(request)
-                except GRPCError as exc:
-                    if exc.status == Status.INVALID_ARGUMENT:
-                        raise InvalidError(exc.message)
-                    if exc.status == Status.FAILED_PRECONDITION:
-                        raise InvalidError(exc.message)
-                    if exc.message and "Received :status = '413'" in exc.message:
+                except Exception as exc:
+                    if "Received :status = '413'" in str(exc):
                         raise InvalidError(f"Function {info.function_name} is too large to deploy.")
                     raise
                 function_creation_status.set_response(response)

{modal-1.2.5.dev10 → modal-1.2.7.dev11}/modal/_grpc_client.py

@@ -5,10 +5,10 @@ import grpclib.client
 from google.protobuf.message import Message
 from grpclib import GRPCError, Status
 
+from . import exception
 from ._traceback import suppress_tb_frames
 from ._utils.grpc_utils import Retry, _retry_transient_errors
 from .config import config, logger
-from .exception import InvalidError, NotFoundError
 
 if TYPE_CHECKING:
     from .client import _Client
@@ -20,6 +20,29 @@ RequestType = TypeVar("RequestType", bound=Message)
 ResponseType = TypeVar("ResponseType", bound=Message)
 
 
+class WrappedGRPCError(exception.Error, exception._GRPCErrorWrapper): ...
+
+
+_STATUS_TO_EXCEPTION: dict[Status, type[exception._GRPCErrorWrapper]] = {
+    Status.CANCELLED: exception.ServiceError,
+    Status.UNKNOWN: exception.ServiceError,
+    Status.INVALID_ARGUMENT: exception.InvalidError,
+    Status.DEADLINE_EXCEEDED: exception.ServiceError,
+    Status.NOT_FOUND: exception.NotFoundError,
+    Status.ALREADY_EXISTS: exception.AlreadyExistsError,
+    Status.PERMISSION_DENIED: exception.PermissionDeniedError,
+    Status.RESOURCE_EXHAUSTED: exception.ResourceExhaustedError,
+    Status.FAILED_PRECONDITION: exception.ConflictError,
+    Status.ABORTED: exception.ConflictError,
+    Status.OUT_OF_RANGE: exception.InvalidError,
+    Status.UNIMPLEMENTED: exception.UnimplementedError,
+    Status.INTERNAL: exception.InternalError,
+    Status.UNAVAILABLE: exception.ServiceError,
+    Status.DATA_LOSS: exception.DataLossError,
+    Status.UNAUTHENTICATED: exception.AuthError,
+}
+
+
 class grpc_error_converter:
     def __enter__(self):
         pass
@@ -29,20 +52,14 @@ class grpc_error_converter:
         use_full_traceback = config.get("traceback")
         with suppress_tb_frames(1):
             if isinstance(exc, GRPCError):
-                if exc.status == Status.NOT_FOUND:
-                    if use_full_traceback:
-                        raise NotFoundError(exc.message)
-                    else:
-                        raise NotFoundError(exc.message) from None  # from None to skip the grpc-internal cause
-
-                if not use_full_traceback:
-                    # just include the frame in grpclib that actually raises the GRPCError
-                    tb = exc.__traceback__
-                    while tb.tb_next:
-                        tb = tb.tb_next
-                    exc.with_traceback(tb)
-                    raise exc from None  # from None to skip the grpc-internal cause
-                raise exc
+                modal_exc = _STATUS_TO_EXCEPTION[exc.status](exc.message)
+                modal_exc._grpc_message = exc.message
+                modal_exc._grpc_status = exc.status
+                modal_exc._grpc_details = exc.details
+                if use_full_traceback:
+                    raise modal_exc
+                else:
+                    raise modal_exc from None  # from None to skip the grpc-internal cause
 
         return False
 
@@ -100,17 +117,20 @@ class UnaryUnaryWrapper(Generic[RequestType, ResponseType]):
     ) -> ResponseType:
         with suppress_tb_frames(1):
             if timeout is not None and retry is not None:
-                raise InvalidError("Retry must be None when timeout is set")
+                raise exception.InvalidError("Retry must be None when timeout is set")
 
             if retry is None:
-                return await self.direct(req, timeout=timeout, metadata=metadata)
-
-            return await _retry_transient_errors(
-                self,  # type: ignore
-                req,
-                retry=retry,
-                metadata=metadata,
-            )
+                with grpc_error_converter():
+                    return await self.direct(req, timeout=timeout, metadata=metadata)
+
+            # TODO do we need suppress_error_frames(1) here too?
+            with grpc_error_converter():
+                return await _retry_transient_errors(
+                    self,  # type: ignore
+                    req,
+                    retry=retry,
+                    metadata=metadata,
+                )
 
     async def direct(
         self,
@@ -135,8 +155,7 @@ class UnaryUnaryWrapper(Generic[RequestType, ResponseType]):
         #
         # [1]: https://github.com/vmagamedov/grpclib/blob/62f968a4c84e3f64e6966097574ff0a59969ea9b/grpclib/client.py#L844
         self.wrapped_method.channel = await self.client._get_channel(self.server_url)
-        with suppress_tb_frames(1), grpc_error_converter():
-            return await self.client._call_unary(self.wrapped_method, req, timeout=timeout, metadata=metadata)
+        return await self.client._call_unary(self.wrapped_method, req, timeout=timeout, metadata=metadata)
 
 
 class UnaryStreamWrapper(Generic[RequestType, ResponseType]):
@@ -167,5 +186,6 @@ class UnaryStreamWrapper(Generic[RequestType, ResponseType]):
             logger.debug(f"refreshing client after snapshot for {self.name.rsplit('/', 1)[1]}")
             self.client = await _Client.from_env()
         self.wrapped_method.channel = await self.client._get_channel(self.server_url)
-        async for response in self.client._call_stream(self.wrapped_method, request, metadata=metadata):
-            yield response
+        with grpc_error_converter():
+            async for response in self.client._call_stream(self.wrapped_method, request, metadata=metadata):
+                yield response

{modal-1.2.5.dev10 → modal-1.2.7.dev11}/modal/_output.py

@@ -12,7 +12,7 @@ from collections.abc import Generator
 from datetime import timedelta
 from typing import Callable, ClassVar
 
-from grpclib.exceptions import GRPCError, StreamTerminatedError
+from grpclib.exceptions import StreamTerminatedError
 from rich.console import Console, Group, RenderableType
 from rich.live import Live
 from rich.panel import Panel
@@ -34,10 +34,11 @@ from rich.text import Text
 from modal._utils.time_utils import timestamp_to_localized_str
 from modal_proto import api_pb2
 
-from ._utils.grpc_utils import RETRYABLE_GRPC_STATUS_CODES, Retry
+from ._utils.grpc_utils import Retry
 from ._utils.shell_utils import stream_from_stdin, write_to_fd
 from .client import _Client
 from .config import logger
+from .exception import InternalError, ServiceError
 
 if platform.system() == "Windows":
     default_spinner = "line"
@@ -556,7 +557,7 @@ async def get_app_logs_loop(
     async def stop_pty_shell():
         nonlocal pty_shell_finish_event, pty_shell_input_task
         if pty_shell_finish_event:
-            print("\r", end="")  # move cursor to beginning of line
+            print("\r", end="")  # move cursor to beginning of line # noqa: T201
             pty_shell_finish_event.set()
             pty_shell_finish_event = None
 
@@ -623,7 +624,7 @@ async def get_app_logs_loop(
                 # This corresponds to the `modal run -i` use case where a breakpoint
                 # triggers and the task drops into an interactive PTY mode
                 if pty_shell_finish_event:
-                    print("ERROR: concurrent PTY shells are not supported.")
+                    print("ERROR: concurrent PTY shells are not supported.")  # noqa: T201
                 else:
                     pty_shell_stdout = output_mgr._stdout
                     pty_shell_finish_event = asyncio.Event()
@@ -644,13 +645,11 @@ async def get_app_logs_loop(
     while True:
         try:
             await _get_logs()
-        except (GRPCError, StreamTerminatedError, socket.gaierror, AttributeError) as exc:
-            if isinstance(exc, GRPCError):
-                if exc.status in RETRYABLE_GRPC_STATUS_CODES:
-                    # Try again if we had a temporary connection drop,
-                    # for example if computer went to sleep.
-                    logger.debug("Log fetching timed out. Retrying ...")
-                    continue
+        except (ServiceError, InternalError, StreamTerminatedError, socket.gaierror, AttributeError) as exc:
+            if isinstance(exc, (ServiceError, InternalError)):
+                # Try again if we had a temporary connection drop, for example if computer went to sleep.
+                logger.debug("Log fetching timed out. Retrying ...")
+                continue
             elif isinstance(exc, StreamTerminatedError):
                 logger.debug("Stream closed. Retrying ...")
                 continue

{modal-1.2.5.dev10 → modal-1.2.7.dev11}/modal/_partial_function.py

@@ -160,9 +160,8 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
             raise InvalidError("Interface decorators cannot be combined with lifecycle decorators.")
 
         has_web_interface = self.flags & _PartialFunctionFlags.WEB_INTERFACE
-        has_http_web_interface = self.flags & _PartialFunctionFlags.HTTP_WEB_INTERFACE
         has_callable_interface = self.flags & _PartialFunctionFlags.CALLABLE_INTERFACE
-        if (has_web_interface or has_http_web_interface) and has_callable_interface:
+        if has_web_interface and has_callable_interface:
             self.registered = True  # Hacky, avoid false-positive warning
             raise InvalidError("Callable decorators cannot be combined with web interface decorators.")
 

{modal-1.2.5.dev10 → modal-1.2.7.dev11}/modal/_runtime/container_io_manager.py

@@ -845,8 +845,9 @@ class _ContainerIOManager:
                     yield inputs
                     yielded = True
 
-                    # We only support max_inputs = 1 at the moment
-                    if final_input_received or self.function_def.max_inputs == 1:
+                    # TODO(michael): Remove use of max_inputs after worker rollover
+                    single_use_container = self.function_def.single_use_containers or self.function_def.max_inputs == 1
+                    if final_input_received or single_use_container:
                         return
             finally:
                 if not yielded:
@@ -991,12 +992,10 @@ class _ContainerIOManager:
         # Busy-wait for restore. `/__modal/restore-state.json` is created
         # by the worker process with updates to the container config.
         restored_path = Path(config.get("restore_state_path"))
-        start = time.perf_counter()
+        logger.debug("Waiting for restore")
         while not restored_path.exists():
-            logger.debug(f"Waiting for restore (elapsed={time.perf_counter() - start:.3f}s)")
             await asyncio.sleep(0.01)
             continue
-
         logger.debug("Container: restored")
 
         # Look for state file and create new client with updated credentials.
@@ -1007,7 +1006,7 @@ class _ContainerIOManager:
         # Start a debugger if the worker tells us to
         if int(restored_state.get("snapshot_debug", 0)):
             logger.debug("Entering snapshot debugger")
-            breakpoint()
+            breakpoint()  # noqa: T100
 
         # Local ContainerIOManager state.
         for key in ["task_id", "function_id"]:

{modal-1.2.5.dev10 → modal-1.2.7.dev11}/modal/_runtime/gpu_memory_snapshot.py

@@ -18,11 +18,14 @@ from modal.config import config, logger
 
 CUDA_CHECKPOINT_PATH: str = config.get("cuda_checkpoint_path")
 
-# Maximum total duration for an entire toggle operation.
-CUDA_CHECKPOINT_TOGGLE_TIMEOUT: float = 5 * 60.0
-
 # Maximum total duration for each individual `cuda-checkpoint` invocation.
-CUDA_CHECKPOINT_TIMEOUT: float = 90
+CUDA_CHECKPOINT_TIMEOUT: float = 3 * 60.0
+
+# Number of retries for each individual `cuda-checkpoint --toggle` invocation.
+CUDA_CHECKPOINT_TOGGLE_NUM_RETRIES: int = 3
+
+# Maximum total duration for an entire toggle operation.
+CUDA_CHECKPOINT_TOGGLE_TIMEOUT: float = CUDA_CHECKPOINT_TOGGLE_NUM_RETRIES * CUDA_CHECKPOINT_TIMEOUT
 
 
 class CudaCheckpointState(Enum):
@@ -58,7 +61,7 @@ class CudaCheckpointProcess:
 
         start_time = time.monotonic()
         retry_count = 0
-        max_retries = 3
+        max_retries = CUDA_CHECKPOINT_TOGGLE_NUM_RETRIES
 
         attempts = 0
         while self._should_continue_toggle(
@@ -201,8 +204,7 @@ class CudaCheckpointSession:
                 [CUDA_CHECKPOINT_PATH, "--get-state", "--pid", str(pid)],
                 capture_output=True,
                 text=True,
-                # This should be quick since no checkpoint has taken place yet
-                timeout=5,
+                timeout=CUDA_CHECKPOINT_TIMEOUT,
             )
 
             # If the command succeeds (return code 0), this PID has a CUDA session

{modal-1.2.5.dev10 → modal-1.2.7.dev11}/modal/_runtime/user_code_imports.py

@@ -30,6 +30,7 @@ from modal._utils.function_utils import (
 from modal.app import _App
 from modal.config import logger
 from modal.exception import ExecutionError, InvalidError
+from modal.experimental.flash import _FlashContainerEntry
 from modal_proto import api_pb2
 
 if typing.TYPE_CHECKING:
@@ -242,7 +243,7 @@ def create_breakpoint_wrapper(container_io_manager: "modal._runtime.container_io
     def breakpoint_wrapper():
         # note: it would be nice to not have breakpoint_wrapper() included in the backtrace
         container_io_manager.interact(from_breakpoint=True)
-        import pdb
+        import pdb  # noqa: T100
 
         current_frame = inspect.currentframe()
         if current_frame is not None:
@@ -392,18 +393,22 @@ class ImportedClass(Service):
         event_loop: UserCodeEventLoop,
         container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
     ):
+        flash_entry = _FlashContainerEntry(self.function_def.http_config)
         # Identify the "enter" methods to run after resuming from a snapshot.
         if not self.function_def.is_auto_snapshot:
             post_snapshot_methods = _find_callables_for_obj(
                 self.user_cls_instance, _PartialFunctionFlags.ENTER_POST_SNAPSHOT
             )
             call_lifecycle_functions(event_loop, container_io_manager, list(post_snapshot_methods.values()))
+            flash_entry.enter()
         try:
             yield
         finally:
             if not self.function_def.is_auto_snapshot:
+                flash_entry.stop()
                 exit_methods = _find_callables_for_obj(self.user_cls_instance, _PartialFunctionFlags.EXIT)
                 call_lifecycle_functions(event_loop, container_io_manager, list(exit_methods.values()))
+                flash_entry.close()
 
 
 def get_user_class_instance(_cls: modal.cls._Cls, args: tuple[Any, ...], kwargs: dict[str, Any]) -> typing.Any:
@@ -460,7 +465,10 @@ def import_single_function_service(
     else:
         # Load the module dynamically
         module = importlib.import_module(function_def.module_name)
-        qual_name: str = function_def.function_name
+
+        # Fall back to function_name just to be safe around the migration
+        # Going forward, implementation_name should always be set
+        qual_name: str = function_def.implementation_name or function_def.function_name
 
         if not is_global_object(qual_name):
             raise LocalFunctionError("Attempted to load a function defined in a function scope")

{modal-1.2.5.dev10 → modal-1.2.7.dev11}/modal/_traceback.py

@@ -119,7 +119,7 @@ def print_exception(exc: Optional[type[BaseException]], value: Optional[BaseExce
     traceback.print_exception(exc, value, tb)
     if sys.version_info < (3, 11) and value is not None:  # type: ignore
         notes = getattr(value, "__notes__", [])
-        print(*notes, sep="\n", file=sys.stderr)
+        print(*notes, sep="\n", file=sys.stderr)  # noqa: T201
 
 
 def print_server_warnings(server_warnings: Iterable[api_pb2.Warning]):

{modal-1.2.5.dev10 → modal-1.2.7.dev11}/modal/_tunnel.py

@@ -5,14 +5,13 @@ from collections.abc import AsyncIterator
 from dataclasses import dataclass
 from typing import Optional
 
-from grpclib import GRPCError, Status
 from synchronicity.async_wrap import asynccontextmanager
 
 from modal_proto import api_pb2
 
 from ._utils.async_utils import synchronize_api
 from .client import _Client
-from .exception import InvalidError, RemoteError
+from .exception import AlreadyExistsError, InvalidError, RemoteError, ServiceError
 
 
 @dataclass(frozen=True)
@@ -186,13 +185,10 @@ async def _forward(
         response = await client.stub.TunnelStart(
             api_pb2.TunnelStartRequest(port=port, unencrypted=unencrypted, tunnel_type=tunnel_type)
         )
-    except GRPCError as exc:
-        if exc.status == Status.ALREADY_EXISTS:
-            raise InvalidError(f"Port {port} is already forwarded")
-        elif exc.status == Status.UNAVAILABLE:
-            raise RemoteError("Relay server is unavailable") from exc
-        else:
-            raise
+    except AlreadyExistsError as exc:
+        raise InvalidError(f"Port {port} is already forwarded")
+    except ServiceError as exc:
+        raise RemoteError("Relay server is unavailable") from exc
 
     try:
         yield Tunnel(response.host, response.port, response.unencrypted_host, response.unencrypted_port)

{modal-1.2.5.dev10 → modal-1.2.7.dev11}/modal/_utils/blob_utils.py

@@ -152,12 +152,13 @@ async def perform_multipart_upload(
     part_etags = await TaskContext.gather(*upload_coros)
 
     # The body of the complete_multipart_upload command needs some data in xml format:
-    completion_body = "<CompleteMultipartUpload>\n"
+    completion_parts = ["<CompleteMultipartUpload>"]
     for part_number, etag in enumerate(part_etags, 1):
-        completion_body += f"""<Part>\n<PartNumber>{part_number}</PartNumber>\n<ETag>"{etag}"</ETag>\n</Part>\n"""
-    completion_body += "</CompleteMultipartUpload>"
+        completion_parts.append(f"""<Part>\n<PartNumber>{part_number}</PartNumber>\n<ETag>"{etag}"</ETag>\n</Part>""")
+    completion_parts.append("</CompleteMultipartUpload>")
+    completion_body = "\n".join(completion_parts)
 
-    # etag of combined object should be md5 hex of concatendated md5 *bytes* from parts + `-{num_parts}`
+    # etag of combined object should be md5 hex of concatenated md5 *bytes* from parts + `-{num_parts}`
     bin_hash_parts = [bytes.fromhex(etag) for etag in part_etags]
 
     expected_multipart_etag = hashlib.md5(b"".join(bin_hash_parts)).hexdigest() + f"-{len(part_etags)}"
@@ -371,11 +372,17 @@ class FileUploadSpec:
     mount_filename: str
 
     use_blob: bool
-    content: Optional[bytes]  # typically None if using blob, required otherwise
     sha256_hex: str
     md5_hex: str
     mode: int  # file permission bits (last 12 bits of st_mode)
     size: int
+    content: Optional[bytes] = None  # Set for very small files to avoid double-read
+
+    def read_content(self) -> bytes:
+        """Read content from source."""
+        with self.source() as fp:
+            fp.seek(0)
+            return fp.read()
 
 
 def _get_file_upload_spec(
@@ -384,6 +391,7 @@ def _get_file_upload_spec(
     mount_filename: PurePosixPath,
     mode: int,
 ) -> FileUploadSpec:
+    content = None
     with source() as fp:
         # Current position is ignored - we always upload from position 0
         fp.seek(0, os.SEEK_END)
@@ -394,12 +402,18 @@ def _get_file_upload_spec(
             # TODO(dano): remove the placeholder md5 once we stop requiring md5 for blobs
             md5_hex = "baadbaadbaadbaadbaadbaadbaadbaad" if size > MULTIPART_UPLOAD_THRESHOLD else None
             use_blob = True
-            content = None
             hashes = get_upload_hashes(fp, md5_hex=md5_hex)
         else:
             use_blob = False
-            content = fp.read()
-            hashes = get_upload_hashes(content)
+            # For very small files (< 256 KiB), read content once and cache it
+            # This avoids double-read penalty while limiting memory usage
+            if size < 256 * 1024:  # 256 KiB threshold
+                fp.seek(0)
+                content = fp.read()
+                hashes = get_upload_hashes(content)
+            else:
+                # For medium files (256 KiB - 4 MiB), compute hashes without caching content
+                hashes = get_upload_hashes(fp)
 
     return FileUploadSpec(
         source=source,
@@ -407,11 +421,11 @@ def _get_file_upload_spec(
         source_is_path=isinstance(source_description, Path),
         mount_filename=mount_filename.as_posix(),
         use_blob=use_blob,
-        content=content,
         sha256_hex=hashes.sha256_hex(),
         md5_hex=hashes.md5_hex(),
         mode=mode & 0o7777,
         size=size,
+        content=content,
     )