modal 1.5.6.dev29__tar.gz → 1.5.6.dev31__tar.gz

{modal-1.5.6.dev29 → modal-1.5.6.dev31}/PKG-INFO

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

{modal-1.5.6.dev29 → modal-1.5.6.dev31}/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={

{modal-1.5.6.dev29 → modal-1.5.6.dev31}/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.dev29 → modal-1.5.6.dev31}/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.dev29 → modal-1.5.6.dev31}/modal/_partial_function.py

@@ -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.dev29 → modal-1.5.6.dev31}/modal/_server.py

@@ -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

{modal-1.5.6.dev29 → modal-1.5.6.dev31}/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