modal 0.67.1__py3-none-any.whl → 0.67.33__py3-none-any.whl

modal/cls.py

@@ -2,7 +2,8 @@
 import inspect
 import os
 import typing
-from typing import Any, Callable, Collection, Dict, List, Optional, Tuple, Type, TypeVar, Union
+from collections.abc import Collection
+from typing import Any, Callable, Optional, TypeVar, Union
 
 from google.protobuf.message import Message
 from grpclib import GRPCError, Status
@@ -71,15 +72,77 @@ def _get_class_constructor_signature(user_cls: type) -> inspect.Signature:
         return inspect.Signature(constructor_parameters)
 
 
+def _bind_instance_method(service_function: _Function, class_bound_method: _Function):
+    """mdmd:hidden
+
+    Binds an "instance service function" to a specific method.
+    This "dummy" _Function gets no unique object_id and isn't backend-backed at the moment, since all
+    it does it forward invocations to the underlying instance_service_function with the specified method,
+    and we don't support web_config for parameterized methods at the moment.
+    """
+    # TODO(elias): refactor to not use `_from_loader()` as a crutch for lazy-loading the
+    #   underlying instance_service_function. It's currently used in order to take advantage
+    #   of resolver logic and get "chained" resolution of lazy loads, even though this thin
+    #   object itself doesn't need any "loading"
+    assert service_function._obj
+    method_name = class_bound_method._use_method_name
+    full_function_name = f"{class_bound_method._function_name}[parameterized]"
+
+    def hydrate_from_instance_service_function(method_placeholder_fun):
+        method_placeholder_fun._hydrate_from_other(service_function)
+        method_placeholder_fun._obj = service_function._obj
+        method_placeholder_fun._web_url = (
+            class_bound_method._web_url
+        )  # TODO: this shouldn't be set when actual parameters are used
+        method_placeholder_fun._function_name = full_function_name
+        method_placeholder_fun._is_generator = class_bound_method._is_generator
+        method_placeholder_fun._cluster_size = class_bound_method._cluster_size
+        method_placeholder_fun._use_method_name = method_name
+        method_placeholder_fun._is_method = True
+
+    async def _load(fun: "_Function", resolver: Resolver, existing_object_id: Optional[str]):
+        # there is currently no actual loading logic executed to create each method on
+        # the *parameterized* instance of a class - it uses the parameter-bound service-function
+        # for the instance. This load method just makes sure to set all attributes after the
+        # `service_function` has been loaded (it's in the `_deps`)
+        hydrate_from_instance_service_function(fun)
+
+    def _deps():
+        if service_function.is_hydrated:
+            # without this check, the common service_function will be reloaded by all methods
+            # TODO(elias): Investigate if we can fix this multi-loader in the resolver - feels like a bug?
+            return []
+        return [service_function]
+
+    rep = f"Method({full_function_name})"
+
+    fun = _Function._from_loader(
+        _load,
+        rep,
+        deps=_deps,
+        hydrate_lazily=True,
+    )
+    if service_function.is_hydrated:
+        # Eager hydration (skip load) if the instance service function is already loaded
+        hydrate_from_instance_service_function(fun)
+
+    fun._info = class_bound_method._info
+    fun._obj = service_function._obj
+    fun._is_method = True
+    fun._app = class_bound_method._app
+    fun._spec = class_bound_method._spec
+    return fun
+
+
 class _Obj:
     """An instance of a `Cls`, i.e. `Cls("foo", 42)` returns an `Obj`.
 
     All this class does is to return `Function` objects."""
 
-    _functions: Dict[str, _Function]
-    _entered: bool
+    _functions: dict[str, _Function]
+    _has_entered: bool
     _user_cls_instance: Optional[Any] = None
-    _construction_args: Tuple[tuple, Dict[str, Any]]
+    _construction_args: tuple[tuple, dict[str, Any]]
 
     _instance_service_function: Optional[_Function]
 
@@ -89,10 +152,9 @@ class _Obj:
 
     def __init__(
         self,
-        user_cls: type,
+        user_cls: Optional[type],  # this would be None in case of lookups
         class_service_function: Optional[_Function],  # only None for <v0.63 classes
-        classbound_methods: Dict[str, _Function],
-        from_other_workspace: bool,
+        classbound_methods: dict[str, _Function],
         options: Optional[api_pb2.FunctionOptions],
         args,
         kwargs,
@@ -106,22 +168,19 @@ class _Obj:
         if class_service_function:
             # >= v0.63 classes
             # first create the singular object function used by all methods on this parameterization
-            self._instance_service_function = class_service_function._bind_parameters(
-                self, from_other_workspace, options, args, kwargs
-            )
+            self._instance_service_function = class_service_function._bind_parameters(self, options, args, kwargs)
             for method_name, class_bound_method in classbound_methods.items():
-                method = self._instance_service_function._bind_instance_method(class_bound_method)
+                method = _bind_instance_method(self._instance_service_function, class_bound_method)
                 self._method_functions[method_name] = method
         else:
             # looked up <v0.63 classes - bind each individual method to the new parameters
             self._instance_service_function = None
             for method_name, class_bound_method in classbound_methods.items():
-                method = class_bound_method._bind_parameters(self, from_other_workspace, options, args, kwargs)
+                method = class_bound_method._bind_parameters(self, options, args, kwargs)
                 self._method_functions[method_name] = method
 
         # Used for construction local object lazily
-        self._entered = False
-        self._local_user_cls_instance = None
+        self._has_entered = False
         self._user_cls = user_cls
         self._construction_args = (args, kwargs)  # used for lazy construction in case of explicit constructors
 
@@ -154,7 +213,7 @@ class _Obj:
         Note that all Modal methods and web endpoints of a class share the same set
         of containers and the warm_pool_size affects that common container pool.
 
-        ```python
+        ```python notest
         # Usage on a parametrized function.
         Model = modal.Cls.lookup("my-app", "Model")
         Model("fine-tuned-model").keep_warm(2)
@@ -175,8 +234,8 @@ class _Obj:
 
         return self._user_cls_instance
 
-    def enter(self):
-        if not self._entered:
+    def _enter(self):
+        if not self._has_entered:
             if hasattr(self._user_cls_instance, "__enter__"):
                 self._user_cls_instance.__enter__()
 
@@ -187,26 +246,26 @@ class _Obj:
                 for enter_method in _find_callables_for_obj(self._user_cls_instance, method_flag).values():
                     enter_method()
 
-        self._entered = True
+        self._has_entered = True
 
     @property
-    def entered(self):
-        # needed because aenter is nowrap
-        return self._entered
+    def _entered(self) -> bool:
+        # needed because _aenter is nowrap
+        return self._has_entered
 
-    @entered.setter
-    def entered(self, val):
-        self._entered = val
+    @_entered.setter
+    def _entered(self, val: bool):
+        self._has_entered = val
 
     @synchronizer.nowrap
-    async def aenter(self):
-        if not self.entered:
+    async def _aenter(self):
+        if not self._entered:  # use the property to get at the impl class
             user_cls_instance = self._cached_user_cls_instance()
             if hasattr(user_cls_instance, "__aenter__"):
                 await user_cls_instance.__aenter__()
             elif hasattr(user_cls_instance, "__enter__"):
                 user_cls_instance.__enter__()
-        self.entered = True
+        self._has_entered = True
 
     def __getattr__(self, k):
         if k in self._method_functions:
@@ -244,10 +303,9 @@ class _Cls(_Object, type_prefix="cs"):
     _class_service_function: Optional[
         _Function
     ]  # The _Function serving *all* methods of the class, used for version >=v0.63
-    _method_functions: Optional[Dict[str, _Function]] = None  # Placeholder _Functions for each method
+    _method_functions: Optional[dict[str, _Function]] = None  # Placeholder _Functions for each method
     _options: Optional[api_pb2.FunctionOptions]
-    _callables: Dict[str, Callable[..., Any]]
-    _from_other_workspace: Optional[bool]  # Functions require FunctionBindParams before invocation.
+    _callables: dict[str, Callable[..., Any]]
     _app: Optional["modal.app._App"] = None  # not set for lookups
 
     def _initialize_from_empty(self):
@@ -255,7 +313,6 @@ class _Cls(_Object, type_prefix="cs"):
         self._class_service_function = None
         self._options = None
         self._callables = {}
-        self._from_other_workspace = None
 
     def _initialize_from_other(self, other: "_Cls"):
         self._user_cls = other._user_cls
@@ -263,9 +320,8 @@ class _Cls(_Object, type_prefix="cs"):
         self._method_functions = other._method_functions
         self._options = other._options
         self._callables = other._callables
-        self._from_other_workspace = other._from_other_workspace
 
-    def _get_partial_functions(self) -> Dict[str, _PartialFunction]:
+    def _get_partial_functions(self) -> dict[str, _PartialFunction]:
         if not self._user_cls:
             raise AttributeError("You can only get the partial functions of a local Cls instance")
         return _find_partial_methods_for_user_cls(self._user_cls, _PartialFunctionFlags.all())
@@ -277,7 +333,7 @@ class _Cls(_Object, type_prefix="cs"):
             and self._class_service_function._method_handle_metadata
             and len(self._class_service_function._method_handle_metadata)
         ):
-            # The class only has a class service service function and no method placeholders (v0.67+)
+            # The class only has a class service function and no method placeholders (v0.67+)
             if self._method_functions:
                 # We're here when the Cls is loaded locally (e.g. _Cls.from_local) so the _method_functions mapping is
                 # populated with (un-hydrated) _Function objects
@@ -298,7 +354,7 @@ class _Cls(_Object, type_prefix="cs"):
                     self._method_functions[method_name] = _Function._new_hydrated(
                         self._class_service_function.object_id, self._client, method_handle_metadata
                     )
-        elif self._class_service_function:
+        elif self._class_service_function and self._class_service_function.object_id:
             # A class with a class service function and method placeholder functions
             self._method_functions = {}
             for method in metadata.methods:
@@ -344,8 +400,8 @@ class _Cls(_Object, type_prefix="cs"):
         # validate signature
         _Cls.validate_construction_mechanism(user_cls)
 
-        method_functions: Dict[str, _Function] = {}
-        partial_functions: Dict[str, _PartialFunction] = _find_partial_methods_for_user_cls(
+        method_functions: dict[str, _Function] = {}
+        partial_functions: dict[str, _PartialFunction] = _find_partial_methods_for_user_cls(
             user_cls, _PartialFunctionFlags.FUNCTION
         )
 
@@ -361,11 +417,11 @@ class _Cls(_Object, type_prefix="cs"):
             partial_function.wrapped = True
 
         # Get all callables
-        callables: Dict[str, Callable] = {
+        callables: dict[str, Callable] = {
             k: pf.raw_f for k, pf in _find_partial_methods_for_user_cls(user_cls, _PartialFunctionFlags.all()).items()
         }
 
-        def _deps() -> List[_Function]:
+        def _deps() -> list[_Function]:
             return [class_service_function]
 
         async def _load(self: "_Cls", resolver: Resolver, existing_object_id: Optional[str]):
@@ -382,7 +438,6 @@ class _Cls(_Object, type_prefix="cs"):
         cls._class_service_function = class_service_function
         cls._method_functions = method_functions
         cls._callables = callables
-        cls._from_other_workspace = False
         return cls
 
     def _uses_common_service_function(self):
@@ -392,7 +447,7 @@ class _Cls(_Object, type_prefix="cs"):
 
     @classmethod
     def from_name(
-        cls: Type["_Cls"],
+        cls: type["_Cls"],
         app_name: str,
         tag: str,
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
@@ -449,16 +504,15 @@ class _Cls(_Object, type_prefix="cs"):
 
         rep = f"Ref({app_name})"
         cls = cls._from_loader(_load_remote, rep, is_another_app=True)
-        cls._from_other_workspace = bool(workspace is not None)
         return cls
 
     def with_options(
         self: "_Cls",
-        cpu: Optional[Union[float, Tuple[float, float]]] = None,
-        memory: Optional[Union[int, Tuple[int, int]]] = None,
+        cpu: Optional[Union[float, tuple[float, float]]] = None,
+        memory: Optional[Union[int, tuple[int, int]]] = None,
         gpu: GPU_T = None,
         secrets: Collection[_Secret] = (),
-        volumes: Dict[Union[str, os.PathLike], _Volume] = {},
+        volumes: dict[Union[str, os.PathLike], _Volume] = {},
         retries: Optional[Union[int, Retries]] = None,
         timeout: Optional[int] = None,
         concurrency_limit: Optional[int] = None,
@@ -524,7 +578,7 @@ class _Cls(_Object, type_prefix="cs"):
         In contrast to `modal.Cls.from_name`, this is an eager method
         that will hydrate the local object with metadata from Modal servers.
 
-        ```python
+        ```python notest
         Class = modal.Cls.lookup("other-app", "Class")
         obj = Class()
         ```
@@ -543,7 +597,6 @@ class _Cls(_Object, type_prefix="cs"):
             self._user_cls,
             self._class_service_function,
             self._method_functions,
-            self._from_other_workspace,
             self._options,
             args,
             kwargs,

modal/cls.pyi

@@ -1,3 +1,4 @@
+import collections.abc
 import google.protobuf.message
 import inspect
 import modal.app
@@ -18,21 +19,23 @@ T = typing.TypeVar("T")
 
 def _use_annotation_parameters(user_cls) -> bool: ...
 def _get_class_constructor_signature(user_cls: type) -> inspect.Signature: ...
+def _bind_instance_method(
+    service_function: modal.functions._Function, class_bound_method: modal.functions._Function
+): ...
 
 class _Obj:
-    _functions: typing.Dict[str, modal.functions._Function]
-    _entered: bool
+    _functions: dict[str, modal.functions._Function]
+    _has_entered: bool
     _user_cls_instance: typing.Optional[typing.Any]
-    _construction_args: typing.Tuple[tuple, typing.Dict[str, typing.Any]]
+    _construction_args: tuple[tuple, dict[str, typing.Any]]
     _instance_service_function: typing.Optional[modal.functions._Function]
 
     def _uses_common_service_function(self): ...
     def __init__(
         self,
-        user_cls: type,
+        user_cls: typing.Optional[type],
         class_service_function: typing.Optional[modal.functions._Function],
-        classbound_methods: typing.Dict[str, modal.functions._Function],
-        from_other_workspace: bool,
+        classbound_methods: dict[str, modal.functions._Function],
         options: typing.Optional[modal_proto.api_pb2.FunctionOptions],
         args,
         kwargs,
@@ -40,27 +43,26 @@ class _Obj:
     def _new_user_cls_instance(self): ...
     async def keep_warm(self, warm_pool_size: int) -> None: ...
     def _cached_user_cls_instance(self): ...
-    def enter(self): ...
+    def _enter(self): ...
     @property
-    def entered(self): ...
-    @entered.setter
-    def entered(self, val): ...
-    async def aenter(self): ...
+    def _entered(self) -> bool: ...
+    @_entered.setter
+    def _entered(self, val: bool): ...
+    async def _aenter(self): ...
     def __getattr__(self, k): ...
 
 class Obj:
-    _functions: typing.Dict[str, modal.functions.Function]
-    _entered: bool
+    _functions: dict[str, modal.functions.Function]
+    _has_entered: bool
     _user_cls_instance: typing.Optional[typing.Any]
-    _construction_args: typing.Tuple[tuple, typing.Dict[str, typing.Any]]
+    _construction_args: tuple[tuple, dict[str, typing.Any]]
     _instance_service_function: typing.Optional[modal.functions.Function]
 
     def __init__(
         self,
-        user_cls: type,
+        user_cls: typing.Optional[type],
         class_service_function: typing.Optional[modal.functions.Function],
-        classbound_methods: typing.Dict[str, modal.functions.Function],
-        from_other_workspace: bool,
+        classbound_methods: dict[str, modal.functions.Function],
         options: typing.Optional[modal_proto.api_pb2.FunctionOptions],
         args,
         kwargs,
@@ -75,26 +77,25 @@ class Obj:
     keep_warm: __keep_warm_spec
 
     def _cached_user_cls_instance(self): ...
-    def enter(self): ...
+    def _enter(self): ...
     @property
-    def entered(self): ...
-    @entered.setter
-    def entered(self, val): ...
-    async def aenter(self): ...
+    def _entered(self) -> bool: ...
+    @_entered.setter
+    def _entered(self, val: bool): ...
+    async def _aenter(self): ...
     def __getattr__(self, k): ...
 
 class _Cls(modal.object._Object):
     _user_cls: typing.Optional[type]
     _class_service_function: typing.Optional[modal.functions._Function]
-    _method_functions: typing.Optional[typing.Dict[str, modal.functions._Function]]
+    _method_functions: typing.Optional[dict[str, modal.functions._Function]]
     _options: typing.Optional[modal_proto.api_pb2.FunctionOptions]
-    _callables: typing.Dict[str, typing.Callable[..., typing.Any]]
-    _from_other_workspace: typing.Optional[bool]
+    _callables: dict[str, typing.Callable[..., typing.Any]]
     _app: typing.Optional[modal.app._App]
 
     def _initialize_from_empty(self): ...
     def _initialize_from_other(self, other: _Cls): ...
-    def _get_partial_functions(self) -> typing.Dict[str, modal.partial_function._PartialFunction]: ...
+    def _get_partial_functions(self) -> dict[str, modal.partial_function._PartialFunction]: ...
     def _hydrate_metadata(self, metadata: google.protobuf.message.Message): ...
     @staticmethod
     def validate_construction_mechanism(user_cls): ...
@@ -103,7 +104,7 @@ class _Cls(modal.object._Object):
     def _uses_common_service_function(self): ...
     @classmethod
     def from_name(
-        cls: typing.Type[_Cls],
+        cls: type[_Cls],
         app_name: str,
         tag: str,
         namespace=1,
@@ -112,11 +113,11 @@ class _Cls(modal.object._Object):
     ) -> _Cls: ...
     def with_options(
         self: _Cls,
-        cpu: typing.Union[float, typing.Tuple[float, float], None] = None,
-        memory: typing.Union[int, typing.Tuple[int, int], None] = None,
+        cpu: typing.Union[float, tuple[float, float], None] = None,
+        memory: typing.Union[int, tuple[int, int], None] = None,
         gpu: typing.Union[None, bool, str, modal.gpu._GPUConfig] = None,
-        secrets: typing.Collection[modal.secret._Secret] = (),
-        volumes: typing.Dict[typing.Union[str, os.PathLike], modal.volume._Volume] = {},
+        secrets: collections.abc.Collection[modal.secret._Secret] = (),
+        volumes: dict[typing.Union[str, os.PathLike], modal.volume._Volume] = {},
         retries: typing.Union[int, modal.retries.Retries, None] = None,
         timeout: typing.Optional[int] = None,
         concurrency_limit: typing.Optional[int] = None,
@@ -138,16 +139,15 @@ class _Cls(modal.object._Object):
 class Cls(modal.object.Object):
     _user_cls: typing.Optional[type]
     _class_service_function: typing.Optional[modal.functions.Function]
-    _method_functions: typing.Optional[typing.Dict[str, modal.functions.Function]]
+    _method_functions: typing.Optional[dict[str, modal.functions.Function]]
     _options: typing.Optional[modal_proto.api_pb2.FunctionOptions]
-    _callables: typing.Dict[str, typing.Callable[..., typing.Any]]
-    _from_other_workspace: typing.Optional[bool]
+    _callables: dict[str, typing.Callable[..., typing.Any]]
     _app: typing.Optional[modal.app.App]
 
     def __init__(self, *args, **kwargs): ...
     def _initialize_from_empty(self): ...
     def _initialize_from_other(self, other: Cls): ...
-    def _get_partial_functions(self) -> typing.Dict[str, modal.partial_function.PartialFunction]: ...
+    def _get_partial_functions(self) -> dict[str, modal.partial_function.PartialFunction]: ...
     def _hydrate_metadata(self, metadata: google.protobuf.message.Message): ...
     @staticmethod
     def validate_construction_mechanism(user_cls): ...
@@ -156,7 +156,7 @@ class Cls(modal.object.Object):
     def _uses_common_service_function(self): ...
     @classmethod
     def from_name(
-        cls: typing.Type[Cls],
+        cls: type[Cls],
         app_name: str,
         tag: str,
         namespace=1,
@@ -165,11 +165,11 @@ class Cls(modal.object.Object):
     ) -> Cls: ...
     def with_options(
         self: Cls,
-        cpu: typing.Union[float, typing.Tuple[float, float], None] = None,
-        memory: typing.Union[int, typing.Tuple[int, int], None] = None,
+        cpu: typing.Union[float, tuple[float, float], None] = None,
+        memory: typing.Union[int, tuple[int, int], None] = None,
         gpu: typing.Union[None, bool, str, modal.gpu._GPUConfig] = None,
-        secrets: typing.Collection[modal.secret.Secret] = (),
-        volumes: typing.Dict[typing.Union[str, os.PathLike], modal.volume.Volume] = {},
+        secrets: collections.abc.Collection[modal.secret.Secret] = (),
+        volumes: dict[typing.Union[str, os.PathLike], modal.volume.Volume] = {},
         retries: typing.Union[int, modal.retries.Retries, None] = None,
         timeout: typing.Optional[int] = None,
         concurrency_limit: typing.Optional[int] = None,

modal/config.py

@@ -80,7 +80,7 @@ import os
 import typing
 import warnings
 from textwrap import dedent
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 from google.protobuf.empty_pb2 import Empty
 
@@ -221,6 +221,7 @@ _SETTINGS = {
     "image_builder_version": _Setting(),
     "strict_parameters": _Setting(False, transform=_to_boolean),  # For internal/experimental use
     "snapshot_debug": _Setting(False, transform=_to_boolean),
+    "client_retries": _Setting(False, transform=_to_boolean),  # For internal testing.
 }
 
 
@@ -282,7 +283,7 @@ configure_logger(logger, config["loglevel"], config["log_format"])
 
 
 def _store_user_config(
-    new_settings: Dict[str, Any], profile: Optional[str] = None, active_profile: Optional[str] = None
+    new_settings: dict[str, Any], profile: Optional[str] = None, active_profile: Optional[str] = None
 ):
     """Internal method, used by the CLI to set tokens."""
     if profile is None:

modal/container_process.py

@@ -128,12 +128,16 @@ class _ContainerProcess(Generic[T]):
         on_connect = asyncio.Event()
 
         async def _write_to_fd_loop(stream: _StreamReader):
-            async for line in stream:
+            # Don't skip empty messages so we can detect when the process has booted.
+            async for chunk in stream._get_logs(skip_empty_messages=False):
+                if chunk is None:
+                    break
+
                 if not on_connect.is_set():
                     connecting_status.stop()
                     on_connect.set()
 
-                await write_to_fd(stream.file_descriptor, line.encode("utf-8"))
+                await write_to_fd(stream.file_descriptor, chunk)
 
         async def _handle_input(data: bytes, message_index: int):
             self.stdin.write(data)

modal/dict.py

@@ -1,5 +1,6 @@
 # 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
@@ -74,7 +75,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,
@@ -88,7 +89,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")
         ```
@@ -314,7 +317,7 @@ class _Dict(_Object, type_prefix="di"):
             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,

modal/dict.pyi

@@ -1,3 +1,4 @@
+import collections.abc
 import modal.client
 import modal.object
 import synchronicity.combined_types
@@ -12,7 +13,7 @@ class _Dict(modal.object._Object):
     def __init__(self, data={}): ...
     @classmethod
     def ephemeral(
-        cls: typing.Type[_Dict],
+        cls: type[_Dict],
         data: typing.Optional[dict] = None,
         client: typing.Optional[modal.client._Client] = None,
         environment_name: typing.Optional[str] = None,
@@ -53,9 +54,9 @@ class _Dict(modal.object._Object):
     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]]: ...
+    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={}): ...
@@ -63,7 +64,7 @@ class Dict(modal.object.Object):
     def new(data: typing.Optional[dict] = None): ...
     @classmethod
     def ephemeral(
-        cls: typing.Type[Dict],
+        cls: type[Dict],
         data: typing.Optional[dict] = None,
         client: typing.Optional[modal.client.Client] = None,
         environment_name: typing.Optional[str] = None,
@@ -186,18 +187,18 @@ class Dict(modal.object.Object):
 
     class __keys_spec(typing_extensions.Protocol):
         def __call__(self) -> typing.Iterator[typing.Any]: ...
-        def aio(self) -> typing.AsyncIterator[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 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

modal/environments.py

@@ -1,6 +1,6 @@
 # Copyright Modal Labs 2023
 from dataclasses import dataclass
-from typing import Dict, List, Optional
+from typing import Optional
 
 from google.protobuf.empty_pb2 import Empty
 from google.protobuf.message import Message
@@ -98,7 +98,7 @@ Environment = synchronize_api(_Environment)
 
 
 # Needs to be after definition; synchronicity interferes with forward references?
-ENVIRONMENT_CACHE: Dict[str, _Environment] = {}
+ENVIRONMENT_CACHE: dict[str, _Environment] = {}
 
 
 async def _get_environment_cached(name: str, client: _Client) -> _Environment:
@@ -151,7 +151,7 @@ async def create_environment(name: str, client: Optional[_Client] = None):
 
 
 @synchronizer.create_blocking
-async def list_environments(client: Optional[_Client] = None) -> List[api_pb2.EnvironmentListItem]:
+async def list_environments(client: Optional[_Client] = None) -> list[api_pb2.EnvironmentListItem]:
     if client is None:
         client = await _Client.from_env()
     resp = await client.stub.EnvironmentList(Empty())

modal/environments.pyi

@@ -87,13 +87,13 @@ create_environment: __create_environment_spec
 class __list_environments_spec(typing_extensions.Protocol):
     def __call__(
         self, client: typing.Optional[modal.client.Client] = None
-    ) -> typing.List[modal_proto.api_pb2.EnvironmentListItem]: ...
+    ) -> list[modal_proto.api_pb2.EnvironmentListItem]: ...
     async def aio(
         self, client: typing.Optional[modal.client.Client] = None
-    ) -> typing.List[modal_proto.api_pb2.EnvironmentListItem]: ...
+    ) -> list[modal_proto.api_pb2.EnvironmentListItem]: ...
 
 list_environments: __list_environments_spec
 
 def ensure_env(environment_name: typing.Optional[str] = None) -> str: ...
 
-ENVIRONMENT_CACHE: typing.Dict[str, _Environment]
+ENVIRONMENT_CACHE: dict[str, _Environment]