modal 1.1.5.dev83__py3-none-any.whl → 1.3.1.dev8__py3-none-any.whl

modal/secret.py

@@ -1,21 +1,21 @@
 # Copyright Modal Labs 2022
+import builtins
 import os
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Optional, Union
 
 from google.protobuf.message import Message
-from grpclib import GRPCError, Status
 from synchronicity import classproperty
 
 from modal_proto import api_pb2
 
+from ._load_context import LoadContext
 from ._object import _get_environment_name, _Object, live_method
 from ._resolver import Resolver
 from ._runtime.execution_context import is_local
 from ._utils.async_utils import synchronize_api
 from ._utils.deprecation import deprecation_warning, warn_if_passing_namespace
-from ._utils.grpc_utils import retry_transient_errors
 from ._utils.name_utils import check_object_name
 from ._utils.time_utils import as_timestamp, timestamp_to_localized_dt
 from .client import _Client
@@ -91,11 +91,9 @@ class _SecretManager:
             env_dict=env_dict,
         )
         try:
-            await retry_transient_errors(client.stub.SecretGetOrCreate, req)
-        except GRPCError as exc:
-            if exc.status == Status.ALREADY_EXISTS and not allow_existing:
-                raise AlreadyExistsError(exc.message)
-            else:
+            await client.stub.SecretGetOrCreate(req)
+        except AlreadyExistsError:
+            if not allow_existing:
                 raise
 
     @staticmethod
@@ -105,7 +103,7 @@ class _SecretManager:
         created_before: Optional[Union[datetime, str]] = None,  # Limit based on creation date
         environment_name: str = "",  # Uses active environment if not specified
         client: Optional[_Client] = None,  # Optional client with Modal credentials
-    ) -> list["_Secret"]:
+    ) -> builtins.list["_Secret"]:
         """Return a list of hydrated Secret objects.
 
         **Examples:**
@@ -143,7 +141,7 @@ class _SecretManager:
             req = api_pb2.SecretListRequest(
                 environment_name=_get_environment_name(environment_name), pagination=pagination
             )
-            resp = await retry_transient_errors(client.stub.SecretList, req)
+            resp = await client.stub.SecretList(req)
             items.extend(resp.items)
             finished = (len(resp.items) < max_page_size) or (max_objects is not None and len(items) >= max_objects)
             return finished
@@ -200,12 +198,32 @@ class _SecretManager:
                 raise
         else:
             req = api_pb2.SecretDeleteRequest(secret_id=obj.object_id)
-            await retry_transient_errors(obj._client.stub.SecretDelete, req)
+            await obj._client.stub.SecretDelete(req)
 
 
 SecretManager = synchronize_api(_SecretManager)
 
 
+async def _load_from_env_dict(instance: "_Secret", load_context: LoadContext, env_dict: dict[str, str]):
+    """helper method for loaders .from_dict and .from_dotenv etc."""
+    if load_context.app_id is not None:
+        req = api_pb2.SecretGetOrCreateRequest(
+            object_creation_type=api_pb2.OBJECT_CREATION_TYPE_ANONYMOUS_OWNED_BY_APP,
+            env_dict=env_dict,
+            app_id=load_context.app_id,
+            environment_name=load_context.environment_name,
+        )
+    else:
+        req = api_pb2.SecretGetOrCreateRequest(
+            object_creation_type=api_pb2.OBJECT_CREATION_TYPE_EPHEMERAL,
+            env_dict=env_dict,
+            environment_name=load_context.environment_name,
+        )
+
+    resp = await load_context.client.stub.SecretGetOrCreate(req)
+    instance._hydrate(resp.secret_id, load_context.client, resp.metadata)
+
+
 class _Secret(_Object, type_prefix="st"):
     """Secrets provide a dictionary of environment variables for images.
 
@@ -260,30 +278,14 @@ class _Secret(_Object, type_prefix="st"):
         if not all(isinstance(v, str) for v in env_dict_filtered.values()):
             raise InvalidError(ENV_DICT_WRONG_TYPE_ERR)
 
-        async def _load(self: _Secret, resolver: Resolver, existing_object_id: Optional[str]):
-            if resolver.app_id is not None:
-                object_creation_type = api_pb2.OBJECT_CREATION_TYPE_ANONYMOUS_OWNED_BY_APP
-            else:
-                object_creation_type = api_pb2.OBJECT_CREATION_TYPE_EPHEMERAL
-
-            req = api_pb2.SecretGetOrCreateRequest(
-                object_creation_type=object_creation_type,
-                env_dict=env_dict_filtered,
-                app_id=resolver.app_id,
-                environment_name=resolver.environment_name,
-            )
-            try:
-                resp = await resolver.client.stub.SecretGetOrCreate(req)
-            except GRPCError as exc:
-                if exc.status == Status.INVALID_ARGUMENT:
-                    raise InvalidError(exc.message)
-                if exc.status == Status.FAILED_PRECONDITION:
-                    raise InvalidError(exc.message)
-                raise
-            self._hydrate(resp.secret_id, resolver.client, resp.metadata)
+        async def _load(
+            self: _Secret, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]
+        ):
+            await _load_from_env_dict(self, load_context, env_dict_filtered)
 
         rep = f"Secret.from_dict([{', '.join(env_dict.keys())}])"
-        return _Secret._from_loader(_load, rep, hydrate_lazily=True)
+        # TODO: scoping - these should probably not be lazily hydrated without having an app and/or sandbox association
+        return _Secret._from_loader(_load, rep, hydrate_lazily=True, load_context_overrides=LoadContext.empty())
 
     @staticmethod
     def from_local_environ(
@@ -303,7 +305,7 @@ class _Secret(_Object, type_prefix="st"):
         return _Secret.from_dict({})
 
     @staticmethod
-    def from_dotenv(path=None, *, filename=".env") -> "_Secret":
+    def from_dotenv(path=None, *, filename=".env", client: Optional[_Client] = None) -> "_Secret":
         """Create secrets from a .env file automatically.
 
         If no argument is provided, it will use the current working directory as the starting
@@ -331,7 +333,9 @@ class _Secret(_Object, type_prefix="st"):
         ```
         """
 
-        async def _load(self: _Secret, resolver: Resolver, existing_object_id: Optional[str]):
+        async def _load(
+            self: _Secret, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]
+        ):
             try:
                 from dotenv import dotenv_values, find_dotenv
                 from dotenv.main import _walk_to_root
@@ -355,18 +359,13 @@ class _Secret(_Object, type_prefix="st"):
                 # To simplify this, we just support the cwd and don't do any automatic path inference.
                 dotenv_path = find_dotenv(filename, usecwd=True)
 
-            env_dict = dotenv_values(dotenv_path)
-
-            req = api_pb2.SecretGetOrCreateRequest(
-                object_creation_type=api_pb2.OBJECT_CREATION_TYPE_ANONYMOUS_OWNED_BY_APP,
-                env_dict=env_dict,
-                app_id=resolver.app_id,
-            )
-            resp = await resolver.client.stub.SecretGetOrCreate(req)
+            env_dict = {k: v or "" for k, v in dotenv_values(dotenv_path).items()}
 
-            self._hydrate(resp.secret_id, resolver.client, resp.metadata)
+            await _load_from_env_dict(self, load_context, env_dict)
 
-        return _Secret._from_loader(_load, "Secret.from_dotenv()", hydrate_lazily=True)
+        return _Secret._from_loader(
+            _load, "Secret.from_dotenv()", hydrate_lazily=True, load_context_overrides=LoadContext(client=client)
+        )
 
     @staticmethod
     def from_name(
@@ -377,6 +376,7 @@ class _Secret(_Object, type_prefix="st"):
         required_keys: list[
             str
         ] = [],  # Optionally, a list of required environment variables (will be asserted server-side)
+        client: Optional[_Client] = None,
     ) -> "_Secret":
         """Reference a Secret by its name.
 
@@ -394,23 +394,25 @@ class _Secret(_Object, type_prefix="st"):
         """
         warn_if_passing_namespace(namespace, "modal.Secret.from_name")
 
-        async def _load(self: _Secret, resolver: Resolver, existing_object_id: Optional[str]):
+        async def _load(
+            self: _Secret, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]
+        ):
             req = api_pb2.SecretGetOrCreateRequest(
                 deployment_name=name,
-                environment_name=_get_environment_name(environment_name, resolver),
+                environment_name=load_context.environment_name,
                 required_keys=required_keys,
             )
-            try:
-                response = await resolver.client.stub.SecretGetOrCreate(req)
-            except GRPCError as exc:
-                if exc.status == Status.NOT_FOUND:
-                    raise NotFoundError(exc.message)
-                else:
-                    raise
-            self._hydrate(response.secret_id, resolver.client, response.metadata)
+            response = await load_context.client.stub.SecretGetOrCreate(req)
+            self._hydrate(response.secret_id, load_context.client, response.metadata)
 
         rep = _Secret._repr(name, environment_name)
-        return _Secret._from_loader(_load, rep, hydrate_lazily=True, name=name)
+        return _Secret._from_loader(
+            _load,
+            rep,
+            hydrate_lazily=True,
+            name=name,
+            load_context_overrides=LoadContext(environment_name=environment_name, client=client),
+        )
 
     @staticmethod
     async def create_deployed(
@@ -454,7 +456,7 @@ class _Secret(_Object, type_prefix="st"):
             object_creation_type=object_creation_type,
             env_dict=env_dict,
         )
-        resp = await retry_transient_errors(client.stub.SecretGetOrCreate, request)
+        resp = await client.stub.SecretGetOrCreate(request)
         return resp.secret_id
 
     @live_method

modal/secret.pyi

@@ -1,5 +1,6 @@
 import datetime
 import google.protobuf.message
+import modal._load_context
 import modal._object
 import modal.client
 import modal.object
@@ -219,7 +220,7 @@ class SecretManager:
             """
             ...
 
-    create: __create_spec
+    create: typing.ClassVar[__create_spec]
 
     class __list_spec(typing_extensions.Protocol):
         def __call__(
@@ -292,7 +293,7 @@ class SecretManager:
             """
             ...
 
-    list: __list_spec
+    list: typing.ClassVar[__list_spec]
 
     class __delete_spec(typing_extensions.Protocol):
         def __call__(
@@ -353,7 +354,13 @@ class SecretManager:
             """
             ...
 
-    delete: __delete_spec
+    delete: typing.ClassVar[__delete_spec]
+
+async def _load_from_env_dict(
+    instance: _Secret, load_context: modal._load_context.LoadContext, env_dict: dict[str, str]
+):
+    """helper method for loaders .from_dict and .from_dotenv etc."""
+    ...
 
 class _Secret(modal._object._Object):
     """Secrets provide a dictionary of environment variables for images.
@@ -392,7 +399,7 @@ class _Secret(modal._object._Object):
         ...
 
     @staticmethod
-    def from_dotenv(path=None, *, filename=".env") -> _Secret:
+    def from_dotenv(path=None, *, filename=".env", client: typing.Optional[modal.client._Client] = None) -> _Secret:
         """Create secrets from a .env file automatically.
 
         If no argument is provided, it will use the current working directory as the starting
@@ -423,7 +430,12 @@ class _Secret(modal._object._Object):
 
     @staticmethod
     def from_name(
-        name: str, *, namespace=None, environment_name: typing.Optional[str] = None, required_keys: list[str] = []
+        name: str,
+        *,
+        namespace=None,
+        environment_name: typing.Optional[str] = None,
+        required_keys: list[str] = [],
+        client: typing.Optional[modal.client._Client] = None,
     ) -> _Secret:
         """Reference a Secret by its name.
 
@@ -469,8 +481,6 @@ class _Secret(modal._object._Object):
         """Return information about the Secret object."""
         ...
 
-SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
-
 class Secret(modal.object.Object):
     """Secrets provide a dictionary of environment variables for images.
 
@@ -512,7 +522,7 @@ class Secret(modal.object.Object):
         ...
 
     @staticmethod
-    def from_dotenv(path=None, *, filename=".env") -> Secret:
+    def from_dotenv(path=None, *, filename=".env", client: typing.Optional[modal.client.Client] = None) -> Secret:
         """Create secrets from a .env file automatically.
 
         If no argument is provided, it will use the current working directory as the starting
@@ -543,7 +553,12 @@ class Secret(modal.object.Object):
 
     @staticmethod
     def from_name(
-        name: str, *, namespace=None, environment_name: typing.Optional[str] = None, required_keys: list[str] = []
+        name: str,
+        *,
+        namespace=None,
+        environment_name: typing.Optional[str] = None,
+        required_keys: list[str] = [],
+        client: typing.Optional[modal.client.Client] = None,
     ) -> Secret:
         """Reference a Secret by its name.
 
@@ -588,7 +603,7 @@ class Secret(modal.object.Object):
             """mdmd:hidden"""
             ...
 
-    create_deployed: __create_deployed_spec
+    create_deployed: typing.ClassVar[__create_deployed_spec]
 
     class ___create_deployed_spec(typing_extensions.Protocol):
         def __call__(
@@ -617,9 +632,9 @@ class Secret(modal.object.Object):
             """mdmd:hidden"""
             ...
 
-    _create_deployed: ___create_deployed_spec
+    _create_deployed: typing.ClassVar[___create_deployed_spec]
 
-    class __info_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __info_spec(typing_extensions.Protocol):
         def __call__(self, /) -> SecretInfo:
             """Return information about the Secret object."""
             ...
@@ -628,4 +643,4 @@ class Secret(modal.object.Object):
             """Return information about the Secret object."""
             ...
 
-    info: __info_spec[typing_extensions.Self]
+    info: __info_spec

modal/serving.py

@@ -4,13 +4,13 @@ import platform
 from collections.abc import AsyncGenerator
 from multiprocessing.context import SpawnProcess
 from multiprocessing.synchronize import Event
-from typing import TYPE_CHECKING, Optional, TypeVar
+from typing import TYPE_CHECKING, Optional
 
 from synchronicity.async_wrap import asynccontextmanager
 
 from modal._output import OutputManager
 
-from ._utils.async_utils import TaskContext, asyncify, synchronize_api, synchronizer
+from ._utils.async_utils import TaskContext, asyncify, synchronize_api
 from ._utils.logger import logger
 from ._watcher import watch
 from .cli.import_refs import ImportRef, import_app_from_ref
@@ -20,20 +20,16 @@ from .output import _get_output_manager, enable_output
 from .runner import _run_app, serve_update
 
 if TYPE_CHECKING:
-    from .app import _App
-else:
-    _App = TypeVar("_App")
+    import modal.app
 
 
 def _run_serve(
     import_ref: ImportRef, existing_app_id: str, is_ready: Event, environment_name: str, show_progress: bool
 ):
-    # subprocess entrypoint
-    _app = import_app_from_ref(import_ref, base_cmd="modal serve")
-    blocking_app = synchronizer._translate_out(_app)
+    app = import_app_from_ref(import_ref, base_cmd="modal serve")
 
     with enable_output(show_progress=show_progress):
-        serve_update(blocking_app, existing_app_id, is_ready, environment_name)
+        serve_update(app, existing_app_id, is_ready, environment_name)
 
 
 async def _restart_serve(
@@ -97,12 +93,12 @@ async def _run_watch_loop(
 
 @asynccontextmanager
 async def _serve_app(
-    app: "_App",
+    app: "modal.app._App",
     import_ref: ImportRef,
     *,
     _watcher: Optional[AsyncGenerator[set[str], None]] = None,  # for testing
     environment_name: Optional[str] = None,
-) -> AsyncGenerator["_App", None]:
+) -> AsyncGenerator["modal.app._App", None]:
     if environment_name is None:
         environment_name = config.get("environment")
 

modal/serving.pyi

@@ -1,4 +1,5 @@
 import collections.abc
+import modal.app
 import modal.cli.import_refs
 import multiprocessing.context
 import multiprocessing.synchronize
@@ -6,8 +7,6 @@ import synchronicity.combined_types
 import typing
 import typing_extensions
 
-_App = typing.TypeVar("_App")
-
 def _run_serve(
     import_ref: modal.cli.import_refs.ImportRef,
     existing_app_id: str,
@@ -27,31 +26,31 @@ async def _run_watch_loop(
     environment_name: str,
 ): ...
 def _serve_app(
-    app: _App,
+    app: modal.app._App,
     import_ref: modal.cli.import_refs.ImportRef,
     *,
     _watcher: typing.Optional[collections.abc.AsyncGenerator[set[str], None]] = None,
     environment_name: typing.Optional[str] = None,
-) -> typing.AsyncContextManager[_App]: ...
+) -> typing.AsyncContextManager[modal.app._App]: ...
 
 class __serve_app_spec(typing_extensions.Protocol):
     def __call__(
         self,
         /,
-        app: _App,
+        app: modal.app.App,
         import_ref: modal.cli.import_refs.ImportRef,
         *,
         _watcher: typing.Optional[typing.Generator[set[str], None, None]] = None,
         environment_name: typing.Optional[str] = None,
-    ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[_App]: ...
+    ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[modal.app.App]: ...
     def aio(
         self,
         /,
-        app: _App,
+        app: modal.app.App,
         import_ref: modal.cli.import_refs.ImportRef,
         *,
         _watcher: typing.Optional[collections.abc.AsyncGenerator[set[str], None]] = None,
         environment_name: typing.Optional[str] = None,
-    ) -> typing.AsyncContextManager[_App]: ...
+    ) -> typing.AsyncContextManager[modal.app.App]: ...
 
 serve_app: __serve_app_spec

modal/snapshot.py

@@ -1,12 +1,15 @@
 # Copyright Modal Labs 2024
-from typing import Optional
+from typing import Optional, cast
 
+import typing_extensions
+
+import modal.client
 from modal_proto import api_pb2
 
+from ._load_context import LoadContext
 from ._object import _Object
 from ._resolver import Resolver
-from ._utils.async_utils import synchronize_api
-from ._utils.grpc_utils import retry_transient_errors
+from ._utils.async_utils import deprecate_aio_usage, synchronize_api, synchronizer
 from .client import _Client
 
 
@@ -19,24 +22,35 @@ class _SandboxSnapshot(_Object, type_prefix="sn"):
     the original Sandbox at the time the snapshot was taken.
     """
 
-    @staticmethod
-    async def from_id(sandbox_snapshot_id: str, client: Optional[_Client] = None):
+    @deprecate_aio_usage((2025, 12, 5), "SandboxSnapshot.from_id")
+    @classmethod
+    def from_id(
+        cls, sandbox_snapshot_id: str, client: Optional["modal.client.Client"] = None
+    ) -> typing_extensions.Self:
         """
         Construct a `SandboxSnapshot` object from a sandbox snapshot ID.
         """
-        if client is None:
-            client = await _Client.from_env()
-
-        async def _load(self: _SandboxSnapshot, resolver: Resolver, existing_object_id: Optional[str]):
-            await retry_transient_errors(
-                client.stub.SandboxSnapshotGet, api_pb2.SandboxSnapshotGetRequest(snapshot_id=sandbox_snapshot_id)
+        _client = cast(_Client, synchronizer._translate_in(client))
+
+        async def _load(
+            self: _SandboxSnapshot, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]
+        ):
+            # hydration doesn't actually do much apart from validating the existance of the id
+            # which is implicitly done by trying to start a sandbox from the snapshot as well
+            resp: api_pb2.SandboxSnapshotGetResponse = await load_context.client.stub.SandboxSnapshotGet(
+                api_pb2.SandboxSnapshotGetRequest(snapshot_id=sandbox_snapshot_id)
             )
+            self._hydrate(resp.snapshot_id, load_context.client, None)
 
         rep = "SandboxSnapshot()"
-        obj = _SandboxSnapshot._from_loader(_load, rep)
-        obj._hydrate(sandbox_snapshot_id, client, None)
-
-        return obj
+        obj = _SandboxSnapshot._from_loader(
+            _load, rep, load_context_overrides=LoadContext(client=_client), hydrate_lazily=True
+        )
+        # Setting the object id directly is a bit hacky, but
+        # it avoids hydrating the object fully if it's going
+        # to be used only for its object id anyway
+        obj._object_id = sandbox_snapshot_id
+        return cast(typing_extensions.Self, synchronizer._translate_out(obj))
 
 
 SandboxSnapshot = synchronize_api(_SandboxSnapshot)

modal/snapshot.pyi

@@ -4,6 +4,8 @@ import modal.object
 import typing
 import typing_extensions
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class _SandboxSnapshot(modal._object._Object):
     """> Sandbox memory snapshots are in **early preview**.
 
@@ -11,10 +13,16 @@ class _SandboxSnapshot(modal._object._Object):
     `._experimental_snapshot()` on a Sandbox instance. This includes both the filesystem and memory state of
     the original Sandbox at the time the snapshot was taken.
     """
-    @staticmethod
-    async def from_id(sandbox_snapshot_id: str, client: typing.Optional[modal.client._Client] = None):
-        """Construct a `SandboxSnapshot` object from a sandbox snapshot ID."""
-        ...
+    class __from_id_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(
+            self, /, sandbox_snapshot_id: str, client: typing.Optional[modal.client.Client] = None
+        ) -> SUPERSELF:
+            """Construct a `SandboxSnapshot` object from a sandbox snapshot ID."""
+            ...
+
+        async def aio(self, /, sandbox_snapshot_id: str, client: typing.Optional[modal.client.Client] = None): ...
+
+    from_id: typing.ClassVar[__from_id_spec[typing_extensions.Self]]
 
 class SandboxSnapshot(modal.object.Object):
     """> Sandbox memory snapshots are in **early preview**.
@@ -27,13 +35,13 @@ class SandboxSnapshot(modal.object.Object):
         """mdmd:hidden"""
         ...
 
-    class __from_id_spec(typing_extensions.Protocol):
-        def __call__(self, /, sandbox_snapshot_id: str, client: typing.Optional[modal.client.Client] = None):
+    class __from_id_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(
+            self, /, sandbox_snapshot_id: str, client: typing.Optional[modal.client.Client] = None
+        ) -> SUPERSELF:
             """Construct a `SandboxSnapshot` object from a sandbox snapshot ID."""
             ...
 
-        async def aio(self, /, sandbox_snapshot_id: str, client: typing.Optional[modal.client.Client] = None):
-            """Construct a `SandboxSnapshot` object from a sandbox snapshot ID."""
-            ...
+        async def aio(self, /, sandbox_snapshot_id: str, client: typing.Optional[modal.client.Client] = None): ...
 
-    from_id: __from_id_spec
+    from_id: typing.ClassVar[__from_id_spec[typing_extensions.Self]]

modal/token_flow.py

@@ -56,7 +56,7 @@ class _TokenFlow:
         req = api_pb2.TokenFlowWaitRequest(
             token_flow_id=self.token_flow_id, timeout=timeout, wait_secret=self.wait_secret
         )
-        resp = await self.stub.TokenFlowWait(req, timeout=(timeout + grpc_extra_timeout))
+        resp = await self.stub.TokenFlowWait(req, retry=None, timeout=timeout + grpc_extra_timeout)
         if not resp.timeout:
             return resp
         else:

modal/token_flow.pyi

@@ -21,12 +21,10 @@ class _TokenFlow:
         """mdmd:hidden"""
         ...
 
-SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
-
 class TokenFlow:
     def __init__(self, client: modal.client.Client): ...
 
-    class __start_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __start_spec(typing_extensions.Protocol):
         def __call__(
             self, /, utm_source: typing.Optional[str] = None, next_url: typing.Optional[str] = None
         ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[tuple[str, str, str]]:
@@ -39,9 +37,9 @@ class TokenFlow:
             """mdmd:hidden"""
             ...
 
-    start: __start_spec[typing_extensions.Self]
+    start: __start_spec
 
-    class __finish_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __finish_spec(typing_extensions.Protocol):
         def __call__(
             self, /, timeout: float = 40.0, grpc_extra_timeout: float = 5.0
         ) -> typing.Optional[modal_proto.api_pb2.TokenFlowWaitResponse]:
@@ -54,7 +52,7 @@ class TokenFlow:
             """mdmd:hidden"""
             ...
 
-    finish: __finish_spec[typing_extensions.Self]
+    finish: __finish_spec
 
 async def _new_token(
     *,