modAL 1.6.3.dev8__tar.gz → 1.6.3.dev9__tar.gz

{modal-1.6.3.dev8 → modal-1.6.3.dev9}/PKG-INFO

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

{modal-1.6.3.dev8 → modal-1.6.3.dev9}/modal/_environments.py

@@ -648,6 +648,7 @@ async def _update_environment(
     *,
     new_name: str | None = None,
     new_web_suffix: str | None = None,
+    new_image_builder_version: str | None = None,
     client: _Client | None = None,
 ):
     new_name_pb2 = None
@@ -662,7 +663,10 @@ async def _update_environment(
         new_web_suffix_pb2 = StringValue(value=new_web_suffix)
 
     update_payload = api_pb2.EnvironmentUpdateRequest(
-        current_name=current_name, name=new_name_pb2, web_suffix=new_web_suffix_pb2
+        current_name=current_name,
+        name=new_name_pb2,
+        web_suffix=new_web_suffix_pb2,
+        image_builder_version=new_image_builder_version,
     )
     if client is None:
         client = await _Client.from_env()

{modal-1.6.3.dev8 → modal-1.6.3.dev9}/modal/_image.py

@@ -40,6 +40,7 @@ from ._utils.blob_utils import MAX_OBJECT_SIZE_BYTES
 from ._utils.docker_utils import (
     extract_copy_command_patterns,
     find_dockerignore_file,
+    splittable_from_line_index,
 )
 from ._utils.function_utils import FunctionSourceInfo, parse_gpu_config
 from ._utils.mount_utils import validate_only_modal_volumes, validate_volumes_by_object_id
@@ -77,7 +78,7 @@ LATEST_IMAGE_BUILDER_VERSION: ImageBuilderVersion = "2025.06"
 # Python versions in mount.py where we specify the "standalone Python versions" we create mounts for.
 # Consider consolidating these multiple sources of truth?
 SUPPORTED_PYTHON_SERIES: dict[ImageBuilderVersion, list[str]] = {
-    "PREVIEW": ["3.10", "3.11", "3.12", "3.13", "3.14", "3.14t", "3.15", "3.15t"],
+    "PREVIEW": ["3.11", "3.12", "3.13", "3.14", "3.14t", "3.15", "3.15t"],
     "2025.06": ["3.10", "3.11", "3.12", "3.13", "3.14", "3.14t", "3.15", "3.15t"],
     "2024.10": ["3.10", "3.11", "3.12", "3.13"],
     "2024.04": ["3.10", "3.11", "3.12"],
@@ -174,6 +175,7 @@ def _validate_python_version(
     allow_free_threading: bool = False,
     caller_name: str = "",
 ) -> str:
+    python_version_unspecified = python_version is None
     if python_version is None:
         # If Python version is unspecified, match the local version, up to the minor component
         python_version = series_version = "{}.{}".format(*sys.version_info)
@@ -196,6 +198,12 @@ def _validate_python_version(
 
     supported_series = SUPPORTED_PYTHON_SERIES[builder_version]
     if series_version not in supported_series:
+        if python_version_unspecified:
+            raise InvalidError(
+                f"Python {series_version} is not supported by the {builder_version!r} Image builder."
+                f" Since `python_version` was not set, Modal tried to match your local Python ({series_version})."
+                f" Set `python_version` to one of the supported series: {supported_series!r}."
+            )
         raise InvalidError(
             f"Unsupported Python version: {python_version!r}."
             f" When using the {builder_version!r} Image builder, Modal supports the following series:"
@@ -2538,25 +2546,22 @@ class _Image(_Object, type_prefix="im"):
         if env:
             secrets = [*secrets, _Secret.from_dict(env)]
 
-        # --- Build the base dockerfile
-
-        def build_dockerfile_base(version: ImageBuilderVersion) -> DockerfileSpec:
-            with open(os.path.expanduser(path)) as f:
-                commands = f.read().split("\n")
-            return DockerfileSpec(commands=commands, context_files={})
-
         gpu_config = parse_gpu_config(gpu)
-        base_image = _Image._from_args(
-            dockerfile_function=build_dockerfile_base,
-            context_mount_function=_create_context_mount_function(
-                ignore=ignore, dockerfile_path=Path(path), context_dir=context_dir
-            ),
-            gpu_config=gpu_config,
-            secrets=secrets,
-            build_args=build_args,
-            force_build=force_build,
+        context_mount_function = _create_context_mount_function(
+            ignore=ignore, dockerfile_path=Path(path), context_dir=context_dir
         )
 
+        def dockerfile_image(commands: list[str], base_images: dict[str, _Image] | None = None) -> _Image:
+            return _Image._from_args(
+                base_images=base_images,
+                dockerfile_function=lambda version: DockerfileSpec(commands=commands, context_files={}),
+                context_mount_function=context_mount_function,
+                gpu_config=gpu_config,
+                secrets=secrets,
+                build_args=build_args,
+                force_build=force_build,
+            )
+
         # --- Now add in the modal dependencies, and, optionally a Python distribution
         # This happening in two steps is probably a vestigial consequence of previous limitations,
         # but it will be difficult to merge them without forcing rebuilds of images.
@@ -2579,12 +2584,49 @@ class _Image(_Object, type_prefix="im"):
                 context_files = {CONTAINER_REQUIREMENTS_PATH: requirements_path}
             return DockerfileSpec(commands=commands, context_files=context_files)
 
-        return _Image._from_args(
-            base_images={"base": base_image},
-            dockerfile_function=build_dockerfile_python,
-            context_mount_function=add_python_mount,
-            force_build=force_build,
-        )
+        def python_image(base_image: _Image) -> _Image:
+            return _Image._from_args(
+                base_images={"base": base_image},
+                dockerfile_function=build_dockerfile_python,
+                context_mount_function=add_python_mount,
+                force_build=force_build,
+            )
+
+        async def _load(self: _Image, resolver: Resolver, load_context: LoadContext, existing_object_id: str | None):
+            builder_version = await _resolve_image_builder_version(load_context)
+            if add_python:
+                # Validate before any Dockerfile layer is built.
+                _validate_python_version(
+                    add_python, builder_version, allow_micro_granularity=False, allow_free_threading=True
+                )
+            with open(os.path.expanduser(path)) as f:
+                dockerfile_lines = f.read().split("\n")
+
+            # Builder versions after 2025.06 put the FROM line of a single-stage Dockerfile in its own image.
+            # Dockerfiles the split could change (see splittable_from_line_index) stay in one layer.
+            from_index = splittable_from_line_index(dockerfile_lines) if builder_version > "2025.06" else None
+            if from_index is None:
+                image = python_image(dockerfile_image(dockerfile_lines))
+            else:
+                from_lines = dockerfile_lines[: from_index + 1]
+                from_image = _Image._from_args(
+                    dockerfile_function=lambda version: DockerfileSpec(commands=from_lines, context_files={}),
+                    force_build=force_build,
+                )
+                rest = dockerfile_lines[from_index + 1 :]
+                rest_is_empty = all(not line.strip() or line.strip().startswith("#") for line in rest)
+                if rest_is_empty:
+                    image = python_image(from_image)
+                else:
+                    image = python_image(dockerfile_image(["FROM base", *rest], base_images={"base": from_image}))
+            await resolver.load(image, load_context)
+            self._hydrate_from_other(image)
+            self._serve_mounts = image._serve_mounts
+
+        rep = f"Image.from_dockerfile({str(path)!r})"
+        obj = _Image._from_loader(_load, rep, load_context_overrides=LoadContext.empty())
+        obj.force_build = force_build
+        return obj
 
     @staticmethod
     def from_scratch(force_build: bool = False) -> "_Image":

{modal-1.6.3.dev8 → modal-1.6.3.dev9}/modal/_utils/docker_utils.py

@@ -74,6 +74,33 @@ def extract_copy_command_patterns(dockerfile_lines: Sequence[str]) -> list[str]:
     return list(copy_source_patterns)
 
 
+_FROM_PATTERN = re.compile(r"^\s*FROM\s", re.IGNORECASE)
+_FROM_ALIAS_PATTERN = re.compile(r"\sAS\s+\S+\s*$", re.IGNORECASE)
+_PARSER_DIRECTIVE_PATTERN = re.compile(r"^#\s*[a-zA-Z][a-zA-Z0-9]*\s*=")
+
+
+def splittable_from_line_index(dockerfile_lines: Sequence[str]) -> int | None:
+    """Return the line index of the FROM instruction if it can be built as its own image.
+
+    Returns None unless the first instruction is a one-line FROM without a stage alias (no global ARGs), no
+    parser directives precede it, and no other line starts with FROM. Lines inside heredocs or continuations
+    count too, so a multi-stage Dockerfile is never split.
+    """
+    start = next(
+        (i for i, line in enumerate(dockerfile_lines) if line.strip() and not line.strip().startswith("#")),
+        None,
+    )
+    if start is None or not _FROM_PATTERN.match(dockerfile_lines[start]):
+        return None
+    if dockerfile_lines[start].rstrip().endswith("\\") or _FROM_ALIAS_PATTERN.search(dockerfile_lines[start]):
+        return None
+    if any(_PARSER_DIRECTIVE_PATTERN.match(line.strip()) for line in dockerfile_lines[:start]):
+        return None
+    if any(_FROM_PATTERN.match(line) for line in dockerfile_lines[start + 1 :]):
+        return None
+    return start
+
+
 def find_dockerignore_file(context_directory: Path, dockerfile_path: Path | None = None) -> Path | None:
     """
     Find dockerignore file relative to current context directory

{modal-1.6.3.dev8 → modal-1.6.3.dev9}/modal/_workspace.py

@@ -9,7 +9,7 @@ from typing import Optional
 from google.protobuf.empty_pb2 import Empty
 
 from modal.exception import DeprecationError, InvalidError, NotFoundError
-from modal.types import ServiceUserInfo
+from modal.types import MemberTokenInfo, ServiceUserInfo
 from modal_proto import api_pb2
 
 from ._load_context import LoadContext
@@ -139,6 +139,11 @@ class _Workspace(_Object, type_prefix="ac"):
         """
         return _WorkspaceServiceUserManager(self)
 
+    @property
+    def member_tokens(self) -> "_WorkspaceMemberTokenManager":
+        """Namespace for managing Member API Tokens in a Workspace."""
+        return _WorkspaceMemberTokenManager(self)
+
 
 class _WorkspaceProxyTokenManager:
     """mdmd:namespace"""
@@ -735,3 +740,62 @@ class _WorkspaceServiceUserManager:
         except NotFoundError:
             if not allow_missing:
                 raise
+
+
+class _WorkspaceMemberTokenManager:
+    """mdmd:namespace"""
+
+    def __init__(self, workspace: _Workspace):
+        self._workspace = workspace
+
+    async def list(self) -> list[MemberTokenInfo]:
+        """List Member Tokens in the specified Workspace.
+
+        If you are a Manager or an Owner of this Workspace, this method will return a list of all the
+        Member Tokens in the Workspace. Otherwise, this method will only return the Tokens you have
+        created.
+
+        Returns:
+            A list of `MemberTokenInfo` dataclasses.
+
+        Examples:
+
+        ```python notest
+        ws = modal.Workspace.from_context()
+        for member_token in ws.member_tokens.list():
+            print(member_token)
+        ```
+        """
+        if not self._workspace._is_hydrated:
+            await self._workspace.hydrate()
+
+        resp = await self._workspace.client._stub.TokensList(Empty())
+
+        return [MemberTokenInfo._from_proto(token) for token in resp.tokens]
+
+    async def delete(self, token_id: str, *, allow_missing: bool = False) -> None:
+        """Delete a Member Token in the specified Workspace.
+
+        If you are a Workspace Manager or Owner, you can use this method to delete any Token in the
+        Workspace. Otherwise, you can only delete Member Tokens that you have created.
+
+        Args:
+            token_id: The ID of the Member Token you would like to delete.
+            allow_missing: If `True`, do not throw an exception if the Member Token does not exist.
+
+        Examples:
+
+        ```python notest
+        ws = modal.Workspace.from_context()
+        ws.member_tokens.delete(token_id="ak-0123456789abcdefghijkl")
+        ```
+        """
+
+        if not self._workspace._is_hydrated:
+            await self._workspace.hydrate()
+
+        try:
+            await self._workspace.client._stub.TokenDelete(req=api_pb2.TokenDeleteRequest(token_id=token_id))
+        except NotFoundError:
+            if not allow_missing:
+                raise

{modal-1.6.3.dev8 → modal-1.6.3.dev9}/modal/app.py

@@ -178,7 +178,7 @@ class _App:
     # Running apps only (container apps or running local)
     _app_id: str | None  # Kept after app finishes
     _running_app: RunningApp | None  # Various app info
-    _client: _Client | None
+    _client: _Client | None  # Kept after app finishes
 
     # Metadata for loading objects within this app
     # passed by reference to functions and classes so it can be updated by run()/deploy()
@@ -400,9 +400,13 @@ class _App:
             print(app.get_dashboard_url())
             ```
         """
+        app_id = self._ensure_app_id("get_dashboard_url")
+        return f"https://modal.com/id/{app_id}"
+
+    def _ensure_app_id(self, method: str) -> str:
         if self._app_id is None:
-            raise InvalidError("App is not running")
-        return f"https://modal.com/id/{self._app_id}"
+            raise InvalidError(f"`App.{method}` requires the App to have an ID.")
+        return self._app_id
 
     def _validate_blueprint_value(self, key: str, value: Any):
         if not isinstance(value, _Object):
@@ -425,7 +429,6 @@ class _App:
             yield
         finally:
             self._running_app = None
-            self._client = None
             self._uncreate_all_objects()
 
     @asynccontextmanager
@@ -582,6 +585,7 @@ class _App:
             self, name=name, environment_name=environment_name, tag=tag, client=client, deployment_strategy=strategy
         )
         self._app_id = result.app_id
+        self._client = self._root_load_context.client
         return self
 
     def _get_default_image(self):
@@ -1596,10 +1600,9 @@ class _App:
         # when the App is running, but lazy (and potentially ignored) otherwise. There would be
         # other complications, like what do you do with any tags set in the constructor, and
         # what should  `.get_tags()` do when it's called before the App is running?
-        if self._app_id is None:
-            raise InvalidError("`App.set_tags` cannot be called before the App is running.")
+        app_id = self._ensure_app_id("set_tags")
         check_tag_dict(tags)
-        req = api_pb2.AppSetTagsRequest(app_id=self._app_id, tags=tags)
+        req = api_pb2.AppSetTagsRequest(app_id=app_id, tags=tags)
 
         client = client or self._client or await _Client.from_env()
         await client._stub.AppSetTags(req)
@@ -1613,13 +1616,33 @@ class _App:
         Returns:
             Tags as a map from key to value.
         """
-        if self._app_id is None:
-            raise InvalidError("`App.get_tags` cannot be called before the App is running.")
-        req = api_pb2.AppGetTagsRequest(app_id=self._app_id)
+        app_id = self._ensure_app_id("get_tags")
+        req = api_pb2.AppGetTagsRequest(app_id=app_id)
         client = client or self._client or await _Client.from_env()
         resp = await client._stub.AppGetTags(req)
         return dict(resp.tags)
 
+    async def stop(self, *, client: _Client | None = None) -> None:
+        """Stop the App.
+
+        Stopping an App terminates all of its running containers and sandboxes and prevents
+        new inputs from being processed.
+
+        **Examples:**
+
+        ```python notest
+        app = modal.App.lookup("my-app")
+        app.stop()
+        ```
+
+        Args:
+            client: Modal client to use for the RPC.
+        """
+        app_id = self._ensure_app_id("stop")
+        req = api_pb2.AppStopRequest(app_id=app_id, source=api_pb2.APP_STOP_SOURCE_PYTHON_CLIENT)
+        client = client or self._client or await _Client.from_env()
+        await client._stub.AppStop(req)
+
     @classmethod
     def _get_container_app(cls) -> "_App | None":
         """Returns the `App` running inside a container.
@@ -1634,11 +1657,10 @@ class _App:
 
     async def _get_log_query_data(self) -> _LogQueryData:
         """Get the data needed to query logs for this app."""
-        if not self._app_id:
-            raise InvalidError("`app.logs` requires a running/stopped app.")
+        app_id = self._ensure_app_id("logs")
         client = self._client or await _Client.from_env()
         filters = LogsFilters()
-        return _LogQueryData(client=client, app_id=self._app_id, filters=filters, source_object_id=self._app_id)
+        return _LogQueryData(client=client, app_id=app_id, filters=filters, source_object_id=app_id)
 
     @property
     def logs(self) -> _AppLogsManager:
@@ -1653,8 +1675,7 @@ class _App:
             - [`modal app logs`](https://modal.com/docs/cli/latest/app#modal-app-logs):
                 CLI access to logs for an App.
         """
-        if not self._app_id:
-            raise InvalidError("`app.logs` requires a running/stopped app.")
+        self._ensure_app_id("logs")
 
         return _AppLogsManager(self)
 
@@ -1682,12 +1703,11 @@ class _App:
                 servers=self._info.servers,
                 lifecycle=self._info.lifecycle,
             )
-        if not self._app_id:
-            raise InvalidError("`app.info` requires a running or stopped app.")
-        request = api_pb2.AppGetInfoRequest(app_id=self._app_id)
+        app_id = self._ensure_app_id("info")
+        request = api_pb2.AppGetInfoRequest(app_id=app_id)
         client = self._client or await _Client.from_env()
         resp = await client._stub.AppGetInfo(request)
-        self._info = AppInfo._from_proto(resp.info, self._app_id)
+        self._info = AppInfo._from_proto(resp.info, app_id)
         return self._info
 
 

{modal-1.6.3.dev8 → modal-1.6.3.dev9}/modal/app.pyi

@@ -298,6 +298,7 @@ class _App:
         """
         ...
 
+    def _ensure_app_id(self, method: str) -> str: ...
     def _validate_blueprint_value(self, key: str, value: typing.Any): ...
     def _uncreate_all_objects(self): ...
     def _set_local_app(
@@ -902,6 +903,24 @@ class _App:
         """
         ...
 
+    async def stop(self, *, client: typing.Optional[modal.client._Client] = None) -> None:
+        """Stop the App.
+
+        Stopping an App terminates all of its running containers and sandboxes and prevents
+        new inputs from being processed.
+
+        **Examples:**
+
+        ```python notest
+        app = modal.App.lookup("my-app")
+        app.stop()
+        ```
+
+        Args:
+            client: Modal client to use for the RPC.
+        """
+        ...
+
     @classmethod
     def _get_container_app(cls) -> typing.Optional[_App]:
         """Returns the `App` running inside a container.
@@ -1187,6 +1206,7 @@ class App:
 
     get_dashboard_url: __get_dashboard_url_spec
 
+    def _ensure_app_id(self, method: str) -> str: ...
     def _validate_blueprint_value(self, key: str, value: typing.Any): ...
     def _uncreate_all_objects(self): ...
 
@@ -1975,6 +1995,45 @@ class App:
 
     get_tags: __get_tags_spec
 
+    class __stop_spec(typing_extensions.Protocol):
+        def __call__(self, /, *, client: typing.Optional[modal.client.Client] = None) -> None:
+            """Stop the App.
+
+            Stopping an App terminates all of its running containers and sandboxes and prevents
+            new inputs from being processed.
+
+            **Examples:**
+
+            ```python notest
+            app = modal.App.lookup("my-app")
+            app.stop()
+            ```
+
+            Args:
+                client: Modal client to use for the RPC.
+            """
+            ...
+
+        async def aio(self, /, *, client: typing.Optional[modal.client.Client] = None) -> None:
+            """Stop the App.
+
+            Stopping an App terminates all of its running containers and sandboxes and prevents
+            new inputs from being processed.
+
+            **Examples:**
+
+            ```python notest
+            app = modal.App.lookup("my-app")
+            app.stop()
+            ```
+
+            Args:
+                client: Modal client to use for the RPC.
+            """
+            ...
+
+    stop: __stop_spec
+
     @classmethod
     def _get_container_app(cls) -> typing.Optional[App]:
         """Returns the `App` running inside a container.

{modal-1.6.3.dev8 → modal-1.6.3.dev9}/modal/builder/PREVIEW.txt

@@ -1,7 +1,6 @@
 aiohappyeyeballs==2.7.1
 aiohttp==3.14.5
 aiosignal==1.4.0
-async-timeout==5.0.1 ; python_version < "3.11"
 attrs==26.1.0
 cbor2==5.9.0
 certifi==2026.10.19

{modal-1.6.3.dev8 → modal-1.6.3.dev9}/modal/cli/environment.py

@@ -64,9 +64,11 @@ def list_(json: bool = False):
     for item in envs:
         is_active = item.name == active_env
         is_active_display: Text | str = str(is_active) if json else RenderableBool(is_active)
-        row = [item.name, item.webhook_suffix, is_active_display]
+        # Unset when the Environment inherits the Workspace's image builder version
+        image_builder_version = item.image_builder_version if item.HasField("image_builder_version") else None
+        row = [item.name, item.webhook_suffix, image_builder_version, is_active_display]
         table_data.append(row)
-    display_table(["name", "web suffix", "active"], table_data, json=json)
+    display_table(["name", "web suffix", "image builder version", "active"], table_data, json=json)
 
 
 @environment_cli.command(
@@ -108,18 +110,32 @@ Deletes all Apps in the selected Environment and deletes the Environment irrevoc
 @click.argument("current_name")
 @click.option("--set-name", default=None, help="New name of the Environment.")
 @click.option("--set-web-suffix", default=None, help="New web suffix of the Environment (empty string is no suffix).")
+@click.option(
+    "--set-image-builder-version",
+    default=None,
+    help="New image builder version of the Environment (empty string uses the Workspace default).",
+)
 def update(
     current_name: str,
     set_name: str | None = None,
     set_web_suffix: str | None = None,
+    set_image_builder_version: str | None = None,
 ):
-    if set_name is None and set_web_suffix is None:
-        raise UsageError("You need to at least one new property (using --set-name or --set-web-suffix)")
+    if set_name is None and set_web_suffix is None and set_image_builder_version is None:
+        raise UsageError(
+            "You need to set at least one new property"
+            " (using --set-name, --set-web-suffix, or --set-image-builder-version)"
+        )
 
     if set_name and set_name != current_name:
         check_environment_name(set_name, allow_periods=False)
 
-    environments.update_environment(current_name, new_name=set_name, new_web_suffix=set_web_suffix)
+    environments.update_environment(
+        current_name,
+        new_name=set_name,
+        new_web_suffix=set_web_suffix,
+        new_image_builder_version=set_image_builder_version,
+    )
     rich.print("[green]✓[/green] Environment updated")
 
 

{modal-1.6.3.dev8 → modal-1.6.3.dev9}/modal/cli/workspace.py

@@ -639,3 +639,103 @@ def service_users_set_role(
             f"[green]✓[/green] Updated Service User [bold]{service_user_name}[/bold]'s role in "
             f"Environment [bold]{environment_name}[/bold] to {role.capitalize()}."
         )
+
+
+MEMBER_TOKENS_HELP_TEXT = """Manage Member API Tokens.
+
+All Member Tokens are associated with a unique Member of the Workspace. Any requests to Modal using a
+Token are authenticated as the associated Member (and as such, are governed by the permissions that
+have been assigned to the specific Member). Workspace Owners and Managers can use [`modal environment roles update`](https://modal.com/docs/cli/latest/environment#modal-environment-roles-update)
+to update these permissions programmatically.
+
+This CLI allows users to list and delete the tokens associated to themselves. Workspace Owners
+and Managers can list all tokens in their Workspace, and can delete any of them.
+"""
+
+member_tokens_cli = ModalGroup(name="member-tokens", help=MEMBER_TOKENS_HELP_TEXT)
+workspace_cli.add_command(member_tokens_cli)
+
+
+@member_tokens_cli.command("list")
+@click.option("--json", is_flag=True, default=False, help="Output as JSON.")
+def member_tokens_list(json: bool):
+    """List Member Tokens in the Workspace. Workspace Managers and Owners can see all tokens in the
+    Workspace.
+
+    ```bash
+    modal workspace member-tokens list
+
+    # Show list in JSON format:
+    modal workspace member-tokens list --json
+    ```
+    """
+    ws = Workspace.from_context()
+    tokens = ws.member_tokens.list()
+
+    output_manager = OutputManager.get()
+
+    if json:
+        output_manager.print_json(
+            json_mod.dumps(
+                [
+                    {
+                        "name": tok.name,
+                        "token_id": tok.token_id,
+                        "user_id": tok.user_id,
+                        "username": tok.username,
+                        "created_at": timestamp_to_localized_str(tok.created_at.timestamp()),
+                        "last_used_at": timestamp_to_localized_str(tok.last_used_at.timestamp())
+                        if tok.last_used_at is not None
+                        else None,
+                        "expires_at": timestamp_to_localized_str(tok.expires_at.timestamp())
+                        if tok.expires_at is not None
+                        else None,
+                    }
+                    for tok in tokens
+                ]
+            )
+        )
+        return
+
+    table = rich.table.Table(box=SIMPLE_HEAD)
+    table.add_column("Token ID")
+    table.add_column("Name")
+    table.add_column("Created By")
+    table.add_column("Created At")
+    table.add_column("Expires")
+
+    for tok in tokens:
+        table.add_row(
+            tok.token_id,
+            tok.name if tok.name else "-",
+            tok.username,
+            timestamp_to_localized_str(tok.created_at.timestamp(), isotz=False),
+            timestamp_to_localized_str(tok.expires_at.timestamp(), isotz=False) if tok.expires_at else "-",
+        )
+
+    output_manager.print(table)
+
+
+@member_tokens_cli.command("delete", no_args_is_help=True)
+@click.argument("token_id")
+@click.option("--allow-missing", is_flag=True, default=False, help="Don't error if the Token doesn't exist.")
+@yes_option
+def member_tokens_delete(token_id: str, *, allow_missing: bool, yes: bool):
+    """Delete a Member Token in this Workspace.
+
+    Note that this action is irreversible. This will immediately invalidate the target token and will
+    render it unable to authenticate with Modal.
+
+    ```bash
+    # Delete the Token with ID `ak-0123456789abcdefghijkl`
+    modal workspace member-tokens delete ak-0123456789abcdefghijkl
+    ```
+    """
+    if not yes:
+        confirm_or_suggest_yes(f"Are you sure you want to irrevocably delete the Token '{token_id}'?")
+
+    ws = Workspace.from_context()
+    ws.member_tokens.delete(token_id, allow_missing=allow_missing)
+
+    output_manager = OutputManager.get()
+    output_manager.print(f"[green]✓[/green] Deleted Token `{token_id}`.")

{modal-1.6.3.dev8 → modal-1.6.3.dev9}/modal/client.pyi

@@ -80,7 +80,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.6.3.dev8",
+        version: str = "1.6.3.dev9",
         *,
         oauth_credentials: typing.Optional[_OAuthCredentials] = None,
     ):
@@ -290,7 +290,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.6.3.dev8",
+        version: str = "1.6.3.dev9",
         *,
         oauth_credentials: typing.Optional[_OAuthCredentials] = None,
     ):