modal 1.2.5.dev14__tar.gz → 1.2.5.dev16__tar.gz

{modal-1.2.5.dev14 → modal-1.2.5.dev16}/PKG-INFO

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

{modal-1.2.5.dev14 → modal-1.2.5.dev16}/modal/_functions.py

@@ -988,6 +988,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 function_definition = api_pb2.Function(
                     module_name=info.module_name or "",
                     function_name=info.function_name,
+                    implementation_name=info.implementation_name,
                     mount_ids=loaded_mount_ids,
                     secret_ids=[secret.object_id for secret in secrets],
                     image_id=(image.object_id if image else ""),
@@ -1054,6 +1055,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     function_data = api_pb2.FunctionData(
                         module_name=function_definition.module_name,
                         function_name=function_definition.function_name,
+                        implementation_name=function_definition.implementation_name,
                         function_type=function_definition.function_type,
                         warm_pool_size=function_definition.warm_pool_size,
                         concurrency_limit=function_definition.concurrency_limit,

{modal-1.2.5.dev14 → modal-1.2.5.dev16}/modal/_partial_function.py

@@ -160,9 +160,8 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
             raise InvalidError("Interface decorators cannot be combined with lifecycle decorators.")
 
         has_web_interface = self.flags & _PartialFunctionFlags.WEB_INTERFACE
-        has_http_web_interface = self.flags & _PartialFunctionFlags.HTTP_WEB_INTERFACE
         has_callable_interface = self.flags & _PartialFunctionFlags.CALLABLE_INTERFACE
-        if (has_web_interface or has_http_web_interface) and has_callable_interface:
+        if has_web_interface and has_callable_interface:
             self.registered = True  # Hacky, avoid false-positive warning
             raise InvalidError("Callable decorators cannot be combined with web interface decorators.")
 

{modal-1.2.5.dev14 → modal-1.2.5.dev16}/modal/_runtime/user_code_imports.py

@@ -30,6 +30,7 @@ from modal._utils.function_utils import (
 from modal.app import _App
 from modal.config import logger
 from modal.exception import ExecutionError, InvalidError
+from modal.experimental.flash import _FlashContainerEntry
 from modal_proto import api_pb2
 
 if typing.TYPE_CHECKING:
@@ -392,18 +393,22 @@ class ImportedClass(Service):
         event_loop: UserCodeEventLoop,
         container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
     ):
+        flash_entry = _FlashContainerEntry(self.function_def.http_config)
         # 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()))
+            flash_entry.enter()
         try:
             yield
         finally:
             if not self.function_def.is_auto_snapshot:
+                flash_entry.stop()
                 exit_methods = _find_callables_for_obj(self.user_cls_instance, _PartialFunctionFlags.EXIT)
                 call_lifecycle_functions(event_loop, container_io_manager, list(exit_methods.values()))
+                flash_entry.close()
 
 
 def get_user_class_instance(_cls: modal.cls._Cls, args: tuple[Any, ...], kwargs: dict[str, Any]) -> typing.Any:
@@ -460,7 +465,7 @@ def import_single_function_service(
     else:
         # Load the module dynamically
         module = importlib.import_module(function_def.module_name)
-        qual_name: str = function_def.function_name
+        qual_name: str = function_def.implementation_name
 
         if not is_global_object(qual_name):
             raise LocalFunctionError("Attempted to load a function defined in a function scope")

{modal-1.2.5.dev14 → modal-1.2.5.dev16}/modal/_utils/function_utils.py

@@ -129,6 +129,7 @@ class FunctionInfo:
 
     raw_f: Optional[Callable[..., Any]]  # if None - this is a "class service function"
     function_name: str
+    implementation_name: str
     user_cls: Optional[type[Any]]
     module_name: Optional[str]
 
@@ -160,20 +161,16 @@ class FunctionInfo:
         self.raw_f = f
         self.user_cls = user_cls
 
-        if name_override is not None:
-            if not serialized:
-                # We may relax this constraint in the future, but currently we don't track the distinction between
-                # the Function's name inside modal and the name of the object that we need to import in a container.
-                raise InvalidError("Setting a custom `name=` also requires setting `serialized=True`")
-            self.function_name = name_override
-        elif f is None and user_cls:
+        if f is None and user_cls:
             # "service function" for running all methods of a class
-            self.function_name = f"{user_cls.__name__}.*"
+            self.implementation_name = f"{user_cls.__name__}.*"
         elif f and user_cls:
             # Method may be defined on superclass of the wrapped class
-            self.function_name = f"{user_cls.__name__}.{f.__name__}"
+            self.implementation_name = f"{user_cls.__name__}.{f.__name__}"
         else:
-            self.function_name = f.__qualname__
+            self.implementation_name = f.__qualname__
+
+        self.function_name = name_override or self.implementation_name
 
         # If it's a cls, the @method could be defined in a base class in a different file.
         if user_cls is not None:

{modal-1.2.5.dev14 → modal-1.2.5.dev16}/modal/app.py

@@ -1098,6 +1098,13 @@ class _App:
                     "The `@modal.http_server` decorator cannot be used on methods; decorate the class instead."
                 )
 
+            if http_config is not None:
+                for method in _find_partial_methods_for_user_cls(
+                    user_cls, _PartialFunctionFlags.CALLABLE_INTERFACE
+                ).values():
+                    method.registered = True  # Avoid warning about not registering the method (hacky!)
+                    raise InvalidError("Callable decorators cannot be combined with web interface decorators.")
+
             info = FunctionInfo(None, serialized=serialized, user_cls=user_cls)
 
             i6pn_enabled = i6pn or cluster_size is not None

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

{modal-1.2.5.dev14 → modal-1.2.5.dev16}/modal/experimental/flash.py

@@ -32,6 +32,7 @@ class _FlashManager:
         process: Optional[subprocess.Popen] = None,  # to be deprecated
         health_check_url: Optional[str] = None,
         startup_timeout: int = 30,
+        exit_grace_period: int = 0,
         h2_enabled: bool = False,
     ):
         self.client = client
@@ -40,6 +41,7 @@ class _FlashManager:
         # Health check is not currently being used
         self.health_check_url = health_check_url
         self.startup_timeout = startup_timeout
+        self.exit_grace_period = exit_grace_period
         self.tunnel_manager = _forward_tunnel(port, h2_enabled=h2_enabled, client=client)
         self.stopped = False
         self.num_failures = 0
@@ -158,9 +160,12 @@ class _FlashManager:
         return self.tunnel.url
 
     async def stop(self):
-        self.heartbeat_task.cancel()
-        await self.client.stub.FlashContainerDeregister(api_pb2.FlashContainerDeregisterRequest())
+        try:
+            self.heartbeat_task.cancel()
+        except Exception as e:
+            logger.error(f"[Modal Flash] Error stopping: {e}")
 
+        await self.client.stub.FlashContainerDeregister(api_pb2.FlashContainerDeregisterRequest())
         self.stopped = True
         logger.warning(f"[Modal Flash] No longer accepting new requests on {self.tunnel.url}.")
 
@@ -171,19 +176,22 @@ class _FlashManager:
         if not self.stopped:
             await self.stop()
 
+        await asyncio.sleep(self.exit_grace_period)
+
         logger.warning(f"[Modal Flash] Closing tunnel on {self.tunnel.url}.")
         await self.tunnel_manager.__aexit__(*sys.exc_info())
 
 
-FlashManager = synchronize_api(_FlashManager)
+FlashManager = synchronize_api(_FlashManager, target_module=__name__)
 
 
 @synchronizer.create_blocking
 async def flash_forward(
     port: int,
-    process: Optional[subprocess.Popen] = None,
+    process: Optional[subprocess.Popen] = None,  # to be deprecated
     health_check_url: Optional[str] = None,
     startup_timeout: int = 30,
+    exit_grace_period: int = 0,
     h2_enabled: bool = False,
 ) -> _FlashManager:
     """
@@ -199,6 +207,7 @@ async def flash_forward(
         process=process,
         health_check_url=health_check_url,
         startup_timeout=startup_timeout,
+        exit_grace_period=exit_grace_period,
         h2_enabled=h2_enabled,
     )
     await manager._start()
@@ -692,3 +701,33 @@ def _http_server(
 
 
 http_server = synchronize_api(_http_server, target_module=__name__)
+
+
+class _FlashContainerEntry:
+    """
+    A class that manages the lifecycle of Flash manager for Flash containers.
+
+    It is intentional that stop() runs before exit handlers and close().
+    This ensures the container is deregistered first, preventing new requests from being routed to it
+    while exit handlers execute and the exit grace period elapses, before finally closing the tunnel.
+    """
+
+    def __init__(self, http_config: api_pb2.HTTPConfig):
+        self.http_config: api_pb2.HTTPConfig = http_config
+        self.flash_manager: Optional[FlashManager] = None  # type: ignore
+
+    def enter(self):
+        if self.http_config != api_pb2.HTTPConfig():
+            self.flash_manager = flash_forward(
+                self.http_config.port,
+                startup_timeout=self.http_config.startup_timeout,
+                exit_grace_period=self.http_config.exit_grace_period,
+            )
+
+    def stop(self):
+        if self.flash_manager:
+            self.flash_manager.stop()
+
+    def close(self):
+        if self.flash_manager:
+            self.flash_manager.close()

{modal-1.2.5.dev14 → modal-1.2.5.dev16}/modal/experimental/flash.pyi

@@ -1,4 +1,5 @@
 import modal.client
+import modal_proto.api_pb2
 import subprocess
 import typing
 import typing_extensions
@@ -11,6 +12,7 @@ class _FlashManager:
         process: typing.Optional[subprocess.Popen] = None,
         health_check_url: typing.Optional[str] = None,
         startup_timeout: int = 30,
+        exit_grace_period: int = 0,
         h2_enabled: bool = False,
     ):
         """Initialize self.  See help(type(self)) for accurate signature."""
@@ -39,6 +41,7 @@ class FlashManager:
         process: typing.Optional[subprocess.Popen] = None,
         health_check_url: typing.Optional[str] = None,
         startup_timeout: int = 30,
+        exit_grace_period: int = 0,
         h2_enabled: bool = False,
     ): ...
 
@@ -97,6 +100,7 @@ class __flash_forward_spec(typing_extensions.Protocol):
         process: typing.Optional[subprocess.Popen] = None,
         health_check_url: typing.Optional[str] = None,
         startup_timeout: int = 30,
+        exit_grace_period: int = 0,
         h2_enabled: bool = False,
     ) -> FlashManager:
         """Forward a port to the Modal Flash service, exposing that port as a stable web endpoint.
@@ -112,6 +116,7 @@ class __flash_forward_spec(typing_extensions.Protocol):
         process: typing.Optional[subprocess.Popen] = None,
         health_check_url: typing.Optional[str] = None,
         startup_timeout: int = 30,
+        exit_grace_period: int = 0,
         h2_enabled: bool = False,
     ) -> FlashManager:
         """Forward a port to the Modal Flash service, exposing that port as a stable web endpoint.
@@ -420,3 +425,18 @@ def http_server(
         exit_grace_period: The time to wait for the HTTP server to exit gracefully.
     """
     ...
+
+class _FlashContainerEntry:
+    """A class that manages the lifecycle of Flash manager for Flash containers.
+
+    It is intentional that stop() runs before exit handlers and close().
+    This ensures the container is deregistered first, preventing new requests from being routed to it
+    while exit handlers execute and the exit grace period elapses, before finally closing the tunnel.
+    """
+    def __init__(self, http_config: modal_proto.api_pb2.HTTPConfig):
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    def enter(self): ...
+    def stop(self): ...
+    def close(self): ...

{modal-1.2.5.dev14 → modal-1.2.5.dev16}/modal/functions.pyi

@@ -409,7 +409,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."""
             ...
@@ -418,7 +418,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]:
@@ -445,7 +445,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.
 
@@ -469,7 +469,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]):
@@ -478,7 +478,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.
 
@@ -499,7 +499,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.dev14 → modal-1.2.5.dev16}/modal.egg-info/PKG-INFO

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

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