modAL 1.2.7.dev11__tar.gz → 1.2.7.dev13__tar.gz

{modal-1.2.7.dev11 → modal-1.2.7.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.2.7.dev11
+Version: 1.2.7.dev13
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0
@@ -13,17 +13,17 @@ Classifier: Topic :: System :: Distributed Computing
 Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Requires-Python: <3.14,>=3.10
+Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp
 Requires-Dist: cbor2
 Requires-Dist: certifi
 Requires-Dist: click~=8.1
-Requires-Dist: grpclib<0.4.9,>=0.4.7
+Requires-Dist: grpclib<0.4.10,>=0.4.7
 Requires-Dist: protobuf!=4.24.0,<7.0,>=3.19
 Requires-Dist: rich>=12.0.0
-Requires-Dist: synchronicity~=0.10.2
+Requires-Dist: synchronicity~=0.11.1
 Requires-Dist: toml
 Requires-Dist: typer>=0.9
 Requires-Dist: types-certifi
@@ -51,7 +51,7 @@ a [user guide](https://modal.com/docs/guide), and the detailed
 
 ## Installation
 
-**This library requires Python 3.10 – 3.13.**
+**This library requires Python 3.10 – 3.14.**
 
 Install the package with `uv` or `pip`:
 

{modal-1.2.7.dev11 → modal-1.2.7.dev13}/README.md

@@ -17,7 +17,7 @@ a [user guide](https://modal.com/docs/guide), and the detailed
 
 ## Installation
 
-**This library requires Python 3.10 – 3.13.**
+**This library requires Python 3.10 – 3.14.**
 
 Install the package with `uv` or `pip`:
 

{modal-1.2.7.dev11 → modal-1.2.7.dev13}/modal/__init__.py

@@ -3,8 +3,8 @@ import sys
 
 if sys.version_info[:2] < (3, 10):
     raise RuntimeError("This version of Modal requires at least Python 3.10")
-if sys.version_info[:2] >= (3, 14):
-    raise RuntimeError("This version of Modal does not support Python 3.14+")
+if sys.version_info[:2] >= (3, 15):
+    raise RuntimeError("This version of Modal does not support Python 3.15+")
 
 from modal_version import __version__
 

{modal-1.2.7.dev11 → modal-1.2.7.dev13}/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-1.2.7.dev13/modal/_ipython.py

@@ -0,0 +1,21 @@
+# Copyright Modal Labs 2022
+import sys
+
+
+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

{modal-1.2.7.dev11 → modal-1.2.7.dev13}/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-1.2.7.dev11 → modal-1.2.7.dev13}/modal/_runtime/container_io_manager.pyi

@@ -252,8 +252,6 @@ class _ContainerIOManager:
     @classmethod
     def stop_fetching_inputs(cls): ...
 
-SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
-
 class ContainerIOManager:
     """Synchronizes all RPC calls and network operations for a running container.
 
@@ -298,47 +296,47 @@ class ContainerIOManager:
         """Only used for tests."""
         ...
 
-    class __hello_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __hello_spec(typing_extensions.Protocol):
         def __call__(self, /): ...
         async def aio(self, /): ...
 
-    hello: __hello_spec[typing_extensions.Self]
+    hello: __hello_spec
 
-    class ___run_heartbeat_loop_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___run_heartbeat_loop_spec(typing_extensions.Protocol):
         def __call__(self, /): ...
         async def aio(self, /): ...
 
-    _run_heartbeat_loop: ___run_heartbeat_loop_spec[typing_extensions.Self]
+    _run_heartbeat_loop: ___run_heartbeat_loop_spec
 
-    class ___heartbeat_handle_cancellations_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___heartbeat_handle_cancellations_spec(typing_extensions.Protocol):
         def __call__(self, /) -> bool: ...
         async def aio(self, /) -> bool: ...
 
-    _heartbeat_handle_cancellations: ___heartbeat_handle_cancellations_spec[typing_extensions.Self]
+    _heartbeat_handle_cancellations: ___heartbeat_handle_cancellations_spec
 
-    class __heartbeats_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __heartbeats_spec(typing_extensions.Protocol):
         def __call__(
             self, /, wait_for_mem_snap: bool
         ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]: ...
         def aio(self, /, wait_for_mem_snap: bool) -> typing.AsyncContextManager[None]: ...
 
-    heartbeats: __heartbeats_spec[typing_extensions.Self]
+    heartbeats: __heartbeats_spec
 
     def stop_heartbeat(self): ...
 
-    class __dynamic_concurrency_manager_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __dynamic_concurrency_manager_spec(typing_extensions.Protocol):
         def __call__(self, /) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]: ...
         def aio(self, /) -> typing.AsyncContextManager[None]: ...
 
-    dynamic_concurrency_manager: __dynamic_concurrency_manager_spec[typing_extensions.Self]
+    dynamic_concurrency_manager: __dynamic_concurrency_manager_spec
 
-    class ___dynamic_concurrency_loop_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___dynamic_concurrency_loop_spec(typing_extensions.Protocol):
         def __call__(self, /): ...
         async def aio(self, /): ...
 
-    _dynamic_concurrency_loop: ___dynamic_concurrency_loop_spec[typing_extensions.Self]
+    _dynamic_concurrency_loop: ___dynamic_concurrency_loop_spec
 
-    class __get_data_in_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __get_data_in_spec(typing_extensions.Protocol):
         def __call__(
             self, /, function_call_id: str, attempt_token: typing.Optional[str]
         ) -> typing.Iterator[typing.Any]:
@@ -351,9 +349,9 @@ class ContainerIOManager:
             """Read from the `data_in` stream of a function call."""
             ...
 
-    get_data_in: __get_data_in_spec[typing_extensions.Self]
+    get_data_in: __get_data_in_spec
 
-    class __put_data_out_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __put_data_out_spec(typing_extensions.Protocol):
         def __call__(
             self,
             /,
@@ -388,9 +386,9 @@ class ContainerIOManager:
             """
             ...
 
-    put_data_out: __put_data_out_spec[typing_extensions.Self]
+    put_data_out: __put_data_out_spec
 
-    class __generator_output_sender_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __generator_output_sender_spec(typing_extensions.Protocol):
         def __call__(
             self, /, function_call_id: str, attempt_token: str, data_format: int, message_rx: asyncio.queues.Queue
         ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]:
@@ -403,9 +401,9 @@ class ContainerIOManager:
             """Runs background task that feeds generator outputs into a function call's `data_out` stream."""
             ...
 
-    generator_output_sender: __generator_output_sender_spec[typing_extensions.Self]
+    generator_output_sender: __generator_output_sender_spec
 
-    class ___queue_create_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___queue_create_spec(typing_extensions.Protocol):
         def __call__(self, /, size: int) -> asyncio.queues.Queue:
             """Create a queue, on the synchronicity event loop (needed on Python 3.8 and 3.9)."""
             ...
@@ -414,9 +412,9 @@ class ContainerIOManager:
             """Create a queue, on the synchronicity event loop (needed on Python 3.8 and 3.9)."""
             ...
 
-    _queue_create: ___queue_create_spec[typing_extensions.Self]
+    _queue_create: ___queue_create_spec
 
-    class ___queue_put_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___queue_put_spec(typing_extensions.Protocol):
         def __call__(self, /, queue: asyncio.queues.Queue, value: typing.Any) -> None:
             """Put a value onto a queue, using the synchronicity event loop."""
             ...
@@ -425,12 +423,12 @@ class ContainerIOManager:
             """Put a value onto a queue, using the synchronicity event loop."""
             ...
 
-    _queue_put: ___queue_put_spec[typing_extensions.Self]
+    _queue_put: ___queue_put_spec
 
     def get_average_call_time(self) -> float: ...
     def get_max_inputs_to_fetch(self): ...
 
-    class ___generate_inputs_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___generate_inputs_spec(typing_extensions.Protocol):
         def __call__(
             self, /, batch_max_size: int, batch_wait_ms: int
         ) -> typing.Iterator[list[tuple[str, int, str, str, modal_proto.api_pb2.FunctionInput]]]: ...
@@ -438,9 +436,9 @@ class ContainerIOManager:
             self, /, batch_max_size: int, batch_wait_ms: int
         ) -> collections.abc.AsyncIterator[list[tuple[str, int, str, str, modal_proto.api_pb2.FunctionInput]]]: ...
 
-    _generate_inputs: ___generate_inputs_spec[typing_extensions.Self]
+    _generate_inputs: ___generate_inputs_spec
 
-    class __run_inputs_outputs_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __run_inputs_outputs_spec(typing_extensions.Protocol):
         def __call__(
             self,
             /,
@@ -456,9 +454,9 @@ class ContainerIOManager:
             batch_wait_ms: int = 0,
         ) -> collections.abc.AsyncIterator[IOContext]: ...
 
-    run_inputs_outputs: __run_inputs_outputs_spec[typing_extensions.Self]
+    run_inputs_outputs: __run_inputs_outputs_spec
 
-    class ___send_outputs_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___send_outputs_spec(typing_extensions.Protocol):
         def __call__(self, /, started_at: float, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
             """Send pre-built output items with retry and chunking."""
             ...
@@ -467,9 +465,9 @@ class ContainerIOManager:
             """Send pre-built output items with retry and chunking."""
             ...
 
-    _send_outputs: ___send_outputs_spec[typing_extensions.Self]
+    _send_outputs: ___send_outputs_spec
 
-    class __handle_user_exception_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __handle_user_exception_spec(typing_extensions.Protocol):
         def __call__(self, /) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]:
             """Sets the task as failed in a way where it's not retried.
 
@@ -486,9 +484,9 @@ class ContainerIOManager:
             """
             ...
 
-    handle_user_exception: __handle_user_exception_spec[typing_extensions.Self]
+    handle_user_exception: __handle_user_exception_spec
 
-    class __handle_input_exception_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __handle_input_exception_spec(typing_extensions.Protocol):
         def __call__(
             self, /, io_context: IOContext, started_at: float
         ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]:
@@ -499,23 +497,23 @@ class ContainerIOManager:
             """Handle an exception while processing a function input."""
             ...
 
-    handle_input_exception: __handle_input_exception_spec[typing_extensions.Self]
+    handle_input_exception: __handle_input_exception_spec
 
     def exit_context(self, started_at, input_ids: list[str]): ...
 
-    class __push_outputs_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __push_outputs_spec(typing_extensions.Protocol):
         def __call__(self, /, io_context: IOContext, started_at: float, output_data: list[typing.Any]) -> None: ...
         async def aio(self, /, io_context: IOContext, started_at: float, output_data: list[typing.Any]) -> None: ...
 
-    push_outputs: __push_outputs_spec[typing_extensions.Self]
+    push_outputs: __push_outputs_spec
 
-    class __memory_restore_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __memory_restore_spec(typing_extensions.Protocol):
         def __call__(self, /) -> None: ...
         async def aio(self, /) -> None: ...
 
-    memory_restore: __memory_restore_spec[typing_extensions.Self]
+    memory_restore: __memory_restore_spec
 
-    class __memory_snapshot_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __memory_snapshot_spec(typing_extensions.Protocol):
         def __call__(self, /) -> None:
             """Message server indicating that function is ready to be checkpointed."""
             ...
@@ -524,9 +522,9 @@ class ContainerIOManager:
             """Message server indicating that function is ready to be checkpointed."""
             ...
 
-    memory_snapshot: __memory_snapshot_spec[typing_extensions.Self]
+    memory_snapshot: __memory_snapshot_spec
 
-    class __volume_commit_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __volume_commit_spec(typing_extensions.Protocol):
         def __call__(self, /, volume_ids: list[str]) -> None:
             """Perform volume commit for given `volume_ids`.
             Only used on container exit to persist uncommitted changes on behalf of user.
@@ -539,13 +537,13 @@ class ContainerIOManager:
             """
             ...
 
-    volume_commit: __volume_commit_spec[typing_extensions.Self]
+    volume_commit: __volume_commit_spec
 
-    class __interact_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __interact_spec(typing_extensions.Protocol):
         def __call__(self, /, from_breakpoint: bool = False): ...
         async def aio(self, /, from_breakpoint: bool = False): ...
 
-    interact: __interact_spec[typing_extensions.Self]
+    interact: __interact_spec
 
     @property
     def target_concurrency(self) -> int: ...

{modal-1.2.7.dev11 → modal-1.2.7.dev13}/modal/_serialization.py

@@ -420,7 +420,8 @@ def check_valid_cls_constructor_arg(key, obj):
     try:
         ClsConstructorPickler(buf).dump(obj)
         return True
-    except (AttributeError, ValueError):
+    except (AttributeError, ValueError, pickle.PicklingError):
+        # Python 3.14+ now raises an PicklingError for certain types of `dump` failures
         raise ValueError(
             f"Only pickle-able types are allowed in remote class constructors: argument {key} of type {type(obj)}."
         )