modal 1.1.4.dev15__tar.gz → 1.2.5.dev4__tar.gz

{modal-1.1.4.dev15 → modal-1.2.5.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.1.4.dev15
+Version: 1.2.5.dev4
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0
@@ -13,10 +13,11 @@ 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.9
+Requires-Python: <3.14,>=3.9
 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
@@ -31,14 +32,14 @@ Requires-Dist: watchfiles
 Requires-Dist: typing_extensions~=4.6
 Dynamic: license-file
 
-# Modal Python Library
+# Modal Python SDK
 
 [![PyPI Version](https://img.shields.io/pypi/v/modal.svg)](https://pypi.org/project/modal/)
 [![License](https://img.shields.io/badge/license-apache_2.0-darkviolet.svg)](https://github.com/modal-labs/modal-client/blob/master/LICENSE)
 [![Tests](https://github.com/modal-labs/modal-client/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/modal-labs/modal-client/actions/workflows/ci-cd.yml)
 [![Slack](https://img.shields.io/badge/slack-join-blue.svg?logo=slack)](https://modal.com/slack)
 
-The [Modal](https://modal.com/) Python library provides convenient, on-demand
+The [Modal](https://modal.com/) Python SDK provides convenient, on-demand
 access to serverless cloud compute from Python scripts on your local computer.
 
 ## Documentation
@@ -52,10 +53,10 @@ a [user guide](https://modal.com/docs/guide), and the detailed
 
 **This library requires Python 3.9 – 3.13.**
 
-Install the package with `pip`:
+Install the package with `uv` or `pip`:
 
 ```bash
-pip install modal
+uv pip install modal
 ```
 
 You can create a Modal account (or link your existing one) directly on the

{modal-1.1.4.dev15 → modal-1.2.5.dev4}/README.md

@@ -1,11 +1,11 @@
-# Modal Python Library
+# Modal Python SDK
 
 [![PyPI Version](https://img.shields.io/pypi/v/modal.svg)](https://pypi.org/project/modal/)
 [![License](https://img.shields.io/badge/license-apache_2.0-darkviolet.svg)](https://github.com/modal-labs/modal-client/blob/master/LICENSE)
 [![Tests](https://github.com/modal-labs/modal-client/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/modal-labs/modal-client/actions/workflows/ci-cd.yml)
 [![Slack](https://img.shields.io/badge/slack-join-blue.svg?logo=slack)](https://modal.com/slack)
 
-The [Modal](https://modal.com/) Python library provides convenient, on-demand
+The [Modal](https://modal.com/) Python SDK provides convenient, on-demand
 access to serverless cloud compute from Python scripts on your local computer.
 
 ## Documentation
@@ -19,10 +19,10 @@ a [user guide](https://modal.com/docs/guide), and the detailed
 
 **This library requires Python 3.9 – 3.13.**
 
-Install the package with `pip`:
+Install the package with `uv` or `pip`:
 
 ```bash
-pip install modal
+uv pip install modal
 ```
 
 You can create a Modal account (or link your existing one) directly on the

modal-1.2.5.dev4/modal/_billing.py

@@ -0,0 +1,80 @@
+# Copyright Modal Labs 2025
+from datetime import datetime, timezone
+from decimal import Decimal
+from typing import Any, Optional, TypedDict
+
+from modal_proto import api_pb2
+
+from .client import _Client
+from .exception import InvalidError
+
+
+class WorkspaceBillingReportItem(TypedDict):
+    object_id: str
+    description: str
+    environment_name: str
+    interval_start: datetime
+    cost: Decimal
+    tags: dict[str, str]
+
+
+async def _workspace_billing_report(
+    *,
+    start: datetime,  # Start of the report, inclusive
+    end: Optional[datetime] = None,  # End of the report, exclusive
+    resolution: str = "d",  # Resolution, e.g. "d" for daily or "h" for hourly
+    tag_names: Optional[list[str]] = None,  # Optional additional metadata to include
+    client: Optional[_Client] = None,
+) -> list[dict[str, Any]]:
+    """Generate a tabular report of workspace usage by object and time.
+
+    The result will be a list of dictionaries for each interval (determined by `resolution`)
+    between the `start` and `end` limits. The dictionary represents a single Modal object
+    that billing can be attributed to (e.g., an App) along with metadata (including user-defined
+    tags) for identifying that object.
+
+    The `start` and `end` parameters are required to either have a UTC timezone or to be
+    timezone-naive (which will be interpreted as UTC times). The timestamps in the result will
+    be in UTC. Cost will be reported for full intervals, even if the provided `start` or `end`
+    parameters are partial: `start` will be rounded to the beginning of its interval, while
+    partial `end` intervals will be excluded.
+
+    Additional user-provided metadata can be included in the report if the objects have tags
+    and `tag_names` (i.e., keys) are specified in the request. Note that tags will be attributed
+    to the entire interval even if they were added or removed at some point within it.
+
+    """
+    if client is None:
+        client = await _Client.from_env()
+
+    tag_names = tag_names or []
+
+    if end is None:
+        end = datetime.now(timezone.utc)
+
+    for dt in (start, end):
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        elif dt.tzinfo != timezone.utc:
+            raise InvalidError("Timezone-aware start/end limits must be in UTC.")
+
+    request = api_pb2.WorkspaceBillingReportRequest(
+        resolution=resolution,
+        tag_names=tag_names,
+    )
+    request.start_timestamp.FromDatetime(start)
+    request.end_timestamp.FromDatetime(end)
+
+    rows = []
+    async for pb_item in client.stub.WorkspaceBillingReport.unary_stream(request):
+        item = {
+            "object_id": pb_item.object_id,
+            "description": pb_item.description,
+            "environment_name": pb_item.environment_name,
+            "interval_start": pb_item.interval.ToDatetime().replace(tzinfo=timezone.utc),
+            "cost": Decimal(pb_item.cost),
+            "tags": dict(pb_item.tags),
+        }
+        rows.append(item)
+
+    return rows

{modal-1.1.4.dev15 → modal-1.2.5.dev4}/modal/_clustered_functions.py

@@ -5,7 +5,6 @@ from dataclasses import dataclass
 from typing import Optional
 
 from modal._utils.async_utils import synchronize_api
-from modal._utils.grpc_utils import retry_transient_errors
 from modal.client import _Client
 from modal.exception import InvalidError
 from modal_proto import api_pb2
@@ -61,8 +60,7 @@ async def _initialize_clustered_function(client: _Client, task_id: str, world_si
         os.environ["NCCL_NSOCKS_PERTHREAD"] = "1"
 
     if world_size > 1:
-        resp: api_pb2.TaskClusterHelloResponse = await retry_transient_errors(
-            client.stub.TaskClusterHello,
+        resp = await client.stub.TaskClusterHello(
             api_pb2.TaskClusterHelloRequest(
                 task_id=task_id,
                 container_ip=container_ip,

{modal-1.1.4.dev15 → modal-1.2.5.dev4}/modal/_container_entrypoint.py

@@ -15,31 +15,23 @@ 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, synchronizer
-from modal._utils.function_utils import (
-    callable_has_non_self_params,
-)
+from modal._utils.async_utils import TaskContext, aclosing, synchronizer
 from modal.app import App, _App
 from modal.client import Client, _Client
 from modal.config import logger
-from modal.exception import ExecutionError, InputCancellation, InvalidError
+from modal.exception import ExecutionError, InputCancellation
 from modal.running_app import RunningApp, running_app_from_layout
 from modal_proto import api_pb2
 
@@ -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",
@@ -184,17 +102,13 @@ def call_function(
     batch_wait_ms: int,
 ):
     async def run_input_async(io_context: IOContext) -> None:
-        started_at = time.time()
         reset_context = execution_context._set_current_context_ids(
             io_context.input_ids, io_context.function_call_ids, io_context.attempt_tokens
         )
+        started_at = time.time()
         async with container_io_manager.handle_input_exception.aio(io_context, started_at):
-            res = io_context.call_finalized_function()
             # TODO(erikbern): any exception below shouldn't be considered a user exception
             if io_context.finalized_function.is_generator:
-                if not inspect.isasyncgen(res):
-                    raise InvalidError(f"Async generator function returned value of type {type(res)}")
-
                 # Send up to this many outputs at a time.
                 current_function_call_id = execution_context.current_function_call_id()
                 assert current_function_call_id is not None  # Set above.
@@ -204,33 +118,24 @@ def call_function(
                 async with container_io_manager.generator_output_sender(
                     current_function_call_id,
                     current_attempt_token,
-                    io_context.finalized_function.data_format,
+                    io_context._generator_output_format(),
                     generator_queue,
                 ):
                     item_count = 0
-                    async for value in res:
-                        await container_io_manager._queue_put.aio(generator_queue, value)
-                        item_count += 1
+                    async with aclosing(io_context.call_generator_async()) as gen:
+                        async for value in gen:
+                            await container_io_manager._queue_put.aio(generator_queue, value)
+                            item_count += 1
 
-                message = api_pb2.GeneratorDone(items_total=item_count)
-                await container_io_manager.push_outputs.aio(
-                    io_context,
-                    started_at,
-                    message,
-                    api_pb2.DATA_FORMAT_GENERATOR_DONE,
+                await container_io_manager._send_outputs.aio(
+                    started_at, io_context.output_items_generator_done(started_at, item_count)
                 )
             else:
-                if not inspect.iscoroutine(res) or inspect.isgenerator(res) or inspect.isasyncgen(res):
-                    raise InvalidError(
-                        f"Async (non-generator) function returned value of type {type(res)}"
-                        " You might need to use @app.function(..., is_generator=True)."
-                    )
-                value = await res
+                value = await io_context.call_function_async()
                 await container_io_manager.push_outputs.aio(
                     io_context,
                     started_at,
                     value,
-                    io_context.finalized_function.data_format,
                 )
         reset_context()
 
@@ -240,13 +145,9 @@ def call_function(
             io_context.input_ids, io_context.function_call_ids, io_context.attempt_tokens
         )
         with container_io_manager.handle_input_exception(io_context, started_at):
-            res = io_context.call_finalized_function()
-
             # TODO(erikbern): any exception below shouldn't be considered a user exception
             if io_context.finalized_function.is_generator:
-                if not inspect.isgenerator(res):
-                    raise InvalidError(f"Generator function returned value of type {type(res)}")
-
+                gen = io_context.call_generator_sync()
                 # Send up to this many outputs at a time.
                 current_function_call_id = execution_context.current_function_call_id()
                 assert current_function_call_id is not None  # Set above.
@@ -256,25 +157,20 @@ def call_function(
                 with container_io_manager.generator_output_sender(
                     current_function_call_id,
                     current_attempt_token,
-                    io_context.finalized_function.data_format,
+                    io_context._generator_output_format(),
                     generator_queue,
                 ):
                     item_count = 0
-                    for value in res:
+                    for value in gen:
                         container_io_manager._queue_put(generator_queue, value)
                         item_count += 1
 
-                message = api_pb2.GeneratorDone(items_total=item_count)
-                container_io_manager.push_outputs(io_context, started_at, message, api_pb2.DATA_FORMAT_GENERATOR_DONE)
-            else:
-                if inspect.iscoroutine(res) or inspect.isgenerator(res) or inspect.isasyncgen(res):
-                    raise InvalidError(
-                        f"Sync (non-generator) function return value of type {type(res)}."
-                        " You might need to use @app.function(..., is_generator=True)."
-                    )
-                container_io_manager.push_outputs(
-                    io_context, started_at, res, io_context.finalized_function.data_format
+                container_io_manager._send_outputs(
+                    started_at, io_context.output_items_generator_done(started_at, item_count)
                 )
+            else:
+                values = io_context.call_function_sync()
+                container_io_manager.push_outputs(io_context, started_at, values)
         reset_context()
 
     if container_io_manager.input_concurrency_enabled:
@@ -353,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):
@@ -379,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():
@@ -437,9 +321,9 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
                         param_kwargs,
                     )
                 else:
+                    assert ser_usr_cls is None
                     service = import_single_function_service(
                         function_def,
-                        ser_usr_cls,
                         ser_fun,
                     )
 
@@ -458,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.
@@ -472,10 +356,13 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
                     f"Function has {len(service.service_deps)} dependencies"
                     f" but container got {len(dep_object_ids)} object ids.\n"
                     f"Code deps: {service.service_deps}\n"
-                    f"Object ids: {dep_object_ids}"
+                    f"Object ids: {dep_object_ids}\n"
+                    "\n"
+                    "This can happen if you are defining Modal objects under a conditional statement "
+                    "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.
@@ -486,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__":