modAL 1.3.1.dev34__tar.gz → 1.3.2__tar.gz

{modal-1.3.1.dev34 → modal-1.3.2}/PKG-INFO

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

{modal-1.3.1.dev34 → modal-1.3.2}/modal/_object.py

@@ -39,6 +39,41 @@ def _get_environment_name(
         return config.get("environment")
 
 
+def live_method(method):
+    @wraps(method)
+    async def wrapped(self, *args, **kwargs):
+        await self.hydrate()
+        return await method(self, *args, **kwargs)
+
+    return wrapped
+
+
+def live_method_gen(method):
+    @wraps(method)
+    async def wrapped(self, *args, **kwargs):
+        await self.hydrate()
+        async with aclosing(method(self, *args, **kwargs)) as stream:
+            async for item in stream:
+                yield item
+
+    return wrapped
+
+
+def live_method_contextmanager(method):
+    # make sure a wrapped function returning an async context manager
+    # will not require both an `await func.aio()` and `async with`
+    # which would have been the case if it was wrapped in live_method
+
+    @wraps(method)
+    @contextlib.asynccontextmanager
+    async def wrapped(self, *args, **kwargs):
+        await self.hydrate()
+        async with method(self, *args, **kwargs) as ctx:
+            yield ctx
+
+    return wrapped
+
+
 class _Object:
     _type_prefix: ClassVar[Optional[str]] = None
     _prefix_to_type: ClassVar[dict[str, type]] = {}
@@ -275,6 +310,11 @@ class _Object:
             raise AttributeError(f"Attempting to get object_id of unhydrated {self}")
         return self._object_id
 
+    @live_method
+    async def get_dashboard_url(self) -> str:
+        """mdmd:hidden"""
+        return f"https://modal.com/id/{self.object_id}"
+
     @property
     def client(self) -> _Client:
         """mdmd:hidden"""
@@ -336,38 +376,3 @@ class _Object:
                 with suppress_tb_frame():  # skip this frame by default
                     await resolver.load(self, root_load_context)
         return self
-
-
-def live_method(method):
-    @wraps(method)
-    async def wrapped(self, *args, **kwargs):
-        await self.hydrate()
-        return await method(self, *args, **kwargs)
-
-    return wrapped
-
-
-def live_method_gen(method):
-    @wraps(method)
-    async def wrapped(self, *args, **kwargs):
-        await self.hydrate()
-        async with aclosing(method(self, *args, **kwargs)) as stream:
-            async for item in stream:
-                yield item
-
-    return wrapped
-
-
-def live_method_contextmanager(method):
-    # make sure a wrapped function returning an async context manager
-    # will not require both an `await func.aio()` and `async with`
-    # which would have been the case if it was wrapped in live_method
-
-    @wraps(method)
-    @contextlib.asynccontextmanager
-    async def wrapped(self, *args, **kwargs):
-        await self.hydrate()
-        async with method(self, *args, **kwargs) as ctx:
-            yield ctx
-
-    return wrapped

{modal-1.3.1.dev34 → modal-1.3.2}/modal/_output.py

@@ -545,7 +545,7 @@ async def get_app_logs_loop(
     output_mgr: OutputManager,
     app_id: str | None = None,
     task_id: str | None = None,
-    app_logs_url: str | None = None,
+    sandbox_id: str | None = None,
 ):
     last_log_batch_entry_id = ""
 
@@ -600,6 +600,7 @@ async def get_app_logs_loop(
         request = api_pb2.AppGetLogsRequest(
             app_id=app_id or "",
             task_id=task_id or "",
+            sandbox_id=sandbox_id or "",
             timeout=55,
             last_entry_id=last_log_batch_entry_id,
         )

{modal-1.3.1.dev34 → modal-1.3.2}/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.2/modal/_utils/browser_utils.py

@@ -0,0 +1,28 @@
+# Copyright Modal Labs 2026
+import webbrowser
+
+from rich.console import Console
+
+
+def open_url(url: str) -> bool:
+    """Opens url in web browser, making sure we use a modern one (not Lynx etc)"""
+    try:
+        browser = webbrowser.get()
+        # zpresto defines `BROWSER=open` by default on macOS, which causes `webbrowser` to return `GenericBrowser`.
+        if isinstance(browser, webbrowser.GenericBrowser) and browser.name != "open":
+            return False
+        else:
+            return browser.open_new_tab(url)
+    except webbrowser.Error:
+        return False
+
+
+def open_url_and_display(url: str, target: str, console: Console) -> None:
+    """Open a URL in the web browser and display it to the user."""
+    if open_url(url):
+        console.print(f"Opening {target} in your web browser...")
+        console.print(f"[link={url}]{url}[/link]")
+    else:
+        console.print("[yellow]Could not open web browser automatically.[/yellow]")
+        console.print("Please open this URL in your browser:")
+        console.print(f"[link={url}]{url}[/link]")

{modal-1.3.1.dev34 → modal-1.3.2}/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.dev34 → modal-1.3.2}/modal/cli/app.py

@@ -10,7 +10,9 @@ from rich.text import Text
 from typer import Argument
 
 from modal._object import _get_environment_name
+from modal._output import make_console
 from modal._utils.async_utils import synchronizer
+from modal._utils.browser_utils import open_url_and_display
 from modal.client import _Client
 from modal.environments import ensure_env
 from modal_proto import api_pb2
@@ -248,3 +250,35 @@ async def history(
 
     if deployments_with_dirty_commit and not json:
         rich.print("* - repo had uncommitted changes")
+
+
+@app_cli.command("dashboard", no_args_is_help=True)
+@synchronizer.create_blocking
+async def dashboard(
+    app_identifier: str = APP_IDENTIFIER,
+    *,
+    env: Optional[str] = ENV_OPTION,
+):
+    """Open an App's dashboard page in your web browser.
+
+    **Examples:**
+
+    Open dashboard for an app by name:
+
+    ```
+    modal app dashboard my-app
+    ```
+
+    Use a specified environment:
+
+    ```
+    modal app dashboard my-app --env dev
+    ```
+    """
+    client = await _Client.from_env()
+    app_id = await get_app_id.aio(app_identifier, env, client)
+
+    console = make_console()
+    url = f"https://modal.com/id/{app_id}"
+
+    open_url_and_display(url, "App dashboard", console)

{modal-1.3.1.dev34 → modal-1.3.2}/modal/cli/container.py

@@ -13,6 +13,7 @@ from modal.client import _Client
 from modal.config import config
 from modal.container_process import _ContainerProcess
 from modal.environments import ensure_env
+from modal.exception import InvalidError
 from modal.stream_type import StreamType
 from modal_proto import api_pb2
 
@@ -52,7 +53,14 @@ def logs(
     timestamps: bool = typer.Option(False, "--timestamps", help="Show timestamps for each log line"),
 ):
     """Show logs for a specific container, streaming while active."""
-    stream_app_logs(task_id=container_id, show_timestamps=timestamps)
+    task_id, sandbox_id = None, None
+    if container_id.startswith("sb-"):
+        sandbox_id = container_id
+    elif container_id.startswith("ta-"):
+        task_id = container_id
+    else:
+        raise InvalidError(f"Invalid container ID: {container_id}")
+    stream_app_logs(task_id=task_id, sandbox_id=sandbox_id, show_timestamps=timestamps)
 
 
 @container_cli.command("exec")

modal-1.3.2/modal/cli/dashboard.py

@@ -0,0 +1,30 @@
+# Copyright Modal Labs 2026
+from typing import Optional
+
+import typer
+
+from modal._output import make_console
+from modal._utils.async_utils import synchronizer
+from modal._utils.browser_utils import open_url_and_display
+from modal.client import _Client
+from modal.config import config
+from modal_proto import api_pb2
+
+
+@synchronizer.create_blocking
+async def dashboard(
+    object_id: Optional[str] = typer.Argument(None, help="Open a view for a specific object."),
+):
+    """Open the Modal Dashboard in a web browser."""
+    console = make_console()
+
+    if object_id:
+        url = f"https://modal.com/id/{object_id}"
+    else:
+        env = config.get("environment")
+        request = api_pb2.WorkspaceDashboardUrlRequest(environment_name=env)
+        client = await _Client.from_env()
+        response = await client.stub.WorkspaceDashboardUrlGet(request)
+        url = response.url
+
+    open_url_and_display(url, "dashboard", console)

{modal-1.3.1.dev34 → modal-1.3.2}/modal/cli/entry_point.py

@@ -13,6 +13,7 @@ from .app import app_cli
 from .cluster import cluster_cli
 from .config import config_cli
 from .container import container_cli
+from .dashboard import dashboard
 from .dict import dict_cli
 from .environment import environment_cli
 from .launch import launch_cli
@@ -118,6 +119,7 @@ async def setup(profile: Optional[str] = None):
 entrypoint_cli_typer.command("deploy", no_args_is_help=True)(run.deploy)
 entrypoint_cli_typer.command("serve", no_args_is_help=True)(run.serve)
 entrypoint_cli_typer.command("shell")(shell_module.shell)
+entrypoint_cli_typer.command("dashboard")(dashboard)
 entrypoint_cli_typer.add_typer(launch_cli)
 
 # Deployments

{modal-1.3.1.dev34 → modal-1.3.2}/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.dev34 → modal-1.3.2}/modal/cli/utils.py

@@ -21,14 +21,16 @@ from ..exception import NotFoundError
 async def stream_app_logs(
     app_id: Optional[str] = None,
     task_id: Optional[str] = None,
+    sandbox_id: Optional[str] = None,
     app_logs_url: Optional[str] = None,
     show_timestamps: bool = False,
 ):
     client = await _Client.from_env()
-    output_mgr = OutputManager(status_spinner_text=f"Tailing logs for {app_id}", show_timestamps=show_timestamps)
+    display_id = app_id or task_id or sandbox_id
+    output_mgr = OutputManager(status_spinner_text=f"Tailing logs for {display_id}", show_timestamps=show_timestamps)
     try:
         with output_mgr.show_status_spinner():
-            await get_app_logs_loop(client, output_mgr, app_id=app_id, task_id=task_id, app_logs_url=app_logs_url)
+            await get_app_logs_loop(client, output_mgr, app_id=app_id, task_id=task_id, sandbox_id=sandbox_id)
     except asyncio.CancelledError:
         pass
     except KeyboardInterrupt:

{modal-1.3.1.dev34 → modal-1.3.2}/modal/cli/volume.py

@@ -12,6 +12,7 @@ from typer import Argument, Option, Typer
 import modal
 from modal._output import OutputManager, ProgressHandler, make_console
 from modal._utils.async_utils import synchronizer
+from modal._utils.browser_utils import open_url_and_display
 from modal._utils.time_utils import timestamp_to_localized_str
 from modal.cli._download import _volume_download
 from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table
@@ -310,3 +311,30 @@ async def rename(
         )
 
     await _Volume.rename(old_name, new_name, environment_name=env)
+
+
+@volume_cli.command(
+    name="dashboard",
+    help="Open the Volume's dashboard page in your web browser.",
+    rich_help_panel="Management",
+)
+@synchronizer.create_blocking
+async def dashboard(
+    volume_name: str = Argument(help="Name of the Volume to view in the dashboard."),
+    env: Optional[str] = ENV_OPTION,
+):
+    """Open a Volume's dashboard page in your web browser.
+
+    **Example:**
+
+    ```
+    modal volume dashboard my-volume
+    ```
+    """
+    env = ensure_env(env)
+    volume = await _Volume.from_name(volume_name, environment_name=env).hydrate()
+
+    console = make_console()
+    url = f"https://modal.com/id/{volume.object_id}"
+
+    open_url_and_display(url, "Volume dashboard", console)

{modal-1.3.1.dev34 → modal-1.3.2}/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.dev34 → modal-1.3.2}/modal/client.pyi

@@ -31,11 +31,7 @@ class _Client:
     client_type: int
 
     def __init__(
-        self,
-        server_url: str,
-        client_type: int,
-        credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.3.1.dev34",
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "1.3.2"
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -43,6 +39,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
@@ -162,11 +163,7 @@ class Client:
     client_type: int
 
     def __init__(
-        self,
-        server_url: str,
-        client_type: int,
-        credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.3.1.dev34",
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "1.3.2"
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -174,6 +171,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.dev34 → modal-1.3.2}/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.dev34 → modal-1.3.2}/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.dev34 → modal-1.3.2}/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"])),