modal 0.62.115__py3-none-any.whl → 0.72.13__py3-none-any.whl

modal/secret.py

@@ -1,17 +1,19 @@
 # Copyright Modal Labs 2022
 import os
-from typing import Dict, List, Optional, Union
+from typing import Optional, Union
 
 from grpclib import GRPCError, Status
 
 from modal_proto import api_pb2
 
 from ._resolver import Resolver
+from ._runtime.execution_context import is_local
 from ._utils.async_utils import synchronize_api
+from ._utils.deprecation import renamed_parameter
 from ._utils.grpc_utils import retry_transient_errors
+from ._utils.name_utils import check_object_name
 from .client import _Client
 from .exception import InvalidError, NotFoundError
-from .execution_context import is_local
 from .object import _get_environment_name, _Object
 
 ENV_DICT_WRONG_TYPE_ERR = "the env_dict argument to Secret has to be a dict[str, Union[str, None]]"
@@ -29,7 +31,7 @@ class _Secret(_Object, type_prefix="st"):
 
     @staticmethod
     def from_dict(
-        env_dict: Dict[
+        env_dict: dict[
             str, Union[str, None]
         ] = {},  # dict of entries to be inserted as environment variables in functions using the secret
     ):
@@ -45,17 +47,23 @@ class _Secret(_Object, type_prefix="st"):
         if not isinstance(env_dict, dict):
             raise InvalidError(ENV_DICT_WRONG_TYPE_ERR)
 
-        env_dict_filtered: Dict[str, str] = {k: v for k, v in env_dict.items() if v is not None}
+        env_dict_filtered: dict[str, str] = {k: v for k, v in env_dict.items() if v is not None}
         if not all(isinstance(k, str) for k in env_dict_filtered.keys()):
             raise InvalidError(ENV_DICT_WRONG_TYPE_ERR)
         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=api_pb2.OBJECT_CREATION_TYPE_ANONYMOUS_OWNED_BY_APP,
+                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)
@@ -68,11 +76,11 @@ class _Secret(_Object, type_prefix="st"):
             self._hydrate(resp.secret_id, resolver.client, None)
 
         rep = f"Secret.from_dict([{', '.join(env_dict.keys())}])"
-        return _Secret._from_loader(_load, rep)
+        return _Secret._from_loader(_load, rep, hydrate_lazily=True)
 
     @staticmethod
     def from_local_environ(
-        env_keys: List[str],  # list of local env vars to be included for remote execution
+        env_keys: list[str],  # list of local env vars to be included for remote execution
     ):
         """Create secrets from local environment variables automatically."""
 
@@ -82,7 +90,7 @@ class _Secret(_Object, type_prefix="st"):
             except KeyError as exc:
                 missing_key = exc.args[0]
                 raise InvalidError(
-                    f"Could not find local environment variable '{missing_key}' for Secret.from_local_env_vars"
+                    f"Could not find local environment variable '{missing_key}' for Secret.from_local_environ"
                 )
 
         return _Secret.from_dict({})
@@ -135,8 +143,8 @@ class _Secret(_Object, type_prefix="st"):
                 else:
                     dotenv_path = ""
             else:
-                # TODO(erikbern): dotenv tries to locate .env files based on the location of the file in the stack frame.
-                # Since the modal code "intermediates" this, a .env file in the user's local directory won't be picked up.
+                # TODO(erikbern): dotenv tries to locate .env files based on location of the file in the stack frame.
+                # Since the modal code "intermediates" this, a .env file in user's local directory won't be picked up.
                 # To simplify this, we just support the cwd and don't do any automatic path inference.
                 dotenv_path = find_dotenv(filename, usecwd=True)
 
@@ -151,15 +159,23 @@ class _Secret(_Object, type_prefix="st"):
 
             self._hydrate(resp.secret_id, resolver.client, None)
 
-        return _Secret._from_loader(_load, "Secret.from_dotenv()")
+        return _Secret._from_loader(_load, "Secret.from_dotenv()", hydrate_lazily=True)
 
     @staticmethod
+    @renamed_parameter((2024, 12, 18), "label", "name")
     def from_name(
-        label: str,
+        name: str,
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         environment_name: Optional[str] = None,
+        required_keys: list[
+            str
+        ] = [],  # Optionally, a list of required environment variables (will be asserted server-side)
     ) -> "_Secret":
-        """Create a reference to a persisted Secret
+        """Reference a Secret by its name.
+
+        In contrast to most other Modal objects, named Secrets must be provisioned
+        from the Dashboard. See other methods for alternate ways of creating a new
+        Secret from code.
 
         ```python
         secret = modal.Secret.from_name("my-secret")
@@ -172,9 +188,10 @@ class _Secret(_Object, type_prefix="st"):
 
         async def _load(self: _Secret, resolver: Resolver, existing_object_id: Optional[str]):
             req = api_pb2.SecretGetOrCreateRequest(
-                deployment_name=label,
+                deployment_name=name,
                 namespace=namespace,
                 environment_name=_get_environment_name(environment_name, resolver),
+                required_keys=required_keys,
             )
             try:
                 response = await resolver.client.stub.SecretGetOrCreate(req)
@@ -185,23 +202,21 @@ class _Secret(_Object, type_prefix="st"):
                     raise
             self._hydrate(response.secret_id, resolver.client, None)
 
-        return _Secret._from_loader(_load, "Secret()")
+        return _Secret._from_loader(_load, "Secret()", hydrate_lazily=True)
 
     @staticmethod
+    @renamed_parameter((2024, 12, 18), "label", "name")
     async def lookup(
-        label: str,
+        name: str,
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         client: Optional[_Client] = None,
         environment_name: Optional[str] = None,
+        required_keys: list[str] = [],
     ) -> "_Secret":
-        """Lookup a secret with a given name
-
-        ```python
-        s = modal.Secret.lookup("my-secret")
-        print(s.object_id)
-        ```
-        """
-        obj = _Secret.from_name(label, namespace=namespace, environment_name=environment_name)
+        """mdmd:hidden"""
+        obj = _Secret.from_name(
+            name, namespace=namespace, environment_name=environment_name, required_keys=required_keys
+        )
         if client is None:
             client = await _Client.from_env()
         resolver = Resolver(client=client)
@@ -211,13 +226,14 @@ class _Secret(_Object, type_prefix="st"):
     @staticmethod
     async def create_deployed(
         deployment_name: str,
-        env_dict: Dict[str, str],
+        env_dict: dict[str, str],
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         client: Optional[_Client] = None,
         environment_name: Optional[str] = None,
         overwrite: bool = False,
     ) -> str:
         """mdmd:hidden"""
+        check_object_name(deployment_name, "Secret")
         if client is None:
             client = await _Client.from_env()
         if overwrite:

modal/secret.pyi

@@ -5,64 +5,84 @@ import typing_extensions
 
 class _Secret(modal.object._Object):
     @staticmethod
-    def from_dict(env_dict: typing.Dict[str, typing.Union[str, None]] = {}):
-        ...
-
+    def from_dict(env_dict: dict[str, typing.Optional[str]] = {}): ...
     @staticmethod
-    def from_local_environ(env_keys: typing.List[str]):
-        ...
-
+    def from_local_environ(env_keys: list[str]): ...
     @staticmethod
-    def from_dotenv(path=None, *, filename='.env'):
-        ...
-
+    def from_dotenv(path=None, *, filename=".env"): ...
     @staticmethod
-    def from_name(label: str, namespace=1, environment_name: typing.Union[str, None] = None) -> _Secret:
-        ...
-
+    def from_name(
+        name: str, namespace=1, environment_name: typing.Optional[str] = None, required_keys: list[str] = []
+    ) -> _Secret: ...
     @staticmethod
-    async def lookup(label: str, namespace=1, client: typing.Union[modal.client._Client, None] = None, environment_name: typing.Union[str, None] = None) -> _Secret:
-        ...
-
+    async def lookup(
+        name: str,
+        namespace=1,
+        client: typing.Optional[modal.client._Client] = None,
+        environment_name: typing.Optional[str] = None,
+        required_keys: list[str] = [],
+    ) -> _Secret: ...
     @staticmethod
-    async def create_deployed(deployment_name: str, env_dict: typing.Dict[str, str], namespace=1, client: typing.Union[modal.client._Client, None] = None, environment_name: typing.Union[str, None] = None, overwrite: bool = False) -> str:
-        ...
-
+    async def create_deployed(
+        deployment_name: str,
+        env_dict: dict[str, str],
+        namespace=1,
+        client: typing.Optional[modal.client._Client] = None,
+        environment_name: typing.Optional[str] = None,
+        overwrite: bool = False,
+    ) -> str: ...
 
 class Secret(modal.object.Object):
-    def __init__(self, *args, **kwargs):
-        ...
-
+    def __init__(self, *args, **kwargs): ...
     @staticmethod
-    def from_dict(env_dict: typing.Dict[str, typing.Union[str, None]] = {}):
-        ...
-
+    def from_dict(env_dict: dict[str, typing.Optional[str]] = {}): ...
     @staticmethod
-    def from_local_environ(env_keys: typing.List[str]):
-        ...
-
+    def from_local_environ(env_keys: list[str]): ...
     @staticmethod
-    def from_dotenv(path=None, *, filename='.env'):
-        ...
-
+    def from_dotenv(path=None, *, filename=".env"): ...
     @staticmethod
-    def from_name(label: str, namespace=1, environment_name: typing.Union[str, None] = None) -> Secret:
-        ...
+    def from_name(
+        name: str, namespace=1, environment_name: typing.Optional[str] = None, required_keys: list[str] = []
+    ) -> Secret: ...
 
     class __lookup_spec(typing_extensions.Protocol):
-        def __call__(self, label: str, namespace=1, client: typing.Union[modal.client.Client, None] = None, environment_name: typing.Union[str, None] = None) -> Secret:
-            ...
-
-        async def aio(self, *args, **kwargs) -> Secret:
-            ...
+        def __call__(
+            self,
+            name: str,
+            namespace=1,
+            client: typing.Optional[modal.client.Client] = None,
+            environment_name: typing.Optional[str] = None,
+            required_keys: list[str] = [],
+        ) -> Secret: ...
+        async def aio(
+            self,
+            name: str,
+            namespace=1,
+            client: typing.Optional[modal.client.Client] = None,
+            environment_name: typing.Optional[str] = None,
+            required_keys: list[str] = [],
+        ) -> Secret: ...
 
     lookup: __lookup_spec
 
     class __create_deployed_spec(typing_extensions.Protocol):
-        def __call__(self, deployment_name: str, env_dict: typing.Dict[str, str], namespace=1, client: typing.Union[modal.client.Client, None] = None, environment_name: typing.Union[str, None] = None, overwrite: bool = False) -> str:
-            ...
-
-        async def aio(self, *args, **kwargs) -> str:
-            ...
+        def __call__(
+            self,
+            deployment_name: str,
+            env_dict: dict[str, str],
+            namespace=1,
+            client: typing.Optional[modal.client.Client] = None,
+            environment_name: typing.Optional[str] = None,
+            overwrite: bool = False,
+        ) -> str: ...
+        async def aio(
+            self,
+            deployment_name: str,
+            env_dict: dict[str, str],
+            namespace=1,
+            client: typing.Optional[modal.client.Client] = None,
+            environment_name: typing.Optional[str] = None,
+            overwrite: bool = False,
+        ) -> str: ...
 
     create_deployed: __create_deployed_spec

modal/serving.py

@@ -1,23 +1,24 @@
 # Copyright Modal Labs 2023
-import io
 import multiprocessing
 import platform
-import sys
+from collections.abc import AsyncGenerator
 from multiprocessing.context import SpawnProcess
 from multiprocessing.synchronize import Event
-from typing import TYPE_CHECKING, AsyncGenerator, Optional, Set, TypeVar
+from typing import TYPE_CHECKING, Optional, TypeVar
 
-from synchronicity import Interface
 from synchronicity.async_wrap import asynccontextmanager
 
-from ._output import OutputManager
+from modal._output import OutputManager
+
 from ._utils.async_utils import TaskContext, asyncify, synchronize_api, synchronizer
+from ._utils.deprecation import deprecation_error
 from ._utils.logger import logger
 from ._watcher import watch
 from .cli.import_refs import import_app
 from .client import _Client
 from .config import config
-from .runner import _disconnect, _run_app, serve_update
+from .output import _get_output_manager, enable_output
+from .runner import _run_app, serve_update
 
 if TYPE_CHECKING:
     from .app import _App
@@ -25,11 +26,13 @@ else:
     _App = TypeVar("_App")
 
 
-def _run_serve(app_ref: str, existing_app_id: str, is_ready: Event, environment_name: str):
+def _run_serve(app_ref: str, existing_app_id: str, is_ready: Event, environment_name: str, show_progress: bool):
     # subprocess entrypoint
     _app = import_app(app_ref)
-    blocking_app = synchronizer._translate_out(_app, Interface.BLOCKING)
-    serve_update(blocking_app, existing_app_id, is_ready, environment_name)
+    blocking_app = synchronizer._translate_out(_app)
+
+    with enable_output(show_progress=show_progress):
+        serve_update(blocking_app, existing_app_id, is_ready, environment_name)
 
 
 async def _restart_serve(
@@ -37,7 +40,9 @@ async def _restart_serve(
 ) -> SpawnProcess:
     ctx = multiprocessing.get_context("spawn")  # Needed to reload the interpreter
     is_ready = ctx.Event()
-    p = ctx.Process(target=_run_serve, args=(app_ref, existing_app_id, is_ready, environment_name))
+    output_mgr = OutputManager.get()
+    show_progress = output_mgr is not None
+    p = ctx.Process(target=_run_serve, args=(app_ref, existing_app_id, is_ready, environment_name, show_progress))
     p.start()
     await asyncify(is_ready.wait)(timeout)
     # TODO(erikbern): we don't fail if the above times out, but that's somewhat intentional, since
@@ -45,18 +50,18 @@ async def _restart_serve(
     return p
 
 
-async def _terminate(proc: Optional[SpawnProcess], output_mgr: OutputManager, timeout: float = 5.0):
+async def _terminate(proc: Optional[SpawnProcess], timeout: float = 5.0):
     if proc is None:
         return
     try:
         proc.terminate()
         await asyncify(proc.join)(timeout)
         if proc.exitcode is not None:
-            output_mgr.print_if_visible(f"Serve process {proc.pid} terminated")
+            if output_mgr := _get_output_manager():
+                output_mgr.print(f"Serve process {proc.pid} terminated")
         else:
-            output_mgr.print_if_visible(
-                f"[red]Serve process {proc.pid} didn't terminate after {timeout}s, killing it[/red]"
-            )
+            if output_mgr := _get_output_manager():
+                output_mgr.print(f"[red]Serve process {proc.pid} didn't terminate after {timeout}s, killing it[/red]")
             proc.kill()
     except ProcessLookupError:
         pass  # Child process already finished
@@ -65,8 +70,7 @@ async def _terminate(proc: Optional[SpawnProcess], output_mgr: OutputManager, ti
 async def _run_watch_loop(
     app_ref: str,
     app_id: str,
-    output_mgr: OutputManager,
-    watcher: AsyncGenerator[Set[str], None],
+    watcher: AsyncGenerator[set[str], None],
     environment_name: str,
 ):
     unsupported_msg = None
@@ -75,36 +79,25 @@ async def _run_watch_loop(
         " This can hopefully be fixed in a future version of Modal."
 
     if unsupported_msg:
-        async for _ in watcher:
-            output_mgr.print_if_visible(unsupported_msg)
+        if output_mgr := _get_output_manager():
+            async for _ in watcher:
+                output_mgr.print(unsupported_msg)
     else:
         curr_proc = None
         try:
             async for trigger_files in watcher:
                 logger.debug(f"The following files triggered an app update: {', '.join(trigger_files)}")
-                await _terminate(curr_proc, output_mgr)
+                await _terminate(curr_proc)
                 curr_proc = await _restart_serve(app_ref, existing_app_id=app_id, environment_name=environment_name)
         finally:
-            await _terminate(curr_proc, output_mgr)
-
-
-def _get_clean_app_description(app_ref: str) -> str:
-    # If possible, consider the 'ref' argument the start of the app's args. Everything
-    # before it Modal CLI cruft (eg. `modal serve --timeout 1.0`).
-    try:
-        func_ref_arg_idx = sys.argv.index(app_ref)
-        return " ".join(sys.argv[func_ref_arg_idx:])
-    except ValueError:
-        return " ".join(sys.argv)
+            await _terminate(curr_proc)
 
 
 @asynccontextmanager
 async def _serve_app(
     app: "_App",
     app_ref: str,
-    stdout: Optional[io.TextIOWrapper] = None,
-    show_progress: bool = True,
-    _watcher: Optional[AsyncGenerator[Set[str], None]] = None,  # for testing
+    _watcher: Optional[AsyncGenerator[set[str], None]] = None,  # for testing
     environment_name: Optional[str] = None,
 ) -> AsyncGenerator["_App", None]:
     if environment_name is None:
@@ -112,23 +105,20 @@ async def _serve_app(
 
     client = await _Client.from_env()
 
-    output_mgr = OutputManager(stdout, show_progress, "Running app...")
-    if _watcher is not None:
-        watcher = _watcher  # Only used by tests
-    else:
-        mounts_to_watch = app._get_watch_mounts()
-        watcher = watch(mounts_to_watch, output_mgr)
-
-    async with _run_app(app, client=client, output_mgr=output_mgr, environment_name=environment_name):
-        app_id: str = app.app_id
-        client.set_pre_stop(lambda: _disconnect(client, app_id))
+    async with _run_app(app, client=client, environment_name=environment_name):
+        if _watcher is not None:
+            watcher = _watcher  # Only used by tests
+        else:
+            mounts_to_watch = app._get_watch_mounts()
+            watcher = watch(mounts_to_watch)
         async with TaskContext(grace=0.1) as tc:
-            tc.create_task(_run_watch_loop(app_ref, app.app_id, output_mgr, watcher, environment_name))
+            tc.create_task(_run_watch_loop(app_ref, app.app_id, watcher, environment_name))
             yield app
 
 
-serve_app = synchronize_api(_serve_app)
+def _serve_stub(*args, **kwargs):
+    deprecation_error((2024, 5, 1), "`serve_stub` is deprecated. Please use `serve_app` instead.")
 
-# Soon-to-be-deprecated ones, add warning soon
-_serve_stub = _serve_app
-serve_stub = serve_app
+
+serve_app = synchronize_api(_serve_app)
+serve_stub = synchronize_api(_serve_stub)

modal/serving.pyi

@@ -1,5 +1,4 @@
-import _io
-import modal._output
+import collections.abc
 import multiprocessing.context
 import multiprocessing.synchronize
 import synchronicity.combined_types
@@ -8,49 +7,44 @@ import typing_extensions
 
 _App = typing.TypeVar("_App")
 
-def _run_serve(app_ref: str, existing_app_id: str, is_ready: multiprocessing.synchronize.Event, environment_name: str):
-    ...
-
-
-async def _restart_serve(app_ref: str, existing_app_id: str, environment_name: str, timeout: float = 5.0) -> multiprocessing.context.SpawnProcess:
-    ...
-
-
-async def _terminate(proc: typing.Union[multiprocessing.context.SpawnProcess, None], output_mgr: modal._output.OutputManager, timeout: float = 5.0):
-    ...
-
-
-async def _run_watch_loop(app_ref: str, app_id: str, output_mgr: modal._output.OutputManager, watcher: typing.AsyncGenerator[typing.Set[str], None], environment_name: str):
-    ...
-
-
-def _get_clean_app_description(app_ref: str) -> str:
-    ...
-
-
-def _serve_app(app: _App, app_ref: str, stdout: typing.Union[_io.TextIOWrapper, None] = None, show_progress: bool = True, _watcher: typing.Union[typing.AsyncGenerator[typing.Set[str], None], None] = None, environment_name: typing.Union[str, None] = None) -> typing.AsyncContextManager[_App]:
-    ...
-
+def _run_serve(
+    app_ref: str,
+    existing_app_id: str,
+    is_ready: multiprocessing.synchronize.Event,
+    environment_name: str,
+    show_progress: bool,
+): ...
+async def _restart_serve(
+    app_ref: str, existing_app_id: str, environment_name: str, timeout: float = 5.0
+) -> multiprocessing.context.SpawnProcess: ...
+async def _terminate(proc: typing.Optional[multiprocessing.context.SpawnProcess], timeout: float = 5.0): ...
+async def _run_watch_loop(
+    app_ref: str, app_id: str, watcher: collections.abc.AsyncGenerator[set[str], None], environment_name: str
+): ...
+def _serve_app(
+    app: _App,
+    app_ref: str,
+    _watcher: typing.Optional[collections.abc.AsyncGenerator[set[str], None]] = None,
+    environment_name: typing.Optional[str] = None,
+) -> typing.AsyncContextManager[_App]: ...
+def _serve_stub(*args, **kwargs): ...
 
 class __serve_app_spec(typing_extensions.Protocol):
-    def __call__(self, app: _App, app_ref: str, stdout: typing.Union[_io.TextIOWrapper, None] = None, show_progress: bool = True, _watcher: typing.Union[typing.Generator[typing.Set[str], None, None], None] = None, environment_name: typing.Union[str, None] = None) -> synchronicity.combined_types.AsyncAndBlockingContextManager[_App]:
-        ...
-
-    def aio(self, app: _App, app_ref: str, stdout: typing.Union[_io.TextIOWrapper, None] = None, show_progress: bool = True, _watcher: typing.Union[typing.AsyncGenerator[typing.Set[str], None], None] = None, environment_name: typing.Union[str, None] = None) -> typing.AsyncContextManager[_App]:
-        ...
+    def __call__(
+        self,
+        app: _App,
+        app_ref: str,
+        _watcher: typing.Optional[typing.Generator[set[str], None, None]] = None,
+        environment_name: typing.Optional[str] = None,
+    ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[_App]: ...
+    def aio(
+        self,
+        app: _App,
+        app_ref: str,
+        _watcher: typing.Optional[collections.abc.AsyncGenerator[set[str], None]] = None,
+        environment_name: typing.Optional[str] = None,
+    ) -> typing.AsyncContextManager[_App]: ...
 
 serve_app: __serve_app_spec
 
-
-def _serve_stub(app: _App, app_ref: str, stdout: typing.Union[_io.TextIOWrapper, None] = None, show_progress: bool = True, _watcher: typing.Union[typing.AsyncGenerator[typing.Set[str], None], None] = None, environment_name: typing.Union[str, None] = None) -> typing.AsyncContextManager[_App]:
-    ...
-
-
-class __serve_stub_spec(typing_extensions.Protocol):
-    def __call__(self, app: _App, app_ref: str, stdout: typing.Union[_io.TextIOWrapper, None] = None, show_progress: bool = True, _watcher: typing.Union[typing.Generator[typing.Set[str], None, None], None] = None, environment_name: typing.Union[str, None] = None) -> synchronicity.combined_types.AsyncAndBlockingContextManager[_App]:
-        ...
-
-    def aio(self, app: _App, app_ref: str, stdout: typing.Union[_io.TextIOWrapper, None] = None, show_progress: bool = True, _watcher: typing.Union[typing.AsyncGenerator[typing.Set[str], None], None] = None, environment_name: typing.Union[str, None] = None) -> typing.AsyncContextManager[_App]:
-        ...
-
-serve_stub: __serve_stub_spec
+def serve_stub(*args, **kwargs): ...

modal/stream_type.py

@@ -0,0 +1,15 @@
+# Copyright Modal Labs 2022
+import subprocess
+from enum import Enum
+
+
+class StreamType(Enum):
+    # Discard all logs from the stream.
+    DEVNULL = subprocess.DEVNULL
+    # Store logs in a pipe to be read by the client.
+    PIPE = subprocess.PIPE
+    # Print logs to stdout immediately.
+    STDOUT = subprocess.STDOUT
+
+    def __repr__(self):
+        return f"{self.__module__}.{self.__class__.__name__}.{self.name}"

modal/token_flow.py

@@ -2,7 +2,8 @@
 import itertools
 import os
 import webbrowser
-from typing import AsyncGenerator, Optional, Tuple
+from collections.abc import AsyncGenerator
+from typing import Optional
 
 import aiohttp.web
 from rich.console import Console
@@ -24,7 +25,7 @@ class _TokenFlow:
     @asynccontextmanager
     async def start(
         self, utm_source: Optional[str] = None, next_url: Optional[str] = None
-    ) -> AsyncGenerator[Tuple[str, str, str], None]:
+    ) -> AsyncGenerator[tuple[str, str, str], None]:
         """mdmd:hidden"""
         # Run a temporary http server returning the token id on /
         # This helps us add direct validation later
@@ -153,7 +154,8 @@ async def _set_token(
     with console.status("Storing token", spinner="dots"):
         _store_user_config(config_data, profile=profile, active_profile=active_profile)
     console.print(
-        f"[green]Token written to [magenta]{user_config_path}[/magenta] in profile [magenta]{profile}[/magenta].[/green]"
+        f"[green]Token written to [magenta]{user_config_path}[/magenta] in profile "
+        f"[magenta]{profile}[/magenta].[/green]"
     )