modAL 1.2.5.dev0__py3-none-any.whl → 1.2.5.dev2__py3-none-any.whl

modal/_container_entrypoint.py

@@ -15,27 +15,19 @@ if telemetry_socket:
     instrument_imports(telemetry_socket)
 
 import asyncio
-import inspect
 import queue
 import signal
-import sys
 import threading
 import time
-from collections.abc import Sequence
-from typing import TYPE_CHECKING, Any, Callable, Optional
+import types
+from typing import TYPE_CHECKING, Any, Optional, cast
 
 from google.protobuf.message import Message
 
 from modal._clustered_functions import initialize_clustered_function
-from modal._partial_function import (
-    _find_callables_for_obj,
-    _PartialFunctionFlags,
-)
+from modal._runtime.user_code_event_loop import UserCodeEventLoop
 from modal._serialization import deserialize, deserialize_params
 from modal._utils.async_utils import TaskContext, aclosing, synchronizer
-from modal._utils.function_utils import (
-    callable_has_non_self_params,
-)
 from modal.app import App, _App
 from modal.client import Client, _Client
 from modal.config import logger
@@ -53,6 +45,7 @@ from ._runtime.container_io_manager import (
 if TYPE_CHECKING:
     import modal._object
     import modal._runtime.container_io_manager
+    import modal._runtime.user_code_imports
 
 
 class DaemonizedThreadPool:
@@ -101,81 +94,6 @@ class DaemonizedThreadPool:
         self.inputs.put((func, args))
 
 
-class UserCodeEventLoop:
-    """Run an async event loop as a context manager and handle signals.
-
-    This will run all *user supplied* async code, i.e. async functions, as well as async enter/exit managers
-
-    The following signals are handled while a coroutine is running on the event loop until
-    completion (and then handlers are deregistered):
-
-    - `SIGUSR1`: converted to an async task cancellation. Note that this only affects the event
-      loop, and the signal handler defined here doesn't run for sync functions.
-    - `SIGINT`: Unless the global signal handler has been set to SIGIGN, the loop's signal handler
-        is set to cancel the current task and raise KeyboardInterrupt to the caller.
-    """
-
-    def __enter__(self):
-        self.loop = asyncio.new_event_loop()
-        self.tasks = set()
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        self.loop.run_until_complete(self.loop.shutdown_asyncgens())
-        if sys.version_info[:2] >= (3, 9):
-            self.loop.run_until_complete(self.loop.shutdown_default_executor())  # Introduced in Python 3.9
-
-        for task in self.tasks:
-            task.cancel()
-
-        self.loop.close()
-
-    def create_task(self, coro):
-        task = self.loop.create_task(coro)
-        self.tasks.add(task)
-        task.add_done_callback(self.tasks.discard)
-        return task
-
-    def run(self, coro):
-        task = asyncio.ensure_future(coro, loop=self.loop)
-        self._sigints = 0
-
-        def _sigint_handler():
-            # cancel the task in order to have run_until_complete return soon and
-            # prevent a bunch of unwanted tracebacks when shutting down the
-            # event loop.
-
-            # this basically replicates the sigint handler installed by asyncio.run()
-            self._sigints += 1
-            if self._sigints == 1:
-                # first sigint is graceful
-                task.cancel()
-                return
-
-            # this should normally not happen, but the second sigint would "hard kill" the event loop!
-            raise KeyboardInterrupt()
-
-        ignore_sigint = signal.getsignal(signal.SIGINT) == signal.SIG_IGN
-        if not ignore_sigint:
-            self.loop.add_signal_handler(signal.SIGINT, _sigint_handler)
-
-        # Before Python 3.9 there is no argument to Task.cancel
-        if sys.version_info[:2] >= (3, 9):
-            self.loop.add_signal_handler(signal.SIGUSR1, task.cancel, "Input was cancelled by user")
-        else:
-            self.loop.add_signal_handler(signal.SIGUSR1, task.cancel)
-
-        try:
-            return self.loop.run_until_complete(task)
-        except asyncio.CancelledError:
-            if self._sigints > 0:
-                raise KeyboardInterrupt()
-        finally:
-            self.loop.remove_signal_handler(signal.SIGUSR1)
-            if not ignore_sigint:
-                self.loop.remove_signal_handler(signal.SIGINT)
-
-
 def call_function(
     user_code_event_loop: UserCodeEventLoop,
     container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
@@ -331,23 +249,25 @@ def call_function(
                     signal.signal(signal.SIGUSR1, usr1_handler)  # reset signal handler
 
 
-def call_lifecycle_functions(
-    event_loop: UserCodeEventLoop,
-    container_io_manager,  #: ContainerIOManager,  TODO: this type is generated at runtime
-    funcs: Sequence[Callable[..., Any]],
-) -> None:
-    """Call function(s), can be sync or async, but any return values are ignored."""
-    with container_io_manager.handle_user_exception():
-        for func in funcs:
-            # We are deprecating parametrized exit methods but want to gracefully handle old code.
-            # We can remove this once the deprecation in the actual @exit decorator is enforced.
-            args = (None, None, None) if callable_has_non_self_params(func) else ()
-            # in case func is non-async, it's executed here and sigint will by default
-            # interrupt it using a KeyboardInterrupt exception
-            res = func(*args)
-            if inspect.iscoroutine(res):
-                # if however func is async, we have to jump through some hoops
-                event_loop.run(res)
+def get_serialized_user_class_and_function(
+    function_def: api_pb2.Function, client: _Client
+) -> tuple[Optional[type], Optional[types.FunctionType]]:
+    if function_def.definition_type == api_pb2.Function.DEFINITION_TYPE_SERIALIZED:
+        assert function_def.function_serialized or function_def.class_serialized
+
+        if function_def.function_serialized:
+            ser_fun = deserialize(function_def.function_serialized, client)
+        else:
+            ser_fun = None
+
+        if function_def.class_serialized:
+            ser_usr_cls = deserialize(function_def.class_serialized, client)
+        else:
+            ser_usr_cls = None
+    else:
+        ser_usr_cls, ser_fun = None, None
+
+    return ser_usr_cls, ser_fun
 
 
 def main(container_args: api_pb2.ContainerArguments, client: Client):
@@ -357,34 +277,20 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
     active_app: _App
     service: Service
     function_def = container_args.function_def
-    is_auto_snapshot: bool = function_def.is_auto_snapshot
     # The worker sets this flag to "1" for snapshot and restore tasks. Otherwise, this flag is unset,
     # in which case snapshots should be disabled.
     is_snapshotting_function = (
         function_def.is_checkpointing_function and os.environ.get("MODAL_ENABLE_SNAP_RESTORE") == "1"
     )
 
-    _client: _Client = synchronizer._translate_in(client)  # TODO(erikbern): ugly
+    _client: _Client = cast(_Client, synchronizer._translate_in(client))  # TODO(erikbern): ugly
 
     # Call ContainerHello - currently a noop but might be used later for things
     container_io_manager.hello()
 
     with container_io_manager.heartbeats(is_snapshotting_function), UserCodeEventLoop() as event_loop:
         # If this is a serialized function, fetch the definition from the server
-        if function_def.definition_type == api_pb2.Function.DEFINITION_TYPE_SERIALIZED:
-            assert function_def.function_serialized or function_def.class_serialized
-
-            if function_def.function_serialized:
-                ser_fun = deserialize(function_def.function_serialized, _client)
-            else:
-                ser_fun = None
-
-            if function_def.class_serialized:
-                ser_usr_cls = deserialize(function_def.class_serialized, _client)
-            else:
-                ser_usr_cls = None
-        else:
-            ser_usr_cls, ser_fun = None, None
+        ser_usr_cls, ser_fun = get_serialized_user_class_and_function(function_def, _client)
 
         # Initialize the function, importing user code.
         with container_io_manager.handle_user_exception():
@@ -436,7 +342,7 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
 
         # Initialize objects on the app.
         # This is basically only functions and classes - anything else is deprecated and will be unsupported soon
-        app: App = synchronizer._translate_out(active_app)
+        app: App = cast(App, synchronizer._translate_out(active_app))
         app._init_container(client, container_app)
 
         # Hydrate all function dependencies.
@@ -456,7 +362,7 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
                     "that evaluates differently in the local and remote environments."
                 )
             for object_id, obj in zip(dep_object_ids, service.service_deps):
-                metadata: Message = container_app.object_handle_metadata[object_id]
+                metadata: Optional[Message] = container_app.object_handle_metadata[object_id]
                 obj._hydrate(object_id, _client, metadata)
 
         # Initialize clustered functions.
@@ -467,91 +373,8 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
                 function_def._experimental_group_size,
             )
 
-        # Identify all "enter" methods that need to run before we snapshot.
-        if service.user_cls_instance is not None and not is_auto_snapshot:
-            pre_snapshot_methods = _find_callables_for_obj(
-                service.user_cls_instance, _PartialFunctionFlags.ENTER_PRE_SNAPSHOT
-            )
-            call_lifecycle_functions(event_loop, container_io_manager, list(pre_snapshot_methods.values()))
-
-        # If this container is being used to create a checkpoint, checkpoint the container after
-        # global imports and initialization. Checkpointed containers run from this point onwards.
-        if is_snapshotting_function:
-            container_io_manager.memory_snapshot()
-
-        # Install hooks for interactive functions.
-        def breakpoint_wrapper():
-            # note: it would be nice to not have breakpoint_wrapper() included in the backtrace
-            container_io_manager.interact(from_breakpoint=True)
-            import pdb
-
-            frame = inspect.currentframe().f_back
-
-            pdb.Pdb().set_trace(frame)
-
-        sys.breakpointhook = breakpoint_wrapper
-
-        # Identify the "enter" methods to run after resuming from a snapshot.
-        if service.user_cls_instance is not None and not is_auto_snapshot:
-            post_snapshot_methods = _find_callables_for_obj(
-                service.user_cls_instance, _PartialFunctionFlags.ENTER_POST_SNAPSHOT
-            )
-            call_lifecycle_functions(event_loop, container_io_manager, list(post_snapshot_methods.values()))
-
-        with container_io_manager.handle_user_exception():
-            finalized_functions = service.get_finalized_functions(function_def, container_io_manager)
-        # Execute the function.
-        lifespan_background_tasks = []
-        try:
-            for finalized_function in finalized_functions.values():
-                if finalized_function.lifespan_manager:
-                    lifespan_background_tasks.append(
-                        event_loop.create_task(finalized_function.lifespan_manager.background_task())
-                    )
-                    with container_io_manager.handle_user_exception():
-                        event_loop.run(finalized_function.lifespan_manager.lifespan_startup())
-            call_function(
-                event_loop,
-                container_io_manager,
-                finalized_functions,
-                batch_max_size,
-                batch_wait_ms,
-            )
-        finally:
-            # Run exit handlers. From this point onward, ignore all SIGINT signals that come from
-            # graceful shutdowns originating on the worker, as well as stray SIGUSR1 signals that
-            # may have been sent to cancel inputs.
-            int_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
-            usr1_handler = signal.signal(signal.SIGUSR1, signal.SIG_IGN)
-
-            try:
-                try:
-                    # run lifespan shutdown for asgi apps
-                    for finalized_function in finalized_functions.values():
-                        if finalized_function.lifespan_manager:
-                            with container_io_manager.handle_user_exception():
-                                event_loop.run(finalized_function.lifespan_manager.lifespan_shutdown())
-                finally:
-                    # no need to keep the lifespan asgi call around - we send it no more messages
-                    for lifespan_background_task in lifespan_background_tasks:
-                        lifespan_background_task.cancel()  # prevent dangling tasks
-
-                    # Identify "exit" methods and run them.
-                    # want to make sure this is called even if the lifespan manager fails
-                    if service.user_cls_instance is not None and not is_auto_snapshot:
-                        exit_methods = _find_callables_for_obj(service.user_cls_instance, _PartialFunctionFlags.EXIT)
-                        call_lifecycle_functions(event_loop, container_io_manager, list(exit_methods.values()))
-
-                # Finally, commit on exit to catch uncommitted volume changes and surface background
-                # commit errors.
-                container_io_manager.volume_commit(
-                    [v.volume_id for v in function_def.volume_mounts if v.allow_background_commits]
-                )
-            finally:
-                # Restore the original signal handler, needed for container_test hygiene since the
-                # test runs `main()` multiple times in the same process.
-                signal.signal(signal.SIGINT, int_handler)
-                signal.signal(signal.SIGUSR1, usr1_handler)
+        with service.execution_context(event_loop, container_io_manager) as finalized_functions:
+            call_function(event_loop, container_io_manager, finalized_functions, batch_max_size, batch_wait_ms)
 
 
 if __name__ == "__main__":

modal/_runtime/user_code_event_loop.py

@@ -0,0 +1,80 @@
+# Copyright Modal Labs 2022
+# ruff: noqa: E402
+import asyncio
+import signal
+import sys
+
+
+class UserCodeEventLoop:
+    """Run an async event loop as a context manager and handle signals.
+
+    This will run all *user supplied* async code, i.e. async functions, as well as async enter/exit managers
+
+    The following signals are handled while a coroutine is running on the event loop until
+    completion (and then handlers are deregistered):
+
+    - `SIGUSR1`: converted to an async task cancellation. Note that this only affects the event
+      loop, and the signal handler defined here doesn't run for sync functions.
+    - `SIGINT`: Unless the global signal handler has been set to SIGIGN, the loop's signal handler
+        is set to cancel the current task and raise KeyboardInterrupt to the caller.
+    """
+
+    def __enter__(self):
+        self.loop = asyncio.new_event_loop()
+        self.tasks = set()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.loop.run_until_complete(self.loop.shutdown_asyncgens())
+        if sys.version_info[:2] >= (3, 9):
+            self.loop.run_until_complete(self.loop.shutdown_default_executor())  # Introduced in Python 3.9
+
+        for task in self.tasks:
+            task.cancel()
+
+        self.loop.close()
+
+    def create_task(self, coro):
+        task = self.loop.create_task(coro)
+        self.tasks.add(task)
+        task.add_done_callback(self.tasks.discard)
+        return task
+
+    def run(self, coro):
+        task = asyncio.ensure_future(coro, loop=self.loop)
+        self._sigints = 0
+
+        def _sigint_handler():
+            # cancel the task in order to have run_until_complete return soon and
+            # prevent a bunch of unwanted tracebacks when shutting down the
+            # event loop.
+
+            # this basically replicates the sigint handler installed by asyncio.run()
+            self._sigints += 1
+            if self._sigints == 1:
+                # first sigint is graceful
+                task.cancel()
+                return
+
+            # this should normally not happen, but the second sigint would "hard kill" the event loop!
+            raise KeyboardInterrupt()
+
+        ignore_sigint = signal.getsignal(signal.SIGINT) == signal.SIG_IGN
+        if not ignore_sigint:
+            self.loop.add_signal_handler(signal.SIGINT, _sigint_handler)
+
+        # Before Python 3.9 there is no argument to Task.cancel
+        if sys.version_info[:2] >= (3, 9):
+            self.loop.add_signal_handler(signal.SIGUSR1, task.cancel, "Input was cancelled by user")
+        else:
+            self.loop.add_signal_handler(signal.SIGUSR1, task.cancel)
+
+        try:
+            return self.loop.run_until_complete(task)
+        except asyncio.CancelledError:
+            if self._sigints > 0:
+                raise KeyboardInterrupt()
+        finally:
+            self.loop.remove_signal_handler(signal.SIGUSR1)
+            if not ignore_sigint:
+                self.loop.remove_signal_handler(signal.SIGINT)

modal/_runtime/user_code_imports.py

@@ -1,17 +1,32 @@
 # Copyright Modal Labs 2024
 import importlib
+import inspect
+import os
+import signal
+import sys
 import typing
 from abc import ABCMeta, abstractmethod
+from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import Any, Callable, Optional, Sequence
+from typing import Any, Callable, Generator, Optional, Sequence
 
 import modal._object
 import modal._runtime.container_io_manager
 import modal.cls
 from modal import Function
 from modal._functions import _Function
+from modal._partial_function import (
+    _find_callables_for_obj,
+    _PartialFunctionFlags,
+)
+from modal._runtime.user_code_event_loop import UserCodeEventLoop
 from modal._utils.async_utils import synchronizer
-from modal._utils.function_utils import LocalFunctionError, is_async as get_is_async, is_global_object
+from modal._utils.function_utils import (
+    LocalFunctionError,
+    callable_has_non_self_params,
+    is_async as get_is_async,
+    is_global_object,
+)
 from modal.app import _App
 from modal.config import logger
 from modal.exception import ExecutionError, InvalidError
@@ -33,6 +48,74 @@ class FinalizedFunction:
     lifespan_manager: Optional["LifespanManager"] = None
 
 
+def call_lifecycle_functions(
+    event_loop: UserCodeEventLoop,
+    container_io_manager: Any,
+    funcs: Sequence[Callable[..., Any]],
+) -> None:
+    """Call function(s), can be sync or async, but any return values are ignored."""
+    with container_io_manager.handle_user_exception():
+        for func in funcs:
+            # We are deprecating parametrized exit methods but want to gracefully handle old code.
+            args = (None, None, None) if callable_has_non_self_params(func) else ()
+            res = func(*args)
+            if inspect.iscoroutine(res):
+                event_loop.run(res)
+
+
+@contextmanager
+def _run_service_lifecycle(
+    event_loop: UserCodeEventLoop,
+    container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
+    function_def: api_pb2.Function,
+    finalized_functions: dict[str, FinalizedFunction],
+    exit_callback: Optional[Callable[[], None]],
+) -> Generator[None, None, None]:
+    lifespan_background_tasks = []
+    try:
+        for finalized_function in finalized_functions.values():
+            if finalized_function.lifespan_manager:
+                lifespan_background_tasks.append(
+                    event_loop.create_task(finalized_function.lifespan_manager.background_task())
+                )
+                with container_io_manager.handle_user_exception():
+                    event_loop.run(finalized_function.lifespan_manager.lifespan_startup())
+        yield
+    finally:
+        # Run exit handlers. From this point onward, ignore all SIGINT signals that come from
+        # graceful shutdowns originating on the worker, as well as stray SIGUSR1 signals that
+        # may have been sent to cancel inputs.
+        int_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
+        usr1_handler = signal.signal(signal.SIGUSR1, signal.SIG_IGN)
+        try:
+            try:
+                # run lifespan shutdown for asgi apps
+                for finalized_function in finalized_functions.values():
+                    if finalized_function.lifespan_manager:
+                        with container_io_manager.handle_user_exception():
+                            event_loop.run(finalized_function.lifespan_manager.lifespan_shutdown())
+            finally:
+                # no need to keep the lifespan asgi call around - we send it no more messages
+                for task in lifespan_background_tasks:
+                    task.cancel()
+
+                # Identify "exit" methods and run them.
+                # want to make sure this is called even if the lifespan manager fails
+                if exit_callback:
+                    exit_callback()
+
+            # Finally, commit on exit to catch uncommitted volume changes and surface background
+            # commit errors.
+            container_io_manager.volume_commit(
+                [v.volume_id for v in function_def.volume_mounts if v.allow_background_commits]
+            )
+        finally:
+            # Restore the original signal handler, needed for container_test hygiene since the
+            # test runs `main()` multiple times in the same process.
+            signal.signal(signal.SIGINT, int_handler)
+            signal.signal(signal.SIGUSR1, usr1_handler)
+
+
 class Service(metaclass=ABCMeta):
     """Common interface for singular functions and class-based "services"
 
@@ -50,6 +133,24 @@ class Service(metaclass=ABCMeta):
         self, fun_def: api_pb2.Function, container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager"
     ) -> dict[str, "FinalizedFunction"]: ...
 
+    @contextmanager
+    @abstractmethod
+    def execution_context(
+        self,
+        event_loop: UserCodeEventLoop,
+        container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
+    ) -> Generator[dict[str, "FinalizedFunction"], None, None]:
+        """
+        Manages the lifecycle of the user code:
+        1. Runs pre-snapshot 'enter' methods
+        2. Calls maybe_snapshot(container_io_manager, function_def)
+        3. Creates breakpoint wrapper
+        4. Runs post-snapshot 'enter' methods
+        5. Initializes finalized functions (and ASGI/WSGI lifespan)
+        6. Yield finalized_functions for execution
+        7. Handles cleanup (lifespan shutdown, 'exit' methods)
+        """
+
 
 def construct_webhook_callable(
     user_defined_callable: Callable,
@@ -91,11 +192,36 @@ def construct_webhook_callable(
         raise InvalidError(f"Unrecognized web endpoint type {webhook_config.type}")
 
 
+def maybe_snapshot(
+    container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager", function_def: api_pb2.Function
+):
+    if function_def.is_checkpointing_function and os.environ.get("MODAL_ENABLE_SNAP_RESTORE") == "1":
+        container_io_manager.memory_snapshot()
+
+
+def create_breakpoint_wrapper(container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager"):
+    # Install hooks for interactive functions.
+    def breakpoint_wrapper():
+        # note: it would be nice to not have breakpoint_wrapper() included in the backtrace
+        container_io_manager.interact(from_breakpoint=True)
+        import pdb
+
+        current_frame = inspect.currentframe()
+        if current_frame is not None:
+            frame = current_frame.f_back
+            pdb.Pdb().set_trace(frame)
+        else:
+            raise RuntimeError("No current frame found")
+
+    sys.breakpointhook = breakpoint_wrapper
+
+
 @dataclass
 class ImportedFunction(Service):
     app: modal.app._App
     service_deps: Optional[Sequence["modal._object._Object"]]
     user_cls_instance = None
+    function_def: api_pb2.Function
 
     _user_defined_callable: Callable[..., Any]
 
@@ -138,6 +264,29 @@ class ImportedFunction(Service):
             )
         }
 
+    @contextmanager
+    def execution_context(
+        self,
+        event_loop: UserCodeEventLoop,
+        container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
+    ) -> Generator[dict[str, "FinalizedFunction"], None, None]:
+        # If this container is being used to create a checkpoint, checkpoint the container after
+        # global imports and initialization. Checkpointed containers run from this point onwards.
+        maybe_snapshot(container_io_manager, self.function_def)
+        create_breakpoint_wrapper(container_io_manager)
+
+        with container_io_manager.handle_user_exception():
+            finalized_functions = self.get_finalized_functions(self.function_def, container_io_manager)
+
+        with _run_service_lifecycle(
+            event_loop,
+            container_io_manager,
+            self.function_def,
+            finalized_functions,
+            None,
+        ):
+            yield finalized_functions
+
 
 @dataclass
 class ImportedClass(Service):
@@ -146,6 +295,7 @@ class ImportedClass(Service):
     service_deps: Optional[Sequence["modal._object._Object"]]
 
     _partial_functions: dict[str, "modal._partial_function._PartialFunction"]
+    function_def: api_pb2.Function
 
     def get_finalized_functions(
         self, fun_def: api_pb2.Function, container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager"
@@ -189,6 +339,54 @@ class ImportedClass(Service):
             finalized_functions[method_name] = finalized_function
         return finalized_functions
 
+    @contextmanager
+    def execution_context(
+        self,
+        event_loop: UserCodeEventLoop,
+        container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
+    ) -> Generator[dict[str, "FinalizedFunction"], None, None]:
+        # 1. Pre-snapshot Enter
+        # Identify all "enter" methods that need to run before we snapshot.
+        if not self.function_def.is_auto_snapshot:
+            pre_snapshot_methods = _find_callables_for_obj(
+                self.user_cls_instance, _PartialFunctionFlags.ENTER_PRE_SNAPSHOT
+            )
+            call_lifecycle_functions(event_loop, container_io_manager, list(pre_snapshot_methods.values()))
+
+        # 2. Snapshot
+        # If this container is being used to create a checkpoint, checkpoint the container after
+        # global imports and initialization. Checkpointed containers run from this point onwards.
+        maybe_snapshot(container_io_manager, self.function_def)
+
+        # 3. Breakpoint wrapper
+        create_breakpoint_wrapper(container_io_manager)
+
+        # 4. Post-snapshot Enter
+        # Identify the "enter" methods to run after resuming from a snapshot.
+        if not self.function_def.is_auto_snapshot:
+            post_snapshot_methods = _find_callables_for_obj(
+                self.user_cls_instance, _PartialFunctionFlags.ENTER_POST_SNAPSHOT
+            )
+            call_lifecycle_functions(event_loop, container_io_manager, list(post_snapshot_methods.values()))
+
+        # 5. Get Functions & Start Lifespan
+        with container_io_manager.handle_user_exception():
+            finalized_functions = self.get_finalized_functions(self.function_def, container_io_manager)
+
+        def exit_callback():
+            if not self.function_def.is_auto_snapshot:
+                exit_methods = _find_callables_for_obj(self.user_cls_instance, _PartialFunctionFlags.EXIT)
+                call_lifecycle_functions(event_loop, container_io_manager, list(exit_methods.values()))
+
+        with _run_service_lifecycle(
+            event_loop,
+            container_io_manager,
+            self.function_def,
+            finalized_functions,
+            exit_callback,
+        ):
+            yield finalized_functions
+
 
 def get_user_class_instance(_cls: modal.cls._Cls, args: tuple[Any, ...], kwargs: dict[str, Any]) -> typing.Any:
     """Returns instance of the underlying class to be used as the `self`
@@ -266,9 +464,10 @@ def import_single_function_service(
             active_app = get_active_app_fallback(function_def)
 
     return ImportedFunction(
-        active_app,
-        service_deps,
-        user_defined_callable,
+        app=active_app,
+        service_deps=service_deps,
+        function_def=function_def,
+        _user_defined_callable=user_defined_callable,
     )
 
 
@@ -338,11 +537,12 @@ def import_class_service(
     user_cls_instance = get_user_class_instance(_cls, cls_args, cls_kwargs)
 
     return ImportedClass(
-        user_cls_instance,
-        active_app,
-        service_deps,
+        user_cls_instance=user_cls_instance,
+        app=active_app,
+        service_deps=service_deps,
         # TODO (elias/deven): instead of using method_partials here we should use a set of api_pb2.MethodDefinition
-        method_partials,
+        _partial_functions=method_partials,
+        function_def=function_def,
     )
 
 

modal/client.pyi

@@ -32,7 +32,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.5.dev0",
+        version: str = "1.2.5.dev2",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -163,7 +163,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.5.dev0",
+        version: str = "1.2.5.dev2",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

modal/experimental/__init__.py

@@ -85,6 +85,19 @@ async def list_deployed_apps(environment_name: str = "", client: Optional[_Clien
     return app_infos
 
 
+@synchronizer.create_blocking
+async def stop_app(name: str, *, environment_name: Optional[str] = None, client: Optional[_Client] = None) -> None:
+    """Stop a deployed App.
+
+    This interface is experimental and may change in the future,
+    although the functionality will continue to be supported.
+    """
+    client_ = client or await _Client.from_env()
+    app = await _App.lookup(name, environment_name=environment_name, client=client_)
+    req = api_pb2.AppStopRequest(app_id=app.app_id, source=api_pb2.APP_STOP_SOURCE_PYTHON_CLIENT)
+    await client_.stub.AppStop(req)
+
+
 @synchronizer.create_blocking
 async def get_app_objects(
     app_name: str, *, environment_name: Optional[str] = None, client: Optional[_Client] = None

{modal-1.2.5.dev0.dist-info → modal-1.2.5.dev2.dist-info}/METADATA

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

{modal-1.2.5.dev0.dist-info → modal-1.2.5.dev2.dist-info}/RECORD

@@ -3,7 +3,7 @@ modal/__main__.py,sha256=45H-GtwzaDfN-1nP4_HYvzN3s7AG_HXR4-ynrsjO_OI,2803
 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=zYk5mC8_IMx4kWnyFMRHKOrFRLBWchy6x-py3M8FYEw,28084
+modal/_container_entrypoint.py,sha256=aRuWG1xl3kDy28CfQrqQ-LU8liX2W_bwm2avVOE63Tw,19812
 modal/_functions.py,sha256=fnmNMS4nGi-YvbWPn6nGt4RYqs11JmSa0b_B1UNSwPU,91499
 modal/_grpc_client.py,sha256=KZcggVNvFL5jRQkFumshMppeFHMbaZI9Dzf13run6As,6083
 modal/_ipython.py,sha256=TW1fkVOmZL3YYqdS2YlM1hqpf654Yf8ZyybHdBnlhSw,301
@@ -26,7 +26,7 @@ modal/app.pyi,sha256=nI_Tibj-rI5I7dJFJnczbHvcmVzCvvCih0tMzoQlr_Y,50835
 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=6JQpR6YUw22b9TRuqx9FZYKMIZyqF7cLd7v3ed_JJJ8,13146
+modal/client.pyi,sha256=DDiMjmFSIARj1BaJNqxZtDRDkt1GM2jSvnvh06g7hxo,13146
 modal/cloud_bucket_mount.py,sha256=cvVj5Rt4nDHoQbTneoJPTaAcnl_Ab_mrsjnnzd0v9OI,6013
 modal/cloud_bucket_mount.pyi,sha256=vXusGMOUk9HjCs4lhxteuCK4xLQclPfugGWKo7LECEA,7539
 modal/cls.py,sha256=4T__mtYlQUnkatif1Wnr8Ld9DN_ySydHj2UwhRg89ok,41984
@@ -92,7 +92,8 @@ modal/_runtime/execution_context.py,sha256=AYrNQRHHXEqX2MwMf8zxelKZnYf25RE_B-NRL
 modal/_runtime/execution_context.pyi,sha256=FVzakehz72ndL-ufe8-EC7TM4IHO_MEBcAdgWuU4W9k,2426
 modal/_runtime/gpu_memory_snapshot.py,sha256=8T85kyfGJ11AnhFRCZTeWj9zin9e9f5XbrRqU8_WjAk,11955
 modal/_runtime/telemetry.py,sha256=T1RoAGyjBDr1swiM6pPsGRSITm7LI5FDK18oNXxY08U,5163
-modal/_runtime/user_code_imports.py,sha256=1MlOgw810aj0MeDvFPvHBIz-aHd7jUX6dwRfIcM3-KE,16498
+modal/_runtime/user_code_event_loop.py,sha256=HwOuDyCZLOakr_DG7p2MrcscjSQNheIhBBuLgB5I3Cc,3014
+modal/_runtime/user_code_imports.py,sha256=9mxg2FMZGR2UQfLcxEPNIiH51SBJTl_1JCCRrGMM0rI,25086
 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
@@ -155,11 +156,11 @@ modal/cli/programs/launch_instance_ssh.py,sha256=GrwK_Vy8-7B4x5a6AqFaF7lqNVgu75J
 modal/cli/programs/run_jupyter.py,sha256=IJw8nds8Cjl9j4dxBqMGxhz-bIyVX0kle7jbt8HFOhM,2688
 modal/cli/programs/run_marimo.py,sha256=QlCGPkwQ0XLajt2LtujR_BGsRV1AZ3OCUgZxkkM1lug,2893
 modal/cli/programs/vscode.py,sha256=E1aJPU7b8RWWj-JX71DifsCoLYsCAnre7lATiBJjUms,3386
-modal/experimental/__init__.py,sha256=sCwNbBLcR2t-jhrpwtMAPGKt2WNqXBg0xkNZdyB-6CE,13940
+modal/experimental/__init__.py,sha256=WlBNjzahOTuhWdfHt0OIArU3pdrErsFrprVhZ7UqU0k,14520
 modal/experimental/flash.py,sha256=0afbNEg8SLBdUbvFpT3R9FE1mfHAV_Iual8x2hqfPMY,26785
 modal/experimental/flash.pyi,sha256=BU7v9gFLWX1OanZ3HpRoVGp4qFfHo93lM9UkzcNFZUY,14832
 modal/experimental/ipython.py,sha256=TrCfmol9LGsRZMeDoeMPx3Hv3BFqQhYnmD_iH0pqdhk,2904
-modal-1.2.5.dev0.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+modal-1.2.5.dev2.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
@@ -187,10 +188,10 @@ modal_proto/task_command_router_pb2.py,sha256=_pD2ZpU0bNzhwBdzmLoLyLtAtftI_Agxwn
 modal_proto/task_command_router_pb2.pyi,sha256=EyDgXPLr7alqjXYERV8w_MPuO404x0uCppmSkrfE9IE,14589
 modal_proto/task_command_router_pb2_grpc.py,sha256=uEQ0HdrCp8v-9bB5yIic9muA8spCShLHY6Bz9cCgOUE,10114
 modal_proto/task_command_router_pb2_grpc.pyi,sha256=s3Yxsrawdj4nr8vqQqsAxyX6ilWaGbdECy425KKbLIA,3301
-modal_version/__init__.py,sha256=cDrHJM8riTJ8snnSygifEVrn53ihgXeZmewwxUgD6IY,120
+modal_version/__init__.py,sha256=y2ih8aafsJLowH_EmA8i4Ghzhd9x2mf_p9cG3NYWFfk,120
 modal_version/__main__.py,sha256=2FO0yYQQwDTh6udt1h-cBnGd1c4ZyHnHSI4BksxzVac,105
-modal-1.2.5.dev0.dist-info/METADATA,sha256=8xhfLMDoSYMY_-hEl9dXQTVFmdJZZrBtouaROoxy92E,2489
-modal-1.2.5.dev0.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-modal-1.2.5.dev0.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
-modal-1.2.5.dev0.dist-info/top_level.txt,sha256=4BWzoKYREKUZ5iyPzZpjqx4G8uB5TWxXPDwibLcVa7k,43
-modal-1.2.5.dev0.dist-info/RECORD,,
+modal-1.2.5.dev2.dist-info/METADATA,sha256=3yOTToFAFT9kAmIjL-NrDmej6f3kE8okAIrwF8r2W3Y,2489
+modal-1.2.5.dev2.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+modal-1.2.5.dev2.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
+modal-1.2.5.dev2.dist-info/top_level.txt,sha256=4BWzoKYREKUZ5iyPzZpjqx4G8uB5TWxXPDwibLcVa7k,43
+modal-1.2.5.dev2.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.5.dev0"
+__version__ = "1.2.5.dev2"