modal 0.68.31__py3-none-any.whl → 0.68.50__py3-none-any.whl

modal/_runtime/asgi.py

@@ -26,6 +26,7 @@ class LifespanManager:
     shutdown: asyncio.Future
     queue: asyncio.Queue
     has_run_init: bool = False
+    lifespan_supported: bool = False
 
     def __init__(self, asgi_app, state):
         self.asgi_app = asgi_app
@@ -46,6 +47,7 @@ class LifespanManager:
         await self.ensure_init()
 
         async def receive():
+            self.lifespan_supported = True
             return await self.queue.get()
 
         async def send(message):
@@ -63,16 +65,21 @@ class LifespanManager:
         try:
             await self.asgi_app({"type": "lifespan", "state": self.state}, receive, send)
         except Exception as e:
+            if not self.lifespan_supported:
+                logger.info(f"ASGI lifespan task exited before receiving any messages with exception:\n{e}")
+                self.startup.set_result(None)
+                self.shutdown.set_result(None)
+                return
+
             logger.error(f"Error in ASGI lifespan task: {e}")
             if not self.startup.done():
                 self.startup.set_exception(ExecutionError("ASGI lifespan task exited startup"))
             if not self.shutdown.done():
                 self.shutdown.set_exception(ExecutionError("ASGI lifespan task exited shutdown"))
         else:
-            if not self.startup.done():
-                self.startup.set_result("ASGI Lifespan protocol is probably not supported by this library")
-            if not self.shutdown.done():
-                self.shutdown.set_result("ASGI Lifespan protocol is probably not supported by this library")
+            logger.info("ASGI Lifespan protocol is probably not supported by this library")
+            self.startup.set_result(None)
+            self.shutdown.set_result(None)
 
     async def lifespan_startup(self):
         await self.ensure_init()

modal/_traceback.py

@@ -74,11 +74,15 @@ def append_modal_tb(exc: BaseException, tb_dict: TBDictType, line_cache: LineCac
 
 def reduce_traceback_to_user_code(tb: Optional[TracebackType], user_source: str) -> TracebackType:
     """Return a traceback that does not contain modal entrypoint or synchronicity frames."""
-    # Step forward all the way through the traceback and drop any synchronicity frames
+
+    # Step forward all the way through the traceback and drop any "Modal support" frames
+    def skip_frame(filename: str) -> bool:
+        return "/site-packages/synchronicity/" in filename or "modal/_utils/deprecation" in filename
+
     tb_root = tb
     while tb is not None:
         while tb.tb_next is not None:
-            if "/site-packages/synchronicity/" in tb.tb_next.tb_frame.f_code.co_filename:
+            if skip_frame(tb.tb_next.tb_frame.f_code.co_filename):
                 tb.tb_next = tb.tb_next.tb_next
             else:
                 break

modal/_utils/deprecation.py

@@ -1,7 +1,11 @@
 # Copyright Modal Labs 2024
+import functools
 import sys
 import warnings
 from datetime import date
+from typing import Any, Callable, TypeVar
+
+from typing_extensions import ParamSpec  # Needed for Python 3.9
 
 from ..exception import DeprecationError, PendingDeprecationError
 
@@ -42,3 +46,44 @@ def deprecation_warning(
 
     # This is a lower-level function that warnings.warn uses
     warnings.warn_explicit(f"{date(*deprecated_on)}: {msg}", warning_cls, filename, lineno)
+
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def renamed_parameter(
+    date: tuple[int, int, int],
+    old_name: str,
+    new_name: str,
+    show_source: bool = True,
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    """Decorator for semi-gracefully changing a parameter name.
+
+    Functions wrapped with this decorator can be defined using only the `new_name` of the parameter.
+    If the function is invoked with the `old_name`, the wrapper will pass the value as a keyword
+    argument for `new_name` and issue a Modal deprecation warning about the change.
+
+    Note that this only prevents parameter renamings from breaking code at runtime.
+    Type checking will fail when code uses `old_name`. To avoid this, the `old_name` can be
+    preserved in the function signature with an `Annotated` type hint indicating the renaming.
+    """
+
+    def decorator(func: Callable[P, R]) -> Callable[P, R]:
+        @functools.wraps(func)
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            mut_kwargs: dict[str, Any] = locals()["kwargs"]  # Avoid referencing kwargs directly due to bug in sigtools
+            if old_name in mut_kwargs:
+                mut_kwargs[new_name] = mut_kwargs.pop(old_name)
+                func_name = func.__qualname__.removeprefix("_")  # Avoid confusion when synchronicity-wrapped
+                message = (
+                    f"The '{old_name}' parameter of `{func_name}` has been renamed to '{new_name}'."
+                    "\nUsing the old name will become an error in a future release. Please update your code."
+                )
+                deprecation_warning(date, message, show_source=show_source)
+
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

modal/_utils/function_utils.py

@@ -99,16 +99,18 @@ def get_function_type(is_generator: Optional[bool]) -> "api_pb2.Function.Functio
 
 
 class FunctionInfo:
-    """Class that helps us extract a bunch of information about a locally defined function.
+    """Utility that determines serialization/deserialization mechanisms for functions
 
-    Used for populating the definition of a remote function, and for making .local() calls
-    on a host with the local definition available.
+    * Stored as file vs serialized
+    * If serialized: how to serialize the function
+    * If file: which module/function name should be used to retrieve
+
+    Used for populating the definition of a remote function
     """
 
     raw_f: Optional[Callable[..., Any]]  # if None - this is a "class service function"
     function_name: str
     user_cls: Optional[type[Any]]
-    definition_type: "modal_proto.api_pb2.Function.DefinitionType.ValueType"
     module_name: Optional[str]
 
     _type: FunctionInfoType
@@ -116,6 +118,12 @@ class FunctionInfo:
     _base_dir: str
     _remote_dir: Optional[PurePosixPath] = None
 
+    def get_definition_type(self) -> "modal_proto.api_pb2.Function.DefinitionType.ValueType":
+        if self.is_serialized():
+            return modal_proto.api_pb2.Function.DEFINITION_TYPE_SERIALIZED
+        else:
+            return modal_proto.api_pb2.Function.DEFINITION_TYPE_FILE
+
     def is_service_class(self):
         if self.raw_f is None:
             assert self.user_cls
@@ -172,7 +180,7 @@ class FunctionInfo:
             self._base_dir = base_dirs[0]
             self.module_name = module.__spec__.name
             self._remote_dir = ROOT_DIR / PurePosixPath(module.__package__.split(".")[0])
-            self.definition_type = api_pb2.Function.DEFINITION_TYPE_FILE
+            self._is_serialized = False
             self._type = FunctionInfoType.PACKAGE
         elif hasattr(module, "__file__") and not serialized:
             # This generally covers the case where it's invoked with
@@ -182,18 +190,18 @@ class FunctionInfo:
             self._file = os.path.abspath(inspect.getfile(module))
             self.module_name = inspect.getmodulename(self._file)
             self._base_dir = os.path.dirname(self._file)
-            self.definition_type = api_pb2.Function.DEFINITION_TYPE_FILE
+            self._is_serialized = False
             self._type = FunctionInfoType.FILE
         else:
             self.module_name = None
             self._base_dir = os.path.abspath("")  # get current dir
-            self.definition_type = api_pb2.Function.DEFINITION_TYPE_SERIALIZED
-            if serialized:
+            self._is_serialized = True  # either explicitly, or by being in a notebook
+            if serialized:  # if explicit
                 self._type = FunctionInfoType.SERIALIZED
             else:
                 self._type = FunctionInfoType.NOTEBOOK
 
-        if self.definition_type == api_pb2.Function.DEFINITION_TYPE_FILE:
+        if not self.is_serialized():
             # Sanity check that this function is defined in global scope
             # Unfortunately, there's no "clean" way to do this in Python
             qualname = f.__qualname__ if f else user_cls.__qualname__
@@ -203,7 +211,7 @@ class FunctionInfo:
                 )
 
     def is_serialized(self) -> bool:
-        return self.definition_type == api_pb2.Function.DEFINITION_TYPE_SERIALIZED
+        return self._is_serialized
 
     def serialized_function(self) -> bytes:
         # Note: this should only be called from .load() and not at function decoration time
@@ -312,7 +320,7 @@ class FunctionInfo:
         if self._type == FunctionInfoType.PACKAGE:
             if config.get("automount"):
                 return [_Mount.from_local_python_packages(self.module_name)]
-            elif self.definition_type == api_pb2.Function.DEFINITION_TYPE_FILE:
+            elif not self.is_serialized():
                 # mount only relevant file and __init__.py:s
                 return [
                     _Mount.from_local_dir(
@@ -322,7 +330,7 @@ class FunctionInfo:
                         condition=entrypoint_only_package_mount_condition(self._file),
                     )
                 ]
-        elif self.definition_type == api_pb2.Function.DEFINITION_TYPE_FILE:
+        elif not self.is_serialized():
             remote_path = ROOT_DIR / Path(self._file).name
             if not _is_modal_path(remote_path):
                 return [
@@ -570,12 +578,15 @@ class FunctionCreationStatus:
 
         elif self.response.function.web_url:
             url_info = self.response.function.web_url_info
+            requires_proxy_auth = self.response.function.webhook_config.requires_proxy_auth
+            proxy_auth_suffix = " 🔑" if requires_proxy_auth else ""
             # Ensure terms used here match terms used in modal.com/docs/guide/webhook-urls doc.
             suffix = _get_suffix_from_web_url_info(url_info)
             # TODO: this is only printed when we're showing progress. Maybe move this somewhere else.
             web_url = self.response.handle_metadata.web_url
             self.status_row.finish(
-                f"Created web function {self.tag} => [magenta underline]{web_url}[/magenta underline]{suffix}"
+                f"Created web function {self.tag} => [magenta underline]{web_url}[/magenta underline]"
+                f"{proxy_auth_suffix}{suffix}"
             )
 
             # Print custom domain in terminal

modal/app.py

@@ -22,7 +22,7 @@ from modal_proto import api_pb2
 
 from ._ipython import is_notebook
 from ._utils.async_utils import synchronize_api
-from ._utils.deprecation import deprecation_error, deprecation_warning
+from ._utils.deprecation import deprecation_error, deprecation_warning, renamed_parameter
 from ._utils.function_utils import FunctionInfo, is_global_object, is_method_fn
 from ._utils.grpc_utils import retry_transient_errors
 from ._utils.mount_utils import validate_volumes
@@ -260,8 +260,9 @@ class _App:
         return self._description
 
     @staticmethod
+    @renamed_parameter((2024, 12, 18), "label", "name")
     async def lookup(
-        label: str,
+        name: str,
         client: Optional[_Client] = None,
         environment_name: Optional[str] = None,
         create_if_missing: bool = False,
@@ -283,14 +284,14 @@ class _App:
         environment_name = _get_environment_name(environment_name)
 
         request = api_pb2.AppGetOrCreateRequest(
-            app_name=label,
+            app_name=name,
             environment_name=environment_name,
             object_creation_type=(api_pb2.OBJECT_CREATION_TYPE_CREATE_IF_MISSING if create_if_missing else None),
         )
 
         response = await retry_transient_errors(client.stub.AppGetOrCreate, request)
 
-        app = _App(label)
+        app = _App(name)
         app._app_id = response.app_id
         app._client = client
         app._running_app = RunningApp(

modal/app.pyi

@@ -107,7 +107,7 @@ class _App:
     def description(self) -> typing.Optional[str]: ...
     @staticmethod
     async def lookup(
-        label: str,
+        name: str,
         client: typing.Optional[modal.client._Client] = None,
         environment_name: typing.Optional[str] = None,
         create_if_missing: bool = False,
@@ -306,14 +306,14 @@ class App:
     class __lookup_spec(typing_extensions.Protocol):
         def __call__(
             self,
-            label: str,
+            name: str,
             client: typing.Optional[modal.client.Client] = None,
             environment_name: typing.Optional[str] = None,
             create_if_missing: bool = False,
         ) -> App: ...
         async def aio(
             self,
-            label: str,
+            name: str,
             client: typing.Optional[modal.client.Client] = None,
             environment_name: typing.Optional[str] = None,
             create_if_missing: bool = False,

modal/cli/dict.py

@@ -89,6 +89,11 @@ async def get(name: str, key: str, *, env: Optional[str] = ENV_OPTION):
     console.print(val)
 
 
+def _display(input: str, use_repr: bool) -> str:
+    val = repr(input) if use_repr else str(input)
+    return val[:80] + "..." if len(val) > 80 else val
+
+
 @dict_cli.command(name="items", rich_help_panel="Inspection")
 @synchronizer.create_blocking
 async def items(
@@ -117,8 +122,7 @@ async def items(
             if json:
                 display_item = key, val
             else:
-                cast = repr if use_repr else str
-                display_item = cast(key), cast(val)  # type: ignore  # mypy/issue/12056
+                display_item = _display(key, use_repr), _display(val, use_repr)  # type: ignore  # mypy/issue/12056
             items.append(display_item)
 
     display_table(["Key", "Value"], items, json)

modal/cli/network_file_system.py

@@ -237,4 +237,4 @@ async def delete(
             abort=True,
         )
 
-    await _NetworkFileSystem.delete(label=nfs_name, environment_name=env)
+    await _NetworkFileSystem.delete(nfs_name, environment_name=env)

modal/cli/run.py

@@ -482,6 +482,7 @@ def shell(
             volumes=function_spec.volumes,
             region=function_spec.scheduler_placement.proto.regions if function_spec.scheduler_placement else None,
             pty=pty,
+            proxy=function_spec.proxy,
         )
     else:
         modal_image = Image.from_registry(image, add_python=add_python) if image else None

modal/cli/volume.py

@@ -286,4 +286,4 @@ async def delete(
             abort=True,
         )
 
-    await _Volume.delete(label=volume_name, environment_name=env)
+    await _Volume.delete(volume_name, environment_name=env)

modal/client.pyi

@@ -26,7 +26,7 @@ class _Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.31"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.50"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -81,7 +81,7 @@ class Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.31"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.50"
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/cls.py

@@ -16,6 +16,7 @@ from ._resources import convert_fn_config_to_resources_config
 from ._serialization import check_valid_cls_constructor_arg
 from ._traceback import print_server_warnings
 from ._utils.async_utils import synchronize_api, synchronizer
+from ._utils.deprecation import renamed_parameter
 from ._utils.grpc_utils import retry_transient_errors
 from ._utils.mount_utils import validate_volumes
 from .client import _Client
@@ -513,10 +514,11 @@ class _Cls(_Object, type_prefix="cs"):
         return self._class_service_function is not None
 
     @classmethod
+    @renamed_parameter((2024, 12, 18), "tag", "name")
     def from_name(
         cls: type["_Cls"],
         app_name: str,
-        tag: str,
+        name: str,
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         environment_name: Optional[str] = None,
         workspace: Optional[str] = None,
@@ -528,7 +530,7 @@ class _Cls(_Object, type_prefix="cs"):
         Modal servers until the first time it is actually used.
 
         ```python
-        Class = modal.Cls.from_name("other-app", "Class")
+        Model = modal.Cls.from_name("other-app", "Model")
         ```
         """
 
@@ -536,7 +538,7 @@ class _Cls(_Object, type_prefix="cs"):
             _environment_name = _get_environment_name(environment_name, resolver)
             request = api_pb2.ClassGetRequest(
                 app_name=app_name,
-                object_tag=tag,
+                object_tag=name,
                 namespace=namespace,
                 environment_name=_environment_name,
                 lookup_published=workspace is not None,
@@ -555,11 +557,11 @@ class _Cls(_Object, type_prefix="cs"):
 
             print_server_warnings(response.server_warnings)
 
-            class_function_tag = f"{tag}.*"  # special name of the base service function for the class
+            class_service_name = f"{name}.*"  # special name of the base service function for the class
 
             class_service_function = _Function.from_name(
                 app_name,
-                class_function_tag,
+                class_service_name,
                 environment_name=_environment_name,
             )
             try:
@@ -635,9 +637,10 @@ class _Cls(_Object, type_prefix="cs"):
         return cls
 
     @staticmethod
+    @renamed_parameter((2024, 12, 18), "tag", "name")
     async def lookup(
         app_name: str,
-        tag: str,
+        name: str,
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         client: Optional[_Client] = None,
         environment_name: Optional[str] = None,
@@ -649,11 +652,14 @@ class _Cls(_Object, type_prefix="cs"):
         that will hydrate the local object with metadata from Modal servers.
 
         ```python notest
-        Class = modal.Cls.lookup("other-app", "Class")
-        obj = Class()
+        Model = modal.Cls.lookup("other-app", "Model")
+        model = Model()
+        model.inference(...)
         ```
         """
-        obj = _Cls.from_name(app_name, tag, namespace=namespace, environment_name=environment_name, workspace=workspace)
+        obj = _Cls.from_name(
+            app_name, name, namespace=namespace, environment_name=environment_name, workspace=workspace
+        )
         if client is None:
             client = await _Client.from_env()
         resolver = Resolver(client=client)

modal/cls.pyi

@@ -112,7 +112,7 @@ class _Cls(modal.object._Object):
     def from_name(
         cls: type[_Cls],
         app_name: str,
-        tag: str,
+        name: str,
         namespace=1,
         environment_name: typing.Optional[str] = None,
         workspace: typing.Optional[str] = None,
@@ -133,7 +133,7 @@ class _Cls(modal.object._Object):
     @staticmethod
     async def lookup(
         app_name: str,
-        tag: str,
+        name: str,
         namespace=1,
         client: typing.Optional[modal.client._Client] = None,
         environment_name: typing.Optional[str] = None,
@@ -164,7 +164,7 @@ class Cls(modal.object.Object):
     def from_name(
         cls: type[Cls],
         app_name: str,
-        tag: str,
+        name: str,
         namespace=1,
         environment_name: typing.Optional[str] = None,
         workspace: typing.Optional[str] = None,
@@ -187,7 +187,7 @@ class Cls(modal.object.Object):
         def __call__(
             self,
             app_name: str,
-            tag: str,
+            name: str,
             namespace=1,
             client: typing.Optional[modal.client.Client] = None,
             environment_name: typing.Optional[str] = None,
@@ -196,7 +196,7 @@ class Cls(modal.object.Object):
         async def aio(
             self,
             app_name: str,
-            tag: str,
+            name: str,
             namespace=1,
             client: typing.Optional[modal.client.Client] = None,
             environment_name: typing.Optional[str] = None,

modal/dict.py

@@ -10,7 +10,7 @@ from modal_proto import api_pb2
 from ._resolver import Resolver
 from ._serialization import deserialize, serialize
 from ._utils.async_utils import TaskContext, synchronize_api
-from ._utils.deprecation import deprecation_error
+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
@@ -58,15 +58,6 @@ class _Dict(_Object, type_prefix="di"):
     For more examples, see the [guide](/docs/guide/dicts-and-queues#modal-dicts).
     """
 
-    @staticmethod
-    def new(data: Optional[dict] = None):
-        """mdmd:hidden"""
-        message = (
-            "`Dict.new` is deprecated."
-            " Please use `Dict.from_name` (for persisted) or `Dict.ephemeral` (for ephemeral) dicts instead."
-        )
-        deprecation_error((2024, 3, 19), message)
-
     def __init__(self, data={}):
         """mdmd:hidden"""
         raise RuntimeError(
@@ -112,8 +103,9 @@ class _Dict(_Object, type_prefix="di"):
             yield cls._new_hydrated(response.dict_id, client, None, is_another_app=True)
 
     @staticmethod
+    @renamed_parameter((2024, 12, 18), "label", "name")
     def from_name(
-        label: str,
+        name: str,
         data: Optional[dict] = None,
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         environment_name: Optional[str] = None,
@@ -130,12 +122,12 @@ class _Dict(_Object, type_prefix="di"):
         d[123] = 456
         ```
         """
-        check_object_name(label, "Dict")
+        check_object_name(name, "Dict")
 
         async def _load(self: _Dict, resolver: Resolver, existing_object_id: Optional[str]):
             serialized = _serialize_dict(data if data is not None else {})
             req = api_pb2.DictGetOrCreateRequest(
-                deployment_name=label,
+                deployment_name=name,
                 namespace=namespace,
                 environment_name=_get_environment_name(environment_name, resolver),
                 object_creation_type=(api_pb2.OBJECT_CREATION_TYPE_CREATE_IF_MISSING if create_if_missing else None),
@@ -148,8 +140,9 @@ class _Dict(_Object, type_prefix="di"):
         return _Dict._from_loader(_load, "Dict()", is_another_app=True, hydrate_lazily=True)
 
     @staticmethod
+    @renamed_parameter((2024, 12, 18), "label", "name")
     async def lookup(
-        label: str,
+        name: str,
         data: Optional[dict] = None,
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         client: Optional[_Client] = None,
@@ -167,7 +160,7 @@ class _Dict(_Object, type_prefix="di"):
         ```
         """
         obj = _Dict.from_name(
-            label,
+            name,
             data=data,
             namespace=namespace,
             environment_name=environment_name,
@@ -180,13 +173,14 @@ class _Dict(_Object, type_prefix="di"):
         return obj
 
     @staticmethod
+    @renamed_parameter((2024, 12, 18), "label", "name")
     async def delete(
-        label: str,
+        name: str,
         *,
         client: Optional[_Client] = None,
         environment_name: Optional[str] = None,
     ):
-        obj = await _Dict.lookup(label, client=client, environment_name=environment_name)
+        obj = await _Dict.lookup(name, client=client, environment_name=environment_name)
         req = api_pb2.DictDeleteRequest(dict_id=obj.object_id)
         await retry_transient_errors(obj._client.stub.DictDelete, req)
 

modal/dict.pyi

@@ -8,8 +8,6 @@ import typing_extensions
 def _serialize_dict(data): ...
 
 class _Dict(modal.object._Object):
-    @staticmethod
-    def new(data: typing.Optional[dict] = None): ...
     def __init__(self, data={}): ...
     @classmethod
     def ephemeral(
@@ -21,7 +19,7 @@ class _Dict(modal.object._Object):
     ) -> typing.AsyncContextManager[_Dict]: ...
     @staticmethod
     def from_name(
-        label: str,
+        name: str,
         data: typing.Optional[dict] = None,
         namespace=1,
         environment_name: typing.Optional[str] = None,
@@ -29,7 +27,7 @@ class _Dict(modal.object._Object):
     ) -> _Dict: ...
     @staticmethod
     async def lookup(
-        label: str,
+        name: str,
         data: typing.Optional[dict] = None,
         namespace=1,
         client: typing.Optional[modal.client._Client] = None,
@@ -38,7 +36,7 @@ class _Dict(modal.object._Object):
     ) -> _Dict: ...
     @staticmethod
     async def delete(
-        label: str,
+        name: str,
         *,
         client: typing.Optional[modal.client._Client] = None,
         environment_name: typing.Optional[str] = None,
@@ -60,8 +58,6 @@ class _Dict(modal.object._Object):
 
 class Dict(modal.object.Object):
     def __init__(self, data={}): ...
-    @staticmethod
-    def new(data: typing.Optional[dict] = None): ...
     @classmethod
     def ephemeral(
         cls: type[Dict],
@@ -72,7 +68,7 @@ class Dict(modal.object.Object):
     ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[Dict]: ...
     @staticmethod
     def from_name(
-        label: str,
+        name: str,
         data: typing.Optional[dict] = None,
         namespace=1,
         environment_name: typing.Optional[str] = None,
@@ -82,7 +78,7 @@ class Dict(modal.object.Object):
     class __lookup_spec(typing_extensions.Protocol):
         def __call__(
             self,
-            label: str,
+            name: str,
             data: typing.Optional[dict] = None,
             namespace=1,
             client: typing.Optional[modal.client.Client] = None,
@@ -91,7 +87,7 @@ class Dict(modal.object.Object):
         ) -> Dict: ...
         async def aio(
             self,
-            label: str,
+            name: str,
             data: typing.Optional[dict] = None,
             namespace=1,
             client: typing.Optional[modal.client.Client] = None,
@@ -104,14 +100,14 @@ class Dict(modal.object.Object):
     class __delete_spec(typing_extensions.Protocol):
         def __call__(
             self,
-            label: str,
+            name: str,
             *,
             client: typing.Optional[modal.client.Client] = None,
             environment_name: typing.Optional[str] = None,
         ): ...
         async def aio(
             self,
-            label: str,
+            name: str,
             *,
             client: typing.Optional[modal.client.Client] = None,
             environment_name: typing.Optional[str] = None,