modAL 1.3.6.dev14__tar.gz → 1.4.0__tar.gz

{modal-1.3.6.dev14 → modal-1.4.0}/PKG-INFO

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

{modal-1.3.6.dev14 → modal-1.4.0}/modal/_functions.py

@@ -1562,7 +1562,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         input_queue: _SynchronizedQueue,
         order_outputs: bool,
         return_exceptions: bool,
-        wrap_returned_exceptions: bool,
     ) -> AsyncGenerator[Any, None]:
         """mdmd:hidden
 
@@ -1588,7 +1587,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     self.client,
                     order_outputs,
                     return_exceptions,
-                    wrap_returned_exceptions,
                     count_update_callback,
                 )
             ) as stream:
@@ -1602,7 +1600,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     self.client,
                     order_outputs,
                     return_exceptions,
-                    wrap_returned_exceptions,
                     count_update_callback,
                     api_pb2.FUNCTION_CALL_INVOCATION_TYPE_SYNC,
                 )

{modal-1.3.6.dev14 → modal-1.4.0}/modal/_output/pty.py

@@ -147,6 +147,11 @@ async def get_app_logs_loop(
             # doesn't support server-side search)
             if search_text and search_text not in log.data:
                 return
+            # Search results may lack trailing newlines; ensure each
+            # match is a complete line so the LineBufferedOutput buffer
+            # doesn't merge it with the next match.
+            if search_text and not log.data.endswith("\n"):
+                log.data += "\n"
             if pty_shell_finish_event:
                 await output_mgr.put_pty_content(log)
             else:

{modal-1.3.6.dev14 → modal-1.4.0}/modal/_utils/async_utils.py

@@ -349,19 +349,18 @@ def retry(
     direct_fn=None,
     *,
     n_attempts=3,
-    base_delay=0,
+    base_delay=0.0,
     delay_factor=2,
+    max_delay: Optional[float] = None,
     attempt_timeout: Optional[float] = 90,
-    attempt_timeout_factor=1,
+    total_timeout: Optional[float] = None,
 ):
     """Decorator that calls an async function multiple times, with a given timeout.
 
     If a `base_delay` is provided, the function is given an exponentially
     increasing delay on each run, up until the maximum number of attempts.
 
-    If `attempt_timeout_factor` is set to a value > 1, the per-attempt timeout
-    increases exponentially (starting from `attempt_timeout`, multiplied by
-    `attempt_timeout_factor` after each failed attempt).
+    If `max_delay` is set, the delay between attempts is capped at this value.
 
     Usage:
 
@@ -377,6 +376,7 @@ def retry(
         pass
     ```
     """
+    ATTEMPT_TIMEOUT_FLOOR = 2.0
 
     def decorator(fn):
         @functools.wraps(fn)
@@ -387,17 +387,35 @@ def retry(
                 local_n_attempts = n_attempts
 
             delay = base_delay
-            current_attempt_timeout = attempt_timeout
+            if total_timeout is not None:
+                total_deadline = time.time() + total_timeout
+            else:
+                total_deadline = None
+
             for i in range(local_n_attempts):
                 t0 = time.time()
+
+                timeouts = []
+                if attempt_timeout is not None:
+                    timeouts.append(attempt_timeout)
+                if total_deadline is not None:
+                    timeouts.append(max(total_deadline - time.time(), ATTEMPT_TIMEOUT_FLOOR))
+                timeout = min(timeouts) if timeouts else None
+
                 try:
-                    return await asyncio.wait_for(fn(*args, **kwargs), timeout=current_attempt_timeout)
+                    return await asyncio.wait_for(fn(*args, **kwargs), timeout=timeout)
                 except asyncio.CancelledError:
                     logger.debug(f"Function {fn} was cancelled")
                     raise
                 except Exception as e:
                     if i >= local_n_attempts - 1:
                         raise
+
+                    # We check if the timeout will be reached **after** the sleep, so we can raise an error early
+                    # without needing to actually sleep.
+                    if total_deadline is not None and time.time() + delay + ATTEMPT_TIMEOUT_FLOOR >= total_deadline:
+                        raise
+
                     logger.debug(
                         f"Failed invoking function {fn}: {e}"
                         f" (took {time.time() - t0}s, sleeping {delay}s"
@@ -405,8 +423,8 @@ def retry(
                     )
                 await asyncio.sleep(delay)
                 delay *= delay_factor
-                if current_attempt_timeout is not None:
-                    current_attempt_timeout *= attempt_timeout_factor
+                if max_delay is not None:
+                    delay = min(delay, max_delay)
 
         return f_wrapped
 

{modal-1.3.6.dev14 → modal-1.4.0}/modal/_utils/grpc_utils.py

@@ -90,8 +90,6 @@ RETRYABLE_GRPC_STATUS_CODES = [
 ]
 SERVER_RETRY_WARNING_TIME_INTERVAL = 30.0
 # Initial per-attempt timeout for TCP/TLS handshake in connect_channel.
-# Doubles each attempt (attempt_timeout_factor=2): 0.5 + 1 + 2 + 4 + 8 = 15.5s + ~1.5s inter-attempt delays.
-CONNECT_TIMEOUT = 0.5
 DEFAULT_MAX_RETRIES = 3
 
 
@@ -225,7 +223,8 @@ def create_channel(
     return channel
 
 
-@retry(n_attempts=5, base_delay=0.1, attempt_timeout=CONNECT_TIMEOUT, attempt_timeout_factor=2)
+# With 18 attempts, the max delays between calls is: 0.1 + 0.2 + 0.4 + 0.8 + 1.6 + 3.2 + 5*11 ~ 62
+@retry(n_attempts=18, base_delay=0.1, attempt_timeout=10.0, max_delay=5.0, total_timeout=63.0)
 async def connect_channel(channel: grpclib.client.Channel):
     """Connect to socket and raise exceptions when there is a connection issue."""
     await channel.__connect__()

{modal-1.3.6.dev14 → modal-1.4.0}/modal/_utils/task_command_router_client.py

@@ -11,7 +11,6 @@ from typing import AsyncGenerator, Optional
 
 import grpclib.client
 import grpclib.config
-import grpclib.events
 from grpclib import GRPCError, Status
 from grpclib.exceptions import StreamTerminatedError
 
@@ -22,8 +21,21 @@ from modal_proto.task_command_router_grpc import TaskCommandRouterStub
 
 from .._grpc_client import grpc_error_converter
 from .._utils.grpc_utils import PermanentCloseableChannel
-from .async_utils import aclosing
-from .grpc_utils import RETRYABLE_GRPC_STATUS_CODES, connect_channel
+from .async_utils import aclosing, retry
+from .grpc_utils import RETRYABLE_GRPC_STATUS_CODES
+
+
+@retry(n_attempts=34, base_delay=1, max_delay=10, attempt_timeout=10, total_timeout=310)
+async def _connect_channel(channel: grpclib.client.Channel):
+    """Connect to the command router channel.
+
+    Uses a longer retry budget than grpc_utils.connect_channel. In rare cases the sandbox
+    may take a long time to start on the worker after scheduling.
+
+    Retries with exponential backoff (1, 2, 4, 8, 10, 10, ...) capped at 10s per delay.
+    Total sleep between attempts: 1 + 2 + 4 + 8 + 10*29 = 305s (~5 min).
+    """
+    await channel.__connect__()
 
 
 def _b64url_decode(data: str) -> bytes:
@@ -169,7 +181,7 @@ class TaskCommandRouterClient:
             closed_error_message="Unable to perform operation on a detached sandbox",
         )
 
-        await connect_channel(channel)
+        await _connect_channel(channel)
         loop = asyncio.get_running_loop()
         jwt_refresh_lock = asyncio.Lock()
 

{modal-1.3.6.dev14 → modal-1.4.0}/modal/cli/app.py

@@ -164,7 +164,7 @@ def logs(
     Get recent logs based on an app ID:
 
     ```
-    modal app logs ap-123456 --tail 100
+    modal app logs ap-123456
     ```
 
     Get recent logs for a currently deployed App based on its name:
@@ -179,6 +179,12 @@ def logs(
     modal app logs my-app -f
     ```
 
+    Fetch the last 1000 entries:
+
+    ```
+    modal app logs my-app --tail 1000
+    ```
+
     Fetch logs from the last 2 hours:
 
     ```

{modal-1.3.6.dev14 → modal-1.4.0}/modal/cli/container.py

@@ -27,7 +27,11 @@ container_cli = typer.Typer(name="container", help="Manage and connect to runnin
 
 @container_cli.command("list")
 @synchronizer.create_blocking
-async def list_(env: Optional[str] = ENV_OPTION, json: bool = False, app_id: str = ""):
+async def list_(
+    app_id: str = typer.Option("", "--app-id", help="List containers running for a specific App."),
+    env: Optional[str] = ENV_OPTION,
+    json: bool = False,
+):
     """List all containers that are currently running."""
     env = ensure_env(env)
     client = await _Client.from_env()
@@ -113,6 +117,12 @@ async def logs(
     modal container logs ta-123456 --since 2026-03-01T05:00:00 --until 2026-03-01T08:00:00
     ```
 
+    Fetch the last 1000 entries:
+
+    ```
+    modal container logs ta-123456 --tail 1000
+    ```
+
     Fetch all container logs:
 
     ```

{modal-1.3.6.dev14 → modal-1.4.0}/modal/client.pyi

@@ -31,11 +31,7 @@ class _Client:
     client_type: int
 
     def __init__(
-        self,
-        server_url: str,
-        client_type: int,
-        credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.3.6.dev14",
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "1.4.0"
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -167,11 +163,7 @@ class Client:
     client_type: int
 
     def __init__(
-        self,
-        server_url: str,
-        client_type: int,
-        credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.3.6.dev14",
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "1.4.0"
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.3.6.dev14 → modal-1.4.0}/modal/functions.pyi

@@ -291,12 +291,7 @@ class Function(
 
     class ___map_spec(typing_extensions.Protocol):
         def __call__(
-            self,
-            /,
-            input_queue: modal.parallel_map.SynchronizedQueue,
-            order_outputs: bool,
-            return_exceptions: bool,
-            wrap_returned_exceptions: bool,
+            self, /, input_queue: modal.parallel_map.SynchronizedQueue, order_outputs: bool, return_exceptions: bool
         ) -> typing.Generator[typing.Any, None, None]:
             """mdmd:hidden
 
@@ -310,12 +305,7 @@ class Function(
             ...
 
         def aio(
-            self,
-            /,
-            input_queue: modal.parallel_map.SynchronizedQueue,
-            order_outputs: bool,
-            return_exceptions: bool,
-            wrap_returned_exceptions: bool,
+            self, /, input_queue: modal.parallel_map.SynchronizedQueue, order_outputs: bool, return_exceptions: bool
         ) -> collections.abc.AsyncGenerator[typing.Any, None]:
             """mdmd:hidden
 
@@ -482,7 +472,7 @@ class Function(
             kwargs={},
             order_outputs: bool = True,
             return_exceptions: bool = False,
-            wrap_returned_exceptions: bool = True,
+            wrap_returned_exceptions: typing.Optional[bool] = None,
         ) -> modal._utils.async_utils.AsyncOrSyncIterable:
             """Parallel map over a set of inputs.
 
@@ -516,7 +506,7 @@ class Function(
 
             @app.local_entrypoint()
             def main():
-                # [0, 1, UserCodeException(Exception('ohno'))]
+                # [0, 1, Exception('ohno')]
                 print(list(my_func.map(range(3), return_exceptions=True)))
             ```
             """
@@ -529,7 +519,7 @@ class Function(
             kwargs={},
             order_outputs: bool = True,
             return_exceptions: bool = False,
-            wrap_returned_exceptions: bool = True,
+            wrap_returned_exceptions: typing.Optional[bool] = None,
         ) -> typing.AsyncGenerator[typing.Any, None]: ...
 
     map: __map_spec
@@ -543,7 +533,7 @@ class Function(
             kwargs={},
             order_outputs: bool = True,
             return_exceptions: bool = False,
-            wrap_returned_exceptions: bool = True,
+            wrap_returned_exceptions: typing.Optional[bool] = None,
         ) -> modal._utils.async_utils.AsyncOrSyncIterable:
             """Like `map`, but spreads arguments over multiple function arguments.
 
@@ -573,7 +563,7 @@ class Function(
             kwargs={},
             order_outputs: bool = True,
             return_exceptions: bool = False,
-            wrap_returned_exceptions: bool = True,
+            wrap_returned_exceptions: typing.Optional[bool] = None,
         ) -> typing.AsyncIterable[typing.Any]: ...
 
     starmap: __starmap_spec

{modal-1.3.6.dev14 → modal-1.4.0}/modal/output.py

@@ -16,7 +16,7 @@ __all__ = ["enable_output", "OutputManager"]
 
 
 @contextlib.contextmanager
-def enable_output() -> Generator[OutputManager, None, None]:
+def enable_output() -> Generator[None, None, None]:
     """Context manager that enable output when using the Python SDK.
 
     This will print to stdout and stderr things such as
@@ -31,9 +31,6 @@ def enable_output() -> Generator[OutputManager, None, None]:
         with app.run():
             ...
     ```
-
-    To suppress progress indicators, use `output_manager.set_quiet_mode(True)`.
-    To enable timestamps, use `output_manager.set_timestamps(True)`.
     """
     previous_output_manager = OutputManager.get()
 
@@ -42,6 +39,6 @@ def enable_output() -> Generator[OutputManager, None, None]:
     new_manager = RichOutputManager()
     OutputManager._set(new_manager)
     try:
-        yield new_manager
+        yield
     finally:
         OutputManager._set(previous_output_manager)

{modal-1.3.6.dev14 → modal-1.4.0}/modal/parallel_map.py

@@ -1,7 +1,6 @@
 # Copyright Modal Labs 2024
 import asyncio
 import enum
-import inspect
 import time
 import typing
 from asyncio import FIRST_COMPLETED
@@ -10,7 +9,6 @@ from typing import Any, Callable, Optional, Union
 
 from grpclib import Status
 
-import modal.exception
 from modal._runtime.execution_context import current_input_id
 from modal._utils.async_utils import (
     AsyncOrSyncIterable,
@@ -365,7 +363,6 @@ async def _map_invocation(
     client: "modal.client._Client",
     order_outputs: bool,
     return_exceptions: bool,
-    wrap_returned_exceptions: bool,
     count_update_callback: Optional[Callable[[int, int], None]],
     function_call_invocation_type: "api_pb2.FunctionCallInvocationType.ValueType",
 ):
@@ -545,13 +542,7 @@ async def _map_invocation(
             output = await _process_result(item.result, item.data_format, client.stub, client)
         except Exception as e:
             if return_exceptions:
-                if wrap_returned_exceptions:
-                    # Prior to client 1.0.4 there was a bug where return_exceptions would wrap
-                    # any returned exceptions in a synchronicity.UserCodeException. This adds
-                    # deprecated non-breaking compatibility bandaid for migrating away from that:
-                    output = modal.exception.UserCodeException(e)
-                else:
-                    output = e
+                output = e
             else:
                 raise e
         return (item.idx, output)
@@ -631,7 +622,6 @@ async def _map_invocation_inputplane(
     client: "modal.client._Client",
     order_outputs: bool,
     return_exceptions: bool,
-    wrap_returned_exceptions: bool,
     count_update_callback: Optional[Callable[[int, int], None]],
 ) -> typing.AsyncGenerator[Any, None]:
     """Input-plane implementation of a function map invocation.
@@ -916,13 +906,7 @@ async def _map_invocation_inputplane(
             output = await _process_result(item.result, item.data_format, input_plane_stub, client)
         except Exception as e:
             if return_exceptions:
-                if wrap_returned_exceptions:
-                    # Prior to client 1.0.4 there was a bug where return_exceptions would wrap
-                    # any returned exceptions in a synchronicity.UserCodeException. This adds
-                    # deprecated non-breaking compatibility bandaid for migrating away from that:
-                    output = modal.exception.UserCodeException(e)
-                else:
-                    output = e
+                output = e
             else:
                 raise e
         return (item.idx, output)
@@ -992,7 +976,6 @@ async def _map_helper(
     kwargs={},  # any extra keyword arguments for the function
     order_outputs: bool = True,  # return outputs in order
     return_exceptions: bool = False,  # propagate exceptions (False) or aggregate them in the results list (True)
-    wrap_returned_exceptions: bool = True,
 ) -> typing.AsyncGenerator[Any, None]:
     """Core implementation that supports `_map_async()`, `_starmap_async()` and `_for_each_async()`.
 
@@ -1022,41 +1005,24 @@ async def _map_helper(
     # synchronicity-wrapped, since they accept executable code in the form of iterators that we don't want to run inside
     # the synchronicity thread. Instead, we delegate to `._map()` with a safer Queue as input.
     async with aclosing(
-        async_merge(
-            self._map.aio(raw_input_queue, order_outputs, return_exceptions, wrap_returned_exceptions), feed_queue()
-        )
+        async_merge(self._map.aio(raw_input_queue, order_outputs, return_exceptions), feed_queue())
     ) as map_output_stream:
         async for output in map_output_stream:
             yield output
 
 
-def _maybe_warn_about_exceptions(func_name: str, return_exceptions: bool, wrap_returned_exceptions: bool):
-    if return_exceptions and wrap_returned_exceptions:
+def _maybe_warn_about_wrap_exceptions(func_name: str, wrap_returned_exceptions: Optional[bool]):
+    if wrap_returned_exceptions is not None:
         deprecation_warning(
-            (2025, 6, 27),
+            (2026, 3, 24),
             (
-                f"Function.{func_name} currently leaks an internal exception wrapping type "
-                "(modal.exceptions.UserCodeException) when `return_exceptions=True` is set. "
-                "In the future, this will change, and the underlying exception will be returned directly.\n"
-                "To opt into the future behavior and silence this warning, add `wrap_returned_exceptions=False`:\n\n"
-                f"    f.{func_name}(..., return_exceptions=True, wrap_returned_exceptions=False)"
+                f"The `wrap_returned_exceptions` parameter of `Function.{func_name}` no longer has any "
+                "effect and can be removed from your code. Exceptions are no longer wrapped before being "
+                f"returned from `Function.{func_name}`. "
             ),
         )
 
 
-def _invoked_from_sync_wrapper() -> bool:
-    """Check whether the calling function was called from a sync wrapper."""
-    # This is temporary: we only need it to avoind double-firing the wrap_returned_exceptions warning.
-    # (We don't want to push the warning lower in the stack beacuse then we can't attribute to the user's code.)
-    try:
-        frame = inspect.currentframe()
-        caller_function_name = frame.f_back.f_back.f_code.co_name
-        # Embeds some assumptions about how the current calling stack works, but this is just temporary.
-        return caller_function_name == "asend"
-    except Exception:
-        return False
-
-
 @warn_if_generator_is_not_consumed(function_name="Function.map.aio")
 async def _map_async(
     self: "modal.functions.Function",
@@ -1066,10 +1032,9 @@ async def _map_async(
     kwargs={},  # any extra keyword arguments for the function
     order_outputs: bool = True,  # return outputs in order
     return_exceptions: bool = False,  # propagate exceptions (False) or aggregate them in the results list (True)
-    wrap_returned_exceptions: bool = True,  # wrap returned exceptions in modal.exception.UserCodeException
+    wrap_returned_exceptions: Optional[bool] = None,
 ) -> typing.AsyncGenerator[Any, None]:
-    if not _invoked_from_sync_wrapper():
-        _maybe_warn_about_exceptions("map.aio", return_exceptions, wrap_returned_exceptions)
+    _maybe_warn_about_wrap_exceptions("map.aio", wrap_returned_exceptions)
     async_input_gen = async_zip(*[sync_or_async_iter(it) for it in input_iterators])
     async for output in _map_helper(
         self,
@@ -1077,7 +1042,6 @@ async def _map_async(
         kwargs=kwargs,
         order_outputs=order_outputs,
         return_exceptions=return_exceptions,
-        wrap_returned_exceptions=wrap_returned_exceptions,
     ):
         yield output
 
@@ -1090,17 +1054,15 @@ async def _starmap_async(
     kwargs={},
     order_outputs: bool = True,
     return_exceptions: bool = False,
-    wrap_returned_exceptions: bool = True,
+    wrap_returned_exceptions: Optional[bool] = None,
 ) -> typing.AsyncIterable[Any]:
-    if not _invoked_from_sync_wrapper():
-        _maybe_warn_about_exceptions("starmap.aio", return_exceptions, wrap_returned_exceptions)
+    _maybe_warn_about_wrap_exceptions("starmap.aio", wrap_returned_exceptions)
     async for output in _map_helper(
         self,
         sync_or_async_iter(input_iterator),
         kwargs=kwargs,
         order_outputs=order_outputs,
         return_exceptions=return_exceptions,
-        wrap_returned_exceptions=wrap_returned_exceptions,
     ):
         yield output
 
@@ -1115,7 +1077,6 @@ async def _for_each_async(self, *input_iterators, kwargs={}, ignore_exceptions:
         kwargs=kwargs,
         order_outputs=False,
         return_exceptions=ignore_exceptions,
-        wrap_returned_exceptions=False,
     ):
         pass
 
@@ -1127,7 +1088,7 @@ def _map_sync(
     kwargs={},  # any extra keyword arguments for the function
     order_outputs: bool = True,  # return outputs in order
     return_exceptions: bool = False,  # propagate exceptions (False) or aggregate them in the results list (True)
-    wrap_returned_exceptions: bool = True,
+    wrap_returned_exceptions: Optional[bool] = None,
 ) -> AsyncOrSyncIterable:
     """Parallel map over a set of inputs.
 
@@ -1161,11 +1122,11 @@ def _map_sync(
 
     @app.local_entrypoint()
     def main():
-        # [0, 1, UserCodeException(Exception('ohno'))]
+        # [0, 1, Exception('ohno')]
         print(list(my_func.map(range(3), return_exceptions=True)))
     ```
     """
-    _maybe_warn_about_exceptions("map", return_exceptions, wrap_returned_exceptions)
+    _maybe_warn_about_wrap_exceptions("map", wrap_returned_exceptions)
 
     return AsyncOrSyncIterable(
         _map_async(
@@ -1174,7 +1135,6 @@ def _map_sync(
             kwargs=kwargs,
             order_outputs=order_outputs,
             return_exceptions=return_exceptions,
-            wrap_returned_exceptions=wrap_returned_exceptions,
         ),
         nested_async_message=(
             "You can't iter(Function.map()) from an async function. Use async for ... in Function.map.aio() instead."
@@ -1304,7 +1264,7 @@ def _starmap_sync(
     kwargs={},
     order_outputs: bool = True,
     return_exceptions: bool = False,
-    wrap_returned_exceptions: bool = True,
+    wrap_returned_exceptions: Optional[bool] = None,
 ) -> AsyncOrSyncIterable:
     """Like `map`, but spreads arguments over multiple function arguments.
 
@@ -1322,7 +1282,7 @@ def _starmap_sync(
         assert list(my_func.starmap([(1, 2), (3, 4)])) == [3, 7]
     ```
     """
-    _maybe_warn_about_exceptions("starmap", return_exceptions, wrap_returned_exceptions)
+    _maybe_warn_about_wrap_exceptions("starmap", wrap_returned_exceptions)
     return AsyncOrSyncIterable(
         _starmap_async(
             self,
@@ -1330,7 +1290,6 @@ def _starmap_sync(
             kwargs=kwargs,
             order_outputs=order_outputs,
             return_exceptions=return_exceptions,
-            wrap_returned_exceptions=wrap_returned_exceptions,
         ),
         nested_async_message=(
             "You can't `iter(Function.starmap())` from an async function. "

{modal-1.3.6.dev14 → modal-1.4.0}/modal/parallel_map.pyi

@@ -140,7 +140,6 @@ def _map_invocation(
     client: modal.client._Client,
     order_outputs: bool,
     return_exceptions: bool,
-    wrap_returned_exceptions: bool,
     count_update_callback: typing.Optional[collections.abc.Callable[[int, int], None]],
     function_call_invocation_type: int,
 ): ...
@@ -150,7 +149,6 @@ def _map_invocation_inputplane(
     client: modal.client._Client,
     order_outputs: bool,
     return_exceptions: bool,
-    wrap_returned_exceptions: bool,
     count_update_callback: typing.Optional[collections.abc.Callable[[int, int], None]],
 ) -> typing.AsyncGenerator[typing.Any, None]:
     """Input-plane implementation of a function map invocation.
@@ -167,7 +165,6 @@ def _map_helper(
     kwargs={},
     order_outputs: bool = True,
     return_exceptions: bool = False,
-    wrap_returned_exceptions: bool = True,
 ) -> typing.AsyncGenerator[typing.Any, None]:
     """Core implementation that supports `_map_async()`, `_starmap_async()` and `_for_each_async()`.
 
@@ -182,18 +179,14 @@ def _map_helper(
     """
     ...
 
-def _maybe_warn_about_exceptions(func_name: str, return_exceptions: bool, wrap_returned_exceptions: bool): ...
-def _invoked_from_sync_wrapper() -> bool:
-    """Check whether the calling function was called from a sync wrapper."""
-    ...
-
+def _maybe_warn_about_wrap_exceptions(func_name: str, wrap_returned_exceptions: typing.Optional[bool]): ...
 def _map_async(
     self: modal.functions.Function,
     *input_iterators: typing.Union[typing.Iterable[typing.Any], typing.AsyncIterable[typing.Any]],
     kwargs={},
     order_outputs: bool = True,
     return_exceptions: bool = False,
-    wrap_returned_exceptions: bool = True,
+    wrap_returned_exceptions: typing.Optional[bool] = None,
 ) -> typing.AsyncGenerator[typing.Any, None]: ...
 def _starmap_async(
     self,
@@ -204,7 +197,7 @@ def _starmap_async(
     kwargs={},
     order_outputs: bool = True,
     return_exceptions: bool = False,
-    wrap_returned_exceptions: bool = True,
+    wrap_returned_exceptions: typing.Optional[bool] = None,
 ) -> typing.AsyncIterable[typing.Any]: ...
 async def _for_each_async(self, *input_iterators, kwargs={}, ignore_exceptions: bool = False) -> None: ...
 def _map_sync(
@@ -213,7 +206,7 @@ def _map_sync(
     kwargs={},
     order_outputs: bool = True,
     return_exceptions: bool = False,
-    wrap_returned_exceptions: bool = True,
+    wrap_returned_exceptions: typing.Optional[bool] = None,
 ) -> modal._utils.async_utils.AsyncOrSyncIterable:
     """Parallel map over a set of inputs.
 
@@ -247,7 +240,7 @@ def _map_sync(
 
     @app.local_entrypoint()
     def main():
-        # [0, 1, UserCodeException(Exception('ohno'))]
+        # [0, 1, Exception('ohno')]
         print(list(my_func.map(range(3), return_exceptions=True)))
     ```
     """
@@ -323,7 +316,7 @@ def _starmap_sync(
     kwargs={},
     order_outputs: bool = True,
     return_exceptions: bool = False,
-    wrap_returned_exceptions: bool = True,
+    wrap_returned_exceptions: typing.Optional[bool] = None,
 ) -> modal._utils.async_utils.AsyncOrSyncIterable:
     """Like `map`, but spreads arguments over multiple function arguments.