modal 1.4.2.dev5__tar.gz → 1.4.2.dev7__tar.gz

{modal-1.4.2.dev5 → modal-1.4.2.dev7}/PKG-INFO

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

{modal-1.4.2.dev5 → modal-1.4.2.dev7}/modal/_utils/grpc_utils.py

@@ -216,7 +216,11 @@ def create_channel(
         for k, v in metadata.items():
             event.metadata[k] = v
 
-        logger.debug(f"Sending request to {event.method_name}")
+        idempotency_key = typing.cast(Optional[str], event.metadata.get("x-idempotency-key"))
+        if idempotency_key is None:
+            logger.debug(f"Sending request to {event.method_name}")
+        else:
+            logger.debug(f"Sending request to {event.method_name} ({idempotency_key[:8]})")
 
     grpclib.events.listen(channel, grpclib.events.SendRequest, send_request)
 
@@ -288,12 +292,14 @@ def process_exception_before_retry(
     n_retries: int,
     delay: float,
     idempotency_key: str,
+    rpc_elapsed: float,
 ):
     """Process exception before retry, used by `_retry_transient_errors`."""
     with suppress_tb_frame():
         if final_attempt:
             logger.debug(
-                f"Final attempt failed with {repr(exc)} {n_retries=} {delay=} for {fn_name} ({idempotency_key[:8]})"
+                f"Final attempt failed with {repr(exc)} {n_retries=} {delay=} {rpc_elapsed=:0.2f}s "
+                f"for {fn_name} ({idempotency_key[:8]})"
             )
             if isinstance(exc, OSError):
                 raise ConnectionError(str(exc))
@@ -310,7 +316,10 @@ def process_exception_before_retry(
             # we handle in the retry logic once we drop this check!
             raise exc
 
-    logger.debug(f"Retryable failure {repr(exc)} {n_retries=} {delay=} for {fn_name} ({idempotency_key[:8]})")
+    logger.debug(
+        f"Retryable failure {repr(exc)} {n_retries=} {delay=} {rpc_elapsed=:0.2f}s "
+        f"for {fn_name} ({idempotency_key[:8]})"
+    )
 
 
 async def _retry_transient_errors(
@@ -373,6 +382,7 @@ async def _retry_transient_errors(
         else:
             timeout = None
 
+        attempt_started_at = time.monotonic()
         try:
             with suppress_tb_frame():
                 return await fn_callable(req, metadata=attempt_metadata, timeout=timeout)
@@ -409,7 +419,13 @@ async def _retry_transient_errors(
 
                 with suppress_tb_frame():
                     process_exception_before_retry(
-                        exc, final_attempt, fn.name, n_retries, server_delay, idempotency_key
+                        exc,
+                        final_attempt,
+                        fn.name,
+                        n_retries,
+                        server_delay,
+                        idempotency_key,
+                        time.monotonic() - attempt_started_at,
                     )
 
                 now = time.time()
@@ -438,7 +454,15 @@ async def _retry_transient_errors(
                 final_attempt = False
 
             with suppress_tb_frame():
-                process_exception_before_retry(exc, final_attempt, fn.name, n_retries, delay, idempotency_key)
+                process_exception_before_retry(
+                    exc,
+                    final_attempt,
+                    fn.name,
+                    n_retries,
+                    delay,
+                    idempotency_key,
+                    time.monotonic() - attempt_started_at,
+                )
 
             n_retries += 1
 

{modal-1.4.2.dev5 → modal-1.4.2.dev7}/modal/_utils/task_command_router_client.py

@@ -502,7 +502,8 @@ class TaskCommandRouterClient:
                 jwt, url = v1_resp.jwt, v1_resp.url
 
             # Ensure the server URL remains stable for the lifetime of this client.
-            assert url == self._server_url, "Task router URL changed during session"
+            if url != self._server_url:
+                logger.warning("Task router URL changed during session")
             self._jwt = jwt
             self._jwt_exp = _parse_jwt_expiration(jwt)
 

{modal-1.4.2.dev5 → modal-1.4.2.dev7}/modal/cli/app.py

@@ -20,13 +20,22 @@ 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.exception import InvalidError, NotFoundError
 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
 from .._utils.time_utils import locale_tz, timestamp_to_localized_str
-from .utils import ENV_OPTION, display_table, fetch_app_logs, get_app_id_from_name, stream_app_logs, tail_app_logs
+from .utils import (
+    ENV_OPTION,
+    YES_OPTION,
+    confirm_or_suggest_yes,
+    display_table,
+    fetch_app_logs,
+    stream_app_logs,
+    tail_app_logs,
+)
 
 APP_IDENTIFIER = Argument("", help="App name or ID")
 NAME_OPTION = typer.Option("", "-n", "--name", help="Deprecated: Pass App name as a positional argument")
@@ -45,12 +54,50 @@ APP_STATE_TO_MESSAGE = {
 }
 
 
-@synchronizer.create_blocking
-async def get_app_id(app_identifier: str, env: Optional[str], client: Optional[_Client] = None) -> str:
-    """Resolve an app_identifier that may be a name or an ID into an ID."""
+async def resolve_app_identifier(
+    app_identifier: str, env: Optional[str], client: Optional[_Client] = None
+) -> tuple[str, str, api_pb2.AppLifecycle]:  # Return app_id, environment_name, lifecycle
+    """Handle an App ID or an App name and return context about the App it points at.
+
+    When a name is provided, we may retrieve either a currently deployed App or an App that
+    was recently stopped (if no other App with that name has been deployed since).
+    It is up to callers of this function to decide whether it's valid to use the App ID
+    based on the lifecycle returned and their specific operations.
+
+    Can also raise a NotFoundError if the argument matches the App ID regex but the App
+    doesn't exist on the backend, or if there is no currently deployed or recently stopped App
+    with that name.
+
+    The function also always returns a valid environment name for any name-based lookups,
+    which may reflect the server-defined default environment when the provided argument was null.
+
+    """
+    if client is None:
+        client = await _Client.from_env()
     if re.match(r"^ap-[a-zA-Z0-9]{22}$", app_identifier):
-        return app_identifier
-    return await get_app_id_from_name.aio(app_identifier, env, client)
+        # Identifier is an App ID. This is unambiguous, so we can make the request and return
+        # the lifecycle. AppGetLifecycle will raise NotFoundError if the ID doesn't point at an App.
+        # If we return, it's a real App, but it's up to the caller to decide what to do based on
+        # the App's current state as conveyed by the lifecycle. We do propagate a NotFoundError
+        # from the server if the App ID doesn't actually exist.
+        request = api_pb2.AppGetLifecycleRequest(app_id=app_identifier)
+        resp = await client.stub.AppGetLifecycle(request)
+        return app_identifier, "", resp.lifecycle
+    else:
+        # Identifier is treated as a name, which may or may not point at a currently deployed App
+        # (inside a specific environment)
+        request = api_pb2.AppGetByDeploymentNameRequest(name=app_identifier, environment_name=env or "")
+        resp = await client.stub.AppGetByDeploymentName(request)
+        if resp.app_id:
+            # App is currently deployed
+            return resp.app_id, resp.environment_name, resp.lifecycle
+        elif resp.previous_app_id:
+            # An App with this name was recently stopped. Return the ID of the stopped App
+            # and let callers decide what to do based on the lifecycle.
+            return resp.previous_app_id, resp.environment_name, resp.lifecycle
+        else:
+            msg = f"No App with name '{app_identifier}' found in the '{resp.environment_name}' environment."
+            raise NotFoundError(msg)
 
 
 @app_cli.command("list")
@@ -129,7 +176,8 @@ _SOURCE_OPTIONS = {
 
 
 @app_cli.command("logs", no_args_is_help=True)
-def logs(
+@synchronizer.create_blocking
+async def logs(
     app_identifier: str = APP_IDENTIFIER,
     follow: bool = typer.Option(False, "-f", "--follow", help="Stream log output until App stops"),
     since: Optional[str] = typer.Option(
@@ -229,7 +277,7 @@ def logs(
     if tail is not None and tail > _FETCH_LIMIT:
         raise UsageError(f"--tail value must not exceed {_FETCH_LIMIT}.")
 
-    app_id = get_app_id(app_identifier, env)
+    app_id, _, _ = await resolve_app_identifier(app_identifier, env)
 
     if source is not None:
         if source not in _SOURCE_OPTIONS:
@@ -255,7 +303,7 @@ def logs(
     )
 
     if follow:
-        stream_app_logs(
+        await stream_app_logs.aio(
             app_id,
             task_id=container_id or "",
             show_timestamps=timestamps,
@@ -278,7 +326,7 @@ def logs(
 
         if since and tail is None:
             # Range mode: --since without --tail fetches everything in the range.
-            fetch_app_logs(
+            await fetch_app_logs.aio(
                 app_id,
                 since_dt,
                 until_dt or now,
@@ -290,7 +338,7 @@ def logs(
             # Tail mode: single fetch with limit.
             # --since is a hard floor, --until shifts the anchor.
             effective_tail = tail if tail is not None else _DEFAULT_LOGS_TAIL
-            tail_app_logs(
+            await tail_app_logs.aio(
                 app_id,
                 effective_tail,
                 show_timestamps=timestamps,
@@ -338,29 +386,125 @@ async def rollback(
     """
     env = ensure_env(env)
     client = await _Client.from_env()
-    app_id = await get_app_id.aio(app_identifier, env, client)
+    app_id, environment_name, lifecycle = await resolve_app_identifier(app_identifier, env, client)
+    if lifecycle.app_state != api_pb2.APP_STATE_DEPLOYED:
+        env_suffix = f" in the '{environment_name}' environment" if environment_name else ""
+        raise InvalidError(f"App '{app_identifier}' is not deployed{env_suffix}.")
+
     if not version:
         version_number = -1
     else:
         if m := re.match(r"v(\d+)", version):
             version_number = int(m.group(1))
         else:
-            raise UsageError(f"Invalid version specifer: {version}")
+            raise UsageError(f"Invalid version specifier: {version}")
     req = api_pb2.AppRollbackRequest(app_id=app_id, version=version_number)
     await client.stub.AppRollback(req)
     rich.print("[green]✓[/green] Deployment rollback successful!")
 
 
+@app_cli.command("rollover", no_args_is_help=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,
+):
+    """Redeploy an App to get new containers without code changes.
+
+    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 will be gracefully replaced by new ones.
+
+    ```
+    modal app rollover my-app
+    ```
+
+    Rollover an App by terminating any running containers. Inputs on the queue will
+    start new containers.
+
+    ```
+    modal app rollover my-app --strategy recreate
+    ```
+    """
+    env = ensure_env(env)
+    client = await _Client.from_env()
+
+    app_id, environment_name, lifecycle = await resolve_app_identifier(app_identifier, env, client)
+    if lifecycle.app_state != api_pb2.APP_STATE_DEPLOYED:
+        env_suffix = f" in the '{environment_name}' environment" if environment_name else ""
+        raise InvalidError(f"App '{app_identifier}' is not deployed{env_suffix}.")
+
+    output_mgr = OutputManager.get()
+    output_mgr.print(f"🔨 Starting app rollover with {strategy} strategy")
+    t0 = time.monotonic()
+
+    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]")
+
+
 @app_cli.command("stop", no_args_is_help=True)
 @synchronizer.create_blocking
 async def stop(
     app_identifier: str = APP_IDENTIFIER,
     *,
+    yes: bool = YES_OPTION,
     env: Optional[str] = ENV_OPTION,
 ):
-    """Stop an app."""
+    """Permanently stop an App and terminate its running containers."""
+    env = ensure_env(env)
     client = await _Client.from_env()
-    app_id = await get_app_id.aio(app_identifier, env)
+    app_id, environment_name, lifecycle = await resolve_app_identifier(app_identifier, env, client)
+
+    if lifecycle.app_state == api_pb2.APP_STATE_STOPPED:
+        msg = "App is already stopped."
+        if lifecycle.stopped_at:
+            stopped_at = timestamp_to_localized_str(lifecycle.stopped_at)
+            verb = "Stopped" if lifecycle.stopped_by else "Finished"
+            attribution = f" by '{lifecycle.stopped_by}'" if lifecycle.stopped_by else ""
+            msg += f" ({verb} at {stopped_at}{attribution})."
+        raise SystemExit(msg)
+
+    if not yes:
+        res = await client.stub.TaskList(api_pb2.TaskListRequest(app_id=app_id))
+        num_containers = len(res.tasks)
+
+        if environment_name:
+            msg = f"Are you sure you want to stop App '{app_identifier}' in the '{environment_name}' environment?"
+        else:
+            msg = f"Are you sure you want to stop App '{app_identifier}'?"
+
+        if num_containers:
+            msg += (
+                f" This will immediately terminate {num_containers} running"
+                f" container{'s' if num_containers != 1 else ''}."
+            )
+        else:
+            msg += " No containers are currently running."
+        confirm_or_suggest_yes(msg)
     req = api_pb2.AppStopRequest(app_id=app_id, source=api_pb2.APP_STOP_SOURCE_CLI)
     await client.stub.AppStop(req)
 
@@ -373,7 +517,7 @@ async def history(
     env: Optional[str] = ENV_OPTION,
     json: bool = False,
 ):
-    """Show App deployment history, for a currently deployed app
+    """Show an App's deployment history.
 
     **Examples:**
 
@@ -383,7 +527,7 @@ async def history(
     modal app history ap-123456
     ```
 
-    Get the history for a currently deployed App based on its name:
+    Get the history for an App based on its name:
 
     ```
     modal app history my-app
@@ -392,7 +536,7 @@ async def history(
     """
     env = ensure_env(env)
     client = await _Client.from_env()
-    app_id = await get_app_id.aio(app_identifier, env, client)
+    app_id, _, _ = await resolve_app_identifier(app_identifier, env, client)
     resp = await client.stub.AppDeploymentHistory(api_pb2.AppDeploymentHistoryRequest(app_id=app_id))
 
     columns = [
@@ -467,66 +611,6 @@ async def dashboard(
     ```
     """
     client = await _Client.from_env()
-    app_id = await get_app_id.aio(app_identifier, env, client)
-
+    app_id, _, _ = await resolve_app_identifier(app_identifier, env, client)
     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.dev5 → modal-1.4.2.dev7}/modal/cli/container.py

@@ -14,7 +14,16 @@ from modal._output.pty import get_pty_info
 from modal._utils.async_utils import synchronizer
 from modal._utils.time_utils import timestamp_to_localized_str
 from modal.cli.app import _DEFAULT_LOGS_TAIL, _SOURCE_OPTIONS, _parse_time_arg
-from modal.cli.utils import ENV_OPTION, display_table, fetch_app_logs, is_tty, stream_app_logs, tail_app_logs
+from modal.cli.utils import (
+    ENV_OPTION,
+    YES_OPTION,
+    confirm_or_suggest_yes,
+    display_table,
+    fetch_app_logs,
+    is_tty,
+    stream_app_logs,
+    tail_app_logs,
+)
 from modal.client import _Client
 from modal.config import config
 from modal.container_process import _ContainerProcess
@@ -285,11 +294,20 @@ async def exec(
 
 @container_cli.command("stop")
 @synchronizer.create_blocking
-async def stop(container_id: str = typer.Argument(help="Container ID")):
+async def stop(
+    container_id: str = typer.Argument(help="Container ID"),
+    *,
+    yes: bool = YES_OPTION,
+):
     """Stop a currently-running container and reassign its in-progress inputs.
 
     This will send the container a SIGINT signal that Modal will handle.
     """
     client = await _Client.from_env()
+    resp = await client.stub.TaskGetInfo(api_pb2.TaskGetInfoRequest(task_id=container_id))
+    if resp.info.finished_at:
+        raise SystemExit(f"Container '{container_id}' is already stopped.")
+    if not yes:
+        confirm_or_suggest_yes(f"Are you sure you want to stop container '{container_id}'?")
     request = api_pb2.ContainerStopRequest(task_id=container_id)
     await client.stub.ContainerStop(request)

{modal-1.4.2.dev5 → modal-1.4.2.dev7}/modal/cli/utils.py

@@ -1,6 +1,7 @@
 # Copyright Modal Labs 2022
 import asyncio
 import io
+import sys
 from collections.abc import Sequence
 from contextlib import nullcontext
 from csv import writer as csv_writer
@@ -12,14 +13,11 @@ import typer
 from rich.table import Column, Table
 from rich.text import Text
 
-from modal_proto import api_pb2
-
 from .._logs import LogsFilters, fetch_logs, tail_logs
 from .._output.pty import _build_log_prefix, get_app_logs_loop
 from .._utils.async_utils import synchronizer
 from ..client import _Client
-from ..environments import ensure_env
-from ..exception import InvalidError, NotFoundError
+from ..exception import InvalidError
 from ..output import OutputManager
 
 
@@ -125,19 +123,6 @@ async def fetch_app_logs(
     await _drain_batches(output_mgr, batches, prefix_fields or [], filters.search_text)
 
 
-@synchronizer.create_blocking
-async def get_app_id_from_name(name: str, env: Optional[str], client: Optional[_Client] = None) -> str:
-    if client is None:
-        client = await _Client.from_env()
-    env_name = ensure_env(env)
-    request = api_pb2.AppGetByDeploymentNameRequest(name=name, environment_name=env_name)
-    resp = await client.stub.AppGetByDeploymentName(request)
-    if not resp.app_id:
-        env_comment = f" in the '{env_name}' environment" if env_name else ""
-        raise NotFoundError(f"Could not find a deployed app named '{name}'{env_comment}.")
-    return resp.app_id
-
-
 def _plain(text: Union[Text, str]) -> str:
     return text.plain if isinstance(text, Text) else text
 
@@ -185,3 +170,11 @@ Otherwise, raises an error if the workspace has multiple environments.
 ENV_OPTION = typer.Option(None, "-e", "--env", help=ENV_OPTION_HELP)
 
 YES_OPTION = typer.Option(False, "-y", "--yes", help="Run without pausing for confirmation.")
+
+
+def confirm_or_suggest_yes(msg: str) -> None:
+    """Prompt for confirmation, or abort with a hint to use --yes if stdin is not a TTY."""
+    if not sys.stdin.isatty():
+        typer.echo(f"{msg} [y/N]: ")
+        raise SystemExit("Aborted: no interactive terminal detected. Rerun with --yes (-y) to skip confirmation.")
+    typer.confirm(msg, default=False, abort=True)

{modal-1.4.2.dev5 → modal-1.4.2.dev7}/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.dev5",
+        version: str = "1.4.2.dev7",
     ):
         """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.dev5",
+        version: str = "1.4.2.dev7",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.4.2.dev5 → modal-1.4.2.dev7}/modal/dict.py

@@ -84,8 +84,8 @@ class DictInfo:
 class _DictManager:
     """Namespace with methods for managing named Dict objects."""
 
-    @staticmethod
     async def create(
+        self,
         name: str,  # Name to use for the new Dict
         *,
         allow_existing: bool = False,  # If True, no-op when the Dict already exists
@@ -137,8 +137,8 @@ class _DictManager:
             if not allow_existing:
                 raise
 
-    @staticmethod
     async def list(
+        self,
         *,
         max_objects: Optional[int] = None,  # Limit results to this size
         created_before: Optional[Union[datetime, str]] = None,  # Limit based on creation date
@@ -205,8 +205,8 @@ class _DictManager:
         ]
         return dicts[:max_objects] if max_objects is not None else dicts
 
-    @staticmethod
     async def delete(
+        self,
         name: str,  # Name of the Dict to delete
         *,
         allow_missing: bool = False,  # If True, don't raise an error if the Dict doesn't exist
@@ -299,8 +299,8 @@ class _Dict(_Object, type_prefix="di"):
 
     @classproperty
     @classmethod
-    def objects(cls) -> type[_DictManager]:
-        return _DictManager
+    def objects(cls) -> _DictManager:
+        return _DictManager()
 
     @property
     def name(self) -> Optional[str]:

{modal-1.4.2.dev5 → modal-1.4.2.dev7}/modal/dict.pyi

@@ -44,8 +44,8 @@ class DictInfo:
 
 class _DictManager:
     """Namespace with methods for managing named Dict objects."""
-    @staticmethod
     async def create(
+        self,
         name: str,
         *,
         allow_existing: bool = False,
@@ -80,8 +80,8 @@ class _DictManager:
         """
         ...
 
-    @staticmethod
     async def list(
+        self,
         *,
         max_objects: typing.Optional[int] = None,
         created_before: typing.Union[datetime.datetime, str, None] = None,
@@ -114,8 +114,8 @@ class _DictManager:
         """
         ...
 
-    @staticmethod
     async def delete(
+        self,
         name: str,
         *,
         allow_missing: bool = False,
@@ -224,7 +224,7 @@ class DictManager:
             """
             ...
 
-    create: typing.ClassVar[__create_spec]
+    create: __create_spec
 
     class __list_spec(typing_extensions.Protocol):
         def __call__(
@@ -297,7 +297,7 @@ class DictManager:
             """
             ...
 
-    list: typing.ClassVar[__list_spec]
+    list: __list_spec
 
     class __delete_spec(typing_extensions.Protocol):
         def __call__(
@@ -360,7 +360,7 @@ class DictManager:
             """
             ...
 
-    delete: typing.ClassVar[__delete_spec]
+    delete: __delete_spec
 
 class _Dict(modal._object._Object):
     """Distributed dictionary for storage in Modal apps.
@@ -413,7 +413,7 @@ class _Dict(modal._object._Object):
 
     @synchronicity.classproperty
     @classmethod
-    def objects(cls) -> type[_DictManager]: ...
+    def objects(cls) -> _DictManager: ...
     @property
     def name(self) -> typing.Optional[str]: ...
     def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
@@ -655,7 +655,7 @@ class Dict(modal.object.Object):
 
     @synchronicity.classproperty
     @classmethod
-    def objects(cls) -> type[DictManager]: ...
+    def objects(cls) -> DictManager: ...
     @property
     def name(self) -> typing.Optional[str]: ...
     def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...