modal 1.5.6.dev30__tar.gz → 1.6.0__tar.gz

{modal-1.5.6.dev30 → modal-1.6.0}/PKG-INFO

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

{modal-1.5.6.dev30 → modal-1.6.0}/modal/_functions.py

@@ -1262,15 +1262,19 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             },
             # We don't have any secret IDs yet as we are dehydrated, so we return the reprs instead
             secrets=[repr(s) for s in secrets],
-            _http_info=FunctionInfo.HttpInfo(
+            startup_timeout=startup_timeout,
+            _inner_server_info=FunctionInfo._InnerServerInfo(
+                server_url="",
                 port=http_config.port,
                 unauthenticated=http_config.unauthenticated,
                 h2_enabled=http_config.h2_enabled,
-                proxy_regions=list(http_config.proxy_regions),
+                routing_region=http_config.proxy_regions[0] if http_config.proxy_regions else None,
+                sessioned=is_sessioned,
+                startup_timeout=http_config.startup_timeout,
+                exit_grace_period=http_config.exit_grace_period,
             )
             if http_config
             else None,
-            _sessioned=is_sessioned,
             web_info=FunctionInfo.WebInfo._from_proto("", webhook_config) if webhook_config else None,
             method_names=list(method_definitions.keys()) if method_definitions is not None else None,
             method_details={
@@ -1745,14 +1749,14 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         return list(self._experimental_flash_urls) if self._experimental_flash_urls else None
 
     async def _fetch_flash_auth_token(self, retry: Retry) -> str:
-        resp = await self.client.stub.FunctionGetFlashAuthToken(
+        resp = await self.client._stub.FunctionGetFlashAuthToken(
             api_pb2.FunctionGetFlashAuthTokenRequest(function_id=self.object_id), retry=retry
         )
         return resp.token
 
     async def _get_flash_auth_token(self) -> str:
         if self._flash_token_manager is None:
-            self._flash_token_manager = _AuthTokenManager(self.client.stub, fetch=self._fetch_flash_auth_token)
+            self._flash_token_manager = _AuthTokenManager(self.client._stub, fetch=self._fetch_flash_auth_token)
         return await self._flash_token_manager.get_token()
 
     def _apply_dynamic_config(

{modal-1.5.6.dev30 → modal-1.6.0}/modal/_grpc_client.py

@@ -44,6 +44,14 @@ _STATUS_TO_EXCEPTION: dict[Status, type[exception._GRPCErrorWrapper]] = {
 }
 
 
+def grpc_error_to_modal_exception(exc: GRPCError) -> exception._GRPCErrorWrapper:
+    modal_exc = _STATUS_TO_EXCEPTION[exc.status](exc.message)
+    modal_exc._grpc_message = exc.message or ""
+    modal_exc._grpc_status = exc.status
+    modal_exc._grpc_details = exc.details
+    return modal_exc
+
+
 class grpc_error_converter:
     def __enter__(self):
         pass
@@ -53,10 +61,7 @@ class grpc_error_converter:
         use_full_traceback = config.get("traceback")
         with suppress_tb_frame():
             if isinstance(exc, GRPCError):
-                modal_exc = _STATUS_TO_EXCEPTION[exc.status](exc.message)
-                modal_exc._grpc_message = exc.message or ""
-                modal_exc._grpc_status = exc.status
-                modal_exc._grpc_details = exc.details
+                modal_exc = grpc_error_to_modal_exception(exc)
                 if use_full_traceback:
                     raise modal_exc
                 else:

{modal-1.5.6.dev30 → modal-1.6.0}/modal/_image.py

@@ -354,6 +354,16 @@ def _create_context_mount(
     copy_patterns = extract_copy_command_patterns(docker_commands)
     if not copy_patterns:
         return None  # no mount needed
+
+    resolved_context_dir = context_dir.resolve()
+    for copy_pattern in copy_patterns:
+        # Docker treats leading slashes as relative to the build context root.
+        resolved_source = (resolved_context_dir / copy_pattern.lstrip("/")).resolve()
+        if not resolved_source.is_relative_to(resolved_context_dir):
+            raise InvalidError(
+                f"COPY source {copy_pattern!r} is outside the build context directory ({str(context_dir)!r})."
+            )
+
     include_fn = FilePatternMatcher(*copy_patterns)
 
     def ignore_with_include(source: Path) -> bool:
@@ -364,7 +374,12 @@ def _create_context_mount(
 
         return False
 
-    return _Mount._add_local_dir(context_dir, PurePosixPath("/"), ignore=ignore_with_include)
+    return _Mount._add_local_dir(
+        context_dir,
+        PurePosixPath("/"),
+        ignore=ignore_with_include,
+        filter_external_links=True,
+    )
 
 
 def _create_context_mount_function(

{modal-1.5.6.dev30 → modal-1.6.0}/modal/_partial_function.py

@@ -732,7 +732,7 @@ def _sessioned() -> Callable[
     [Callable[P, ReturnType] | _PartialFunction[P, ReturnType, ReturnType]],
     _PartialFunction[P, ReturnType, ReturnType],
 ]:
-    """Decorator that enables sessions on a Server.
+    """Decorator that enables sticky sessions on a Server.
 
     Every request must carry a session token obtained from a session start request; requests with the same token are
     routed to the same container until the session is idle for `idle_timeout` seconds or explicitly terminated. A
@@ -741,7 +741,7 @@ def _sessioned() -> Callable[
     Only valid with `@app.server()`.
 
     Examples:
-        Define a sessioned Server:
+        Define a Server with the `@modal.sessioned()` decorator:
 
         ```python
         app = modal.App("my-app")
@@ -828,7 +828,7 @@ def _clustered(*, size: int, rdma: bool = False) -> _ClusteredDecorator:
     containers and must be multiples of `size`. For example, `size=4` with
     `min_containers=8` keeps two clusters warm.
 
-    See the [multi-node clusters guide](https://modal.com/docs/guide/multi-node-training)
+    See the [multi-node clusters guide](https://modal.com/docs/guide/multi-node-clusters)
     for hardware requirements and networking details.
 
     Parameters:

{modal-1.5.6.dev30 → modal-1.6.0}/modal/_server.py

@@ -113,7 +113,7 @@ class _Server:
 
     @property
     def sessions(self) -> "_ServerSessionsManager":
-        """Start and terminate sessions on a Server decorated with `@modal.sessioned()`."""
+        """Start and terminate sticky sessions on a Server decorated with `@modal.sessioned()`."""
         return _ServerSessionsManager(self)
 
     async def info(self, *, refresh: bool = False) -> ServerInfo:
@@ -160,7 +160,7 @@ class _Server:
         This interface is experimental and may change or be removed without warning.
         """
         service_function = self._get_service_function()
-        response = await service_function.client.stub.FlashContainerList(
+        response = await service_function.client._stub.FlashContainerList(
             api_pb2.FlashContainerListRequest(function_id=service_function.object_id)
         )
         return [
@@ -250,8 +250,11 @@ class _Server:
         # This is required since we want to support @livemethod() decorated methods
         service_function = self._get_service_function()
         await service_function.hydrate(client)
-        if service_function._function_info is not None:
-            self._is_sessioned = service_function._function_info._sessioned
+        if (
+            service_function._function_info is not None
+            and service_function._function_info._inner_server_info is not None
+        ):
+            self._is_sessioned = service_function._function_info._inner_server_info.sessioned
         return self
 
     @classmethod
@@ -470,13 +473,13 @@ class _Server:
         request.until.FromDatetime(until)
         if container:
             request.container_id = container
-        stats = await self._get_service_function().client.stub.ServerGetTimeRangeStats(request)
+        stats = await self._get_service_function().client._stub.ServerGetTimeRangeStats(request)
         return ServerStats._from_proto(stats)
 
 
 @retry(n_attempts=5, base_delay=0.5, attempt_timeout=65, total_timeout=200)
 async def _post_session_control(url: str, headers: dict[str, str]) -> tuple[int, str, str]:
-    """POST to a session control endpoint, retrying connection errors and 5xx. Returns (status, reason, body)."""
+    """POST to a sticky session control endpoint, retrying connection errors and 5xx. Returns (status, reason, body)."""
     async with ClientSessionRegistry.get_session().post(url, headers=headers) as resp:
         body = await resp.text()
         if resp.status >= 400:
@@ -498,11 +501,11 @@ class _ServerSessionsManager:
             raise InvalidError("`sessions` requires `@modal.sessioned()` on the Server.")
 
     async def start(self, idle_timeout: int = 600) -> ServerSessionCredentials:
-        """Start a session and return its ID and token.
+        """Start a sticky session and return its ID and token.
 
-        Requests to the server URL that carry the returned token are routed to the same container until the session
-        has had no connections for `idle_timeout` seconds or is terminated. A container won't be scaled down for as long
-        as it holds a live session.
+        Requests to the server URL that carry the returned token are routed to the same container until the
+        session has had no connections for `idle_timeout` seconds or is terminated. A container won't be scaled down
+        for as long as it holds a live session.
 
         Args:
             idle_timeout: Seconds without an in-flight request before the session ends.
@@ -547,7 +550,9 @@ class _ServerSessionsManager:
             raise ExecutionError("Failed to start session: unexpected response from server") from None
 
     async def terminate(self, token: str) -> None:
-        """Terminate a session. New requests to it will be rejected. Container will continue serving other sessions.
+        """Terminate a sticky session.
+
+        New requests to it will be rejected. The container continues serving other sessions.
 
         Args:
             token: The `token` of the `ServerSessionCredentials` to terminate.

{modal-1.5.6.dev30 → modal-1.6.0}/modal/_server.pyi

@@ -67,7 +67,7 @@ class _Server:
 
     @property
     def sessions(self) -> _ServerSessionsManager:
-        """Start and terminate sessions on a Server decorated with `@modal.sessioned()`."""
+        """Start and terminate sticky sessions on a Server decorated with `@modal.sessioned()`."""
         ...
 
     async def info(self, *, refresh: bool = False) -> modal.types.ServerInfo:
@@ -272,7 +272,7 @@ class _Server:
         ...
 
 async def _post_session_control(url: str, headers: dict[str, str]) -> tuple[int, str, str]:
-    """POST to a session control endpoint, retrying connection errors and 5xx. Returns (status, reason, body)."""
+    """POST to a sticky session control endpoint, retrying connection errors and 5xx. Returns (status, reason, body)."""
     ...
 
 class _ServerSessionsManager:
@@ -283,11 +283,11 @@ class _ServerSessionsManager:
 
     def _validate(self) -> None: ...
     async def start(self, idle_timeout: int = 600) -> modal.types.ServerSessionCredentials:
-        """Start a session and return its ID and token.
+        """Start a sticky session and return its ID and token.
 
-        Requests to the server URL that carry the returned token are routed to the same container until the session
-        has had no connections for `idle_timeout` seconds or is terminated. A container won't be scaled down for as long
-        as it holds a live session.
+        Requests to the server URL that carry the returned token are routed to the same container until the
+        session has had no connections for `idle_timeout` seconds or is terminated. A container won't be scaled down
+        for as long as it holds a live session.
 
         Args:
             idle_timeout: Seconds without an in-flight request before the session ends.
@@ -308,7 +308,9 @@ class _ServerSessionsManager:
         ...
 
     async def terminate(self, token: str) -> None:
-        """Terminate a session. New requests to it will be rejected. Container will continue serving other sessions.
+        """Terminate a sticky session.
+
+        New requests to it will be rejected. The container continues serving other sessions.
 
         Args:
             token: The `token` of the `ServerSessionCredentials` to terminate.
@@ -334,11 +336,11 @@ class ServerSessionsManager:
 
     class __start_spec(typing_extensions.Protocol):
         def __call__(self, /, idle_timeout: int = 600) -> modal.types.ServerSessionCredentials:
-            """Start a session and return its ID and token.
+            """Start a sticky session and return its ID and token.
 
-            Requests to the server URL that carry the returned token are routed to the same container until the session
-            has had no connections for `idle_timeout` seconds or is terminated. A container won't be scaled down for as long
-            as it holds a live session.
+            Requests to the server URL that carry the returned token are routed to the same container until the
+            session has had no connections for `idle_timeout` seconds or is terminated. A container won't be scaled down
+            for as long as it holds a live session.
 
             Args:
                 idle_timeout: Seconds without an in-flight request before the session ends.
@@ -359,11 +361,11 @@ class ServerSessionsManager:
             ...
 
         async def aio(self, /, idle_timeout: int = 600) -> modal.types.ServerSessionCredentials:
-            """Start a session and return its ID and token.
+            """Start a sticky session and return its ID and token.
 
-            Requests to the server URL that carry the returned token are routed to the same container until the session
-            has had no connections for `idle_timeout` seconds or is terminated. A container won't be scaled down for as long
-            as it holds a live session.
+            Requests to the server URL that carry the returned token are routed to the same container until the
+            session has had no connections for `idle_timeout` seconds or is terminated. A container won't be scaled down
+            for as long as it holds a live session.
 
             Args:
                 idle_timeout: Seconds without an in-flight request before the session ends.
@@ -387,7 +389,9 @@ class ServerSessionsManager:
 
     class __terminate_spec(typing_extensions.Protocol):
         def __call__(self, /, token: str) -> None:
-            """Terminate a session. New requests to it will be rejected. Container will continue serving other sessions.
+            """Terminate a sticky session.
+
+            New requests to it will be rejected. The container continues serving other sessions.
 
             Args:
                 token: The `token` of the `ServerSessionCredentials` to terminate.
@@ -404,7 +408,9 @@ class ServerSessionsManager:
             ...
 
         async def aio(self, /, token: str) -> None:
-            """Terminate a session. New requests to it will be rejected. Container will continue serving other sessions.
+            """Terminate a sticky session.
+
+            New requests to it will be rejected. The container continues serving other sessions.
 
             Args:
                 token: The `token` of the `ServerSessionCredentials` to terminate.

{modal-1.5.6.dev30 → modal-1.6.0}/modal/_utils/grpc_utils.py

@@ -26,7 +26,12 @@ from grpclib.exceptions import StreamTerminatedError
 from grpclib.protocol import H2Protocol
 from h2.exceptions import ProtocolError as H2ProtocolError
 
-from modal.exception import ClientClosed, ConnectionError, NotFoundError
+from modal.exception import (
+    ClientClosed,
+    ConnectionError,
+    NotFoundError,
+    TimeoutError as ModalTimeoutError,
+)
 from modal_proto import api_pb2
 from modal_version import __version__
 
@@ -486,6 +491,26 @@ class Retry:
     warning_message: RetryWarningMessage | None = None
 
 
+class RetryTimeoutError(ModalTimeoutError):
+    """Raised by `_retry_transient_errors` when `Retry.total_timeout` is spent before an attempt succeeds.
+
+    Internal: callers with a user-supplied timeout should convert this into a plain `modal.exception.TimeoutError`
+    with a message referring to that timeout. `final_exception` is the failure of the last attempt (server errors
+    already converted to their `modal.exception` type), which the caller can inspect to decide how to report the
+    timeout.
+    """
+
+    final_exception: Exception
+
+    def __init__(self, final_exception: Exception):
+        super().__init__(
+            "The operation timed out after repeated failures "
+            f"(last error: {type(final_exception).__name__}: {final_exception}). "
+            "Please try again, and contact Modal support if the problem persists."
+        )
+        self.final_exception = final_exception
+
+
 async def retry_transient_errors(
     fn: "grpclib.client.UnaryUnaryMethod[RequestType, ResponseType]",
     req: RequestType,
@@ -527,14 +552,22 @@ def process_exception_before_retry(
     delay: float,
     idempotency_key: str,
     rpc_elapsed: float,
+    total_deadline_reached: bool = False,
 ):
     """Process exception before retry, used by `_retry_transient_errors`."""
     with suppress_tb_frame():
         if final_attempt:
+            reason = "total deadline consumed" if total_deadline_reached else "max retries reached"
             logger.debug(
-                f"Final attempt failed with {repr(exc)} {n_retries=} {delay=} {rpc_elapsed=:0.2f}s "
+                f"Final attempt failed ({reason}) with {repr(exc)} {n_retries=} {delay=} {rpc_elapsed=:0.2f}s "
                 f"for {fn_name} ({idempotency_key[:8]})"
             )
+            if total_deadline_reached:
+                import modal._grpc_client
+
+                if isinstance(exc, GRPCError):
+                    exc = modal._grpc_client.grpc_error_to_modal_exception(exc)
+                raise RetryTimeoutError(exc) from exc
             if isinstance(exc, OSError):
                 raise ConnectionError(str(exc))
             elif isinstance(exc, asyncio.TimeoutError):
@@ -664,6 +697,7 @@ async def _retry_transient_errors(
                         server_delay,
                         idempotency_key,
                         elapsed_time,
+                        total_deadline_reached=total_timeout_will_be_reached,
                     )
 
                 if last_server_retry_warning_time is None or (
@@ -687,12 +721,12 @@ async def _retry_transient_errors(
             # Client handles retry
             if isinstance(exc, GRPCError) and exc.status not in status_codes:
                 raise exc
-            if retry.max_retries is not None and n_retries >= retry.max_retries:
-                final_attempt = True
-            elif total_deadline is not None and time.time() + delay + retry.attempt_timeout_floor >= total_deadline:
-                final_attempt = True
-            else:
-                final_attempt = False
+            max_retries_reached = retry.max_retries is not None and n_retries >= retry.max_retries
+            total_deadline_reached = total_deadline is not None and (
+                time.time() >= total_deadline
+                or (not max_retries_reached and time.time() + delay + retry.attempt_timeout_floor >= total_deadline)
+            )
+            final_attempt = max_retries_reached or total_deadline_reached
 
             with suppress_tb_frame():
                 process_exception_before_retry(
@@ -703,6 +737,7 @@ async def _retry_transient_errors(
                     delay,
                     idempotency_key,
                     time.monotonic() - attempt_started_at,
+                    total_deadline_reached=total_deadline_reached,
                 )
 
             n_retries += 1