modAL 1.2.5.dev6__tar.gz → 1.2.5.dev8__tar.gz

{modal-1.2.5.dev6 → modal-1.2.5.dev8}/PKG-INFO

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

{modal-1.2.5.dev6 → modal-1.2.5.dev8}/modal/_runtime/user_code_imports.py

@@ -64,12 +64,10 @@ def call_lifecycle_functions(
 
 
 @contextmanager
-def _run_service_lifecycle(
+def lifecycle_asgi(
     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:
@@ -82,38 +80,34 @@ def _run_service_lifecycle(
                     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]
-            )
+            # 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:
-            # 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)
+            # no need to keep the lifespan asgi call around - we send it no more messages
+            for task in lifespan_background_tasks:
+                task.cancel()
+
+
+def disable_signals():
+    int_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
+    usr1_handler = signal.signal(signal.SIGUSR1, signal.SIG_IGN)
+    return int_handler, usr1_handler
+
+
+def try_enable_signals(int_handler, usr1_handler):
+    if int_handler is not None and usr1_handler is not None:
+        signal.signal(signal.SIGINT, int_handler)
+        signal.signal(signal.SIGUSR1, usr1_handler)
+
+
+def volume_commit(
+    container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager", function_def: api_pb2.Function
+):
+    container_io_manager.volume_commit([v.volume_id for v in function_def.volume_mounts if v.allow_background_commits])
 
 
 class Service(metaclass=ABCMeta):
@@ -127,14 +121,30 @@ class Service(metaclass=ABCMeta):
     user_cls_instance: Any
     app: "modal.app._App"
     service_deps: Optional[Sequence["modal._object._Object"]]
+    function_def: api_pb2.Function
 
     @abstractmethod
     def get_finalized_functions(
         self, fun_def: api_pb2.Function, container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager"
     ) -> dict[str, "FinalizedFunction"]: ...
 
+    @abstractmethod
     @contextmanager
+    def lifecycle_presnapshot(
+        self,
+        event_loop: UserCodeEventLoop,
+        container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
+    ) -> Generator[None, None, None]: ...
+
     @abstractmethod
+    @contextmanager
+    def lifecycle_postsnapshot(
+        self,
+        event_loop: UserCodeEventLoop,
+        container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
+    ) -> Generator[None, None, None]: ...
+
+    @contextmanager
     def execution_context(
         self,
         event_loop: UserCodeEventLoop,
@@ -150,6 +160,34 @@ class Service(metaclass=ABCMeta):
         6. Yield finalized_functions for execution
         7. Handles cleanup (lifespan shutdown, 'exit' methods)
         """
+        int_handler, usr1_handler = None, None
+        try:
+            # 1. Pre-snapshot Enter
+            with self.lifecycle_presnapshot(event_loop, container_io_manager):
+                # 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
+                with self.lifecycle_postsnapshot(event_loop, container_io_manager):
+                    # Get Functions
+                    with container_io_manager.handle_user_exception():
+                        finalized_functions = self.get_finalized_functions(self.function_def, container_io_manager)
+                    # 5. Start ASGI lifespan
+                    with lifecycle_asgi(event_loop, container_io_manager, finalized_functions):
+                        # 6. Yield Finalized Functions
+                        try:
+                            yield finalized_functions
+                        finally:
+                            int_handler, usr1_handler = disable_signals()
+        finally:
+            # 9. Volume commit - runs OUTSIDE all lifecycle managers so exit handlers
+            # have a chance to write to disk before we commit volumes
+            try:
+                volume_commit(container_io_manager, self.function_def)
+            finally:
+                try_enable_signals(int_handler, usr1_handler)
 
 
 def construct_webhook_callable(
@@ -265,27 +303,22 @@ class ImportedFunction(Service):
         }
 
     @contextmanager
-    def execution_context(
+    def lifecycle_presnapshot(
         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)
+    ):
+        # This is a no-op for imported functions since @enter methods are not supported
+        yield
 
-        with _run_service_lifecycle(
-            event_loop,
-            container_io_manager,
-            self.function_def,
-            finalized_functions,
-            None,
-        ):
-            yield finalized_functions
+    @contextmanager
+    def lifecycle_postsnapshot(
+        self,
+        event_loop: UserCodeEventLoop,
+        container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
+    ):
+        # This is a no-op for imported functions since @enter methods are not supported
+        yield
 
 
 @dataclass
@@ -340,53 +373,38 @@ class ImportedClass(Service):
         return finalized_functions
 
     @contextmanager
-    def execution_context(
+    def lifecycle_presnapshot(
         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()))
+        yield
 
-        # 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
+    @contextmanager
+    def lifecycle_postsnapshot(
+        self,
+        event_loop: UserCodeEventLoop,
+        container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
+    ):
         # 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():
+        try:
+            yield
+        finally:
             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`

{modal-1.2.5.dev6 → modal-1.2.5.dev8}/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.dev6",
+        version: str = "1.2.5.dev8",
     ):
         """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.dev6",
+        version: str = "1.2.5.dev8",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.2.5.dev6 → modal-1.2.5.dev8}/modal/functions.pyi

@@ -408,7 +408,7 @@ class Function(
 
     _call_generator: ___call_generator_spec[typing_extensions.Self]
 
-    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
+    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
         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."""
             ...
@@ -417,7 +417,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, typing_extensions.Self]
+    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
 
     class __remote_gen_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -444,7 +444,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
         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.
 
@@ -468,7 +468,7 @@ class Function(
             ...
 
     _experimental_spawn: ___experimental_spawn_spec[
-        modal._functions.P, modal._functions.ReturnType, typing_extensions.Self
+        modal._functions.ReturnType, modal._functions.P, typing_extensions.Self
     ]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER, SUPERSELF]):
@@ -477,7 +477,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P, typing_extensions.Self]
 
-    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
+    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
         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.
 
@@ -498,7 +498,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
+    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]:
         """Return the inner Python object wrapped by this Modal Function."""

{modal-1.2.5.dev6 → modal-1.2.5.dev8}/modal/io_streams.py

@@ -2,6 +2,7 @@
 import asyncio
 import codecs
 import contextlib
+import io
 import sys
 import time
 from collections.abc import AsyncGenerator, AsyncIterator
@@ -403,10 +404,10 @@ class _BytesStreamReaderThroughCommandRouter:
         return self._params.file_descriptor
 
     async def read(self) -> bytes:
-        data_bytes = b""
+        buffer = io.BytesIO()
         async for part in self:
-            data_bytes += cast(bytes, part)
-        return data_bytes
+            buffer.write(part)
+        return buffer.getvalue()
 
     def __aiter__(self) -> AsyncGenerator[bytes, None]:
         return _stdio_stream_from_command_router(self._params)
@@ -438,10 +439,10 @@ class _TextStreamReaderThroughCommandRouter:
         return self._params.file_descriptor
 
     async def read(self) -> str:
-        data_str = ""
+        buffer = io.StringIO()
         async for part in self:
-            data_str += cast(str, part)
-        return data_str
+            buffer.write(part)
+        return buffer.getvalue()
 
     async def __aiter__(self) -> AsyncGenerator[str, None]:
         async with aclosing(_stdio_stream_from_command_router(self._params)) as bytes_stream:

{modal-1.2.5.dev6 → modal-1.2.5.dev8}/modal.egg-info/PKG-INFO

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

{modal-1.2.5.dev6 → modal-1.2.5.dev8}/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.dev6"
+__version__ = "1.2.5.dev8"