modal 1.3.1.dev35__tar.gz → 1.3.2.dev0__tar.gz

{modal-1.3.1.dev35 → modal-1.3.2.dev0}/PKG-INFO

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

{modal-1.3.1.dev35 → modal-1.3.2.dev0}/modal/_server.py

@@ -84,7 +84,7 @@ class _Server:
 
         return {
             _extract_region_from_url(url): url
-            for url in await self._get_service_function()._experimental_get_flash_urls()
+            for url in await self._get_service_function()._experimental_get_flash_urls() or []
         }
 
     @live_method

{modal-1.3.1.dev35 → modal-1.3.2.dev0}/modal/_utils/task_command_router_client.py

@@ -15,7 +15,7 @@ import grpclib.events
 from grpclib import GRPCError, Status
 from grpclib.exceptions import StreamTerminatedError
 
-from modal.config import config, logger
+from modal.config import logger
 from modal.exception import ConflictError, ExecTimeoutError
 from modal_proto import api_pb2, task_command_router_pb2 as sr_pb2
 from modal_proto.task_command_router_grpc import TaskCommandRouterStub
@@ -152,8 +152,8 @@ class TaskCommandRouterClient:
         ssl_context = ssl.create_default_context()
 
         # Allow insecure TLS when explicitly enabled via config.
-        if config["task_command_router_insecure"]:
-            logger.warning("Using insecure TLS for task command router due to MODAL_TASK_COMMAND_ROUTER_INSECURE")
+        if server_client._is_localhost:
+            logger.warning("Using insecure TLS for task command router because server client points to localhost")
             ssl_context.check_hostname = False
             ssl_context.verify_mode = ssl.CERT_NONE
 

{modal-1.3.1.dev35 → modal-1.3.2.dev0}/modal/cli/token.py

@@ -87,6 +87,8 @@ async def info():
         console.print(f"[dim](Using {env_vars_str} environment variable{plural})[/dim]")
 
     console.print(f"[bold]Token:[/bold] {resp.token_id}")
+    if resp.token_name:
+        console.print(f"[bold]Name:[/bold] {resp.token_name}")
     console.print(f"[bold]Workspace:[/bold] {resp.workspace_name} [dim]({resp.workspace_id})[/dim]")
 
     if resp.HasField("user_identity"):

{modal-1.3.1.dev35 → modal-1.3.2.dev0}/modal/client.py

@@ -100,6 +100,12 @@ class _Client:
     def is_closed(self) -> bool:
         return self._closed
 
+    @property
+    def _is_localhost(self) -> bool:
+        """Returns True if the server URL points to localhost."""
+        hostname = urllib.parse.urlparse(self.server_url).hostname
+        return hostname in {"localhost", "127.0.0.1", "::1", "172.21.0.1"}
+
     @property
     def stub(self) -> modal_api_grpc.ModalClientModal:
         """mdmd:hidden

{modal-1.3.1.dev35 → modal-1.3.2.dev0}/modal/client.pyi

@@ -35,7 +35,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.3.1.dev35",
+        version: str = "1.3.2.dev0",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -43,6 +43,11 @@ class _Client:
         ...
 
     def is_closed(self) -> bool: ...
+    @property
+    def _is_localhost(self) -> bool:
+        """Returns True if the server URL points to localhost."""
+        ...
+
     @property
     def stub(self) -> modal_proto.modal_api_grpc.ModalClientModal:
         """mdmd:hidden
@@ -166,7 +171,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.3.1.dev35",
+        version: str = "1.3.2.dev0",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -174,6 +179,11 @@ class Client:
         ...
 
     def is_closed(self) -> bool: ...
+    @property
+    def _is_localhost(self) -> bool:
+        """Returns True if the server URL points to localhost."""
+        ...
+
     @property
     def stub(self) -> modal_proto.modal_api_grpc.ModalClientModal:
         """mdmd:hidden

{modal-1.3.1.dev35 → modal-1.3.2.dev0}/modal/cls.py

@@ -99,21 +99,27 @@ class _ServiceOptions:
         """Implement protobuf-like MergeFrom semantics for this dataclass.
 
         This mostly exists to support "stacking" of `.with_options()` calls.
+        Returns a new _ServiceOptions instance without modifying self.
         """
+        # Create a shallow copy of self to start with
+        merged = dataclasses.replace(self)
+
         # Don't use dataclasses.asdict() because it does a deepcopy(), which chokes on a hydrated object
         new_options_dict = {k.name: getattr(new_options, k.name) for k in dataclasses.fields(new_options)}
 
         # Resources needs special merge handling because individual fields are parameters in the public API
         merged_resources = api_pb2.Resources()
-        if self.resources:
-            merged_resources.MergeFrom(self.resources)
+        if merged.resources:
+            merged_resources.MergeFrom(merged.resources)
         if new_resources := new_options_dict.pop("resources"):
             merged_resources.MergeFrom(new_resources)
-        self.resources = merged_resources
+        merged.resources = merged_resources
 
         for key, value in new_options_dict.items():
             if value:  # Only overwrite data when the value was set in the new options
-                setattr(self, key, value)
+                setattr(merged, key, value)
+
+        return merged
 
 
 def _bind_instance_method(cls: "_Cls", service_function: _Function, method_name: str):
@@ -743,32 +749,6 @@ More information on class parameterization can be found here: https://modal.com/
                 " please use the `.with_concurrency` method instead.",
             )
 
-        async def _load_from_base(new_cls, resolver, load_context, existing_object_id):
-            # this is a bit confusing, the cls will always have the same metadata
-            # since it has the same *class* service function (i.e. "template")
-            # But the (instance) service function for each Obj will be different
-            # since it will rebind to whatever `_options` have been assigned on
-            # the particular Cls parent
-            if not self.is_hydrated:
-                # this should only happen for Cls.from_name instances
-                # other classes should already be hydrated!
-                await resolver.load(self, load_context)
-
-            new_cls._initialize_from_other(self)
-
-        def _deps():
-            return []
-
-        cls = _Cls._from_loader(
-            _load_from_base,
-            rep=f"{self._name}.with_options(...)",
-            is_another_app=True,
-            deps=_deps,
-            load_context_overrides=self._load_context_overrides,
-            hydrate_lazily=True,
-        )
-        cls._initialize_from_other(self)
-
         # Validate volumes
         validated_volumes = validate_volumes(volumes)
         cloud_bucket_mounts = [(k, v) for k, v in validated_volumes if isinstance(v, _CloudBucketMount)]
@@ -801,8 +781,37 @@ More information on class parameterization can be found here: https://modal.com/
             target_concurrent_inputs=allow_concurrent_inputs,
         )
 
-        cls._options.merge_options(new_options)
-        return cls
+        combined_options = self._options.merge_options(new_options)
+
+        async def _load_from_base(new_cls, resolver, load_context, existing_object_id):
+            # this is a bit confusing, the cls will always have the same metadata
+            # since it has the same *class* service function (i.e. "template")
+            # But the (instance) service function for each Obj will be different
+            # since it will rebind to whatever `_options` have been assigned on
+            # the particular Cls parent
+            if not self.is_hydrated:
+                # this should only happen for Cls.from_name instances
+                # other classes should already be hydrated!
+                await resolver.load(self, load_context)
+
+            new_cls._initialize_from_other(self)
+            # Restore the merged options after _initialize_from_other overwrites them
+            new_cls._options = combined_options
+
+        def _deps():
+            return []
+
+        new_cls = _Cls._from_loader(
+            _load_from_base,
+            rep=f"{self._name}.with_options(...)",
+            is_another_app=True,
+            deps=_deps,
+            load_context_overrides=self._load_context_overrides,
+            hydrate_lazily=True,
+        )
+        new_cls._initialize_from_other(self)
+        new_cls._options = combined_options
+        return new_cls
 
     def with_concurrency(self: "_Cls", *, max_inputs: int, target_inputs: Optional[int] = None) -> "_Cls":
         """Create an instance of the Cls with input concurrency enabled or overridden with new values.
@@ -815,16 +824,20 @@ More information on class parameterization can be found here: https://modal.com/
         ModelUsingGPU().generate.remote(42)  # will run on an A100 GPU with input concurrency enabled
         ```
         """
+        concurrency_options = _ServiceOptions(max_concurrent_inputs=max_inputs, target_concurrent_inputs=target_inputs)
+        combined_options = self._options.merge_options(concurrency_options)
 
         async def _load_from_base(new_cls, resolver, load_context, existing_object_id):
             if not self.is_hydrated:
                 await resolver.load(self, load_context)
             new_cls._initialize_from_other(self)
+            # Restore the merged options after _initialize_from_other overwrites them
+            new_cls._options = combined_options
 
         def _deps():
             return []
 
-        cls = _Cls._from_loader(
+        new_cls = _Cls._from_loader(
             _load_from_base,
             rep=f"{self._name}.with_concurrency(...)",
             is_another_app=True,
@@ -832,11 +845,9 @@ More information on class parameterization can be found here: https://modal.com/
             load_context_overrides=self._load_context_overrides,
             hydrate_lazily=True,
         )
-        cls._initialize_from_other(self)
-
-        concurrency_options = _ServiceOptions(max_concurrent_inputs=max_inputs, target_concurrent_inputs=target_inputs)
-        cls._options.merge_options(concurrency_options)
-        return cls
+        new_cls._initialize_from_other(self)
+        new_cls._options = combined_options
+        return new_cls
 
     def with_batching(self: "_Cls", *, max_batch_size: int, wait_ms: int) -> "_Cls":
         """Create an instance of the Cls with dynamic batching enabled or overridden with new values.
@@ -849,16 +860,20 @@ More information on class parameterization can be found here: https://modal.com/
         ModelUsingGPU().generate.remote(42)  # will run on an A100 GPU with input concurrency enabled
         ```
         """
+        batching_options = _ServiceOptions(batch_max_size=max_batch_size, batch_wait_ms=wait_ms)
+        combined_options = self._options.merge_options(batching_options)
 
         async def _load_from_base(new_cls, resolver, load_context, existing_object_id):
             if not self.is_hydrated:
                 await resolver.load(self, load_context)
             new_cls._initialize_from_other(self)
+            # Restore the merged options after _initialize_from_other overwrites them
+            new_cls._options = combined_options
 
         def _deps():
             return []
 
-        cls = _Cls._from_loader(
+        new_cls = _Cls._from_loader(
             _load_from_base,
             rep=f"{self._name}.with_batching(...)",
             is_another_app=True,
@@ -866,11 +881,9 @@ More information on class parameterization can be found here: https://modal.com/
             load_context_overrides=self._load_context_overrides,
             hydrate_lazily=True,
         )
-        cls._initialize_from_other(self)
-
-        batching_options = _ServiceOptions(batch_max_size=max_batch_size, batch_wait_ms=wait_ms)
-        cls._options.merge_options(batching_options)
-        return cls
+        new_cls._initialize_from_other(self)
+        new_cls._options = combined_options
+        return new_cls
 
     @synchronizer.no_input_translation
     def __call__(self, *args, **kwargs) -> _Obj:

{modal-1.3.1.dev35 → modal-1.3.2.dev0}/modal/cls.pyi

@@ -47,6 +47,7 @@ class _ServiceOptions:
         """Implement protobuf-like MergeFrom semantics for this dataclass.
 
         This mostly exists to support "stacking" of `.with_options()` calls.
+        Returns a new _ServiceOptions instance without modifying self.
         """
         ...
 

{modal-1.3.1.dev35 → modal-1.3.2.dev0}/modal/config.py

@@ -251,8 +251,6 @@ _SETTINGS = {
     "traceback": _Setting(False, transform=_to_boolean),
     "image_builder_version": _Setting(),
     "strict_parameters": _Setting(False, transform=_to_boolean),  # For internal/experimental use
-    # Allow insecure TLS for the task command router when running locally (testing/dev only)
-    "task_command_router_insecure": _Setting(False, transform=_to_boolean),
     "snapshot_debug": _Setting(False, transform=_to_boolean),
     "cuda_checkpoint_path": _Setting("/__modal/.bin/cuda-checkpoint"),  # Used for snapshotting GPU memory.
     "build_validation": _Setting("error", transform=_check_value(["error", "warn", "ignore"])),

{modal-1.3.1.dev35 → modal-1.3.2.dev0}/modal/experimental/flash.py

@@ -15,6 +15,7 @@ from modal.cls import _Cls
 from modal.dict import _Dict
 from modal_proto import api_pb2
 
+from .._runtime.container_io_manager import UserException
 from .._server import validate_http_server_config
 from .._tunnel import _forward as _forward_tunnel
 from .._utils.async_utils import synchronize_api, synchronizer
@@ -45,14 +46,12 @@ class _FlashManager:
         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
+        self.num_heartbeat_failures = 0
         self.task_id = os.environ["MODAL_TASK_ID"]
 
     async def is_port_connection_healthy(
         self, process: Optional[subprocess.Popen], timeout: float = 0.5
     ) -> tuple[bool, Optional[Exception]]:
-        import socket
-
         start_time = time.monotonic()
 
         def check_process_is_running() -> Optional[Exception]:
@@ -64,10 +63,16 @@ class _FlashManager:
             try:
                 if error := check_process_is_running():
                     return False, error
-                # TODO(claudia): use asyncio socket create connection
-                with socket.create_connection(("localhost", self.port), timeout=0.5):
-                    return True, None
-            except (ConnectionRefusedError, OSError):
+                _, writer = await asyncio.wait_for(asyncio.open_connection("localhost", self.port), timeout=0.5)
+                try:
+                    writer.close()
+                    await writer.wait_closed()
+                except Exception:
+                    pass
+                return True, None
+            except asyncio.CancelledError:
+                raise
+            except (OSError, asyncio.TimeoutError):
                 await asyncio.sleep(0.1)
 
         return False, Exception(f"Waited too long for port {self.port} to start accepting connections")
@@ -78,9 +83,25 @@ class _FlashManager:
         host = parsed_url.hostname
         port = parsed_url.port or 443
 
+        try:
+            await self._wait_for_port_success(host, port)
+        except (Exception, KeyboardInterrupt, asyncio.CancelledError):
+            await self._deregister()
+            await self.tunnel_manager.__aexit__(*sys.exc_info())
+            raise
+
         self.heartbeat_task = asyncio.create_task(self._run_heartbeat(host, port))
         self.drain_task = asyncio.create_task(self._drain_container())
 
+    async def _deregister(self):
+        await asyncio.shield(
+            self.client.stub.FlashContainerDeregister(
+                api_pb2.FlashContainerDeregisterRequest(),
+                timeout=2,
+                retry=None,
+            )
+        )
+
     async def _drain_container(self):
         """
         Background task that checks if we've encountered too many failures and drains the container if so.
@@ -88,7 +109,7 @@ class _FlashManager:
         while True:
             try:
                 # Check if the container should be drained (e.g., too many failures)
-                if self.num_failures > _MAX_FAILURES:
+                if self.num_heartbeat_failures > _MAX_FAILURES:
                     logger.warning(
                         f"[Modal Flash] Draining task {self.task_id} on {self.tunnel.url} due to too many failures."
                     )
@@ -111,9 +132,37 @@ class _FlashManager:
                 logger.warning("[Modal Flash] Shutting down...")
                 return
 
-    async def _run_heartbeat(self, host: str, port: int):
-        first_registration = True
+    async def _wait_for_port_success(self, host: str, port: int) -> bool:
         start_time = time.monotonic()
+        while time.monotonic() - start_time < self.startup_timeout:
+            try:
+                port_check_resp, _ = await self.is_port_connection_healthy(process=self.process)
+                if port_check_resp:
+                    resp = await self.client.stub.FlashContainerRegister(
+                        api_pb2.FlashContainerRegisterRequest(
+                            priority=10,
+                            weight=5,
+                            host=host,
+                            port=port,
+                        ),
+                        timeout=10,
+                        retry=None,
+                    )
+                    logger.info(f"Listening at {resp.url} over {self.tunnel.url} for task_id {self.task_id}")
+                    return True
+            except asyncio.CancelledError:
+                logger.warning("Waited too long for port to start accepting connections. Shutting down...")
+                raise
+            except Exception as e:
+                logger.error(f"Error waiting for port to start accepting connections: {e}")
+            try:
+                await asyncio.sleep(1)
+            except asyncio.CancelledError:
+                logger.warning("Waited too long for port to start accepting connections. Shutting down...")
+                raise
+        raise TimeoutError("Waited too long for port to start accepting connections. Shutting down...")
+
+    async def _run_heartbeat(self, host: str, port: int):
         while True:
             try:
                 port_check_resp, port_check_error = await self.is_port_connection_healthy(process=self.process)
@@ -128,32 +177,24 @@ class _FlashManager:
                         timeout=10,
                         retry=None,
                     )
-                    self.num_failures = 0
-                    if first_registration:
-                        logger.warning(
-                            f"[Modal Flash] Listening at {resp.url} over {self.tunnel.url} for task_id {self.task_id}"
-                        )
-                        first_registration = False
+                    self.num_heartbeat_failures = 0
                 else:
-                    if first_registration and (time.monotonic() - start_time < self.startup_timeout):
-                        continue
-                    else:
-                        logger.error(
-                            f"[Modal Flash] Deregistering container {self.task_id} on {self.tunnel.url} "
-                            f"due to error: {port_check_error}, num_failures: {self.num_failures}"
-                        )
-                        self.num_failures += 1
-                        await self.client.stub.FlashContainerDeregister(api_pb2.FlashContainerDeregisterRequest())
+                    logger.error(
+                        f"[Modal Flash] Deregistering container {self.task_id} on {self.tunnel.url} "
+                        f"due to error: {port_check_error}, num_heartbeat_failures: {self.num_heartbeat_failures}"
+                    )
+                    self.num_heartbeat_failures += 1
+                    await self._deregister()
             except asyncio.CancelledError:
                 logger.warning("[Modal Flash] Shutting down...")
+                await self._deregister()
                 break
             except Exception as e:
                 logger.error(f"[Modal Flash] Heartbeat failed: {e}")
-
             try:
                 await asyncio.sleep(1)
             except asyncio.CancelledError:
-                logger.warning("[Modal Flash] Shutting down...")
+                await self._deregister()
                 break
 
     def get_container_url(self):
@@ -162,11 +203,14 @@ class _FlashManager:
 
     async def stop(self):
         try:
-            self.heartbeat_task.cancel()
+            if self.heartbeat_task:
+                self.heartbeat_task.cancel()
+                try:
+                    await asyncio.wait_for(self.heartbeat_task, timeout=5)
+                except (asyncio.TimeoutError, asyncio.CancelledError):
+                    logger.warning("[Modal Flash] Heartbeat task did not stop within 5s.")
         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}.")
 
@@ -716,12 +760,16 @@ class _FlashContainerEntry:
 
     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,
-                h2_enabled=self.http_config.h2_enabled,
-            )
+            try:
+                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,
+                    h2_enabled=self.http_config.h2_enabled,
+                )
+            except Exception as e:
+                logger.warning(f"[Modal Flash] Startup failed: {e}")
+                raise UserException()
 
     def stop(self):
         if self.flash_manager:

{modal-1.3.1.dev35 → modal-1.3.2.dev0}/modal/experimental/flash.pyi

@@ -22,10 +22,12 @@ class _FlashManager:
         self, process: typing.Optional[subprocess.Popen], timeout: float = 0.5
     ) -> tuple[bool, typing.Optional[Exception]]: ...
     async def _start(self): ...
+    async def _deregister(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 _wait_for_port_success(self, host: str, port: int) -> bool: ...
     async def _run_heartbeat(self, host: str, port: int): ...
     def get_container_url(self): ...
     async def stop(self): ...
@@ -59,6 +61,12 @@ class FlashManager:
 
     _start: ___start_spec
 
+    class ___deregister_spec(typing_extensions.Protocol):
+        def __call__(self, /): ...
+        async def aio(self, /): ...
+
+    _deregister: ___deregister_spec
+
     class ___drain_container_spec(typing_extensions.Protocol):
         def __call__(self, /):
             """Background task that checks if we've encountered too many failures and drains the container if so."""
@@ -70,6 +78,12 @@ class FlashManager:
 
     _drain_container: ___drain_container_spec
 
+    class ___wait_for_port_success_spec(typing_extensions.Protocol):
+        def __call__(self, /, host: str, port: int) -> bool: ...
+        async def aio(self, /, host: str, port: int) -> bool: ...
+
+    _wait_for_port_success: ___wait_for_port_success_spec
+
     class ___run_heartbeat_spec(typing_extensions.Protocol):
         def __call__(self, /, host: str, port: int): ...
         async def aio(self, /, host: str, port: int): ...

{modal-1.3.1.dev35 → modal-1.3.2.dev0}/modal/queue.py

@@ -469,7 +469,17 @@ class _Queue(_Object, type_prefix="qu"):
 
     @live_method
     async def clear(self, *, partition: Optional[str] = None, all: bool = False) -> None:
-        """Clear the contents of a single partition or all partitions."""
+        """Clear the contents of a single partition or all partitions.
+
+        Warning: this is a destructive operation and will irrevocably delete data.
+
+        **Examples:**
+
+        ```python
+        q = modal.Queue.from_name("my-queue", create_if_missing=True)
+        q.clear()
+        ```
+        """
         if partition and all:
             raise InvalidError("Partition must be null when requesting to clear all.")
         request = api_pb2.QueueClearRequest(

{modal-1.3.1.dev35 → modal-1.3.2.dev0}/modal/queue.pyi

@@ -510,7 +510,17 @@ class _Queue(modal._object._Object):
         self, partition: typing.Optional[str], timeout: typing.Optional[float], n_values: int
     ) -> list[typing.Any]: ...
     async def clear(self, *, partition: typing.Optional[str] = None, all: bool = False) -> None:
-        """Clear the contents of a single partition or all partitions."""
+        """Clear the contents of a single partition or all partitions.
+
+        Warning: this is a destructive operation and will irrevocably delete data.
+
+        **Examples:**
+
+        ```python
+        q = modal.Queue.from_name("my-queue", create_if_missing=True)
+        q.clear()
+        ```
+        """
         ...
 
     async def get(
@@ -840,11 +850,31 @@ class Queue(modal.object.Object):
 
     class __clear_spec(typing_extensions.Protocol):
         def __call__(self, /, *, partition: typing.Optional[str] = None, all: bool = False) -> None:
-            """Clear the contents of a single partition or all partitions."""
+            """Clear the contents of a single partition or all partitions.
+
+            Warning: this is a destructive operation and will irrevocably delete data.
+
+            **Examples:**
+
+            ```python
+            q = modal.Queue.from_name("my-queue", create_if_missing=True)
+            q.clear()
+            ```
+            """
             ...
 
         async def aio(self, /, *, partition: typing.Optional[str] = None, all: bool = False) -> None:
-            """Clear the contents of a single partition or all partitions."""
+            """Clear the contents of a single partition or all partitions.
+
+            Warning: this is a destructive operation and will irrevocably delete data.
+
+            **Examples:**
+
+            ```python
+            q = modal.Queue.from_name("my-queue", create_if_missing=True)
+            q.clear()
+            ```
+            """
             ...
 
     clear: __clear_spec

{modal-1.3.1.dev35 → modal-1.3.2.dev0}/modal/sandbox.py

@@ -75,8 +75,7 @@ def _validate_exec_args(args: Sequence[str]) -> None:
     total_arg_len = sum(len(arg) for arg in args)
     if total_arg_len > ARG_MAX_BYTES:
         raise InvalidError(
-            f"Total length of CMD arguments must be less than {ARG_MAX_BYTES} bytes (ARG_MAX). "
-            f"Got {total_arg_len} bytes."
+            f"Total length of CMD arguments cannot exceed {ARG_MAX_BYTES} bytes (ARG_MAX). Got {total_arg_len} bytes."
         )
 
 
@@ -307,6 +306,8 @@ class _Sandbox(_Object, type_prefix="sb"):
         h2_ports: Sequence[int] = [],
         # List of ports to tunnel into the sandbox without encryption.
         unencrypted_ports: Sequence[int] = [],
+        # Allow connections to the Sandbox via a subdomain of this parent rather than a default Modal domain.
+        custom_domain: Optional[str] = None,
         # Reference to a Modal Proxy to use in front of this Sandbox.
         proxy: Optional[_Proxy] = None,
         # Enable verbose logging for sandbox operations.
@@ -317,10 +318,6 @@ class _Sandbox(_Object, type_prefix="sb"):
         client: Optional[_Client] = None,
         environment_name: Optional[str] = None,  # *DEPRECATED* Optionally override the default environment
         pty_info: Optional[api_pb2.PTYInfo] = None,  # *DEPRECATED* Use `pty` instead. `pty` will override `pty_info`.
-        # If set, connections to this sandbox will be subdomains of this domain rather than the default.
-        # Custom domains must be configured manually by Modal. They are different from the custom domains
-        # in the Modal dashboard.
-        custom_domain: Optional[str] = None,
     ) -> "_Sandbox":
         """
         Create a new Sandbox to run untrusted, arbitrary code.

{modal-1.3.1.dev35 → modal-1.3.2.dev0}/modal.egg-info/PKG-INFO

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

{modal-1.3.1.dev35 → modal-1.3.2.dev0}/modal_proto/api.proto

@@ -3366,6 +3366,8 @@ message TokenInfoGetResponse {
   // Token metadata
   google.protobuf.Timestamp created_at = 6;
   google.protobuf.Timestamp expires_at = 7;
+
+  string token_name = 8;
 }
 
 message TunnelData {