modal 1.4.2.dev0__tar.gz → 1.4.2.dev2__tar.gz

{modal-1.4.2.dev0 → modal-1.4.2.dev2}/PKG-INFO

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

{modal-1.4.2.dev0 → modal-1.4.2.dev2}/modal/_utils/rand_pb_testing.py

@@ -52,8 +52,9 @@ def _fill(msg, desc: Descriptor, rand: Random) -> None:
         if hasattr(field, "is_repeated"):
             is_repeated = field.is_repeated  # type: ignore
         else:
-            is_repeated = field.label == FieldDescriptor.LABEL_REPEATED
+            is_repeated = field.label == FieldDescriptor.LABEL_REPEATED  # type: ignore[attr-defined]
         if is_message:
+            assert field.message_type is not None
             msg_field = getattr(msg, field.name)
             if is_repeated:
                 num = rand.randint(0, 2)
@@ -64,6 +65,7 @@ def _fill(msg, desc: Descriptor, rand: Random) -> None:
                 _fill(msg_field, field.message_type, rand)
         else:
             if field.type == FieldDescriptor.TYPE_ENUM:
+                assert field.enum_type is not None
                 enum_values = [x.number for x in field.enum_type.values]
                 generator = lambda rand: rand.choice(enum_values)  # noqa: E731
 

{modal-1.4.2.dev0 → modal-1.4.2.dev2}/modal/_utils/task_command_router_client.py

@@ -122,6 +122,15 @@ async def fetch_command_router_access(server_client, task_id: str) -> api_pb2.Ta
     )
 
 
+async def fetch_command_router_access_v2(
+    server_client, sandbox_id: str
+) -> api_pb2.SandboxGetCommandRouterAccessResponse:
+    """Fetch direct command router access info from Modal server for a V2 sandbox."""
+    return await server_client.stub.SandboxGetCommandRouterAccess(
+        api_pb2.SandboxGetCommandRouterAccessRequest(sandbox_id=sandbox_id),
+    )
+
+
 def _finalize_channel(loop, channel):
     if not loop.is_closed():
         # only run if loop has not shut down
@@ -139,27 +148,19 @@ class TaskCommandRouterClient:
     """
 
     @classmethod
-    async def try_init(
+    async def _connect(
         cls,
         server_client,
         task_id: str,
-    ) -> Optional["TaskCommandRouterClient"]:
-        """Attempt to initialize a TaskCommandRouterClient by fetching direct access.
-
-        Returns None if command router access is not enabled (FAILED_PRECONDITION).
-        """
-        try:
-            resp = await fetch_command_router_access(server_client, task_id)
-        except ConflictError:
-            logger.debug(f"Command router access is not enabled for task {task_id}")
-            return None
-
-        logger.debug(f"Using command router access for task {task_id}")
-
-        # Build and connect a channel to the task command router now that we have access info.
-        o = urllib.parse.urlparse(resp.url)
+        url: str,
+        jwt: str,
+        *,
+        sandbox_id: Optional[str] = None,
+    ) -> "TaskCommandRouterClient":
+        """Build a connected client from a jwt and url."""
+        o = urllib.parse.urlparse(url)
         if o.scheme != "https":
-            raise ValueError(f"Task router URL must be https, got: {resp.url}")
+            raise ValueError(f"Task router URL must be https, got: {url}")
 
         host, _, port_str = o.netloc.partition(":")
         port = int(port_str) if port_str else 443
@@ -189,7 +190,38 @@ class TaskCommandRouterClient:
         loop = asyncio.get_running_loop()
         jwt_refresh_lock = asyncio.Lock()
 
-        return cls(server_client, task_id, resp.url, resp.jwt, channel, loop, jwt_refresh_lock)
+        return cls(server_client, task_id, url, jwt, channel, loop, jwt_refresh_lock, sandbox_id=sandbox_id)
+
+    @classmethod
+    async def try_init(
+        cls,
+        server_client,
+        task_id: str,
+    ) -> Optional["TaskCommandRouterClient"]:
+        """Attempt to initialize a TaskCommandRouterClient by fetching direct access.
+
+        Returns None if command router access is not enabled (FAILED_PRECONDITION).
+        """
+        try:
+            resp = await fetch_command_router_access(server_client, task_id)
+        except ConflictError:
+            logger.debug(f"Command router access is not enabled for task {task_id}")
+            return None
+
+        logger.debug(f"Using command router access for task {task_id}")
+        return await cls._connect(server_client, task_id, resp.url, resp.jwt)
+
+    @classmethod
+    async def init_v2(
+        cls,
+        server_client,
+        sandbox_id: str,
+        task_id: str,
+    ) -> "TaskCommandRouterClient":
+        """Initialize a TaskCommandRouterClient for a V2 sandbox."""
+        resp = await fetch_command_router_access_v2(server_client, sandbox_id)
+        logger.debug(f"Using command router access for sandbox {sandbox_id}")
+        return await cls._connect(server_client, task_id, resp.url, resp.jwt, sandbox_id=sandbox_id)
 
     def __init__(
         self,
@@ -201,6 +233,7 @@ class TaskCommandRouterClient:
         loop: asyncio.AbstractEventLoop,
         jwt_refresh_lock: asyncio.Lock,
         *,
+        sandbox_id: Optional[str] = None,
         stream_stdio_retry_delay_secs: float = 0.01,
         stream_stdio_retry_delay_factor: float = 2,
         stream_stdio_max_retries: int = 10,
@@ -213,6 +246,7 @@ class TaskCommandRouterClient:
         # Attach bearer token on all requests to the worker-side router service.
         self._server_client = server_client
         self._task_id = task_id
+        self._sandbox_id = sandbox_id
         self._server_url = server_url
         self._jwt = jwt
         self._channel = channel
@@ -237,6 +271,10 @@ class TaskCommandRouterClient:
 
         self._stub = TaskCommandRouterStub(self._channel)
 
+    @property
+    def _is_v2_sandbox(self) -> bool:
+        return self._sandbox_id is not None
+
     def _get_metadata(self):
         return {"authorization": f"Bearer {self._jwt}"}
 
@@ -452,14 +490,21 @@ class TaskCommandRouterClient:
                 )
                 return
 
-            logger.debug(f"Refreshing JWT for exec with task ID {self._task_id}")
-            resp = await fetch_command_router_access(self._server_client, self._task_id)
-            logger.debug(f"Finished refreshing JWT for exec with task ID {self._task_id}")
+            if self._is_v2_sandbox:
+                logger.debug(f"Refreshing JWT for exec with sandbox ID {self._sandbox_id}")
+                v2_resp = await fetch_command_router_access_v2(self._server_client, self._sandbox_id)
+                logger.debug(f"Finished refreshing JWT for exec with sandbox ID {self._sandbox_id}")
+                jwt, url = v2_resp.jwt, v2_resp.url
+            else:
+                logger.debug(f"Refreshing JWT for exec with task ID {self._task_id}")
+                v1_resp = await fetch_command_router_access(self._server_client, self._task_id)
+                logger.debug(f"Finished refreshing JWT for exec with task ID {self._task_id}")
+                jwt, url = v1_resp.jwt, v1_resp.url
 
             # Ensure the server URL remains stable for the lifetime of this client.
-            assert resp.url == self._server_url, "Task router URL changed during session"
-            self._jwt = resp.jwt
-            self._jwt_exp = _parse_jwt_expiration(resp.jwt)
+            assert url == self._server_url, "Task router URL changed during session"
+            self._jwt = jwt
+            self._jwt_exp = _parse_jwt_expiration(jwt)
 
     async def _call_with_auth_retry(self, func, *args, **kwargs):
         try:

{modal-1.4.2.dev0 → modal-1.4.2.dev2}/modal/app.py

@@ -1290,12 +1290,12 @@ class _App:
 
         ```python
         app_a = modal.App("a")
-        @app.function()
+        @app_a.function()
         def foo():
             ...
 
         app_b = modal.App("b")
-        @app.function()
+        @app_b.function()
         def bar():
             ...
 

{modal-1.4.2.dev0 → modal-1.4.2.dev2}/modal/app.pyi

@@ -618,12 +618,12 @@ class _App:
 
         ```python
         app_a = modal.App("a")
-        @app.function()
+        @app_a.function()
         def foo():
             ...
 
         app_b = modal.App("b")
-        @app.function()
+        @app_b.function()
         def bar():
             ...
 
@@ -1334,12 +1334,12 @@ class App:
 
         ```python
         app_a = modal.App("a")
-        @app.function()
+        @app_a.function()
         def foo():
             ...
 
         app_b = modal.App("b")
-        @app.function()
+        @app_b.function()
         def bar():
             ...
 

{modal-1.4.2.dev0 → modal-1.4.2.dev2}/modal/cli/app.py

@@ -1,8 +1,12 @@
 # Copyright Modal Labs 2022
 import re
+import sys
+import time
+import warnings
 from datetime import datetime, timedelta, timezone
-from typing import Optional, Union
+from typing import Optional, Union, get_args
 
+import click
 import rich
 import typer
 from click import UsageError
@@ -11,10 +15,13 @@ from rich.text import Text
 from typer import Argument
 
 from modal._object import _get_environment_name
+from modal._traceback import print_server_warnings
 from modal._utils.async_utils import synchronizer
 from modal._utils.browser_utils import open_url_and_display
 from modal.client import _Client
 from modal.environments import ensure_env
+from modal.output import OutputManager
+from modal.runner import DEPLOYMENT_STRATEGY_TYPE, _stop_and_wait_for_containers
 from modal_proto import api_pb2
 
 from .._logs import _FETCH_LIMIT, _MAX_FETCH_RANGE, LogsFilters
@@ -464,3 +471,62 @@ async def dashboard(
 
     url = f"https://modal.com/id/{app_id}"
     open_url_and_display(url, "App dashboard")
+
+
+@app_cli.command("rollover", no_args_is_help=True, context_settings={"ignore_unknown_options": True})
+@synchronizer.create_blocking
+async def rollover(
+    app_identifier: str = APP_IDENTIFIER,
+    *,
+    strategy: str = typer.Option(
+        "rolling",
+        help="Strategy for rollover",
+        click_type=click.Choice(get_args(DEPLOYMENT_STRATEGY_TYPE)),
+    ),
+    env: Optional[str] = ENV_OPTION,
+):
+    """Rollover an App.
+
+    A rollover replaces existing containers with fresh ones built from the same
+    App version — useful for refreshing containers without changing your code.
+    The rollover appears as a new entry in the App's deployment history.
+
+    **Examples:**
+
+    Rollover an App using a rolling deployment. Running containers are now considered
+    outdated and new containers will replace them.
+
+    ```
+    modal app rollover my-app
+    ```
+
+    Rollover an App by termatining all running containers. Inputs on the queue will
+    start new containers.
+
+    ```
+    modal app rollover my-app --strategy recreate
+    ```
+    """
+    env = ensure_env(env)
+    output_mgr = OutputManager.get()
+    output_mgr.print(f"🔨 Starting app rollover with {strategy} strategy")
+    t0 = time.monotonic()
+
+    client = await _Client.from_env()
+    app_id = await get_app_id.aio(app_identifier, env, client)
+
+    req = api_pb2.AppRolloverRequest(app_id=app_id)
+    response = await client.stub.AppRollover(req)
+    print_server_warnings(response.server_warnings)
+
+    if strategy == "recreate":
+        try:
+            await _stop_and_wait_for_containers(client, app_id, response.deployed_at, env)
+        except Exception as exc:
+            warnings.warn(f"App updated successfully, but containers did not all terminate. {exc}", UserWarning)
+            output_mgr.print(f"\nView Deployment: [magenta]{response.url}[/magenta]")
+            sys.exit(1)
+
+    duration = time.monotonic() - t0
+    output_mgr.step_completed(f"Rollover completed in {duration:.3f}s with {strategy} strategy! 🎉")
+    output_mgr.print(f"\nView Deployment: [magenta]{response.url}[/magenta]")

{modal-1.4.2.dev0 → modal-1.4.2.dev2}/modal/cli/import_refs.py

@@ -40,8 +40,11 @@ class ImportRef:
     # app [+ function/entrypoint on that app]
     object_path: str = dataclasses.field(default="")
 
+    # modal command that was invoked, so that we can provide helpful error messages
+    command: str = dataclasses.field(default="")
 
-def parse_import_ref(object_ref: str, use_module_mode: bool = False) -> ImportRef:
+
+def parse_import_ref(object_ref: str, use_module_mode: bool = False, command: str = "") -> ImportRef:
     if object_ref.find("::") > 1:
         file_or_module, object_path = object_ref.split("::", 1)
     elif object_ref.find(":") > 1:
@@ -49,7 +52,7 @@ def parse_import_ref(object_ref: str, use_module_mode: bool = False) -> ImportRe
     else:
         file_or_module, object_path = object_ref, ""
 
-    return ImportRef(file_or_module, use_module_mode, object_path)
+    return ImportRef(file_or_module, use_module_mode, object_path, command)
 
 
 DEFAULT_APP_NAME = "app"
@@ -94,6 +97,22 @@ def import_file_or_module(import_ref: ImportRef, base_cmd: str = ""):
             assert spec.loader
             spec.loader.exec_module(module)
         except Exception as exc:
+            if isinstance(exc, ImportError) and "attempted relative import with no known parent package" in str(exc):
+                if import_ref.file_or_module and import_ref.command and not import_ref.use_module_mode:
+                    file_path = Path(import_ref.file_or_module)
+                    suggested_module_path = ".".join(file_path.parts).removesuffix(".py").lstrip(".")
+                    suffix = f"::{import_ref.object_path}" if import_ref.object_path else ""
+                    new_message = (
+                        "The source file contains relative imports and is therefore written as "
+                        "part of a Python package, but Modal was invoked in script mode "
+                        f"(`{import_ref.command} {import_ref.file_or_module}{suffix}`). "
+                        "Try invoking Modal in module mode instead, i.e. "
+                        f"`{import_ref.command} -m {suggested_module_path}{suffix}`, "
+                        "assuming that your path starts at the root of the package."
+                    )
+                    new_exc = InvalidError(new_message)
+                    new_exc.__traceback__ = exc.__traceback__
+                    raise _CliUserExecutionError(str(full_path)) from new_exc
             raise _CliUserExecutionError(str(full_path)) from exc
 
     return module

{modal-1.4.2.dev0 → modal-1.4.2.dev2}/modal/cli/run.py

@@ -407,7 +407,7 @@ class RunGroup(click.Group):
         ctx.ensure_object(dict)
         ctx.obj["env"] = ensure_env(ctx.params["env"])
 
-        import_ref = parse_import_ref(func_ref, use_module_mode=ctx.params["m"])
+        import_ref = parse_import_ref(func_ref, use_module_mode=ctx.params["m"], command="modal run")
         runnable, all_usable_commands = import_and_filter(
             import_ref, base_cmd="modal run", accept_local_entrypoint=True, accept_webhook=False
         )
@@ -517,7 +517,7 @@ def deploy(
     # this ensures that lookups without environment specification use the same env as specified
     env = ensure_env(env)
 
-    import_ref = parse_import_ref(app_ref, use_module_mode=use_module_mode)
+    import_ref = parse_import_ref(app_ref, use_module_mode=use_module_mode, command="modal deploy")
 
     OutputManager.get().set_timestamps(timestamps)
     app = import_app_from_ref(import_ref, base_cmd="modal deploy")
@@ -568,7 +568,7 @@ def serve(
 
     """
     env = ensure_env(env)
-    import_ref = parse_import_ref(app_ref, use_module_mode=use_module_mode)
+    import_ref = parse_import_ref(app_ref, use_module_mode=use_module_mode, command="modal serve")
 
     OutputManager.get().set_timestamps(timestamps)
     app = import_app_from_ref(import_ref, base_cmd="modal serve")

{modal-1.4.2.dev0 → modal-1.4.2.dev2}/modal/cli/shell.py

@@ -140,7 +140,7 @@ def _start_shell_in_running_container(ref: str, cmd: str, pty: bool) -> None:
 
 
 def _function_spec_from_ref(ref: str, use_module_mode: bool) -> _FunctionSpec:
-    import_ref = parse_import_ref(ref, use_module_mode=use_module_mode)
+    import_ref = parse_import_ref(ref, use_module_mode=use_module_mode, command="modal shell")
     runnable, all_usable_commands = import_and_filter(
         import_ref,
         base_cmd="modal shell",

{modal-1.4.2.dev0 → modal-1.4.2.dev2}/modal/client.pyi

@@ -35,7 +35,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.4.2.dev0",
+        version: str = "1.4.2.dev2",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -171,7 +171,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.4.2.dev0",
+        version: str = "1.4.2.dev2",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.4.2.dev0 → modal-1.4.2.dev2}/modal/config.py

@@ -136,12 +136,13 @@ def _agent_environment() -> Optional[str]:
     # Tool-specific environment variables
     _TOOL_SPECIFIC_ENV_VARS: list[tuple[str, str]] = [
         ("CLAUDECODE", "claude-code"),
+        ("CODEX_THREAD_ID", "codex"),
         ("GEMINI_CLI", "gemini-cli"),
         ("CURSOR_AGENT", "cursor"),
         ("CLINE_ACTIVE", "cline"),
         ("AUGMENT_AGENT", "augment"),
         ("OPENCODE_CLIENT", "opencode"),
-        ("GOOSE_TERMINAL", "goose"),
+        ("GOOSE_TERMINAL", "goose"),  # honk
         ("TRAE_AI_SHELL_ID", "trae"),
     ]
     for env_var, agent_name in _TOOL_SPECIFIC_ENV_VARS:

{modal-1.4.2.dev0 → modal-1.4.2.dev2}/modal/functions.pyi

@@ -348,7 +348,7 @@ class Function(
 
     _call_generator: ___call_generator_spec
 
-    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER:
             """Calls the function remotely, executing it with the given arguments and returning the execution's result."""
             ...
@@ -357,7 +357,7 @@ class Function(
             """Calls the function remotely, executing it with the given arguments and returning the execution's result."""
             ...
 
-    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P]
+    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType]
 
     class __remote_gen_spec(typing_extensions.Protocol):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -384,7 +384,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """[Experimental] Calls the function with the given arguments, without waiting for the results.
 
@@ -407,7 +407,7 @@ class Function(
             """
             ...
 
-    _experimental_spawn: ___experimental_spawn_spec[modal._functions.ReturnType, modal._functions.P]
+    _experimental_spawn: ___experimental_spawn_spec[modal._functions.P, modal._functions.ReturnType]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> None: ...
@@ -415,7 +415,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P]
 
-    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """Calls the function with the given arguments, without waiting for the results.
 
@@ -436,7 +436,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P]
+    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]:
         """Return the inner Python object wrapped by this Modal Function."""

{modal-1.4.2.dev0 → modal-1.4.2.dev2}/modal/sandbox.py

@@ -1187,9 +1187,13 @@ class _Sandbox(_Object, type_prefix="sb"):
 
     async def _get_command_router_client(self, task_id: str) -> Optional[TaskCommandRouterClient]:
         if self._command_router_client is None:
-            # Attempt to initialize a router client. Returns None if the new exec path not enabled
-            # for this sandbox.
-            self._command_router_client = await TaskCommandRouterClient.try_init(self._client, task_id)
+            if self._is_v2:
+                self._command_router_client = await TaskCommandRouterClient.init_v2(
+                    self._client, self.object_id, task_id
+                )
+            else:
+                # Returns None if command router access is not enabled for this sandbox.
+                self._command_router_client = await TaskCommandRouterClient.try_init(self._client, task_id)
         return self._command_router_client
 
     @property
@@ -1267,7 +1271,6 @@ class _Sandbox(_Object, type_prefix="sb"):
             print(line)
         ```
         """
-        self._ensure_v1("exec")
         if pty_info is not None or _pty_info is not None:
             deprecation_warning(
                 (2025, 9, 12),

{modal-1.4.2.dev0 → modal-1.4.2.dev2}/modal.egg-info/PKG-INFO

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

{modal-1.4.2.dev0 → modal-1.4.2.dev2}/modal_proto/api_grpc.py

@@ -51,6 +51,10 @@ class ModalClientBase(abc.ABC):
     async def AppGetLayout(self, stream: 'grpclib.server.Stream[modal_proto.api_pb2.AppGetLayoutRequest, modal_proto.api_pb2.AppGetLayoutResponse]') -> None:
         pass
 
+    @abc.abstractmethod
+    async def AppGetLifecycle(self, stream: 'grpclib.server.Stream[modal_proto.api_pb2.AppGetLifecycleRequest, modal_proto.api_pb2.AppGetLifecycleResponse]') -> None:
+        pass
+
     @abc.abstractmethod
     async def AppGetLogs(self, stream: 'grpclib.server.Stream[modal_proto.api_pb2.AppGetLogsRequest, modal_proto.api_pb2.TaskLogsBatch]') -> None:
         pass
@@ -87,6 +91,10 @@ class ModalClientBase(abc.ABC):
     async def AppRollback(self, stream: 'grpclib.server.Stream[modal_proto.api_pb2.AppRollbackRequest, google.protobuf.empty_pb2.Empty]') -> None:
         pass
 
+    @abc.abstractmethod
+    async def AppRollover(self, stream: 'grpclib.server.Stream[modal_proto.api_pb2.AppRolloverRequest, modal_proto.api_pb2.AppRolloverResponse]') -> None:
+        pass
+
     @abc.abstractmethod
     async def AppSetObjects(self, stream: 'grpclib.server.Stream[modal_proto.api_pb2.AppSetObjectsRequest, google.protobuf.empty_pb2.Empty]') -> None:
         pass
@@ -675,6 +683,10 @@ class ModalClientBase(abc.ABC):
     async def TaskResult(self, stream: 'grpclib.server.Stream[modal_proto.api_pb2.TaskResultRequest, google.protobuf.empty_pb2.Empty]') -> None:
         pass
 
+    @abc.abstractmethod
+    async def TemplateList(self, stream: 'grpclib.server.Stream[modal_proto.api_pb2.TemplateListRequest, modal_proto.api_pb2.TemplateListResponse]') -> None:
+        pass
+
     @abc.abstractmethod
     async def TokenFlowCreate(self, stream: 'grpclib.server.Stream[modal_proto.api_pb2.TokenFlowCreateRequest, modal_proto.api_pb2.TokenFlowCreateResponse]') -> None:
         pass
@@ -829,6 +841,12 @@ class ModalClientBase(abc.ABC):
                 modal_proto.api_pb2.AppGetLayoutRequest,
                 modal_proto.api_pb2.AppGetLayoutResponse,
             ),
+            '/modal.client.ModalClient/AppGetLifecycle': grpclib.const.Handler(
+                self.AppGetLifecycle,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                modal_proto.api_pb2.AppGetLifecycleRequest,
+                modal_proto.api_pb2.AppGetLifecycleResponse,
+            ),
             '/modal.client.ModalClient/AppGetLogs': grpclib.const.Handler(
                 self.AppGetLogs,
                 grpclib.const.Cardinality.UNARY_STREAM,
@@ -883,6 +901,12 @@ class ModalClientBase(abc.ABC):
                 modal_proto.api_pb2.AppRollbackRequest,
                 google.protobuf.empty_pb2.Empty,
             ),
+            '/modal.client.ModalClient/AppRollover': grpclib.const.Handler(
+                self.AppRollover,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                modal_proto.api_pb2.AppRolloverRequest,
+                modal_proto.api_pb2.AppRolloverResponse,
+            ),
             '/modal.client.ModalClient/AppSetObjects': grpclib.const.Handler(
                 self.AppSetObjects,
                 grpclib.const.Cardinality.UNARY_UNARY,
@@ -1765,6 +1789,12 @@ class ModalClientBase(abc.ABC):
                 modal_proto.api_pb2.TaskResultRequest,
                 google.protobuf.empty_pb2.Empty,
             ),
+            '/modal.client.ModalClient/TemplateList': grpclib.const.Handler(
+                self.TemplateList,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                modal_proto.api_pb2.TemplateListRequest,
+                modal_proto.api_pb2.TemplateListResponse,
+            ),
             '/modal.client.ModalClient/TokenFlowCreate': grpclib.const.Handler(
                 self.TokenFlowCreate,
                 grpclib.const.Cardinality.UNARY_UNARY,
@@ -1975,6 +2005,12 @@ class ModalClientStub:
             modal_proto.api_pb2.AppGetLayoutRequest,
             modal_proto.api_pb2.AppGetLayoutResponse,
         )
+        self.AppGetLifecycle = grpclib.client.UnaryUnaryMethod(
+            channel,
+            '/modal.client.ModalClient/AppGetLifecycle',
+            modal_proto.api_pb2.AppGetLifecycleRequest,
+            modal_proto.api_pb2.AppGetLifecycleResponse,
+        )
         self.AppGetLogs = grpclib.client.UnaryStreamMethod(
             channel,
             '/modal.client.ModalClient/AppGetLogs',
@@ -2029,6 +2065,12 @@ class ModalClientStub:
             modal_proto.api_pb2.AppRollbackRequest,
             google.protobuf.empty_pb2.Empty,
         )
+        self.AppRollover = grpclib.client.UnaryUnaryMethod(
+            channel,
+            '/modal.client.ModalClient/AppRollover',
+            modal_proto.api_pb2.AppRolloverRequest,
+            modal_proto.api_pb2.AppRolloverResponse,
+        )
         self.AppSetObjects = grpclib.client.UnaryUnaryMethod(
             channel,
             '/modal.client.ModalClient/AppSetObjects',
@@ -2911,6 +2953,12 @@ class ModalClientStub:
             modal_proto.api_pb2.TaskResultRequest,
             google.protobuf.empty_pb2.Empty,
         )
+        self.TemplateList = grpclib.client.UnaryUnaryMethod(
+            channel,
+            '/modal.client.ModalClient/TemplateList',
+            modal_proto.api_pb2.TemplateListRequest,
+            modal_proto.api_pb2.TemplateListResponse,
+        )
         self.TokenFlowCreate = grpclib.client.UnaryUnaryMethod(
             channel,
             '/modal.client.ModalClient/TokenFlowCreate',