modal 1.2.5.dev4__tar.gz → 1.2.7.dev11__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.2.5.dev4
+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.dev4 → 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.dev4 → 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.dev4 → 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.dev4 → 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.dev4 → 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,13 +694,14 @@ 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,
         _experimental_proxy_ip: Optional[str] = None,
         _experimental_custom_scaling_factor: Optional[float] = None,
         restrict_output: bool = False,
+        http_config: Optional[api_pb2.HTTPConfig] = None,
     ) -> "_Function":
         """mdmd:hidden
 
@@ -809,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)]
@@ -987,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 ""),
@@ -1022,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(),
@@ -1046,12 +1041,14 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     function_schema=function_schema,
                     supported_input_formats=supported_input_formats,
                     supported_output_formats=supported_output_formats,
+                    http_config=http_config,
                 )
 
                 if isinstance(gpu, list):
                     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,
@@ -1083,6 +1080,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         untrusted=function_definition.untrusted,
                         supported_input_formats=supported_input_formats,
                         supported_output_formats=supported_output_formats,
+                        http_config=http_config,
                     )
 
                     ranked_functions = []
@@ -1121,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.dev4 → 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.dev4 → 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.dev4 → modal-1.2.7.dev11}/modal/_partial_function.py

@@ -46,6 +46,7 @@ class _PartialFunctionFlags(enum.IntFlag):
     BATCHED = 64
     CONCURRENT = 128
     CLUSTERED = 256  # Experimental: Clustered functions
+    HTTP_WEB_INTERFACE = 512  # Experimental: HTTP server
 
     @staticmethod
     def all() -> int:
@@ -76,6 +77,7 @@ class _PartialFunctionParams:
     target_concurrent_inputs: Optional[int] = None
     build_timeout: Optional[int] = None
     rdma: Optional[bool] = None
+    http_config: Optional[api_pb2.HTTPConfig] = None
 
     def update(self, other: "_PartialFunctionParams") -> None:
         """Update self with params set in other."""

{modal-1.2.5.dev4 → 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.dev4 → 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