modAL 1.2.7.dev12__py3-none-any.whl → 1.2.7.dev13__py3-none-any.whl

modal/_functions.py

@@ -38,6 +38,7 @@ from ._utils.async_utils import (
     aclosing,
     async_merge,
     callable_to_agen,
+    deprecate_aio_usage,
     synchronizer,
     warn_if_generator_is_not_consumed,
 )
@@ -96,6 +97,7 @@ from .volume import _Volume
 if TYPE_CHECKING:
     import modal.app
     import modal.cls
+    import modal.functions
 
 MAX_INTERNAL_FAILURE_COUNT = 8
 TERMINAL_STATUSES = (
@@ -2025,8 +2027,11 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         assert self._client and self._client.stub
         await self._client.stub.FunctionCallCancel(request)
 
-    @staticmethod
-    async def from_id(function_call_id: str, client: Optional[_Client] = None) -> "_FunctionCall[Any]":
+    @deprecate_aio_usage((2025, 11, 14), "FunctionCall.from_id")
+    @classmethod
+    def from_id(
+        cls, function_call_id: str, client: Optional["modal.client.Client"] = None
+    ) -> "modal.functions.FunctionCall[Any]":
         """Instantiate a FunctionCall object from an existing ID.
 
         Examples:
@@ -2037,7 +2042,7 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         fc_id = fc.object_id
 
         # Later, use the ID to re-instantiate the FunctionCall object
-        fc = _FunctionCall.from_id(fc_id)
+        fc = FunctionCall.from_id(fc_id)
         result = fc.get()
         ```
 
@@ -2045,6 +2050,7 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         if you no longer have access to the original object returned from `Function.spawn`.
 
         """
+        _client = typing.cast(_Client, synchronizer._translate_in(client))
 
         async def _load(
             self: _FunctionCall, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]
@@ -2053,10 +2059,10 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
             self._hydrate(function_call_id, load_context.client, None)
 
         rep = f"FunctionCall.from_id({function_call_id!r})"
-
-        return _FunctionCall._from_loader(
-            _load, rep, hydrate_lazily=True, load_context_overrides=LoadContext(client=client)
+        impl_instance = _FunctionCall._from_loader(
+            _load, rep, hydrate_lazily=True, load_context_overrides=LoadContext(client=_client)
         )
+        return typing.cast("modal.functions.FunctionCall[Any]", synchronizer._translate_out(impl_instance))
 
     @staticmethod
     async def gather(*function_calls: "_FunctionCall[T]") -> typing.Sequence[T]:

modal/_ipython.py

@@ -2,10 +2,20 @@
 import sys
 
 
-def is_notebook(stdout=None):
-    ipykernel_iostream = sys.modules.get("ipykernel.iostream")
-    if ipykernel_iostream is None:
+def is_interactive_ipython():
+    """
+    Detect if we're running in an interactive IPython session.
+
+    Returns True for IPython shells (including Jupyter notebooks), False otherwise.
+    """
+    try:
+        # Check if IPython is available and get the current instance
+        ipython = sys.modules.get("IPython")
+        if ipython is None:
+            return False
+
+        # Try to get the active IPython instance
+        shell = ipython.get_ipython()
+        return shell is not None
+    except Exception:
         return False
-    if stdout is None:
-        stdout = sys.stdout
-    return isinstance(stdout, ipykernel_iostream.OutStream)

modal/_object.py

@@ -1,4 +1,5 @@
 # Copyright Modal Labs 2022
+import contextlib
 import typing
 import uuid
 from collections.abc import Awaitable, Hashable, Sequence
@@ -350,3 +351,18 @@ def live_method_gen(method):
                 yield item
 
     return wrapped
+
+
+def live_method_contextmanager(method):
+    # make sure a wrapped function returning an async context manager
+    # will not require both an `await func.aio()` and `async with`
+    # which would have been the case if it was wrapped in live_method
+
+    @wraps(method)
+    @contextlib.asynccontextmanager
+    async def wrapped(self, *args, **kwargs):
+        await self.hydrate()
+        async with method(self, *args, **kwargs) as ctx:
+            yield ctx
+
+    return wrapped

modal/_utils/async_utils.py

@@ -5,8 +5,10 @@ import contextlib
 import functools
 import inspect
 import itertools
+import os
 import sys
 import time
+import types
 import typing
 import warnings
 from collections.abc import AsyncGenerator, AsyncIterable, Awaitable, Iterable, Iterator
@@ -24,10 +26,14 @@ from typing import (
 
 import synchronicity
 from synchronicity.async_utils import Runner
+from synchronicity.combined_types import MethodWithAio
 from synchronicity.exceptions import NestedEventLoops
 from typing_extensions import ParamSpec, assert_type
 
-from ..exception import InvalidError
+from modal._ipython import is_interactive_ipython
+from modal._utils.deprecation import deprecation_warning
+
+from ..exception import AsyncUsageWarning, InvalidError
 from .logger import logger
 
 T = TypeVar("T")
@@ -38,7 +44,285 @@ if sys.platform == "win32":
     # quick workaround for deadlocks on shutdown - need to investigate further
     asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
-synchronizer = synchronicity.Synchronizer()
+
+def rewrite_sync_to_async(code_line: str, original_func: Callable) -> tuple[bool, str]:
+    """
+    Rewrite a blocking call to use async/await syntax.
+
+    Handles four patterns:
+    1. __aiter__: for x in obj -> async for x in obj
+    2. __aenter__: with obj as x -> async with obj as x
+    3. Async generators in for loops: for x in obj.method(...) -> async for x in obj.method(...)
+    4. Regular methods: obj.method() -> await obj.method.aio()
+
+    Args:
+        code_line: The line of code containing the blocking call
+        original_func: The original function object being called
+
+    Returns:
+        A tuple of (success, rewritten_code):
+        - success: True if the pattern was found and rewritten, False if falling back to generic
+        - rewritten_code: The rewritten code or a generic suggestion
+    """
+    import re
+
+    func_name = original_func.__name__  # type: ignore
+
+    # Check if this is an async generator function
+    is_async_gen = inspect.isasyncgenfunction(original_func)
+
+    # Handle __aiter__ pattern: for x in obj -> async for x in obj
+    if func_name == "__aiter__" and code_line.startswith("for "):
+        suggestion = code_line.replace("for ", "async for ", 1)
+        return (True, suggestion)
+
+    # Handle __aenter__ pattern: with obj as x -> async with obj as x
+    if func_name == "__aenter__" and code_line.startswith("with "):
+        suggestion = code_line.replace("with ", "async with ", 1)
+        return (True, suggestion)
+
+    # Handle __setitem__ pattern: dct['key'] = value -> suggest alternative
+    if func_name == "__setitem__":
+        # Try to extract the object and key from the bracket syntax
+        setitem_match = re.match(r"(\w+)\[([^\]]+)\]\s*=\s*(.+)", code_line.strip())
+        if setitem_match:
+            obj, key, value = setitem_match.groups()
+            suggestion = (
+                f"You can't use `{obj}[{key}] = {value}` syntax asynchronously - "
+                f"there may be an alternative api, e.g. {obj}.put.aio({key}, {value})"
+            )
+            return (False, suggestion)
+        return (False, f"await ...{func_name}.aio(...)")
+
+    # Handle __getitem__ pattern: dct['key'] -> suggest alternative
+    if func_name == "__getitem__":
+        # Try to extract the object and key from the bracket syntax
+        getitem_match = re.match(r"(\w+)\[([^\]]+)\]$", code_line.strip())
+        if getitem_match:
+            obj, key = getitem_match.groups()
+            suggestion = (
+                f"You can't use `{obj}[{key}]` syntax asynchronously - "
+                f"there may be an alternative api, e.g. {obj}.get.aio({key})"
+            )
+            return (False, suggestion)
+        return (False, f"await ...{func_name}.aio(...)")
+
+    # Handle async generator methods in for loops: for x in obj.method(...) -> async for x in obj.method(...)
+    if is_async_gen and code_line.strip().startswith("for "):
+        # Pattern: for <var> in <expr>.<method>(<args>):
+        for_pattern = rf"(for\s+\w+\s+in\s+.*\.){re.escape(func_name)}(\s*\()"
+        for_match = re.search(for_pattern, code_line)
+
+        if for_match:
+            # Just replace "for" with "async for" - no .aio() needed for async generators
+            suggestion = code_line.replace("for ", "async for ", 1)
+            return (True, suggestion)
+
+    # Handle regular method calls and property access
+    # First check if it's a property access (no parentheses after the name)
+    property_pattern = rf"\.{re.escape(func_name)}(?!\s*\()"
+    property_match = re.search(property_pattern, code_line)
+
+    if property_match:
+        # This is a property access, rewrite to use await without .aio()
+        # Find the start of the expression (skip statement keywords and assignments)
+        statement_start = 0
+        prefix_match = re.match(r"^(\s*(?:\w+\s*=|return|yield|raise)\s+)", code_line)
+        if prefix_match:
+            statement_start = len(prefix_match.group(1))
+
+        before_expr = code_line[:statement_start]
+        after_prefix = code_line[statement_start:]
+
+        # Just add await before the expression for properties
+        suggestion = before_expr + "await " + after_prefix.lstrip()
+        return (True, suggestion)
+
+    # Try to find a method call (with parentheses)
+    method_pattern = rf"\.{re.escape(func_name)}\s*\("
+    method_match = re.search(method_pattern, code_line)
+
+    if not method_match:
+        # Can't find the function call or property
+        return (False, f"await ...{func_name}.aio(...)")
+
+    # Safety check: don't attempt rewrite for complex expressions
+    unsafe_keywords = ["if", "elif", "while", "and", "or", "not", "in", "is", "for"]
+
+    # Check if line contains control flow keywords (might be too complex)
+    for keyword in unsafe_keywords:
+        if re.search(rf"\b{keyword}\b", code_line):
+            # Fall back to generic suggestion for complex expressions
+            return (False, f"await ...{func_name}.aio(...)")
+
+    # Find the start of the object expression that leads to the method call
+    # We need to find where the object/chain starts, e.g., in "2 * foo.bar.method()" we want "foo"
+    # Work backwards from the method match to find the start of the identifier chain
+    method_start = method_match.start()
+
+    # Find the start of the identifier chain (the object being called)
+    # Walk backwards to find identifiers and dots that form the chain
+    expr_start = method_start
+    i = method_start - 1
+    while i >= 0:
+        c = code_line[i]
+        if c.isalnum() or c == "_" or c == ".":
+            expr_start = i
+            i -= 1
+        elif c.isspace():
+            # Skip whitespace within the chain (though unusual)
+            i -= 1
+        else:
+            # Found a non-identifier character, stop
+            break
+
+    # Now expr_start points to the start of the object chain (e.g., "foo" in "foo.method()")
+    # But we need to check if the identifier we found is actually a keyword like return/yield/raise
+    # In that case, skip over it and find the actual object
+    before_obj = code_line[:expr_start]
+    obj_and_rest = code_line[expr_start:]
+
+    # Check if what we found starts with a statement keyword
+    keyword_match = re.match(r"^(return|yield|raise)\s+", obj_and_rest)
+    if keyword_match:
+        # The "object" we found is actually a keyword, adjust to skip it
+        keyword_len = len(keyword_match.group(0))
+        before_obj = code_line[: expr_start + keyword_len]
+        obj_and_rest = code_line[expr_start + keyword_len :]
+
+    # Add .aio() after the method name and await before the object
+    rewritten_expr = re.sub(rf"(\.{re.escape(func_name)})\s*\(", r"\1.aio(", obj_and_rest, count=1)
+    suggestion = before_obj + "await " + rewritten_expr
+
+    return (True, suggestion)
+
+
+@dataclass
+class _CallFrame:
+    """Simple dataclass to hold call frame information."""
+
+    filename: str
+    lineno: int
+    line: Optional[str]
+
+
+def _extract_user_call_frame():
+    """
+    Extract the call frame from user code by filtering out frames from synchronicity and asyncio.
+
+    Returns a _CallFrame with the filename, line number, and source line, or None if not found.
+    """
+    import linecache
+    import os
+
+    # Get the current call stack
+    stack = inspect.stack()
+
+    # Get the absolute path of this module to filter it out
+    this_file = os.path.abspath(__file__)
+
+    # Filter out frames from synchronicity, asyncio, and this module
+    for frame_info in stack:
+        filename = frame_info.filename
+        # Skip frames from synchronicity, asyncio packages, and this module
+        # Use path separators to ensure we're matching packages, not just filenames containing these words
+        if (
+            os.path.sep + "synchronicity" + os.path.sep in filename
+            or os.path.sep + "asyncio" + os.path.sep in filename
+            or os.path.abspath(filename) == this_file
+        ):
+            continue
+
+        # Found a user frame
+        line = linecache.getline(filename, frame_info.lineno)
+        return _CallFrame(filename=filename, lineno=frame_info.lineno, line=line if line else None)
+
+    # Fallback if we can't find a suitable frame
+    return None
+
+
+def _blocking_in_async_warning(original_func: types.FunctionType):
+    if is_interactive_ipython():
+        # in notebooks or interactive sessions where sync usage is expected
+        # even if it's actually running in an event loop
+        return
+
+    import warnings
+
+    # Skip warnings for __aexit__ and __anext__ - the __aenter__ and __aiter__ warnings are sufficient
+    if original_func:
+        func_name = getattr(original_func, "__name__", str(original_func))
+        if func_name in ("__aexit__", "__anext__"):
+            # These dunders would typically already have caused a warning on the __aenter__ or __aiter__ respectively
+            return
+
+    # Extract the call frame from the stack
+    call_frame = _extract_user_call_frame()
+
+    # Build detailed warning message with location and function first
+    message_parts = [
+        "A blocking Modal interface is being used in an async context.",
+        "\n\nThis may cause performance issues or bugs.",
+        " Consider rewriting to use Modal's async interfaces:",
+        "\nhttps://modal.com/docs/guide/async",
+    ]
+
+    # Generate intelligent suggestion based on the context
+    suggestion = None
+    code_line = None
+
+    if original_func and call_frame and call_frame.line:
+        code_line = call_frame.line.strip()
+        # Use the unified rewrite function for all patterns
+        _, suggestion = rewrite_sync_to_async(code_line, original_func)
+
+    # Add suggestion in "change X to Y" format
+    if suggestion and code_line:
+        # this is a bit ugly, but the warnings formatter will show the offending source line
+        # on the last line regardless what we do, so we add this to not make it look out of place
+        message_parts.append(f"\n\nSuggested rewrite:\n  {suggestion}\n\nOriginal line:")
+
+    # Use warn_explicit to provide precise location information from the call frame
+    if call_frame:
+        # Extract module name from filename, or use a default
+        module_name = os.path.splitext(os.path.basename(call_frame.filename))[0]
+
+        warnings.warn_explicit(
+            "".join(message_parts),
+            AsyncUsageWarning,
+            filename=call_frame.filename,
+            lineno=call_frame.lineno,
+            module=module_name,
+        )
+    else:
+        # Fallback to regular warn if no frame information available
+        warnings.warn("".join(message_parts), AsyncUsageWarning)
+
+
+def _safe_blocking_in_async_warning(original_func: types.FunctionType):
+    """
+    Safety wrapper around _blocking_in_async_warning to ensure it never raises exceptions.
+
+    This is non-critical functionality (just a warning), so we don't want it to break user code.
+    However, if the warning has been configured to be treated as an error (via filterwarnings),
+    we should let that propagate.
+    """
+    from ..config import config
+
+    if not config.get("async_warnings"):
+        return
+    try:
+        _blocking_in_async_warning(original_func)
+    except AsyncUsageWarning:
+        # Re-raise the warning if it's been configured as an error
+        raise
+    except Exception:
+        # Silently ignore any other errors in the warning system
+        # We don't want the warning mechanism itself to cause problems
+        pass
+
+
+synchronizer = synchronicity.Synchronizer(blocking_in_async_callback=_safe_blocking_in_async_warning)
 
 
 def synchronize_api(obj, target_module=None):
@@ -389,6 +673,7 @@ class _WarnIfGeneratorIsNotConsumed:
         self.function_name = function_name
         self.iterated = False
         self.warned = False
+        self.__wrapped__ = gen
 
     def __aiter__(self):
         self.iterated = True
@@ -897,3 +1182,26 @@ async def async_chain(*generators: AsyncGenerator[T, None]) -> AsyncGenerator[T,
                 logger.exception(f"Error closing async generator: {e}")
         if first_exception is not None:
             raise first_exception
+
+
+def deprecate_aio_usage(deprecation_date: tuple[int, int, int], readable_sync_call: str):
+    # Note: Currently only works on methods, not top level functions
+    def deco(sync_implementation):
+        if isinstance(sync_implementation, classmethod):
+            sync_implementation = sync_implementation.__func__
+            is_classmethod = True
+        else:
+            is_classmethod = False
+
+        async def _async_proxy(*args, **kwargs):
+            deprecation_warning(
+                deprecation_date,
+                f"""The async constructor {readable_sync_call}.aio(...) will be deprecated in a future version of Modal.
+                Please use {readable_sync_call}(...) instead (it doesn't perform any IO, and is safe in async contexts)
+                """,
+            )
+            return sync_implementation(*args, **kwargs)
+
+        return MethodWithAio(sync_implementation, _async_proxy, synchronizer, is_classmethod=is_classmethod)
+
+    return deco

modal/_utils/grpc_testing.py

@@ -45,8 +45,11 @@ def patch_mock_servicer(cls):
     Also patches all unimplemented abstract methods in a mock servicer with default error implementations.
     """
 
-    async def fallback(self, stream) -> None:
-        raise GRPCError(Status.UNIMPLEMENTED, "Not implemented in mock servicer " + repr(cls))
+    def fallback(name: str):
+        async def _fallback(self, stream) -> None:
+            raise GRPCError(Status.UNIMPLEMENTED, f"{name} not implemented in mock servicer " + repr(cls))
+
+        return _fallback
 
     @contextlib.contextmanager
     def intercept(servicer):
@@ -85,7 +88,7 @@ def patch_mock_servicer(cls):
     for name in dir(cls):
         method = getattr(cls, name)
         if getattr(method, "__isabstractmethod__", False):
-            setattr(cls, name, patch_grpc_method(name, fallback))
+            setattr(cls, name, patch_grpc_method(name, fallback(name)))
         elif name[0].isupper() and inspect.isfunction(method):
             setattr(cls, name, patch_grpc_method(name, method))
 

modal/app.py

@@ -21,7 +21,7 @@ from synchronicity.async_wrap import asynccontextmanager
 from modal_proto import api_pb2
 
 from ._functions import _Function
-from ._ipython import is_notebook
+from ._ipython import is_interactive_ipython
 from ._load_context import LoadContext
 from ._object import _get_environment_name, _Object
 from ._partial_function import (
@@ -509,9 +509,10 @@ class _App:
             if old_function is function:
                 return  # already added the same exact instance, ignore
 
-            # In notebooks, re-registering the same function with the same app will cause a named collision.
-            # This is common notebook coding behavior, so we hide the warning.
-            if not is_notebook():
+            # In a notebook or interactive REPL it would be relatively normal to rerun a cell that
+            # registers a function multiple times (i.e. as you iterate on the Function definition),
+            # and we don't want to warn about a collision in that case.
+            if not is_interactive_ipython():
                 logger.warning(
                     f"Warning: function name '{function.tag}' collision!"
                     " Overriding existing function "

modal/client.py

@@ -71,14 +71,15 @@ class _Client:
     _client_from_env_lock: ClassVar[Optional[asyncio.Lock]] = None
     _cancellation_context: TaskContext
     _cancellation_context_event_loop: Optional[asyncio.AbstractEventLoop] = None
-    _stub: Optional[modal_api_grpc.ModalClientModal]
+    _stub: Optional[modal_api_grpc.ModalClientModal] = None
     _auth_token_manager: Optional[_AuthTokenManager] = None
     _snapshotted: bool = False
+    client_type: "api_pb2.ClientType.ValueType"
 
     def __init__(
         self,
         server_url: str,
-        client_type: int,
+        client_type: "api_pb2.ClientType.ValueType",
         credentials: Optional[tuple[str, str]],
         version: str = __version__,
     ):

modal/client.pyi

@@ -26,13 +26,14 @@ class _Client:
     _stub: typing.Optional[modal_proto.modal_api_grpc.ModalClientModal]
     _auth_token_manager: typing.Optional[modal._utils.auth_token_manager._AuthTokenManager]
     _snapshotted: bool
+    client_type: int
 
     def __init__(
         self,
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.7.dev12",
+        version: str = "1.2.7.dev13",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -155,13 +156,14 @@ class Client:
     _stub: typing.Optional[modal_proto.modal_api_grpc.ModalClientModal]
     _auth_token_manager: typing.Optional[modal._utils.auth_token_manager._AuthTokenManager]
     _snapshotted: bool
+    client_type: int
 
     def __init__(
         self,
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.7.dev12",
+        version: str = "1.2.7.dev13",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

modal/config.py

@@ -263,6 +263,7 @@ _SETTINGS = {
     ),
     "dev_suffix": _Setting("", transform=_enforce_suffix_rules),
     "max_throttle_wait": _Setting(None, transform=lambda x: int(x) if x else None),
+    "async_warnings": _Setting(False, transform=_to_boolean),  # Feature flag for async API warnings
 }
 
 

modal/exception.py

@@ -252,6 +252,10 @@ class ServerWarning(UserWarning):
     """Warning originating from the Modal server and re-issued in client code."""
 
 
+class AsyncUsageWarning(UserWarning):
+    """Warning emitted when a blocking Modal interface is used in an async context."""
+
+
 class InternalFailure(Error):
     """Retriable internal error."""
 

modal/functions.pyi

@@ -407,7 +407,7 @@ class Function(
 
     _call_generator: ___call_generator_spec
 
-    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER:
             """Calls the function remotely, executing it with the given arguments and returning the execution's result."""
             ...
@@ -416,7 +416,7 @@ class Function(
             """Calls the function remotely, executing it with the given arguments and returning the execution's result."""
             ...
 
-    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType]
+    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P]
 
     class __remote_gen_spec(typing_extensions.Protocol):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -443,7 +443,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """[Experimental] Calls the function with the given arguments, without waiting for the results.
 
@@ -466,7 +466,7 @@ class Function(
             """
             ...
 
-    _experimental_spawn: ___experimental_spawn_spec[modal._functions.P, modal._functions.ReturnType]
+    _experimental_spawn: ___experimental_spawn_spec[modal._functions.ReturnType, modal._functions.P]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> None: ...
@@ -474,7 +474,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P]
 
-    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """Calls the function with the given arguments, without waiting for the results.
 
@@ -495,7 +495,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType]
+    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]:
         """Return the inner Python object wrapped by this Modal Function."""
@@ -864,7 +864,7 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
             fc_id = fc.object_id
 
             # Later, use the ID to re-instantiate the FunctionCall object
-            fc = _FunctionCall.from_id(fc_id)
+            fc = FunctionCall.from_id(fc_id)
             result = fc.get()
             ```
 
@@ -873,27 +873,7 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
             """
             ...
 
-        async def aio(
-            self, /, function_call_id: str, client: typing.Optional[modal.client.Client] = None
-        ) -> FunctionCall[typing.Any]:
-            """Instantiate a FunctionCall object from an existing ID.
-
-            Examples:
-
-            ```python notest
-            # Spawn a FunctionCall and keep track of its object ID
-            fc = my_func.spawn()
-            fc_id = fc.object_id
-
-            # Later, use the ID to re-instantiate the FunctionCall object
-            fc = _FunctionCall.from_id(fc_id)
-            result = fc.get()
-            ```
-
-            Note that it's only necessary to re-instantiate the `FunctionCall` with this method
-            if you no longer have access to the original object returned from `Function.spawn`.
-            """
-            ...
+        async def aio(self, /, function_call_id: str, client: typing.Optional[modal.client.Client] = None): ...
 
     from_id: typing.ClassVar[__from_id_spec]
 

modal/image.py

@@ -21,6 +21,7 @@ from typing import (
     get_args,
 )
 
+import typing_extensions
 from google.protobuf.message import Message
 from grpclib.exceptions import StreamTerminatedError
 from typing_extensions import Self
@@ -32,7 +33,7 @@ from ._load_context import LoadContext
 from ._object import _Object, live_method_gen
 from ._resolver import Resolver
 from ._serialization import get_preferred_payload_format, serialize
-from ._utils.async_utils import synchronize_api
+from ._utils.async_utils import deprecate_aio_usage, synchronize_api, synchronizer
 from ._utils.blob_utils import MAX_OBJECT_SIZE_BYTES
 from ._utils.docker_utils import (
     extract_copy_command_patterns,
@@ -63,6 +64,7 @@ from .volume import _Volume
 
 if typing.TYPE_CHECKING:
     import modal._functions
+    import modal.client
 
 # This is used for both type checking and runtime validation
 ImageBuilderVersion = Literal["2023.12", "2024.04", "2024.10", "2025.06", "PREVIEW"]
@@ -866,22 +868,25 @@ class _Image(_Object, type_prefix="im"):
         img._added_python_source_set |= set(modules)
         return img
 
-    @staticmethod
-    async def from_id(image_id: str, client: Optional[_Client] = None) -> "_Image":
+    @deprecate_aio_usage((2025, 11, 14), "Image.from_id")
+    @classmethod
+    def from_id(cls, image_id: str, client: Optional["modal.client.Client"] = None) -> typing_extensions.Self:
         """Construct an Image from an id and look up the Image result.
 
         The ID of an Image object can be accessed using `.object_id`.
         """
+        _client = typing.cast(_Client, synchronizer._translate_in(client))
 
         async def _load(self: _Image, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]):
             resp = await load_context.client.stub.ImageFromId(api_pb2.ImageFromIdRequest(image_id=image_id))
             self._hydrate(resp.image_id, load_context.client, resp.metadata)
 
         rep = f"Image.from_id({image_id!r})"
-        obj = _Image._from_loader(_load, rep, load_context_overrides=LoadContext(client=client))
+
+        obj = _Image._from_loader(_load, rep, load_context_overrides=LoadContext(client=_client))
         obj._object_id = image_id
 
-        return obj
+        return typing.cast(typing_extensions.Self, synchronizer._translate_out(obj))
 
     async def build(self, app: "modal.app._App") -> "_Image":
         """Eagerly build an image.

modal/image.pyi

@@ -124,6 +124,8 @@ async def _image_await_build_result(
     image_id: str, client: modal.client._Client
 ) -> modal_proto.api_pb2.ImageJoinStreamingResponse: ...
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class _Image(modal._object._Object):
     """Base class for container images to run functions in.
 
@@ -311,13 +313,17 @@ class _Image(modal._object._Object):
         """
         ...
 
-    @staticmethod
-    async def from_id(image_id: str, client: typing.Optional[modal.client._Client] = None) -> _Image:
-        """Construct an Image from an id and look up the Image result.
+    class __from_id_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /, image_id: str, client: typing.Optional[modal.client.Client] = None) -> SUPERSELF:
+            """Construct an Image from an id and look up the Image result.
 
-        The ID of an Image object can be accessed using `.object_id`.
-        """
-        ...
+            The ID of an Image object can be accessed using `.object_id`.
+            """
+            ...
+
+        async def aio(self, /, image_id: str, client: typing.Optional[modal.client.Client] = None): ...
+
+    from_id: typing.ClassVar[__from_id_spec[typing_extensions.Self]]
 
     async def build(self, app: modal.app._App) -> _Image:
         """Eagerly build an image.
@@ -1035,8 +1041,6 @@ class _Image(modal._object._Object):
         """mdmd:hidden"""
         ...
 
-SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
-
 class Image(modal.object.Object):
     """Base class for container images to run functions in.
 
@@ -1228,22 +1232,17 @@ class Image(modal.object.Object):
         """
         ...
 
-    class __from_id_spec(typing_extensions.Protocol):
-        def __call__(self, /, image_id: str, client: typing.Optional[modal.client.Client] = None) -> Image:
+    class __from_id_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /, image_id: str, client: typing.Optional[modal.client.Client] = None) -> SUPERSELF:
             """Construct an Image from an id and look up the Image result.
 
             The ID of an Image object can be accessed using `.object_id`.
             """
             ...
 
-        async def aio(self, /, image_id: str, client: typing.Optional[modal.client.Client] = None) -> Image:
-            """Construct an Image from an id and look up the Image result.
-
-            The ID of an Image object can be accessed using `.object_id`.
-            """
-            ...
+        async def aio(self, /, image_id: str, client: typing.Optional[modal.client.Client] = None): ...
 
-    from_id: typing.ClassVar[__from_id_spec]
+    from_id: typing.ClassVar[__from_id_spec[typing_extensions.Self]]
 
     class __build_spec(typing_extensions.Protocol):
         def __call__(self, /, app: modal.app.App) -> Image:

modal/snapshot.py

@@ -1,12 +1,15 @@
 # Copyright Modal Labs 2024
-from typing import Optional
+from typing import Optional, cast
 
+import typing_extensions
+
+import modal.client
 from modal_proto import api_pb2
 
 from ._load_context import LoadContext
 from ._object import _Object
 from ._resolver import Resolver
-from ._utils.async_utils import synchronize_api
+from ._utils.async_utils import deprecate_aio_usage, synchronize_api, synchronizer
 from .client import _Client
 
 
@@ -19,27 +22,35 @@ class _SandboxSnapshot(_Object, type_prefix="sn"):
     the original Sandbox at the time the snapshot was taken.
     """
 
-    @staticmethod
-    async def from_id(sandbox_snapshot_id: str, client: Optional[_Client] = None):
+    @deprecate_aio_usage((2025, 12, 5), "SandboxSnapshot.from_id")
+    @classmethod
+    def from_id(
+        cls, sandbox_snapshot_id: str, client: Optional["modal.client.Client"] = None
+    ) -> typing_extensions.Self:
         """
         Construct a `SandboxSnapshot` object from a sandbox snapshot ID.
         """
-        # TODO: remove this - from_id constructor should not do io:
-        client = client or await _Client.from_env()
+        _client = cast(_Client, synchronizer._translate_in(client))
 
         async def _load(
             self: _SandboxSnapshot, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]
         ):
-            await load_context.client.stub.SandboxSnapshotGet(
+            # hydration doesn't actually do much apart from validating the existance of the id
+            # which is implicitly done by trying to start a sandbox from the snapshot as well
+            resp: api_pb2.SandboxSnapshotGetResponse = await load_context.client.stub.SandboxSnapshotGet(
                 api_pb2.SandboxSnapshotGetRequest(snapshot_id=sandbox_snapshot_id)
             )
+            self._hydrate(resp.snapshot_id, load_context.client, None)
 
         rep = "SandboxSnapshot()"
-        obj = _SandboxSnapshot._from_loader(_load, rep, load_context_overrides=LoadContext(client=client))
-        # TODO: should this be a _Object._new_hydrated instead?
-        obj._hydrate(sandbox_snapshot_id, client, None)
-
-        return obj
+        obj = _SandboxSnapshot._from_loader(
+            _load, rep, load_context_overrides=LoadContext(client=_client), hydrate_lazily=True
+        )
+        # Setting the object id directly is a bit hacky, but
+        # it avoids hydrating the object fully if it's going
+        # to be used only for its object id anyway
+        obj._object_id = sandbox_snapshot_id
+        return cast(typing_extensions.Self, synchronizer._translate_out(obj))
 
 
 SandboxSnapshot = synchronize_api(_SandboxSnapshot)

modal/snapshot.pyi

@@ -4,6 +4,8 @@ import modal.object
 import typing
 import typing_extensions
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class _SandboxSnapshot(modal._object._Object):
     """> Sandbox memory snapshots are in **early preview**.
 
@@ -11,10 +13,16 @@ class _SandboxSnapshot(modal._object._Object):
     `._experimental_snapshot()` on a Sandbox instance. This includes both the filesystem and memory state of
     the original Sandbox at the time the snapshot was taken.
     """
-    @staticmethod
-    async def from_id(sandbox_snapshot_id: str, client: typing.Optional[modal.client._Client] = None):
-        """Construct a `SandboxSnapshot` object from a sandbox snapshot ID."""
-        ...
+    class __from_id_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(
+            self, /, sandbox_snapshot_id: str, client: typing.Optional[modal.client.Client] = None
+        ) -> SUPERSELF:
+            """Construct a `SandboxSnapshot` object from a sandbox snapshot ID."""
+            ...
+
+        async def aio(self, /, sandbox_snapshot_id: str, client: typing.Optional[modal.client.Client] = None): ...
+
+    from_id: typing.ClassVar[__from_id_spec[typing_extensions.Self]]
 
 class SandboxSnapshot(modal.object.Object):
     """> Sandbox memory snapshots are in **early preview**.
@@ -27,13 +35,13 @@ class SandboxSnapshot(modal.object.Object):
         """mdmd:hidden"""
         ...
 
-    class __from_id_spec(typing_extensions.Protocol):
-        def __call__(self, /, sandbox_snapshot_id: str, client: typing.Optional[modal.client.Client] = None):
+    class __from_id_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(
+            self, /, sandbox_snapshot_id: str, client: typing.Optional[modal.client.Client] = None
+        ) -> SUPERSELF:
             """Construct a `SandboxSnapshot` object from a sandbox snapshot ID."""
             ...
 
-        async def aio(self, /, sandbox_snapshot_id: str, client: typing.Optional[modal.client.Client] = None):
-            """Construct a `SandboxSnapshot` object from a sandbox snapshot ID."""
-            ...
+        async def aio(self, /, sandbox_snapshot_id: str, client: typing.Optional[modal.client.Client] = None): ...
 
-    from_id: typing.ClassVar[__from_id_spec]
+    from_id: typing.ClassVar[__from_id_spec[typing_extensions.Self]]

modal/volume.py

@@ -8,6 +8,7 @@ import multiprocessing
 import os
 import platform
 import re
+import sys
 import time
 import typing
 from collections.abc import AsyncGenerator, AsyncIterator, Generator, Sequence
@@ -39,6 +40,7 @@ from ._object import (
     _get_environment_name,
     _Object,
     live_method,
+    live_method_contextmanager,
     live_method_gen,
 )
 from ._resolver import Resolver
@@ -643,7 +645,7 @@ class _Volume(_Object, type_prefix="vo"):
         return [entry async for entry in self.iterdir(path, recursive=recursive)]
 
     @live_method_gen
-    async def read_file(self, path: str) -> AsyncIterator[bytes]:
+    async def read_file(self, path: str) -> AsyncGenerator[bytes, None]:
         """
         Read a file from the modal.Volume.
 
@@ -816,8 +818,9 @@ class _Volume(_Object, type_prefix="vo"):
             )
             await self._client.stub.VolumeCopyFiles2(request, retry=Retry(base_delay=1))
 
-    @live_method
-    async def batch_upload(self, force: bool = False) -> "_AbstractVolumeUploadContextManager":
+    @live_method_contextmanager
+    @asynccontextmanager
+    async def batch_upload(self, force: bool = False) -> AsyncGenerator["_AbstractVolumeUploadContextManager", None]:
         """
         Initiate a batched upload to a volume.
 
@@ -838,9 +841,15 @@ class _Volume(_Object, type_prefix="vo"):
         if self._read_only:
             raise InvalidError("Read-only Volume can not be written to")
 
-        return _AbstractVolumeUploadContextManager.resolve(
+        version_context_manager = _AbstractVolumeUploadContextManager.resolve(
             self._metadata.version, self.object_id, self._client, force=force
         )
+        await version_context_manager.__aenter__()
+        try:
+            yield version_context_manager
+        finally:
+            exc_type, exc_value, traceback = sys.exc_info()
+            await version_context_manager.__aexit__(exc_type, exc_value, traceback)
 
     @live_method
     async def _instance_delete(self):

modal/volume.pyi

@@ -597,7 +597,7 @@ class _Volume(modal._object._Object):
         """
         ...
 
-    def read_file(self, path: str) -> collections.abc.AsyncIterator[bytes]:
+    def read_file(self, path: str) -> collections.abc.AsyncGenerator[bytes, None]:
         """Read a file from the modal.Volume.
 
         Note - this function is primarily intended to be used outside of a Modal App.
@@ -666,7 +666,7 @@ class _Volume(modal._object._Object):
         """
         ...
 
-    async def batch_upload(self, force: bool = False) -> _AbstractVolumeUploadContextManager:
+    def batch_upload(self, force: bool = False) -> typing.AsyncContextManager[_AbstractVolumeUploadContextManager]:
         """Initiate a batched upload to a volume.
 
         To allow overwriting existing files, set `force` to `True` (you cannot overwrite existing directories with
@@ -1033,7 +1033,7 @@ class Volume(modal.object.Object):
     listdir: __listdir_spec
 
     class __read_file_spec(typing_extensions.Protocol):
-        def __call__(self, /, path: str) -> typing.Iterator[bytes]:
+        def __call__(self, /, path: str) -> typing.Generator[bytes, None, None]:
             """Read a file from the modal.Volume.
 
             Note - this function is primarily intended to be used outside of a Modal App.
@@ -1052,7 +1052,7 @@ class Volume(modal.object.Object):
             """
             ...
 
-        def aio(self, /, path: str) -> collections.abc.AsyncIterator[bytes]:
+        def aio(self, /, path: str) -> collections.abc.AsyncGenerator[bytes, None]:
             """Read a file from the modal.Volume.
 
             Note - this function is primarily intended to be used outside of a Modal App.
@@ -1189,7 +1189,9 @@ class Volume(modal.object.Object):
     copy_files: __copy_files_spec
 
     class __batch_upload_spec(typing_extensions.Protocol):
-        def __call__(self, /, force: bool = False) -> AbstractVolumeUploadContextManager:
+        def __call__(
+            self, /, force: bool = False
+        ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[AbstractVolumeUploadContextManager]:
             """Initiate a batched upload to a volume.
 
             To allow overwriting existing files, set `force` to `True` (you cannot overwrite existing directories with
@@ -1208,7 +1210,7 @@ class Volume(modal.object.Object):
             """
             ...
 
-        async def aio(self, /, force: bool = False) -> AbstractVolumeUploadContextManager:
+        def aio(self, /, force: bool = False) -> typing.AsyncContextManager[AbstractVolumeUploadContextManager]:
             """Initiate a batched upload to a volume.
 
             To allow overwriting existing files, set `force` to `True` (you cannot overwrite existing directories with

{modal-1.2.7.dev12.dist-info → modal-1.2.7.dev13.dist-info}/METADATA

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

{modal-1.2.7.dev12.dist-info → modal-1.2.7.dev13.dist-info}/RECORD

@@ -4,12 +4,12 @@ modal/_billing.py,sha256=C1jUN9f_1WqozSZAt9EOk1nImXUdiLrgFeeAu3R23cI,3012
 modal/_clustered_functions.py,sha256=7amiOxErtlciWeBJBL2KvaxerUomJpTAJ3qElflFHQA,2884
 modal/_clustered_functions.pyi,sha256=JmYwAGOLEnD5AF-gYF9O5tu-SgGjeoJz-X1j48b1Ijg,1157
 modal/_container_entrypoint.py,sha256=aatoboeM3fe9w7DVdCgVOhW4iW9EwduZwiVS3ri0HgA,19787
-modal/_functions.py,sha256=VqhEE8cctHkonWvtdXOCYnW06TvXPTV1ONeIMoR1SFA,91262
+modal/_functions.py,sha256=7mw9Te71sMhIoOEKcl9lo2DRhs6bWoXn7jeJdKhjY4I,91611
 modal/_grpc_client.py,sha256=t3Ubaul6YD2-pt0lTPLz2nW1z25VuUfmyGDHewO0jx0,6929
-modal/_ipython.py,sha256=TW1fkVOmZL3YYqdS2YlM1hqpf654Yf8ZyybHdBnlhSw,301
+modal/_ipython.py,sha256=Bu9fc3hm3xt2O47qLe_d-Mu2jS81LwMsmXNJ1sawBA0,575
 modal/_load_context.py,sha256=P7bMvu-_E1YXWhunYU46EqQX78r4D3b05YGz9blSsy8,3786
 modal/_location.py,sha256=joiX-0ZeutEUDTrrqLF1GHXCdVLF-rHzstocbMcd_-k,366
-modal/_object.py,sha256=kRTugj_eB4lD6bcVIo57hQ12Dho8KEdCWhURrOd6KVE,13232
+modal/_object.py,sha256=6h5a-dcHRKpctpUIyVvQfaygJ5v0fIJAo4n4cFpODys,13729
 modal/_output.py,sha256=pKRLDyoEXjLe-oV12-hb6gYOpdUmNzrq7FQna-maC70,26832
 modal/_partial_function.py,sha256=xRaU_A5SE30jywgU_-S1kV2y9WUrm0S906T5OWpS2Vg,38684
 modal/_pty.py,sha256=E58MQ8d5-wkbMatRKpQR-G9FdbCRcZGiZxOpGy__VuY,1481
@@ -21,32 +21,32 @@ modal/_tunnel.py,sha256=bbjVuWiDyC3m_NaVBpgoNQte-NM1FUtDVQsMobQbhc8,6578
 modal/_tunnel.pyi,sha256=FoedJzHymbPk4Bmnbszm6uhay2rMq1JS9mIiHELYf3k,13804
 modal/_type_manager.py,sha256=DWjgmjYJuOagw2erin506UUbG2H5UzZCFEekS-7hmfA,9087
 modal/_watcher.py,sha256=K6LYnlmSGQB4tWWI9JADv-tvSvQ1j522FwT71B51CX8,3584
-modal/app.py,sha256=xyTCQwLVNBoKENy0aKZIoK7TVegvwXz984VOoKTs-PE,59466
+modal/app.py,sha256=RNtwU9xibABT7m7c6idX49wtEi0HWNuJvsTi9R5RHeo,59571
 modal/app.pyi,sha256=WR0nGSUh8-8OYRHFqEnijGoPp_IbawNY1JW_0pozXsE,50857
 modal/billing.py,sha256=zmQ3bcCJlwa4KD1IA_QgdWpm1pn13c-7qfy79iEauYI,195
 modal/call_graph.py,sha256=1g2DGcMIJvRy-xKicuf63IVE98gJSnQsr8R_NVMptNc,2581
-modal/client.py,sha256=k1CqQ_0t4-vHylkqYZgYCnClg-FT0QrTPAKivL01A_k,14354
-modal/client.pyi,sha256=fCTgoqk8EYlqyQokJOKNDKhIj5HcasgzAPrL4KTE7Bg,14431
+modal/client.py,sha256=CXnyJYLhY--xaCkjv3tpjYDca8AuXGQG1IiaXQVX4y4,14436
+modal/client.pyi,sha256=0iz_8ZlCD4j-mRt3uF7rsiuaHNhfIiIaODwD4NQLg-A,14473
 modal/cloud_bucket_mount.py,sha256=cvVj5Rt4nDHoQbTneoJPTaAcnl_Ab_mrsjnnzd0v9OI,6013
 modal/cloud_bucket_mount.pyi,sha256=vXusGMOUk9HjCs4lhxteuCK4xLQclPfugGWKo7LECEA,7539
 modal/cls.py,sha256=Cmqt1vOw0-01ktjJBOrdzvdyDbHpjKMTaZ2eEy_8YUE,41694
 modal/cls.pyi,sha256=ZsJBwboZJ95wqgQUFi2VB6etbDXrmMPwJ61c-r8T2kY,27262
-modal/config.py,sha256=byOUVfUibX9Ixrhbz5z4HDcgn-8S5OFicD6xGUErqZs,13415
+modal/config.py,sha256=JvNf4jr5xRLlFgIp4l38z1CJQyDxOHc_DnPOAYCJGvE,13516
 modal/container_process.py,sha256=xMJ93EeBcI-BoGDv78-a0UEbvSza-ye_TFi5fpGAxbw,16777
 modal/container_process.pyi,sha256=jyV3WIkTn2NsXqAFf5Jseciz2mdq_sjO9zQMoJnquIg,8211
 modal/dict.py,sha256=9tyzgvLLribY5dJAC5n8_kiF5GNZTr0QD35LuEtYgC4,22664
 modal/dict.pyi,sha256=1g6wUpLESOsSecE9oLiu61wg9wOhl5t1e0jX0qHqkJQ,32381
 modal/environments.py,sha256=wMiMNpPkvIl_BdxRb81CY9Djzhczp_y4GEYKWp0JyBc,6135
 modal/environments.pyi,sha256=bMIxvwahckgaolGD3-hP2iovRHDXewvgbVs_nx4ze0o,3808
-modal/exception.py,sha256=YPIa5uL1ug6SNJ9YvI4xefS5J6jGisdZwTBD4OWzpSo,10309
+modal/exception.py,sha256=uKUHnCfMTkYeDwTBpv3AvAr3hdJnQZJjkSyaL1vUgWA,10436
 modal/file_io.py,sha256=dx90C5L8cQv2Z7pVVPaQmE0R3pUOGv2h-wn1qNNXbGQ,19818
 modal/file_io.pyi,sha256=up9OhV2Y54n-X7nlfV6j_eBwJ8D2cNMEswZ1iddrEQw,15877
 modal/file_pattern_matcher.py,sha256=A_Kdkej6q7YQyhM_2-BvpFmPqJ0oHb54B6yf9VqvPVE,8116
 modal/functions.py,sha256=kcNHvqeGBxPI7Cgd57NIBBghkfbeFJzXO44WW0jSmao,325
-modal/functions.pyi,sha256=gtBInyEElako585pVRplfXskzg2UAIvlUQcHjMUvbqM,37160
+modal/functions.pyi,sha256=fkjxeYAqh6sX9C84gjUGoLVgHT1IfNB_07h0fpmIyWw,36465
 modal/gpu.py,sha256=Fe5ORvVPDIstSq1xjmM6OoNgLYFWvogP9r5BgmD3hYg,6769
-modal/image.py,sha256=AHvMjgEGuFScT4rPJJy0jCV4d2TFcjZu7wy5miCC4cE,107886
-modal/image.pyi,sha256=hVmhjP4KT0DmOuo70kAYvqCrvytUcRSrouhvBGXqo_A,78149
+modal/image.py,sha256=sPaYxx4Dwdod1FjVooDaDDcPbcyyBXY4ChpbQvWe5mc,108197
+modal/image.pyi,sha256=UMwAaYu4feSDzJS9l-5xKYP_yaJm18bY_s3pREOQF6A,78249
 modal/io_streams.py,sha256=g6H6QAl48qZtN5OY6WIIVwF9TXBj3jMNYCgn7RYYrVg,30697
 modal/io_streams.pyi,sha256=aBxCcbHTprL08FLvPlkzu4bypCTT7xUdelNe5kc7OZY,18506
 modal/mount.py,sha256=5ps0p8dik2McxetRfHakLouzOvBrQPYBFCUCrgNlXik,33856
@@ -77,13 +77,13 @@ modal/secret.py,sha256=XOHgwhjPJpzsIe7eo3DGAQ66hvyepc232UEEAREnjtk,18203
 modal/secret.pyi,sha256=wzGS_qOE0YwmoXvxWT5FyzKlTYS4wPFblbqDSuXRnoY,21016
 modal/serving.py,sha256=rfzj23Q4hPSMpc3vj_cQg3awkZULu4hLtRs83cOEB-w,4291
 modal/serving.pyi,sha256=eNqF_bhO_JQ0EDpqvSjSUdNs48vv7AcPXinp7GEs5wI,1966
-modal/snapshot.py,sha256=HiXLbJAZiQv2cEQ4ur8M3AVbI_ZSL-eoteVfCL77lUw,1640
-modal/snapshot.pyi,sha256=zks3WMIDoiegU0ZIDVacVhEVU4bmh0m7Hynu7WTqaRw,1699
+modal/snapshot.py,sha256=vIKxA1XRRsH8cFcpSUqC9M8NccKIaYaDpmiEC2clNks,2297
+modal/snapshot.pyi,sha256=vMYDx1s9Ds4qtH-PXgB_9RzVuS5wsTchVcclR5Q-mmM,2014
 modal/stream_type.py,sha256=A6320qoAAWhEfwOCZfGtymQTu5AfLfJXXgARqooTPvY,417
 modal/token_flow.py,sha256=tLvBE9OT50p8AnYYh4b5MvBMQc1vV1-6C0GsmyFDfxw,7626
 modal/token_flow.pyi,sha256=xxMmxKU2_Z8aLhQazqhnBng8PVPKaPgZXKnUuS5WykI,2406
-modal/volume.py,sha256=ayTo-z_f0zTQJVI6p31w73v35Kj6q-HumIEW7jV2MGQ,52335
-modal/volume.pyi,sha256=N4EKjbbpUIwwQG-p6j-DgaJamX-fQGu5Sw59rJ5DGek,53761
+modal/volume.py,sha256=vej3tMfs0ayarcp2Y3wsDnStJdnQ6u2U8VKYQi7YTn8,52733
+modal/volume.pyi,sha256=lrfm3p_IvWysX0OItHpsti7v9yJN1JA1XtGQrXOT1AM,53915
 modal/_runtime/__init__.py,sha256=MIEP8jhXUeGq_eCjYFcqN5b1bxBM4fdk0VESpjWR0fc,28
 modal/_runtime/asgi.py,sha256=AOcduIlijmlxhXVWo7AIUhigo-bqm6nDkHj4Q4JLy6o,22607
 modal/_runtime/container_io_manager.py,sha256=EQF1aAtzb0A2chhr0B8es_G0rawbBUKZaFu0-p6dsQU,52102
@@ -96,7 +96,7 @@ modal/_runtime/user_code_event_loop.py,sha256=HwOuDyCZLOakr_DG7p2MrcscjSQNheIhBB
 modal/_runtime/user_code_imports.py,sha256=_6uHDfTpqCcspHpgjNV14uMyiGdWkAHU7zqHfUx9uzU,25997
 modal/_utils/__init__.py,sha256=waLjl5c6IPDhSsdWAm9Bji4e2PVxamYABKAze6CHVXY,28
 modal/_utils/app_utils.py,sha256=88BT4TPLWfYAQwKTHcyzNQRHg8n9B-QE2UyJs96iV-0,108
-modal/_utils/async_utils.py,sha256=PnwHfaHcqjLwMnlGC2kn8nqubxpXcSKcy4jHx6477dg,30625
+modal/_utils/async_utils.py,sha256=2KQs7W2OwU6-5wxCoYbkt8_sLocDDQSyyBbb1gulZ20,43322
 modal/_utils/auth_token_manager.py,sha256=QsDokl1c1dN9m6Z9N-Se-8cY3laphByjJtNdRXUTieI,5151
 modal/_utils/blob_utils.py,sha256=L4lEL-rvZwoxCxrGaa8zWVoaHjhq1eQfO4SLrvt4g8k,23376
 modal/_utils/bytes_io_segment_payload.py,sha256=vaXPq8b52-x6G2hwE7SrjS58pg_aRm7gV3bn3yjmTzQ,4261
@@ -104,7 +104,7 @@ modal/_utils/deprecation.py,sha256=-Bgg7jZdcJU8lROy18YyVnQYbM8hue-hVmwJqlWAGH0,5
 modal/_utils/docker_utils.py,sha256=h1uETghR40mp_y3fSWuZAfbIASH1HMzuphJHghAL6DU,3722
 modal/_utils/function_utils.py,sha256=uoOcn_pyl6fOVHr_Q6ci1_5eJqo90so7G9izfs-T-As,28272
 modal/_utils/git_utils.py,sha256=qtUU6JAttF55ZxYq51y55OR58B0tDPZsZWK5dJe6W5g,3182
-modal/_utils/grpc_testing.py,sha256=H1zHqthv19eGPJz2HKXDyWXWGSqO4BRsxah3L5Xaa8A,8619
+modal/_utils/grpc_testing.py,sha256=fZLyfMA5VYmIo-dUCcKQrVCH3ZKPT7K4_6ww373jt0Y,8697
 modal/_utils/grpc_utils.py,sha256=2Q88G0u22q4yo91Ud1SfxPF9YoR7C-YDU2e__KTMNp8,16279
 modal/_utils/hash_utils.py,sha256=zg3J6OGxTFGSFri1qQ12giDz90lWk8bzaxCTUCRtiX4,3034
 modal/_utils/http_utils.py,sha256=yeTFsXYr0rYMEhB7vBP7audG9Uc7OLhzKBANFDZWVt0,2451
@@ -158,7 +158,7 @@ modal/experimental/__init__.py,sha256=GOuo3t4-Le0ZVddiHIOw0MQxkdTJge-bVbhDvgnblm
 modal/experimental/flash.py,sha256=GJZwSr-4OHlP6gCIZdcbsSb8D8WX9xJwMphjwcfsRoU,31262
 modal/experimental/flash.pyi,sha256=W62a0AhmLUuH9a0n8Y3-DYhyEEFH3-bRUQFphOQfKHg,16418
 modal/experimental/ipython.py,sha256=TrCfmol9LGsRZMeDoeMPx3Hv3BFqQhYnmD_iH0pqdhk,2904
-modal-1.2.7.dev12.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+modal-1.2.7.dev13.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
 modal_docs/__init__.py,sha256=svYKtV8HDwDCN86zbdWqyq5T8sMdGDj0PVlzc2tIxDM,28
 modal_docs/gen_cli_docs.py,sha256=c1yfBS_x--gL5bs0N4ihMwqwX8l3IBWSkBAKNNIi6bQ,3801
 modal_docs/gen_reference_docs.py,sha256=d_CQUGQ0rfw28u75I2mov9AlS773z9rG40-yq5o7g2U,6359
@@ -180,10 +180,10 @@ modal_proto/task_command_router_pb2.py,sha256=2Y8wRvnq4_7RiQ-5ZAPIgXaxrHv_MXzgS5
 modal_proto/task_command_router_pb2.pyi,sha256=yI4tFteErLlonFA2HyaWtONfhY_VGSe7KCWFIspvmkE,16323
 modal_proto/task_command_router_pb2_grpc.py,sha256=q2VWfK2-4uDcPaPLhAqPZkgxhuQRYnWmwUcnEbPbGuk,13895
 modal_proto/task_command_router_pb2_grpc.pyi,sha256=e1MM10VGUgDkm041v53QeTglGQPzTpA0FUsFtezjp74,4536
-modal_version/__init__.py,sha256=rFvO4YkopMGR4cQf3a1rGgiW7XIPrL2INupCBz_QS1g,121
+modal_version/__init__.py,sha256=xODVrqo8G7Gk8Jq6O1pQPDO4Cq1T80Fzo0ksqa7pEN0,121
 modal_version/__main__.py,sha256=nLUbubxKx7GXNzJIkTB7M7_u8080LyLM0IS0rzFkC_c,119
-modal-1.2.7.dev12.dist-info/METADATA,sha256=hK-tSsEsRYfwg5lzDUJAJrf0YalSSw1msHt_6cj-Xx8,2493
-modal-1.2.7.dev12.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-modal-1.2.7.dev12.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
-modal-1.2.7.dev12.dist-info/top_level.txt,sha256=4BWzoKYREKUZ5iyPzZpjqx4G8uB5TWxXPDwibLcVa7k,43
-modal-1.2.7.dev12.dist-info/RECORD,,
+modal-1.2.7.dev13.dist-info/METADATA,sha256=bc4BKkJwEQBggwxs9gCaVlt6jWvf9eJNx4pRPeESlYk,2493
+modal-1.2.7.dev13.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+modal-1.2.7.dev13.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
+modal-1.2.7.dev13.dist-info/top_level.txt,sha256=4BWzoKYREKUZ5iyPzZpjqx4G8uB5TWxXPDwibLcVa7k,43
+modal-1.2.7.dev13.dist-info/RECORD,,

modal_version/__init__.py

@@ -1,4 +1,4 @@
 # Copyright Modal Labs 2025
 """Supplies the current version of the modal client library."""
 
-__version__ = "1.2.7.dev12"
+__version__ = "1.2.7.dev13"