modal 1.0.3.dev10__py3-none-any.whl → 1.2.3.dev7__py3-none-any.whl

modal/_partial_function.py

@@ -19,7 +19,7 @@ from ._functions import _Function
 from ._utils.async_utils import synchronizer
 from ._utils.deprecation import deprecation_warning
 from ._utils.function_utils import callable_has_non_self_params
-from .config import logger
+from .config import config, logger
 from .exception import InvalidError
 
 MAX_MAX_BATCH_SIZE = 1000
@@ -31,7 +31,6 @@ if typing.TYPE_CHECKING:
 
 class _PartialFunctionFlags(enum.IntFlag):
     # Lifecycle method flags
-    BUILD = 1  # Deprecated, will be removed
     ENTER_PRE_SNAPSHOT = 2
     ENTER_POST_SNAPSHOT = 4
     EXIT = 8
@@ -55,8 +54,7 @@ class _PartialFunctionFlags(enum.IntFlag):
     @staticmethod
     def lifecycle_flags() -> int:
         return (
-            _PartialFunctionFlags.BUILD  # Deprecated, will be removed
-            | _PartialFunctionFlags.ENTER_PRE_SNAPSHOT
+            _PartialFunctionFlags.ENTER_PRE_SNAPSHOT
             | _PartialFunctionFlags.ENTER_POST_SNAPSHOT
             | _PartialFunctionFlags.EXIT
         )
@@ -95,6 +93,26 @@ NullaryFuncOrMethod = Union[Callable[[], Any], Callable[[Any], Any]]
 NullaryMethod = Callable[[Any], Any]
 
 
+def verify_concurrent_params(params: _PartialFunctionParams, is_flash: bool = False) -> None:
+    def _verify_concurrent_params_with_flash_settings(params: _PartialFunctionParams) -> None:
+        if params.max_concurrent_inputs is not None:
+            raise TypeError(
+                "@modal.concurrent(max_inputs=...) is not yet supported for Flash functions. "
+                "Use `@modal.concurrent(target_inputs=...)` instead."
+            )
+        if params.target_concurrent_inputs is None:
+            raise TypeError("`@modal.concurrent()` missing required argument: `target_inputs`.")
+
+    def _verify_concurrent_params(params: _PartialFunctionParams) -> None:
+        if params.max_concurrent_inputs is None:
+            raise TypeError("`@modal.concurrent()` missing required argument: `max_inputs`.")
+
+    if is_flash:
+        _verify_concurrent_params_with_flash_settings(params)
+    else:
+        _verify_concurrent_params(params)
+
+
 class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
     """Object produced by a decorator in the `modal` namespace
 
@@ -284,7 +302,7 @@ class _MethodDecoratorType:
 
 # TODO(elias): fix support for coroutine type unwrapping for methods (static typing)
 def _method(
-    _warn_parentheses_missing=None,
+    _warn_parentheses_missing=None,  # mdmd:line-hidden
     *,
     # Set this to True if it's a non-generator function returning
     # a [sync/async] generator object
@@ -339,7 +357,7 @@ def _parse_custom_domains(custom_domains: Optional[Iterable[str]] = None) -> lis
 
 
 def _fastapi_endpoint(
-    _warn_parentheses_missing=None,
+    _warn_parentheses_missing=None,  # mdmd:line-hidden
     *,
     method: str = "GET",  # REST method for the created endpoint.
     label: Optional[str] = None,  # Label for created endpoint. Final subdomain will be <workspace>--<label>.modal.run.
@@ -380,6 +398,7 @@ def _fastapi_endpoint(
         method=method,
         web_endpoint_docs=docs,
         requested_suffix=label or "",
+        ephemeral_suffix=config.get("dev_suffix"),
         async_mode=api_pb2.WEBHOOK_ASYNC_MODE_AUTO,
         custom_domains=_parse_custom_domains(custom_domains),
         requires_proxy_auth=requires_proxy_auth,
@@ -402,7 +421,7 @@ def _fastapi_endpoint(
 
 
 def _web_endpoint(
-    _warn_parentheses_missing=None,
+    _warn_parentheses_missing=None,  # mdmd:line-hidden
     *,
     method: str = "GET",  # REST method for the created endpoint.
     label: Optional[str] = None,  # Label for created endpoint. Final subdomain will be <workspace>--<label>.modal.run.
@@ -448,6 +467,7 @@ def _web_endpoint(
         method=method,
         web_endpoint_docs=docs,
         requested_suffix=label or "",
+        ephemeral_suffix=config.get("dev_suffix"),
         async_mode=api_pb2.WEBHOOK_ASYNC_MODE_AUTO,
         custom_domains=_parse_custom_domains(custom_domains),
         requires_proxy_auth=requires_proxy_auth,
@@ -470,7 +490,7 @@ def _web_endpoint(
 
 
 def _asgi_app(
-    _warn_parentheses_missing=None,
+    _warn_parentheses_missing=None,  # mdmd:line-hidden
     *,
     label: Optional[str] = None,  # Label for created endpoint. Final subdomain will be <workspace>--<label>.modal.run.
     custom_domains: Optional[Iterable[str]] = None,  # Deploy this endpoint on a custom domain.
@@ -507,6 +527,7 @@ def _asgi_app(
     webhook_config = api_pb2.WebhookConfig(
         type=api_pb2.WEBHOOK_TYPE_ASGI_APP,
         requested_suffix=label or "",
+        ephemeral_suffix=config.get("dev_suffix"),
         async_mode=api_pb2.WEBHOOK_ASYNC_MODE_AUTO,
         custom_domains=_parse_custom_domains(custom_domains),
         requires_proxy_auth=requires_proxy_auth,
@@ -527,7 +548,7 @@ def _asgi_app(
 
 
 def _wsgi_app(
-    _warn_parentheses_missing=None,
+    _warn_parentheses_missing=None,  # mdmd:line-hidden
     *,
     label: Optional[str] = None,  # Label for created endpoint. Final subdomain will be <workspace>--<label>.modal.run.
     custom_domains: Optional[Iterable[str]] = None,  # Deploy this endpoint on a custom domain.
@@ -538,7 +559,7 @@ def _wsgi_app(
     Web Server Gateway Interface (WSGI) is a standard for synchronous Python web apps.
     It has been [succeeded by the ASGI interface](https://asgi.readthedocs.io/en/latest/introduction.html#wsgi-compatibility)
     which is compatible with ASGI and supports additional functionality such as web sockets.
-    Modal supports ASGI via [`asgi_app`](/docs/reference/modal.asgi_app).
+    Modal supports ASGI via [`asgi_app`](https://modal.com/docs/reference/modal.asgi_app).
 
     **Usage:**
 
@@ -564,6 +585,7 @@ def _wsgi_app(
     webhook_config = api_pb2.WebhookConfig(
         type=api_pb2.WEBHOOK_TYPE_WSGI_APP,
         requested_suffix=label or "",
+        ephemeral_suffix=config.get("dev_suffix"),
         async_mode=api_pb2.WEBHOOK_ASYNC_MODE_AUTO,
         custom_domains=_parse_custom_domains(custom_domains),
         requires_proxy_auth=requires_proxy_auth,
@@ -625,6 +647,7 @@ def _web_server(
     webhook_config = api_pb2.WebhookConfig(
         type=api_pb2.WEBHOOK_TYPE_WEB_SERVER,
         requested_suffix=label or "",
+        ephemeral_suffix=config.get("dev_suffix"),
         async_mode=api_pb2.WEBHOOK_ASYNC_MODE_AUTO,
         custom_domains=_parse_custom_domains(custom_domains),
         web_server_port=port,
@@ -646,61 +669,8 @@ def _web_server(
     return wrapper
 
 
-def _build(
-    _warn_parentheses_missing=None, *, force: bool = False, timeout: int = 86400
-) -> Callable[[Union[_PartialFunction, NullaryMethod]], _PartialFunction]:
-    """mdmd:hidden
-    Decorator for methods that execute at _build time_ to create a new Image layer.
-
-    **Deprecated**: This function is deprecated. We recommend using `modal.Volume`
-    to store large assets (such as model weights) instead of writing them to the
-    Image during the build process. For other use cases, you can replace this
-    decorator with the `Image.run_function` method.
-
-    **Usage**
-
-    ```python notest
-    @app.cls(gpu="A10G")
-    class AlpacaLoRAModel:
-        @build()
-        def download_models(self):
-            model = LlamaForCausalLM.from_pretrained(
-                base_model,
-            )
-            PeftModel.from_pretrained(model, lora_weights)
-            LlamaTokenizer.from_pretrained(base_model)
-    ```
-    """
-    if _warn_parentheses_missing is not None:
-        raise InvalidError(
-            "Positional arguments are not allowed. Did you forget parentheses? Suggestion: `@modal.build()`."
-        )
-
-    deprecation_warning(
-        (2025, 1, 15),
-        "The `@modal.build` decorator is deprecated and will be removed in a future release."
-        "\n\nWe now recommend storing large assets (such as model weights) using a `modal.Volume`"
-        " instead of writing them directly into the `modal.Image` filesystem."
-        " For other use cases we recommend using `Image.run_function` instead."
-        "\n\nSee https://modal.com/docs/guide/modal-1-0-migration for more information.",
-    )
-
-    flags = _PartialFunctionFlags.BUILD
-    params = _PartialFunctionParams(force_build=force, build_timeout=timeout)
-
-    def wrapper(obj: Union[_PartialFunction, NullaryMethod]) -> _PartialFunction:
-        if isinstance(obj, _PartialFunction):
-            pf = obj.stack(flags, params)
-        else:
-            pf = _PartialFunction(obj, flags, params)
-        pf.validate_obj_compatibility("build")
-        return pf
-
-    return wrapper
-
-
 def _enter(
-    _warn_parentheses_missing=None,
+    _warn_parentheses_missing=None,  # mdmd:line-hidden
     *,
     snap: bool = False,
 ) -> Callable[[Union[_PartialFunction, NullaryMethod]], _PartialFunction]:
@@ -751,7 +721,7 @@ def _exit(_warn_parentheses_missing=None) -> Callable[[NullaryMethod], _PartialF
 
 
 def _batched(
-    _warn_parentheses_missing=None,
+    _warn_parentheses_missing=None,  # mdmd:line-hidden
     *,
     max_batch_size: int,
     wait_ms: int,
@@ -789,12 +759,12 @@ def _batched(
         )
     if max_batch_size < 1:
         raise InvalidError("max_batch_size must be a positive integer.")
-    if max_batch_size >= MAX_MAX_BATCH_SIZE:
-        raise InvalidError(f"max_batch_size must be less than {MAX_MAX_BATCH_SIZE}.")
+    if max_batch_size > MAX_MAX_BATCH_SIZE:
+        raise InvalidError(f"max_batch_size cannot be greater than {MAX_MAX_BATCH_SIZE}.")
     if wait_ms < 0:
         raise InvalidError("wait_ms must be a non-negative integer.")
-    if wait_ms >= MAX_BATCH_WAIT_MS:
-        raise InvalidError(f"wait_ms must be less than {MAX_BATCH_WAIT_MS}.")
+    if wait_ms > MAX_BATCH_WAIT_MS:
+        raise InvalidError(f"wait_ms cannot be greater than {MAX_BATCH_WAIT_MS}.")
 
     flags = _PartialFunctionFlags.CALLABLE_INTERFACE | _PartialFunctionFlags.BATCHED
     params = _PartialFunctionParams(batch_max_size=max_batch_size, batch_wait_ms=wait_ms)
@@ -813,9 +783,9 @@ def _batched(
 
 
 def _concurrent(
-    _warn_parentheses_missing=None,
+    _warn_parentheses_missing=None,  # mdmd:line-hidden
     *,
-    max_inputs: int,  # Hard limit on each container's input concurrency
+    max_inputs: Optional[int] = None,  # Hard limit on each container's input concurrency
     target_inputs: Optional[int] = None,  # Input concurrency that Modal's autoscaler should target
 ) -> Callable[
     [Union[Callable[P, ReturnType], _PartialFunction[P, ReturnType, ReturnType]]],
@@ -867,7 +837,7 @@ def _concurrent(
             "Positional arguments are not allowed. Did you forget parentheses? Suggestion: `@modal.concurrent()`."
         )
 
-    if target_inputs and target_inputs > max_inputs:
+    if max_inputs is not None and target_inputs is not None and target_inputs > max_inputs:
         raise InvalidError("`target_inputs` parameter cannot be greater than `max_inputs`.")
 
     flags = _PartialFunctionFlags.CONCURRENT
@@ -891,7 +861,12 @@ def _concurrent(
 
 
 # NOTE: clustered is currently exposed through modal.experimental, not the top-level namespace
-def _clustered(size: int, broadcast: bool = True, rdma: bool = False):
+def _clustered(
+    size: int, broadcast: bool = True, rdma: bool = False
+) -> Callable[
+    [Union[Callable[P, ReturnType], _PartialFunction[P, ReturnType, ReturnType]]],
+    _PartialFunction[P, ReturnType, ReturnType],
+]:
     """Provision clusters of colocated and networked containers for the Function.
 
     Parameters:

modal/_pty.py

@@ -7,8 +7,11 @@ from typing import Optional
 from modal_proto import api_pb2
 
 
-def get_winsz(fd) -> tuple[Optional[int], Optional[int]]:
+def get_winsz(fd=None) -> tuple[Optional[int], Optional[int]]:
     try:
+        if fd is None:
+            fd = sys.stdin.fileno()
+
         import fcntl
         import struct
         import termios
@@ -40,8 +43,8 @@ def raw_terminal():
         termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
 
 
-def get_pty_info(shell: bool) -> api_pb2.PTYInfo:
-    rows, cols = get_winsz(sys.stdin.fileno())
+def get_pty_info(shell: bool, no_terminate_on_idle_stdin: bool = False) -> api_pb2.PTYInfo:
+    rows, cols = get_winsz()
     return api_pb2.PTYInfo(
         enabled=True,  # TODO(erikbern): deprecated
         winsz_rows=rows,
@@ -50,4 +53,5 @@ def get_pty_info(shell: bool) -> api_pb2.PTYInfo:
         env_colorterm=os.environ.get("COLORTERM"),
         env_term_program=os.environ.get("TERM_PROGRAM"),
         pty_type=api_pb2.PTYInfo.PTY_TYPE_SHELL if shell else api_pb2.PTYInfo.PTY_TYPE_FUNCTION,
+        no_terminate_on_idle_stdin=no_terminate_on_idle_stdin,
     )

modal/_resolver.py

@@ -8,19 +8,16 @@ from asyncio import Future
 from collections.abc import Hashable
 from typing import TYPE_CHECKING, Optional
 
-from grpclib import GRPCError, Status
-
+import modal._object
+from modal._traceback import suppress_tb_frames
 from modal_proto import api_pb2
 
+from ._load_context import LoadContext
 from ._utils.async_utils import TaskContext
-from .client import _Client
-from .exception import NotFoundError
 
 if TYPE_CHECKING:
     from rich.tree import Tree
 
-    import modal._object
-
 
 class StatusRow:
     def __init__(self, progress: "typing.Optional[Tree]"):
@@ -50,19 +47,10 @@ class StatusRow:
 
 class Resolver:
     _local_uuid_to_future: dict[str, Future]
-    _environment_name: Optional[str]
-    _app_id: Optional[str]
     _deduplication_cache: dict[Hashable, Future]
-    _client: _Client
     _build_start: float
 
-    def __init__(
-        self,
-        client: _Client,
-        *,
-        environment_name: Optional[str] = None,
-        app_id: Optional[str] = None,
-    ):
+    def __init__(self):
         try:
             # TODO(michael) If we don't clean this up more thoroughly, it would probably
             # be good to have a single source of truth for "rich is installed" rather than
@@ -77,9 +65,6 @@ class Resolver:
 
         self._local_uuid_to_future = {}
         self._tree = tree
-        self._client = client
-        self._app_id = app_id
-        self._environment_name = environment_name
         self._deduplication_cache = {}
 
         with tempfile.TemporaryFile() as temp_file:
@@ -87,27 +72,24 @@ class Resolver:
             # to the mtime on mounted files, and want those measurements to have the same resolution.
             self._build_start = os.fstat(temp_file.fileno()).st_mtime
 
-    @property
-    def app_id(self) -> Optional[str]:
-        return self._app_id
-
-    @property
-    def client(self):
-        return self._client
-
-    @property
-    def environment_name(self):
-        return self._environment_name
-
     @property
     def build_start(self) -> float:
         return self._build_start
 
-    async def preload(self, obj, existing_object_id: Optional[str]):
+    async def preload(
+        self, obj: "modal._object._Object", parent_load_context: "LoadContext", existing_object_id: Optional[str]
+    ):
         if obj._preload is not None:
-            await obj._preload(obj, self, existing_object_id)
+            load_context = obj._load_context_overrides.merged_with(parent_load_context)
+            await obj._preload(obj, self, load_context, existing_object_id)
 
-    async def load(self, obj: "modal._object._Object", existing_object_id: Optional[str] = None):
+    async def load(
+        self,
+        obj: "modal._object._Object",
+        parent_load_context: "LoadContext",
+        *,
+        existing_object_id: Optional[str] = None,
+    ):
         if obj._is_hydrated and obj._is_another_app:
             # No need to reload this, it won't typically change
             if obj.local_uuid not in self._local_uuid_to_future:
@@ -131,25 +113,23 @@ class Resolver:
             cached_future = self._deduplication_cache.get(deduplication_key)
             if cached_future:
                 hydrated_object = await cached_future
-                obj._hydrate(hydrated_object.object_id, self._client, hydrated_object._get_metadata())
+                # Use the client from the already-hydrated object
+                obj._hydrate(hydrated_object.object_id, hydrated_object.client, hydrated_object._get_metadata())
                 return obj
 
         if not cached_future:
             # don't run any awaits within this if-block to prevent race conditions
             async def loader():
-                # Wait for all its dependencies
+                load_context = await obj._load_context_overrides.merged_with(parent_load_context).apply_defaults()
+
                 # TODO(erikbern): do we need existing_object_id for those?
-                await TaskContext.gather(*[self.load(dep) for dep in obj.deps()])
+                await TaskContext.gather(*[self.load(dep, load_context) for dep in obj.deps()])
 
                 # Load the object itself
                 if not obj._load:
                     raise Exception(f"Object {obj} has no loader function")
-                try:
-                    await obj._load(obj, self, existing_object_id)
-                except GRPCError as exc:
-                    if exc.status == Status.NOT_FOUND:
-                        raise NotFoundError(exc.message)
-                    raise
+
+                await obj._load(obj, self, load_context, existing_object_id)
 
                 # Check that the id of functions didn't change
                 # Persisted refs are ignored because their life cycle is managed independently.
@@ -169,9 +149,9 @@ class Resolver:
             self._local_uuid_to_future[obj.local_uuid] = cached_future
             if deduplication_key is not None:
                 self._deduplication_cache[deduplication_key] = cached_future
-
-        # TODO(elias): print original exception/trace rather than the Resolver-internal trace
-        return await cached_future
+        with suppress_tb_frames(2):
+            # skip current frame + `loader()` closure frame from above
+            return await cached_future
 
     def objects(self) -> list["modal._object._Object"]:
         unique_objects: dict[str, "modal._object._Object"] = {}

modal/_runtime/asgi.py

@@ -16,7 +16,7 @@ from modal.config import logger
 from modal.exception import ExecutionError, InvalidError
 from modal.experimental import stop_fetching_inputs
 
-from .execution_context import current_function_call_id
+from .execution_context import current_attempt_token, current_function_call_id
 
 FIRST_MESSAGE_TIMEOUT_SECONDS = 5.0
 
@@ -106,6 +106,7 @@ def asgi_app_wrapper(asgi_app, container_io_manager) -> tuple[Callable[..., Asyn
             raise ExecutionError("Unpexected state in ASGI scope")
         scope["state"] = state
         function_call_id = current_function_call_id()
+        attempt_token = current_attempt_token()
         assert function_call_id, "internal error: function_call_id not set in asgi_app() scope"
 
         messages_from_app: asyncio.Queue[dict[str, Any]] = asyncio.Queue(1)
@@ -119,7 +120,7 @@ def asgi_app_wrapper(asgi_app, container_io_manager) -> tuple[Callable[..., Asyn
 
         async def handle_first_input_timeout():
             if scope["type"] == "http":
-                await messages_from_app.put({"type": "http.response.start", "status": 502})
+                await messages_from_app.put({"type": "http.response.start", "status": 408})
                 await messages_from_app.put(
                     {
                         "type": "http.response.body",
@@ -142,7 +143,7 @@ def asgi_app_wrapper(asgi_app, container_io_manager) -> tuple[Callable[..., Asyn
             # This initial message, "http.request" or "websocket.connect", should be sent
             # immediately after starting the ASGI app's function call. If it is not received, that
             # indicates a request cancellation or other abnormal circumstance.
-            message_gen = container_io_manager.get_data_in.aio(function_call_id)
+            message_gen = container_io_manager.get_data_in.aio(function_call_id, attempt_token)
             first_message_task = asyncio.create_task(message_gen.__anext__())
 
             try: