modal 1.6.4.dev9__tar.gz → 1.6.4.dev11__tar.gz

{modal-1.6.4.dev9 → modal-1.6.4.dev11}/PKG-INFO

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

{modal-1.6.4.dev9 → modal-1.6.4.dev11}/modal/__init__.py

@@ -1,4 +1,5 @@
 # Copyright Modal Labs 2022
+import os
 import sys
 
 if sys.version_info[:2] < (3, 10):
@@ -59,6 +60,16 @@ except Exception:
     print()
     raise
 
+if sys.version_info[:2] == (3, 10) and os.environ.get("MODAL_IS_REMOTE") != "1":
+    from ._utils.deprecation import deprecation_warning
+
+    deprecation_warning(
+        (2026, 11, 4),
+        "Python 3.10 is EOL and Modal will not support it in version 1.7.0. "
+        "Please upgrade your local Python to 3.11 or later.",
+        show_source=False,
+    )
+
 
 __all__ = [
     "__version__",

modal-1.6.4.dev11/modal/_audit_logs/__init__.py

@@ -0,0 +1 @@
+# Copyright Modal Labs 2026

modal-1.6.4.dev11/modal/_audit_logs/_rpcs.py

@@ -0,0 +1,66 @@
+# Copyright Modal Labs 2026
+"""The audit log RPCs, one call each, retried with backoff. Ordering and batching live in list.py."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING, TypeVar
+
+from modal._utils.grpc_utils import Retry
+from modal_proto import api_pb2
+
+if TYPE_CHECKING:
+    from modal.client import _Client
+
+
+_Resp = TypeVar("_Resp")
+
+
+_MAX_RETRIES = 4
+_PLAN_MAX_RETRIES = 2
+
+
+async def _call(
+    rpc: Callable[..., Awaitable[_Resp]], req: object, *, timeout: float, max_retries: int = _MAX_RETRIES
+) -> _Resp:
+    """Call with backoff on timeouts and transient errors; rate and resource limits wait as the server says."""
+    retry = Retry(base_delay=1.0, delay_factor=2.0, max_delay=8.0, max_retries=max_retries, attempt_timeout=timeout)
+    return await rpc(req, retry=retry)
+
+
+async def get_settings(client: _Client) -> api_pb2.AuditLogSettingsGetResponse:
+    return await client._stub.AuditLogSettingsGet(api_pb2.AuditLogSettingsGetRequest())
+
+
+async def count_entries(
+    client: _Client, q: str, oldest_ms: int, newest_ms: int, config: api_pb2.AuditLogSettingsGetResponse
+) -> int:
+    req = api_pb2.AuditLogCountRequest(q=q, oldest_ms=oldest_ms, newest_ms=newest_ms)
+    resp = await _call(client._stub.AuditLogCount, req, timeout=config.request_timeout_secs)
+    return resp.count
+
+
+async def list_page(
+    client: _Client,
+    q: str,
+    oldest_ms: int,
+    newest_ms: int,
+    limit: int,
+    config: api_pb2.AuditLogSettingsGetResponse,
+    newest_cursor: api_pb2.AuditLogCursor | None = None,
+    oldest_cursor: api_pb2.AuditLogCursor | None = None,
+) -> api_pb2.AuditLogListResponse:
+    req = api_pb2.AuditLogListRequest(q=q, oldest_ms=oldest_ms, newest_ms=newest_ms, limit=limit)
+    if newest_cursor is not None:
+        req.newest_cursor.CopyFrom(newest_cursor)
+    if oldest_cursor is not None:
+        req.oldest_cursor.CopyFrom(oldest_cursor)
+    return await _call(client._stub.AuditLogList, req, timeout=config.request_timeout_secs)
+
+
+async def plan_buckets(
+    client: _Client, q: str, oldest_ms: int, newest_ms: int, config: api_pb2.AuditLogSettingsGetResponse
+) -> list[api_pb2.AuditLogCursor]:
+    req = api_pb2.AuditLogBucketsRequest(q=q, oldest_ms=oldest_ms, newest_ms=newest_ms, bucket_size=config.bucket_size)
+    resp = await _call(client._stub.AuditLogPlan, req, timeout=config.plan_timeout_secs, max_retries=_PLAN_MAX_RETRIES)
+    return list(resp.cursors)

modal-1.6.4.dev11/modal/_audit_logs/count.py

@@ -0,0 +1,17 @@
+# Copyright Modal Labs 2026
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from modal._audit_logs import _rpcs
+from modal_proto import api_pb2
+
+if TYPE_CHECKING:
+    from modal.client import _Client
+
+
+async def count_audit_logs(
+    client: _Client, q: str, oldest_ms: int, newest_ms: int, config: api_pb2.AuditLogSettingsGetResponse
+) -> int:
+    """Count the entries in [oldest_ms, newest_ms) that match the query."""
+    return await _rpcs.count_entries(client, q, oldest_ms, newest_ms, config)

modal-1.6.4.dev11/modal/_audit_logs/list.py

@@ -0,0 +1,83 @@
+# Copyright Modal Labs 2026
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+from contextlib import aclosing
+
+from modal._audit_logs import _rpcs
+from modal._utils.async_utils import async_map_ordered
+from modal.client import _Client
+from modal_proto import api_pb2
+
+# (newest_cursor, oldest_cursor); None where the bucket is open-ended.
+Bucket = tuple[api_pb2.AuditLogCursor | None, api_pb2.AuditLogCursor | None]
+
+
+async def get_bucket_cursors(
+    client: _Client, q: str, oldest_ms: int, newest_ms: int, config: api_pb2.AuditLogSettingsGetResponse
+) -> list[Bucket]:
+    """Split the range into buckets, as (newest_cursor, oldest_cursor) pairs ordered oldest to newest.
+
+    The first bucket has no oldest cursor and the last has no newest cursor.
+    """
+    cursors = await _rpcs.plan_buckets(client, q, oldest_ms, newest_ms, config)
+    return list(zip([None, *cursors], [*cursors, None]))[::-1]
+
+
+async def _fetch_bucket(
+    client: _Client,
+    q: str,
+    oldest_ms: int,
+    newest_ms: int,
+    config: api_pb2.AuditLogSettingsGetResponse,
+    bucket: Bucket,
+) -> list[api_pb2.AuditLogEntry]:
+    """Read one bucket's entries, oldest to newest, using pagination"""
+    newest_cursor, oldest_cursor = bucket
+    entries: list[api_pb2.AuditLogEntry] = []
+    while True:
+        resp = await _rpcs.list_page(
+            client, q, oldest_ms, newest_ms, config.page_size, config, newest_cursor, oldest_cursor
+        )
+        entries.extend(resp.items)
+        # Skips the empty request a full last page would otherwise trigger; an unset next_cursor also ends the loop.
+        if oldest_cursor is not None and resp.items and resp.items[-1].id == oldest_cursor.id:
+            break
+        if not resp.HasField("next_cursor"):
+            break
+        newest_cursor = resp.next_cursor
+    entries.reverse()
+    return entries
+
+
+async def fetch_audit_logs(
+    q: str,
+    oldest_ms: int,
+    newest_ms: int,
+    *,
+    client: _Client | None = None,
+    config: api_pb2.AuditLogSettingsGetResponse,
+) -> AsyncGenerator[api_pb2.AuditLogEntry]:
+    """Yield the range's entries from the oldest to the newest, one bucket at a time.
+
+    At most `max_concurrent_requests` buckets are fetched at once, and at most `max_buffered_buckets` are fetched
+    or held at once. A new bucket is admitted only after the consumer has taken all of a bucket's entries, so a slow
+    consumer or a stalled request cannot grow memory.
+    If any request fails after its attempts, the remaining requests are cancelled and the error is raised.
+    """
+    if client is None:
+        client = await _Client.from_env()
+    buckets = await get_bucket_cursors(client, q, oldest_ms, newest_ms, config)
+
+    async def bucket_stream() -> AsyncGenerator[Bucket]:
+        for bucket in buckets:
+            yield bucket
+
+    async def fetch(bucket: Bucket) -> list[api_pb2.AuditLogEntry]:
+        return await _fetch_bucket(client, q, oldest_ms, newest_ms, config, bucket)
+
+    fetched = async_map_ordered(bucket_stream(), fetch, config.max_concurrent_requests, config.max_buffered_buckets)
+    async with aclosing(fetched) as stream:
+        async for entries in stream:
+            for entry in entries:
+                yield entry

{modal-1.6.4.dev9 → modal-1.6.4.dev11}/modal/_function_variants.py

@@ -408,6 +408,7 @@ def _make_function_variant(
         if not base_function._is_hydrated:
             await base_function.hydrate(load_context.client)
 
+        base_function._check_not_observability_only()
         assert base_function._client and base_function._client._stub
 
         if parameter_schema is None:

{modal-1.6.4.dev9 → modal-1.6.4.dev11}/modal/_functions.py

@@ -119,6 +119,15 @@ if TYPE_CHECKING:
     import modal.functions
 
 MAX_INTERNAL_FAILURE_COUNT = 8
+_OBSERVABILITY_ONLY_APIS = (
+    ".logs",
+    ".metrics",
+    ".info()",
+    ".stats()",
+    ".get_current_stats()",
+    ".get_web_url()",
+    ".autoscaler.settings()",
+)
 TERMINAL_STATUSES = (
     api_pb2.GenericResult.GENERIC_STATUS_SUCCESS,
     api_pb2.GenericResult.GENERIC_STATUS_TERMINATED,
@@ -651,6 +660,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     _base_function: "_Function | None" = None
     _app_id: str | None = None
     _function_info: FunctionInfo | None = None
+    _is_observability_only: bool = False
 
     async def _get_log_query_data(self) -> _LogQueryData:
         await self.hydrate()
@@ -1398,6 +1408,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
         """
 
+        self._check_not_observability_only()
         deprecation_warning(
             (2026, 10, 16),
             "`Function.update_autoscaler()` is deprecated and will be removed in a future version "
@@ -1485,16 +1496,15 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 # refine the error message
                 msg = f"Lookup failed for {called_from} '{function_id}': {exc}."
                 raise NotFoundError(msg) from None
-            if called_from == "Function" and (response.function.is_server or response.function.is_class):
-                if response.function.is_server:
-                    raise InvalidError(f"{function_id} is a Server. Use \n ``modal.Server.from_id('{function_id}')``")
-                raise InvalidError(f"{function_id} is a Cls and cannot be loaded with Function.from_id().")
+            if called_from == "Function" and response.function.is_server:
+                raise InvalidError(f"{function_id} is a Server. Use \n ``modal.Server.from_id('{function_id}')``")
             if called_from == "Server" and not response.function.is_server:
                 if response.function.is_class:
                     raise InvalidError(f"{function_id} is a Cls and cannot be loaded with Server.from_id().")
                 raise InvalidError(f"{function_id} is a Function. Use \n ``modal.Function.from_id('{function_id}')``")
             self._hydrate(function_id, load_context.client, response.handle_metadata)
             self._function_info = FunctionInfo._from_function_proto(response.function)
+            self._is_observability_only = called_from == "Function" and response.function.is_class
 
         rep = f"modal.Function.from_id('{function_id}')"
         return cls._from_loader(
@@ -1514,6 +1524,11 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         object with metadata from Modal servers until the first
         time it is actually used.
 
+        If the ID belongs to a Cls, the Function only supports the following APIs:
+        `.logs`, `.metrics`, `.info()`, `.stats()`, `.get_current_stats()`,
+        `.get_web_url()` and `.autoscaler.settings()`. Use `modal.Cls.from_name(...)`
+        to invoke all other methods.
+
         Args:
             function_id: ID of the function.
             client: Modal client to use; defaults to `Client.from_env()` when omitted.
@@ -1744,6 +1759,18 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 + f"or call it locally: {self._function_name}.local()"
             )
 
+    def _check_not_observability_only(self):
+        if self._is_observability_only:
+            assert self._function_name
+            class_name = self._function_name.removesuffix(".*")
+            apis = [f"`{name}`" for name in _OBSERVABILITY_ONLY_APIS]
+            allowed_apis = ", ".join(apis[:-1]) + " and " + apis[-1]
+            raise InvalidError(
+                f"`{self.object_id}` belongs to the Cls `{class_name}`. A Function loaded with "
+                f"`Function.from_id` only supports {allowed_apis}. "
+                "Use `modal.Cls.from_name(...)` to invoke all other methods."
+            )
+
     @live_method
     async def get_web_url(self) -> str | None:
         """URL for addressing a Web Function via HTTP.
@@ -1779,6 +1806,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         config_method_name: str,
     ) -> "_Function[P, ReturnType, OriginalReturnType]":
         base_function = self._base_function or self
+        base_function._check_not_observability_only()
         combined_options = self._options.merge_options(new_options)
 
         # For "True Functions" (i.e. not the Function inside a Cls), we will use
@@ -1941,6 +1969,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         _SynchronizedQueue is used instead of asyncio.Queue so that the main thread can put
         items in the queue safely.
         """
+        self._check_not_observability_only()
         self._check_no_web_url("map")
         if self._is_generator:
             raise InvalidError("A generator function cannot be called with `.map(...)`.")
@@ -1978,6 +2007,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
     @live_method
     async def _spawn_map(self, input_queue: _SynchronizedQueue) -> "_FunctionCall[ReturnType]":
+        self._check_not_observability_only()
         self._check_no_web_url("spawn_map")
         if self._is_generator:
             raise InvalidError("A generator function cannot be called with `.spawn_map(...)`.")
@@ -1995,6 +2025,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         return fc
 
     async def _call_function(self, args, kwargs) -> ReturnType:
+        self._check_not_observability_only()
         invocation: _Invocation | _InputPlaneInvocation
         if self._input_plane_url:
             invocation = await _InputPlaneInvocation.create(
@@ -2024,6 +2055,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         function_call_invocation_type: "api_pb2.FunctionCallInvocationType.ValueType",
         from_spawn_map: bool = False,
     ) -> _Invocation:
+        self._check_not_observability_only()
         return await _Invocation.create(
             self,
             args,
@@ -2037,6 +2069,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     @live_method_gen
     @synchronizer.no_input_translation
     async def _call_generator(self, args, kwargs):
+        self._check_not_observability_only()
         invocation: _Invocation | _InputPlaneInvocation
         if self._input_plane_url:
             invocation = await _InputPlaneInvocation.create(
@@ -2093,6 +2126,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             Values produced by the remote generator.
         """
         # TODO: Generics/TypeVars
+        self._check_not_observability_only()
         self._check_no_web_url("remote_gen")
 
         if not self._is_generator:
@@ -2669,6 +2703,7 @@ class _FunctionAutoscalerManager:
         if not self._function._is_hydrated:
             await self._function.hydrate()
 
+        self._function._check_not_observability_only()
         settings: api_pb2.AutoscalerSettings = api_pb2.AutoscalerSettings()
 
         if min_containers != UNSET_PARAMETER:

{modal-1.6.4.dev9 → modal-1.6.4.dev11}/modal/_image.py

@@ -37,6 +37,7 @@ from ._serialization import get_preferred_payload_format, serialize
 from ._supports_logs import _ImageLogQueryData
 from ._utils.async_utils import TaskContext, deprecate_aio_usage, synchronizer
 from ._utils.blob_utils import MAX_OBJECT_SIZE_BYTES
+from ._utils.deprecation import deprecation_warning
 from ._utils.docker_utils import (
     extract_copy_command_patterns,
     find_dockerignore_file,
@@ -87,6 +88,23 @@ SUPPORTED_PYTHON_SERIES: dict[ImageBuilderVersion, list[str]] = {
     "2023.12": ["3.10", "3.11", "3.12"],
 }
 
+
+def _uses_python_310(metadata: api_pb2.ImageMetadata | None) -> bool:
+    return metadata is not None and bool(re.match(r"Python 3\.10\.", metadata.python_version_info))
+
+
+def _warn_if_python_310(image_id: str, metadata: api_pb2.ImageMetadata | None) -> None:
+    if _uses_python_310(metadata):
+        deprecation_warning(
+            (2026, 11, 4),
+            f"Image {image_id} uses Python 3.10, which is EOL. Modal 1.7.0 and later will not run or deploy apps "
+            "that use Images with Python 3.10; apps already deployed with older clients keep working. "
+            "Please update the Image to use Python 3.11 or later "
+            "(e.g. via `python_version=` or `add_python=`).",
+            show_source=False,
+        )
+
+
 LOCAL_REQUIREMENTS_DIR = Path(__file__).parent / "builder"
 CONTAINER_REQUIREMENTS_PATH = "/modal_requirements.txt"
 
@@ -877,6 +895,8 @@ class _Image(_Object, type_prefix="im"):
                 raise ImageBuildError("Unknown status %s!" % result.status, image_id)
 
             self._hydrate(image_id, load_context.client, metadata)
+            if not any(_uses_python_310(base._metadata) for base in base_images.values()):
+                _warn_if_python_310(image_id, metadata)
             local_mounts: set[_Mount] = set()
             for base in base_images.values():
                 local_mounts |= base._serve_mounts
@@ -1098,6 +1118,7 @@ class _Image(_Object, type_prefix="im"):
         async def _load(self: _Image, resolver: Resolver, load_context: LoadContext, existing_object_id: str | None):
             resp = await load_context.client._stub.ImageFromId(api_pb2.ImageFromIdRequest(image_id=image_id))
             self._hydrate(resp.image_id, load_context.client, resp.metadata)
+            _warn_if_python_310(resp.image_id, resp.metadata)
 
         rep = f"Image.from_id({image_id!r})"
 
@@ -2064,8 +2085,7 @@ class _Image(_Object, type_prefix="im"):
         if not isinstance(entrypoint_commands, list) or not all(isinstance(x, str) for x in entrypoint_commands):
             raise InvalidError("entrypoint_commands must be a list of strings.")
         args = _flatten_str_args("entrypoint", "entrypoint_commands", entrypoint_commands)
-        args_str = '"' + '", "'.join(args) + '"' if args else ""
-        dockerfile_cmd = f"ENTRYPOINT [{args_str}]"
+        dockerfile_cmd = f"ENTRYPOINT {json.dumps(args, ensure_ascii=False)}"
 
         return self.dockerfile_commands(dockerfile_cmd)
 
@@ -2085,8 +2105,7 @@ class _Image(_Object, type_prefix="im"):
         if not isinstance(shell_commands, list) or not all(isinstance(x, str) for x in shell_commands):
             raise InvalidError("shell_commands must be a list of strings.")
         args = _flatten_str_args("shell", "shell_commands", shell_commands)
-        args_str = '"' + '", "'.join(args) + '"' if args else ""
-        dockerfile_cmd = f"SHELL [{args_str}]"
+        dockerfile_cmd = f"SHELL {json.dumps(args, ensure_ascii=False)}"
 
         return self.dockerfile_commands(dockerfile_cmd)
 
@@ -3076,8 +3095,7 @@ class _Image(_Object, type_prefix="im"):
             raise InvalidError("Image CMD must be a list of strings.")
 
         cmd_args = _flatten_str_args("cmd", "cmd", cmd)
-        cmd_str = '"' + '", "'.join(cmd_args) + '"' if cmd_args else ""
-        dockerfile_cmd = f"CMD [{cmd_str}]"
+        dockerfile_cmd = f"CMD {json.dumps(cmd_args, ensure_ascii=False)}"
 
         return self.dockerfile_commands(dockerfile_cmd)
 

{modal-1.6.4.dev9 → modal-1.6.4.dev11}/modal/_type_manager.py

@@ -1,4 +1,5 @@
 # Copyright Modal Labs 2025
+import types
 import typing
 from typing import Any
 
@@ -186,6 +187,12 @@ class SchemaRegistry:
 
     def get_proto_generic_type(self, declared_type: type):
         if origin := typing_extensions.get_origin(declared_type):
+            if origin in (typing.Union, types.UnionType):
+                args = [arg for arg in typing_extensions.get_args(declared_type) if arg is not type(None)]
+                if len(args) == 1:
+                    return self.get_proto_generic_type(args[0])
+                return unknown_type_schema(declared_type)
+
             base_type = origin
         else:
             base_type = declared_type

{modal-1.6.4.dev9 → modal-1.6.4.dev11}/modal/_utils/name_utils.py

@@ -16,6 +16,13 @@ def replace_invalid_subdomain_chars(label: str) -> str:
     return re.sub("[^a-z0-9-]", "-", label.lower())
 
 
+app_id_regex = re.compile("^ap-[a-zA-Z0-9]{22}$")
+
+
+def is_app_id(identifier: str) -> bool:
+    return app_id_regex.match(identifier) is not None
+
+
 def is_valid_object_name(name: str) -> bool:
     return (
         # Limit object name length
@@ -23,7 +30,7 @@ def is_valid_object_name(name: str) -> bool:
         # Limit character set
         and re.match("^[a-zA-Z0-9-_.]+$", name) is not None
         # Avoid collisions with App IDs
-        and re.match("^ap-[a-zA-Z0-9]{22}$", name) is None
+        and not is_app_id(name)
     )
 
 

{modal-1.6.4.dev9 → modal-1.6.4.dev11}/modal/cli/profile.py

@@ -5,11 +5,12 @@ import os
 from contextlib import suppress
 
 import click
-from rich.json import JSON
-from rich.table import Table
+from rich.box import SIMPLE_HEAD
+from rich.text import Text
 
 from modal import config as config_module
 from modal._utils.async_utils import synchronizer
+from modal.cli.utils import display_table
 from modal.config import (
     Config,
     _lookup_workspace,
@@ -28,7 +29,7 @@ profile_cli = ModalGroup(name="profile", help="Switch between Modal profiles.")
 @profile_cli.command("list", help="Show all Modal profiles and highlight the active one.")
 @click.option("--json", is_flag=True, default=False)
 @synchronizer.create_blocking
-async def list_(json: bool | None = False):
+async def list_(json: bool = False):
     config = Config()
     profiles = config_profiles()
     lookup_coros = [
@@ -44,22 +45,6 @@ async def list_(json: bool | None = False):
     ]
     responses = await asyncio.gather(*lookup_coros, return_exceptions=True)
 
-    rows = []
-    for profile, resp in zip(profiles, responses):
-        active = profile == config_module._profile
-        if isinstance(resp, AuthError):
-            workspace = "Unknown (authentication failure)"
-        elif isinstance(resp, TimeoutError):
-            workspace = "Unknown (timed out)"
-        elif isinstance(resp, Exception):
-            # Catch-all for other exceptions, like incorrect server url
-            workspace = "Unknown (profile misconfigured)"
-        else:
-            assert not isinstance(resp, BaseException)
-            workspace = resp.username
-        content = ["•" if active else "", profile, workspace]
-        rows.append((active, content))
-
     env_based_workspace: str | None = None
     credential_env_vars = (
         "MODAL_TOKEN_ID",
@@ -87,18 +72,44 @@ async def list_(json: bool | None = False):
 
     output = OutputManager.get()
     highlight = "bold green" if env_based_workspace is None else "yellow"
-    if json:
-        json_data = []
-        for active, content in rows:
-            json_data.append({"name": content[1], "workspace": content[2], "active": active})
-        output.print(JSON.from_data(json_data))
+
+    if not json:
+        table_columns = ["  Profile", "Workspace"]
     else:
-        table = Table(" ", "Profile", "Workspace")
-        for active, content in rows:
-            table.add_row(*content, style=highlight if active else "dim")
-        output.print(table)
+        table_columns = ["name", "workspace", "active"]
+
+    table_rows: list[list[str | Text | bool]] = []
+    for profile, resp in zip(profiles, responses):
+        active = profile == config_module._profile
+
+        if isinstance(resp, AuthError):
+            workspace = "Unknown (authentication failure)"
+        elif isinstance(resp, TimeoutError):
+            workspace = "Unknown (timed out)"
+        elif isinstance(resp, Exception):
+            # Catch-all for other exceptions, like incorrect server url
+            workspace = "Unknown (profile misconfigured)"
+        else:
+            assert not isinstance(resp, BaseException)
+            workspace = resp.username
+
+        if json:
+            table_rows.append([profile, workspace, active])
+            continue
+
+        rendered_profile = f"• {profile}" if active else f"  {profile}"
+        style = highlight if active else "dim"
+
+        table_rows.append(
+            [
+                Text(rendered_profile, style=style),
+                Text(workspace, style=style),
+            ]
+        )
+
+    display_table(table_columns, table_rows, json=json, table_box=SIMPLE_HEAD)
 
-    if env_based_workspace is not None:
+    if not json and env_based_workspace is not None:
         output.print(
             f"[yellow]Using [bold]{env_based_workspace}[/bold] workspace based on environment variables[/yellow]"
         )

{modal-1.6.4.dev9 → modal-1.6.4.dev11}/modal/cli/shell.py

@@ -448,7 +448,7 @@ def shell(
     app = App("modal shell")
 
     # NB: invoking under bash makes --cmd a lot more flexible.
-    cmds = shlex.split(f'/bin/bash -c "{cmd}"')
+    cmds = ["/bin/bash", "-c", cmd]
     timeout = 3600
     parsed_experimental_options = _parse_experimental_options(experimental_options)