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

modal/container_process.pyi

@@ -0,0 +1,82 @@
+import modal.client
+import modal.io_streams
+import modal.stream_type
+import typing
+import typing_extensions
+
+T = typing.TypeVar("T")
+
+class _ContainerProcess(typing.Generic[T]):
+    _process_id: typing.Optional[str]
+    _stdout: modal.io_streams._StreamReader[T]
+    _stderr: modal.io_streams._StreamReader[T]
+    _stdin: modal.io_streams._StreamWriter
+    _text: bool
+    _by_line: bool
+    _returncode: typing.Optional[int]
+
+    def __init__(
+        self,
+        process_id: str,
+        client: modal.client._Client,
+        stdout: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
+        stderr: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
+        text: bool = True,
+        by_line: bool = False,
+    ) -> None: ...
+    @property
+    def stdout(self) -> modal.io_streams._StreamReader[T]: ...
+    @property
+    def stderr(self) -> modal.io_streams._StreamReader[T]: ...
+    @property
+    def stdin(self) -> modal.io_streams._StreamWriter: ...
+    @property
+    def returncode(self) -> int: ...
+    async def poll(self) -> typing.Optional[int]: ...
+    async def wait(self) -> int: ...
+    async def attach(self, *, pty: typing.Optional[bool] = None): ...
+
+class ContainerProcess(typing.Generic[T]):
+    _process_id: typing.Optional[str]
+    _stdout: modal.io_streams.StreamReader[T]
+    _stderr: modal.io_streams.StreamReader[T]
+    _stdin: modal.io_streams.StreamWriter
+    _text: bool
+    _by_line: bool
+    _returncode: typing.Optional[int]
+
+    def __init__(
+        self,
+        process_id: str,
+        client: modal.client.Client,
+        stdout: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
+        stderr: modal.stream_type.StreamType = modal.stream_type.StreamType.PIPE,
+        text: bool = True,
+        by_line: bool = False,
+    ) -> None: ...
+    @property
+    def stdout(self) -> modal.io_streams.StreamReader[T]: ...
+    @property
+    def stderr(self) -> modal.io_streams.StreamReader[T]: ...
+    @property
+    def stdin(self) -> modal.io_streams.StreamWriter: ...
+    @property
+    def returncode(self) -> int: ...
+
+    class __poll_spec(typing_extensions.Protocol):
+        def __call__(self) -> typing.Optional[int]: ...
+        async def aio(self) -> typing.Optional[int]: ...
+
+    poll: __poll_spec
+
+    class __wait_spec(typing_extensions.Protocol):
+        def __call__(self) -> int: ...
+        async def aio(self) -> int: ...
+
+    wait: __wait_spec
+
+    class __attach_spec(typing_extensions.Protocol):
+        def __call__(self, *, pty: typing.Optional[bool] = None): ...
+        async def aio(self, *, pty: typing.Optional[bool] = None): ...
+
+    attach: __attach_spec

modal/dict.py

@@ -1,6 +1,8 @@
 # Copyright Modal Labs 2022
-from typing import Any, AsyncIterator, Optional, Tuple, Type
+from collections.abc import AsyncIterator
+from typing import Any, Optional
 
+from grpclib import GRPCError
 from synchronicity.async_wrap import asynccontextmanager
 
 from modal_proto import api_pb2
@@ -8,10 +10,12 @@ 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.grpc_utils import retry_transient_errors, unary_stream
+from ._utils.deprecation import renamed_parameter
+from ._utils.grpc_utils import retry_transient_errors
+from ._utils.name_utils import check_object_name
 from .client import _Client
 from .config import logger
-from .exception import deprecation_warning
+from .exception import RequestSizeError
 from .object import EPHEMERAL_OBJECT_HEARTBEAT_SLEEP, _get_environment_name, _Object, live_method, live_method_gen
 
 
@@ -54,25 +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) -> "_Dict":
-        """`Dict.new` is deprecated.
-
-        Please use `Dict.from_name` (for persisted) or `Dict.ephemeral` (for ephemeral) dicts.
-        """
-        deprecation_warning((2024, 3, 19), Dict.new.__doc__)
-
-        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.DictCreateRequest(
-                app_id=resolver.app_id, data=serialized, existing_dict_id=existing_object_id
-            )
-            response = await resolver.client.stub.DictCreate(req)
-            logger.debug(f"Created dict with id {response.dict_id}")
-            self._hydrate(response.dict_id, resolver.client, None)
-
-        return _Dict._from_loader(_load, "Dict()")
-
     def __init__(self, data={}):
         """mdmd:hidden"""
         raise RuntimeError(
@@ -82,7 +67,7 @@ class _Dict(_Object, type_prefix="di"):
     @classmethod
     @asynccontextmanager
     async def ephemeral(
-        cls: Type["_Dict"],
+        cls: type["_Dict"],
         data: Optional[dict] = None,
         client: Optional[_Client] = None,
         environment_name: Optional[str] = None,
@@ -96,7 +81,9 @@ class _Dict(_Object, type_prefix="di"):
 
         with Dict.ephemeral() as d:
             d["foo"] = "bar"
+        ```
 
+        ```python notest
         async with Dict.ephemeral() as d:
             await d.put.aio("foo", "bar")
         ```
@@ -109,36 +96,38 @@ class _Dict(_Object, type_prefix="di"):
             environment_name=_get_environment_name(environment_name),
             data=serialized,
         )
-        response = await client.stub.DictGetOrCreate(request)
+        response = await retry_transient_errors(client.stub.DictGetOrCreate, request, total_timeout=10.0)
         async with TaskContext() as tc:
             request = api_pb2.DictHeartbeatRequest(dict_id=response.dict_id)
             tc.infinite_loop(lambda: client.stub.DictHeartbeat(request), sleep=_heartbeat_sleep)
             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,
         create_if_missing: bool = False,
     ) -> "_Dict":
-        """Create a reference to a persisted Dict
+        """Reference a named Dict, creating if necessary.
 
-        **Examples**
+        In contrast to `modal.Dict.lookup`, this is a lazy method
+        that defers hydrating the local object with metadata from
+        Modal servers until the first time it is actually used.
 
         ```python
-        from modal import Dict
-
-        dict = Dict.from_name("my-dict", create_if_missing=True)
-        dict[123] = 456
+        d = modal.Dict.from_name("my-dict", create_if_missing=True)
+        d[123] = 456
         ```
         """
+        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),
@@ -151,33 +140,27 @@ class _Dict(_Object, type_prefix="di"):
         return _Dict._from_loader(_load, "Dict()", is_another_app=True, hydrate_lazily=True)
 
     @staticmethod
-    def persisted(
-        label: str, namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE, environment_name: Optional[str] = None
-    ) -> "_Dict":
-        """Deprecated! Use `Dict.from_name(name, create_if_missing=True)`."""
-        deprecation_warning((2024, 3, 1), _Dict.persisted.__doc__)
-        return _Dict.from_name(label, namespace, environment_name, create_if_missing=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,
         environment_name: Optional[str] = None,
         create_if_missing: bool = False,
     ) -> "_Dict":
-        """Lookup a dict with a given name and tag.
+        """Lookup a named Dict.
 
-        ```python
-        from modal import Dict
+        In contrast to `modal.Dict.from_name`, this is an eager method
+        that will hydrate the local object with metadata from Modal servers.
 
-        d = Dict.lookup("my-dict")
+        ```python
+        d = modal.Dict.lookup("my-dict")
         d["xyz"] = 123
         ```
         """
         obj = _Dict.from_name(
-            label,
+            name,
             data=data,
             namespace=namespace,
             environment_name=environment_name,
@@ -190,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)
 
@@ -250,7 +234,13 @@ class _Dict(_Object, type_prefix="di"):
         """Update the dictionary with additional items."""
         serialized = _serialize_dict(kwargs)
         req = api_pb2.DictUpdateRequest(dict_id=self.object_id, updates=serialized)
-        await retry_transient_errors(self._client.stub.DictUpdate, req)
+        try:
+            await retry_transient_errors(self._client.stub.DictUpdate, req)
+        except GRPCError as exc:
+            if "status = '413'" in exc.message:
+                raise RequestSizeError("Dict.update request is too large") from exc
+            else:
+                raise exc
 
     @live_method
     async def put(self, key: Any, value: Any) -> None:
@@ -258,7 +248,13 @@ class _Dict(_Object, type_prefix="di"):
         updates = {key: value}
         serialized = _serialize_dict(updates)
         req = api_pb2.DictUpdateRequest(dict_id=self.object_id, updates=serialized)
-        await retry_transient_errors(self._client.stub.DictUpdate, req)
+        try:
+            await retry_transient_errors(self._client.stub.DictUpdate, req)
+        except GRPCError as exc:
+            if "status = '413'" in exc.message:
+                raise RequestSizeError("Dict.put request is too large") from exc
+            else:
+                raise exc
 
     @live_method
     async def __setitem__(self, key: Any, value: Any) -> None:
@@ -301,7 +297,7 @@ class _Dict(_Object, type_prefix="di"):
         and results are unordered.
         """
         req = api_pb2.DictContentsRequest(dict_id=self.object_id, keys=True)
-        async for resp in unary_stream(self._client.stub.DictContents, req):
+        async for resp in self._client.stub.DictContents.unary_stream(req):
             yield deserialize(resp.key, self._client)
 
     @live_method_gen
@@ -312,18 +308,18 @@ class _Dict(_Object, type_prefix="di"):
         and results are unordered.
         """
         req = api_pb2.DictContentsRequest(dict_id=self.object_id, values=True)
-        async for resp in unary_stream(self._client.stub.DictContents, req):
+        async for resp in self._client.stub.DictContents.unary_stream(req):
             yield deserialize(resp.value, self._client)
 
     @live_method_gen
-    async def items(self) -> AsyncIterator[Tuple[Any, Any]]:
+    async def items(self) -> AsyncIterator[tuple[Any, Any]]:
         """Return an iterator over the (key, value) tuples in this dictionary.
 
         Note that (unlike with Python dicts) the return value is a simple iterator,
         and results are unordered.
         """
         req = api_pb2.DictContentsRequest(dict_id=self.object_id, keys=True, values=True)
-        async for resp in unary_stream(self._client.stub.DictContents, req):
+        async for resp in self._client.stub.DictContents.unary_stream(req):
             yield (deserialize(resp.key, self._client), deserialize(resp.value, self._client))
 
 

modal/dict.pyi

@@ -1,244 +1,200 @@
+import collections.abc
 import modal.client
 import modal.object
 import synchronicity.combined_types
 import typing
 import typing_extensions
 
-def _serialize_dict(data):
-    ...
-
+def _serialize_dict(data): ...
 
 class _Dict(modal.object._Object):
-    @staticmethod
-    def new(data: typing.Union[dict, None] = None) -> _Dict:
-        ...
-
-    def __init__(self, data={}):
-        ...
-
+    def __init__(self, data={}): ...
     @classmethod
-    def ephemeral(cls: typing.Type[_Dict], data: typing.Union[dict, None] = None, client: typing.Union[modal.client._Client, None] = None, environment_name: typing.Union[str, None] = None, _heartbeat_sleep: float = 300) -> typing.AsyncContextManager[_Dict]:
-        ...
-
-    @staticmethod
-    def from_name(label: str, data: typing.Union[dict, None] = None, namespace=1, environment_name: typing.Union[str, None] = None, create_if_missing: bool = False) -> _Dict:
-        ...
-
+    def ephemeral(
+        cls: type[_Dict],
+        data: typing.Optional[dict] = None,
+        client: typing.Optional[modal.client._Client] = None,
+        environment_name: typing.Optional[str] = None,
+        _heartbeat_sleep: float = 300,
+    ) -> typing.AsyncContextManager[_Dict]: ...
     @staticmethod
-    def persisted(label: str, namespace=1, environment_name: typing.Union[str, None] = None) -> _Dict:
-        ...
-
+    def from_name(
+        name: str,
+        data: typing.Optional[dict] = None,
+        namespace=1,
+        environment_name: typing.Optional[str] = None,
+        create_if_missing: bool = False,
+    ) -> _Dict: ...
     @staticmethod
-    async def lookup(label: str, data: typing.Union[dict, None] = None, namespace=1, client: typing.Union[modal.client._Client, None] = None, environment_name: typing.Union[str, None] = None, create_if_missing: bool = False) -> _Dict:
-        ...
-
+    async def lookup(
+        name: str,
+        data: typing.Optional[dict] = None,
+        namespace=1,
+        client: typing.Optional[modal.client._Client] = None,
+        environment_name: typing.Optional[str] = None,
+        create_if_missing: bool = False,
+    ) -> _Dict: ...
     @staticmethod
-    async def delete(label: str, *, client: typing.Union[modal.client._Client, None] = None, environment_name: typing.Union[str, None] = None):
-        ...
-
-    async def clear(self) -> None:
-        ...
-
-    async def get(self, key: typing.Any, default: typing.Union[typing.Any, None] = None) -> typing.Any:
-        ...
-
-    async def contains(self, key: typing.Any) -> bool:
-        ...
-
-    async def len(self) -> int:
-        ...
-
-    async def __getitem__(self, key: typing.Any) -> typing.Any:
-        ...
-
-    async def update(self, **kwargs) -> None:
-        ...
-
-    async def put(self, key: typing.Any, value: typing.Any) -> None:
-        ...
-
-    async def __setitem__(self, key: typing.Any, value: typing.Any) -> None:
-        ...
-
-    async def pop(self, key: typing.Any) -> typing.Any:
-        ...
-
-    async def __delitem__(self, key: typing.Any) -> typing.Any:
-        ...
-
-    async def __contains__(self, key: typing.Any) -> bool:
-        ...
-
-    def keys(self) -> typing.AsyncIterator[typing.Any]:
-        ...
-
-    def values(self) -> typing.AsyncIterator[typing.Any]:
-        ...
-
-    def items(self) -> typing.AsyncIterator[typing.Tuple[typing.Any, typing.Any]]:
-        ...
-
+    async def delete(
+        name: str,
+        *,
+        client: typing.Optional[modal.client._Client] = None,
+        environment_name: typing.Optional[str] = None,
+    ): ...
+    async def clear(self) -> None: ...
+    async def get(self, key: typing.Any, default: typing.Optional[typing.Any] = None) -> typing.Any: ...
+    async def contains(self, key: typing.Any) -> bool: ...
+    async def len(self) -> int: ...
+    async def __getitem__(self, key: typing.Any) -> typing.Any: ...
+    async def update(self, **kwargs) -> None: ...
+    async def put(self, key: typing.Any, value: typing.Any) -> None: ...
+    async def __setitem__(self, key: typing.Any, value: typing.Any) -> None: ...
+    async def pop(self, key: typing.Any) -> typing.Any: ...
+    async def __delitem__(self, key: typing.Any) -> typing.Any: ...
+    async def __contains__(self, key: typing.Any) -> bool: ...
+    def keys(self) -> collections.abc.AsyncIterator[typing.Any]: ...
+    def values(self) -> collections.abc.AsyncIterator[typing.Any]: ...
+    def items(self) -> collections.abc.AsyncIterator[tuple[typing.Any, typing.Any]]: ...
 
 class Dict(modal.object.Object):
-    def __init__(self, data={}):
-        ...
-
-    @staticmethod
-    def new(data: typing.Union[dict, None] = None) -> Dict:
-        ...
-
+    def __init__(self, data={}): ...
     @classmethod
-    def ephemeral(cls: typing.Type[Dict], data: typing.Union[dict, None] = None, client: typing.Union[modal.client.Client, None] = None, environment_name: typing.Union[str, None] = None, _heartbeat_sleep: float = 300) -> synchronicity.combined_types.AsyncAndBlockingContextManager[Dict]:
-        ...
-
-    @staticmethod
-    def from_name(label: str, data: typing.Union[dict, None] = None, namespace=1, environment_name: typing.Union[str, None] = None, create_if_missing: bool = False) -> Dict:
-        ...
-
+    def ephemeral(
+        cls: type[Dict],
+        data: typing.Optional[dict] = None,
+        client: typing.Optional[modal.client.Client] = None,
+        environment_name: typing.Optional[str] = None,
+        _heartbeat_sleep: float = 300,
+    ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[Dict]: ...
     @staticmethod
-    def persisted(label: str, namespace=1, environment_name: typing.Union[str, None] = None) -> Dict:
-        ...
+    def from_name(
+        name: str,
+        data: typing.Optional[dict] = None,
+        namespace=1,
+        environment_name: typing.Optional[str] = None,
+        create_if_missing: bool = False,
+    ) -> Dict: ...
 
     class __lookup_spec(typing_extensions.Protocol):
-        def __call__(self, label: str, data: typing.Union[dict, None] = None, namespace=1, client: typing.Union[modal.client.Client, None] = None, environment_name: typing.Union[str, None] = None, create_if_missing: bool = False) -> Dict:
-            ...
-
-        async def aio(self, *args, **kwargs) -> Dict:
-            ...
+        def __call__(
+            self,
+            name: str,
+            data: typing.Optional[dict] = None,
+            namespace=1,
+            client: typing.Optional[modal.client.Client] = None,
+            environment_name: typing.Optional[str] = None,
+            create_if_missing: bool = False,
+        ) -> Dict: ...
+        async def aio(
+            self,
+            name: str,
+            data: typing.Optional[dict] = None,
+            namespace=1,
+            client: typing.Optional[modal.client.Client] = None,
+            environment_name: typing.Optional[str] = None,
+            create_if_missing: bool = False,
+        ) -> Dict: ...
 
     lookup: __lookup_spec
 
     class __delete_spec(typing_extensions.Protocol):
-        def __call__(self, label: str, *, client: typing.Union[modal.client.Client, None] = None, environment_name: typing.Union[str, None] = None):
-            ...
-
-        async def aio(self, *args, **kwargs):
-            ...
+        def __call__(
+            self,
+            name: str,
+            *,
+            client: typing.Optional[modal.client.Client] = None,
+            environment_name: typing.Optional[str] = None,
+        ): ...
+        async def aio(
+            self,
+            name: str,
+            *,
+            client: typing.Optional[modal.client.Client] = None,
+            environment_name: typing.Optional[str] = None,
+        ): ...
 
     delete: __delete_spec
 
     class __clear_spec(typing_extensions.Protocol):
-        def __call__(self) -> None:
-            ...
-
-        async def aio(self, *args, **kwargs) -> None:
-            ...
+        def __call__(self) -> None: ...
+        async def aio(self) -> None: ...
 
     clear: __clear_spec
 
     class __get_spec(typing_extensions.Protocol):
-        def __call__(self, key: typing.Any, default: typing.Union[typing.Any, None] = None) -> typing.Any:
-            ...
-
-        async def aio(self, *args, **kwargs) -> typing.Any:
-            ...
+        def __call__(self, key: typing.Any, default: typing.Optional[typing.Any] = None) -> typing.Any: ...
+        async def aio(self, key: typing.Any, default: typing.Optional[typing.Any] = None) -> typing.Any: ...
 
     get: __get_spec
 
     class __contains_spec(typing_extensions.Protocol):
-        def __call__(self, key: typing.Any) -> bool:
-            ...
-
-        async def aio(self, *args, **kwargs) -> bool:
-            ...
+        def __call__(self, key: typing.Any) -> bool: ...
+        async def aio(self, key: typing.Any) -> bool: ...
 
     contains: __contains_spec
 
     class __len_spec(typing_extensions.Protocol):
-        def __call__(self) -> int:
-            ...
-
-        async def aio(self, *args, **kwargs) -> int:
-            ...
+        def __call__(self) -> int: ...
+        async def aio(self) -> int: ...
 
     len: __len_spec
 
     class ____getitem___spec(typing_extensions.Protocol):
-        def __call__(self, key: typing.Any) -> typing.Any:
-            ...
-
-        async def aio(self, *args, **kwargs) -> typing.Any:
-            ...
+        def __call__(self, key: typing.Any) -> typing.Any: ...
+        async def aio(self, key: typing.Any) -> typing.Any: ...
 
     __getitem__: ____getitem___spec
 
     class __update_spec(typing_extensions.Protocol):
-        def __call__(self, **kwargs) -> None:
-            ...
-
-        async def aio(self, *args, **kwargs) -> None:
-            ...
+        def __call__(self, **kwargs) -> None: ...
+        async def aio(self, **kwargs) -> None: ...
 
     update: __update_spec
 
     class __put_spec(typing_extensions.Protocol):
-        def __call__(self, key: typing.Any, value: typing.Any) -> None:
-            ...
-
-        async def aio(self, *args, **kwargs) -> None:
-            ...
+        def __call__(self, key: typing.Any, value: typing.Any) -> None: ...
+        async def aio(self, key: typing.Any, value: typing.Any) -> None: ...
 
     put: __put_spec
 
     class ____setitem___spec(typing_extensions.Protocol):
-        def __call__(self, key: typing.Any, value: typing.Any) -> None:
-            ...
-
-        async def aio(self, *args, **kwargs) -> None:
-            ...
+        def __call__(self, key: typing.Any, value: typing.Any) -> None: ...
+        async def aio(self, key: typing.Any, value: typing.Any) -> None: ...
 
     __setitem__: ____setitem___spec
 
     class __pop_spec(typing_extensions.Protocol):
-        def __call__(self, key: typing.Any) -> typing.Any:
-            ...
-
-        async def aio(self, *args, **kwargs) -> typing.Any:
-            ...
+        def __call__(self, key: typing.Any) -> typing.Any: ...
+        async def aio(self, key: typing.Any) -> typing.Any: ...
 
     pop: __pop_spec
 
     class ____delitem___spec(typing_extensions.Protocol):
-        def __call__(self, key: typing.Any) -> typing.Any:
-            ...
-
-        async def aio(self, *args, **kwargs) -> typing.Any:
-            ...
+        def __call__(self, key: typing.Any) -> typing.Any: ...
+        async def aio(self, key: typing.Any) -> typing.Any: ...
 
     __delitem__: ____delitem___spec
 
     class ____contains___spec(typing_extensions.Protocol):
-        def __call__(self, key: typing.Any) -> bool:
-            ...
-
-        async def aio(self, *args, **kwargs) -> bool:
-            ...
+        def __call__(self, key: typing.Any) -> bool: ...
+        async def aio(self, key: typing.Any) -> bool: ...
 
     __contains__: ____contains___spec
 
     class __keys_spec(typing_extensions.Protocol):
-        def __call__(self) -> typing.Iterator[typing.Any]:
-            ...
-
-        def aio(self) -> typing.AsyncIterator[typing.Any]:
-            ...
+        def __call__(self) -> typing.Iterator[typing.Any]: ...
+        def aio(self) -> collections.abc.AsyncIterator[typing.Any]: ...
 
     keys: __keys_spec
 
     class __values_spec(typing_extensions.Protocol):
-        def __call__(self) -> typing.Iterator[typing.Any]:
-            ...
-
-        def aio(self) -> typing.AsyncIterator[typing.Any]:
-            ...
+        def __call__(self) -> typing.Iterator[typing.Any]: ...
+        def aio(self) -> collections.abc.AsyncIterator[typing.Any]: ...
 
     values: __values_spec
 
     class __items_spec(typing_extensions.Protocol):
-        def __call__(self) -> typing.Iterator[typing.Tuple[typing.Any, typing.Any]]:
-            ...
-
-        def aio(self) -> typing.AsyncIterator[typing.Tuple[typing.Any, typing.Any]]:
-            ...
+        def __call__(self) -> typing.Iterator[tuple[typing.Any, typing.Any]]: ...
+        def aio(self) -> collections.abc.AsyncIterator[tuple[typing.Any, typing.Any]]: ...
 
     items: __items_spec