modal 1.1.4.dev30__tar.gz → 1.1.5.dev0__tar.gz

{modal-1.1.4.dev30 → modal-1.1.5.dev0}/PKG-INFO

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

{modal-1.1.4.dev30 → modal-1.1.5.dev0}/modal/client.pyi

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

{modal-1.1.4.dev30 → modal-1.1.5.dev0}/modal/experimental/__init__.py

@@ -317,14 +317,11 @@ async def notebook_base_image(*, python_version: Optional[str] = None, force_bui
         # Install uv since it's faster than pip for installing packages.
         "pip install uv",
         # https://github.com/astral-sh/uv/issues/11480
-        "pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu126",
+        "pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu129",
         f"uv pip install --system {shlex.join(sorted(environment_packages))}",
         f"uv pip install --system {shlex.join(sorted(kernelshim_packages))}",
     ]
 
-    # TODO: Also install the CUDA Toolkit, so `nvcc` is available.
-    # https://github.com/charlesfrye/cuda-modal/blob/7fef8db12402986cf42d9c8cca8c63d1da6d7700/cuda/use_cuda.py#L158-L188
-
     def build_dockerfile(version: ImageBuilderVersion) -> DockerfileSpec:
         return DockerfileSpec(
             commands=[

{modal-1.1.4.dev30 → modal-1.1.5.dev0}/modal/experimental/flash.py

@@ -1,6 +1,8 @@
 # Copyright Modal Labs 2025
 import asyncio
 import math
+import os
+import subprocess
 import sys
 import time
 import traceback
@@ -19,28 +21,87 @@ from ..client import _Client
 from ..config import logger
 from ..exception import InvalidError
 
+MAX_FAILURES = 3
+
 
 class _FlashManager:
-    def __init__(self, client: _Client, port: int, health_check_url: Optional[str] = None):
+    def __init__(
+        self,
+        client: _Client,
+        port: int,
+        process: Optional[subprocess.Popen] = None,
+        health_check_url: Optional[str] = None,
+    ):
         self.client = client
         self.port = port
+        # Health check is not currently being used
         self.health_check_url = health_check_url
+        self.process = process
         self.tunnel_manager = _forward_tunnel(port, client=client)
         self.stopped = False
+        self.num_failures = 0
+        self.task_id = os.environ["MODAL_TASK_ID"]
+
+    async def check_port_connection(self, process: Optional[subprocess.Popen], timeout: int = 10):
+        import socket
+
+        start_time = time.monotonic()
+
+        while time.monotonic() - start_time < timeout:
+            try:
+                if process is not None and process.poll() is not None:
+                    return Exception(f"Process {process.pid} exited with code {process.returncode}")
+                with socket.create_connection(("localhost", self.port), timeout=1):
+                    return
+            except (ConnectionRefusedError, OSError):
+                await asyncio.sleep(0.1)
+
+        return Exception(f"Waited too long for port {self.port} to start accepting connections")
 
     async def _start(self):
         self.tunnel = await self.tunnel_manager.__aenter__()
-
         parsed_url = urlparse(self.tunnel.url)
         host = parsed_url.hostname
         port = parsed_url.port or 443
 
         self.heartbeat_task = asyncio.create_task(self._run_heartbeat(host, port))
+        self.drain_task = asyncio.create_task(self._drain_container())
+
+    async def _drain_container(self):
+        """
+        Background task that checks if we've encountered too many failures and drains the container if so.
+        """
+        while True:
+            try:
+                # Check if the container should be drained (e.g., too many failures)
+                if self.num_failures > MAX_FAILURES:
+                    logger.warning(
+                        f"[Modal Flash] Draining task {self.task_id} on {self.tunnel.url} due to too many failures."
+                    )
+                    await self.stop()
+                    # handle close upon container exit
+
+                    if self.task_id:
+                        await self.client.stub.ContainerStop(api_pb2.ContainerStopRequest(task_id=self.task_id))
+                    return
+            except asyncio.CancelledError:
+                logger.warning("[Modal Flash] Shutting down...")
+                return
+            except Exception as e:
+                logger.error(f"[Modal Flash] Error draining container: {e}")
+                await asyncio.sleep(1)
+
+            try:
+                await asyncio.sleep(1)
+            except asyncio.CancelledError:
+                logger.warning("[Modal Flash] Shutting down...")
+                return
 
     async def _run_heartbeat(self, host: str, port: int):
         first_registration = True
         while True:
             try:
+                await self.check_port_connection(process=self.process)
                 resp = await self.client.stub.FlashContainerRegister(
                     api_pb2.FlashContainerRegisterRequest(
                         priority=10,
@@ -50,14 +111,25 @@ class _FlashManager:
                     ),
                     timeout=10,
                 )
+                self.num_failures = 0
                 if first_registration:
-                    logger.warning(f"[Modal Flash] Listening at {resp.url} over {self.tunnel.url}")
+                    logger.warning(
+                        f"[Modal Flash] Listening at {resp.url} over {self.tunnel.url} for task_id {self.task_id}"
+                    )
                     first_registration = False
             except asyncio.CancelledError:
                 logger.warning("[Modal Flash] Shutting down...")
                 break
             except Exception as e:
                 logger.error(f"[Modal Flash] Heartbeat failed: {e}")
+                self.num_failures += 1
+                logger.error(
+                    f"[Modal Flash] Deregistering container {self.tunnel.url}, num_failures: {self.num_failures}"
+                )
+                await retry_transient_errors(
+                    self.client.stub.FlashContainerDeregister,
+                    api_pb2.FlashContainerDeregisterRequest(),
+                )
 
             try:
                 await asyncio.sleep(1)
@@ -94,16 +166,17 @@ FlashManager = synchronize_api(_FlashManager)
 
 
 @synchronizer.create_blocking
-async def flash_forward(port: int, health_check_url: Optional[str] = None) -> _FlashManager:
+async def flash_forward(
+    port: int, process: Optional[subprocess.Popen] = None, health_check_url: Optional[str] = None
+) -> _FlashManager:
     """
     Forward a port to the Modal Flash service, exposing that port as a stable web endpoint.
-
     This is a highly experimental method that can break or be removed at any time without warning.
     Do not use this method unless explicitly instructed to do so by Modal support.
     """
     client = await _Client.from_env()
 
-    manager = _FlashManager(client, port, health_check_url)
+    manager = _FlashManager(client, port, process=process, health_check_url=health_check_url)
     await manager._start()
     return manager
 
@@ -127,6 +200,8 @@ class _FlashPrometheusAutoscaler:
         scale_down_stabilization_window_seconds: int,
         autoscaling_interval_seconds: int,
     ):
+        import aiohttp
+
         if scale_up_stabilization_window_seconds > self._max_window_seconds:
             raise InvalidError(
                 f"scale_up_stabilization_window_seconds must be less than or equal to {self._max_window_seconds}"
@@ -138,8 +213,6 @@ class _FlashPrometheusAutoscaler:
         if target_metric_value <= 0:
             raise InvalidError("target_metric_value must be greater than 0")
 
-        import aiohttp
-
         self.client = client
         self.app_name = app_name
         self.cls_name = cls_name

{modal-1.1.4.dev30 → modal-1.1.5.dev0}/modal/experimental/flash.pyi

@@ -1,14 +1,26 @@
 import modal.client
 import modal_proto.api_pb2
+import subprocess
 import typing
 import typing_extensions
 
 class _FlashManager:
-    def __init__(self, client: modal.client._Client, port: int, health_check_url: typing.Optional[str] = None):
+    def __init__(
+        self,
+        client: modal.client._Client,
+        port: int,
+        process: typing.Optional[subprocess.Popen] = None,
+        health_check_url: typing.Optional[str] = None,
+    ):
         """Initialize self.  See help(type(self)) for accurate signature."""
         ...
 
+    async def check_port_connection(self, process: typing.Optional[subprocess.Popen], timeout: int = 10): ...
     async def _start(self): ...
+    async def _drain_container(self):
+        """Background task that checks if we've encountered too many failures and drains the container if so."""
+        ...
+
     async def _run_heartbeat(self, host: str, port: int): ...
     def get_container_url(self): ...
     async def stop(self): ...
@@ -17,7 +29,19 @@ class _FlashManager:
 SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
 
 class FlashManager:
-    def __init__(self, client: modal.client.Client, port: int, health_check_url: typing.Optional[str] = None): ...
+    def __init__(
+        self,
+        client: modal.client.Client,
+        port: int,
+        process: typing.Optional[subprocess.Popen] = None,
+        health_check_url: typing.Optional[str] = None,
+    ): ...
+
+    class __check_port_connection_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /, process: typing.Optional[subprocess.Popen], timeout: int = 10): ...
+        async def aio(self, /, process: typing.Optional[subprocess.Popen], timeout: int = 10): ...
+
+    check_port_connection: __check_port_connection_spec[typing_extensions.Self]
 
     class ___start_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /): ...
@@ -25,6 +49,17 @@ class FlashManager:
 
     _start: ___start_spec[typing_extensions.Self]
 
+    class ___drain_container_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /):
+            """Background task that checks if we've encountered too many failures and drains the container if so."""
+            ...
+
+        async def aio(self, /):
+            """Background task that checks if we've encountered too many failures and drains the container if so."""
+            ...
+
+    _drain_container: ___drain_container_spec[typing_extensions.Self]
+
     class ___run_heartbeat_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /, host: str, port: int): ...
         async def aio(self, /, host: str, port: int): ...
@@ -46,17 +81,27 @@ class FlashManager:
     close: __close_spec[typing_extensions.Self]
 
 class __flash_forward_spec(typing_extensions.Protocol):
-    def __call__(self, /, port: int, health_check_url: typing.Optional[str] = None) -> FlashManager:
+    def __call__(
+        self,
+        /,
+        port: int,
+        process: typing.Optional[subprocess.Popen] = None,
+        health_check_url: typing.Optional[str] = None,
+    ) -> FlashManager:
         """Forward a port to the Modal Flash service, exposing that port as a stable web endpoint.
-
         This is a highly experimental method that can break or be removed at any time without warning.
         Do not use this method unless explicitly instructed to do so by Modal support.
         """
         ...
 
-    async def aio(self, /, port: int, health_check_url: typing.Optional[str] = None) -> FlashManager:
+    async def aio(
+        self,
+        /,
+        port: int,
+        process: typing.Optional[subprocess.Popen] = None,
+        health_check_url: typing.Optional[str] = None,
+    ) -> FlashManager:
         """Forward a port to the Modal Flash service, exposing that port as a stable web endpoint.
-
         This is a highly experimental method that can break or be removed at any time without warning.
         Do not use this method unless explicitly instructed to do so by Modal support.
         """

{modal-1.1.4.dev30 → modal-1.1.5.dev0}/modal/functions.pyi

@@ -445,7 +445,7 @@ class Function(
 
     _call_generator: ___call_generator_spec[typing_extensions.Self]
 
-    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_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."""
             ...
@@ -454,7 +454,7 @@ class Function(
             """Calls the function remotely, executing it with the given arguments and returning the execution's result."""
             ...
 
-    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
+    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
 
     class __remote_gen_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -481,7 +481,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_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.
 
@@ -505,7 +505,7 @@ class Function(
             ...
 
     _experimental_spawn: ___experimental_spawn_spec[
-        modal._functions.ReturnType, modal._functions.P, typing_extensions.Self
+        modal._functions.P, modal._functions.ReturnType, typing_extensions.Self
     ]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER, SUPERSELF]):
@@ -514,7 +514,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P, typing_extensions.Self]
 
-    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_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.
 
@@ -535,7 +535,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
+    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType, 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.1.4.dev30 → modal-1.1.5.dev0}/modal.egg-info/PKG-INFO

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

{modal-1.1.4.dev30 → modal-1.1.5.dev0}/modal_version/__init__.py

@@ -1,4 +1,4 @@
 # Copyright Modal Labs 2025
 """Supplies the current version of the modal client library."""
 
-__version__ = "1.1.4.dev30"
+__version__ = "1.1.5.dev0"