modal 1.1.4.dev29__tar.gz → 1.1.4.dev33__tar.gz

{modal-1.1.4.dev29 → modal-1.1.4.dev33}/PKG-INFO

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

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

{modal-1.1.4.dev29 → modal-1.1.4.dev33}/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.dev29 → modal-1.1.4.dev33}/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.dev29 → modal-1.1.4.dev33}/modal/sandbox.py

@@ -24,6 +24,7 @@ from ._utils.async_utils import TaskContext, synchronize_api
 from ._utils.deprecation import deprecation_warning
 from ._utils.grpc_utils import retry_transient_errors
 from ._utils.mount_utils import validate_network_file_systems, validate_volumes
+from ._utils.name_utils import is_valid_object_name
 from .client import _Client
 from .config import config
 from .container_process import _ContainerProcess
@@ -73,6 +74,16 @@ def _validate_exec_args(args: Sequence[str]) -> None:
         )
 
 
+def _warn_if_invalid_name(name: str) -> None:
+    if not is_valid_object_name(name):
+        deprecation_warning(
+            (2025, 9, 3),
+            f"Sandbox name '{name}' will be considered invalid in a future release."
+            "\n\nNames may contain only alphanumeric characters, dashes, periods, and underscores,"
+            " must be shorter than 64 characters, and cannot conflict with App ID strings.",
+        )
+
+
 class DefaultSandboxNameOverride(str):
     """A singleton class that represents the default sandbox name override.
 
@@ -404,6 +415,8 @@ class _Sandbox(_Object, type_prefix="sb"):
         from .app import _App
 
         _validate_exec_args(args)
+        if name is not None:
+            _warn_if_invalid_name(name)
 
         if block_network and (encrypted_ports or h2_ports or unencrypted_ports):
             raise InvalidError("Cannot specify open ports when `block_network` is enabled")
@@ -787,6 +800,9 @@ class _Sandbox(_Object, type_prefix="sb"):
     ):
         client = client or await _Client.from_env()
 
+        if name is not None and name != _DEFAULT_SANDBOX_NAME_OVERRIDE:
+            _warn_if_invalid_name(name)
+
         if name is _DEFAULT_SANDBOX_NAME_OVERRIDE:
             restore_req = api_pb2.SandboxRestoreRequest(
                 snapshot_id=snapshot.object_id,

{modal-1.1.4.dev29 → modal-1.1.4.dev33}/modal/sandbox.pyi

@@ -26,6 +26,7 @@ import typing
 import typing_extensions
 
 def _validate_exec_args(args: collections.abc.Sequence[str]) -> None: ...
+def _warn_if_invalid_name(name: str) -> None: ...
 
 class DefaultSandboxNameOverride(str):
     """A singleton class that represents the default sandbox name override.

{modal-1.1.4.dev29 → modal-1.1.4.dev33}/modal.egg-info/PKG-INFO

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

{modal-1.1.4.dev29 → modal-1.1.4.dev33}/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.dev29"
+__version__ = "1.1.4.dev33"