modal 0.62.16__py3-none-any.whl → 0.72.11__py3-none-any.whl

modal/secret.py

@@ -1,15 +1,17 @@
 # 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 .app import is_local
+from ._utils.name_utils import check_object_name
 from .client import _Client
 from .exception import InvalidError, NotFoundError
 from .object import _get_environment_name, _Object
@@ -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
     ):
@@ -37,7 +39,7 @@ class _Secret(_Object, type_prefix="st"):
 
         Usage:
         ```python
-        @stub.function(secrets=[modal.Secret.from_dict({"FOO": "bar"})])
+        @app.function(secrets=[modal.Secret.from_dict({"FOO": "bar"})])
         def run():
             print(os.environ["FOO"])
         ```
@@ -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,13 +90,13 @@ 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({})
 
     @staticmethod
-    def from_dotenv(path=None):
+    def from_dotenv(path=None, *, filename=".env"):
         """Create secrets from a .env file automatically.
 
         If no argument is provided, it will use the current working directory as the starting
@@ -98,13 +106,22 @@ class _Secret(_Object, type_prefix="st"):
         If called with an argument, it will use that as a starting point for finding `.env` files.
         In particular, you can call it like this:
         ```python
-        @stub.function(secrets=[modal.Secret.from_dotenv(__file__)])
+        @app.function(secrets=[modal.Secret.from_dotenv(__file__)])
         def run():
             print(os.environ["USERNAME"])  # Assumes USERNAME is defined in your .env file
         ```
 
         This will use the location of the script calling `modal.Secret.from_dotenv` as a
         starting point for finding the `.env` file.
+
+        A file named `.env` is expected by default, but this can be overridden with the `filename`
+        keyword argument:
+
+        ```python
+        @app.function(secrets=[modal.Secret.from_dotenv(filename=".env-dev")])
+        def run():
+            ...
+        ```
         """
 
         async def _load(self: _Secret, resolver: Resolver, existing_object_id: Optional[str]):
@@ -119,17 +136,17 @@ class _Secret(_Object, type_prefix="st"):
             if path is not None:
                 # This basically implements the logic in find_dotenv
                 for dirname in _walk_to_root(path):
-                    check_path = os.path.join(dirname, ".env")
+                    check_path = os.path.join(dirname, filename)
                     if os.path.isfile(check_path):
                         dotenv_path = check_path
                         break
                 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(usecwd=True)
+                dotenv_path = find_dotenv(filename, usecwd=True)
 
             env_dict = dotenv_values(dotenv_path)
 
@@ -142,20 +159,28 @@ 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")
 
-        @stub.function(secrets=[secret])
+        @app.function(secrets=[secret])
         def run():
            ...
         ```
@@ -163,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)
@@ -176,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)
@@ -202,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):
-        ...
-
+    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):
-        ...
-
+    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,43 +1,48 @@
 # 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_stub
+from .cli.import_refs import import_app
 from .client import _Client
 from .config import config
-from .runner import _run_stub, serve_update
+from .output import _get_output_manager, enable_output
+from .runner import _run_app, serve_update
 
 if TYPE_CHECKING:
-    from .stub import _Stub
+    from .app import _App
 else:
-    _Stub = TypeVar("_Stub")
+    _App = TypeVar("_App")
 
 
-def _run_serve(stub_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
-    _stub = import_stub(stub_ref)
-    blocking_stub = synchronizer._translate_out(_stub, Interface.BLOCKING)
-    serve_update(blocking_stub, existing_app_id, is_ready, environment_name)
+    _app = import_app(app_ref)
+    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(
-    stub_ref: str, existing_app_id: str, environment_name: str, timeout: float = 5.0
+    app_ref: str, existing_app_id: str, environment_name: str, timeout: float = 5.0
 ) -> SpawnProcess:
     ctx = multiprocessing.get_context("spawn")  # Needed to reload the interpreter
     is_ready = ctx.Event()
-    p = ctx.Process(target=_run_serve, args=(stub_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,28 +50,27 @@ 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
 
 
 async def _run_watch_loop(
-    stub_ref: str,
+    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,55 +79,46 @@ 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)
-                curr_proc = await _restart_serve(stub_ref, existing_app_id=app_id, environment_name=environment_name)
+                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_stub_description(stub_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(stub_ref)
-        return " ".join(sys.argv[func_ref_arg_idx:])
-    except ValueError:
-        return " ".join(sys.argv)
+            await _terminate(curr_proc)
 
 
 @asynccontextmanager
-async def _serve_stub(
-    stub: "_Stub",
-    stub_ref: str,
-    stdout: Optional[io.TextIOWrapper] = None,
-    show_progress: bool = True,
-    _watcher: Optional[AsyncGenerator[Set[str], None]] = None,  # for testing
+async def _serve_app(
+    app: "_App",
+    app_ref: str,
+    _watcher: Optional[AsyncGenerator[set[str], None]] = None,  # for testing
     environment_name: Optional[str] = None,
-) -> AsyncGenerator["_Stub", None]:
+) -> AsyncGenerator["_App", None]:
     if environment_name is None:
         environment_name = config.get("environment")
 
     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 = stub._get_watch_mounts()
-        watcher = watch(mounts_to_watch, output_mgr)
-
-    async with _run_stub(stub, client=client, output_mgr=output_mgr, environment_name=environment_name):
-        client.set_pre_stop(stub._local_app.disconnect)
+    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(stub_ref, stub.app_id, output_mgr, watcher, environment_name))
-            yield stub
+            tc.create_task(_run_watch_loop(app_ref, app.app_id, watcher, environment_name))
+            yield app
+
+
+def _serve_stub(*args, **kwargs):
+    deprecation_error((2024, 5, 1), "`serve_stub` is deprecated. Please use `serve_app` instead.")
 
 
+serve_app = synchronize_api(_serve_app)
 serve_stub = synchronize_api(_serve_stub)

modal/serving.pyi

@@ -1,42 +1,50 @@
-import _io
-import modal._output
+import collections.abc
 import multiprocessing.context
 import multiprocessing.synchronize
 import synchronicity.combined_types
 import typing
 import typing_extensions
 
-_Stub = typing.TypeVar("_Stub")
-
-def _run_serve(stub_ref: str, existing_app_id: str, is_ready: multiprocessing.synchronize.Event, environment_name: str):
-    ...
-
-
-async def _restart_serve(stub_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(stub_ref: str, app_id: str, output_mgr: modal._output.OutputManager, watcher: typing.AsyncGenerator[typing.Set[str], None], environment_name: str):
-    ...
-
-
-def _get_clean_stub_description(stub_ref: str) -> str:
-    ...
-
-
-def _serve_stub(stub: _Stub, stub_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[_Stub]:
-    ...
-
-
-class __serve_stub_spec(typing_extensions.Protocol):
-    def __call__(self, stub: _Stub, stub_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[_Stub]:
-        ...
-
-    def aio(self, stub: _Stub, stub_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[_Stub]:
-        ...
-
-serve_stub: __serve_stub_spec
+_App = typing.TypeVar("_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,
+        _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(*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]"
     )