modal 0.67.6__py3-none-any.whl → 0.67.11__py3-none-any.whl

modal/cls.pyi

@@ -1,3 +1,4 @@
+import collections.abc
 import google.protobuf.message
 import inspect
 import modal.app
@@ -20,10 +21,10 @@ def _use_annotation_parameters(user_cls) -> bool: ...
 def _get_class_constructor_signature(user_cls: type) -> inspect.Signature: ...
 
 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): ...
@@ -31,7 +32,7 @@ class _Obj:
         self,
         user_cls: type,
         class_service_function: typing.Optional[modal.functions._Function],
-        classbound_methods: typing.Dict[str, modal.functions._Function],
+        classbound_methods: dict[str, modal.functions._Function],
         from_other_workspace: bool,
         options: typing.Optional[modal_proto.api_pb2.FunctionOptions],
         args,
@@ -40,26 +41,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,
         class_service_function: typing.Optional[modal.functions.Function],
-        classbound_methods: typing.Dict[str, modal.functions.Function],
+        classbound_methods: dict[str, modal.functions.Function],
         from_other_workspace: bool,
         options: typing.Optional[modal_proto.api_pb2.FunctionOptions],
         args,
@@ -75,26 +76,26 @@ 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]]
+    _callables: dict[str, typing.Callable[..., typing.Any]]
     _from_other_workspace: typing.Optional[bool]
     _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,16 @@ 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]]
+    _callables: dict[str, typing.Callable[..., typing.Any]]
     _from_other_workspace: typing.Optional[bool]
     _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 +157,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 +166,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/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,
@@ -316,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]

modal/exception.py

@@ -4,7 +4,6 @@ import signal
 import sys
 import warnings
 from datetime import date
-from typing import Tuple
 
 
 class Error(Exception):
@@ -132,12 +131,12 @@ def _is_internal_frame(frame):
     return module in _INTERNAL_MODULES
 
 
-def deprecation_error(deprecated_on: Tuple[int, int, int], msg: str):
+def deprecation_error(deprecated_on: tuple[int, int, int], msg: str):
     raise DeprecationError(f"Deprecated on {date(*deprecated_on)}: {msg}")
 
 
 def deprecation_warning(
-    deprecated_on: Tuple[int, int, int], msg: str, *, pending: bool = False, show_source: bool = True
+    deprecated_on: tuple[int, int, int], msg: str, *, pending: bool = False, show_source: bool = True
 ) -> None:
     """Utility for getting the proper stack entry.
 

modal/functions.py

@@ -1,24 +1,18 @@
 # Copyright Modal Labs 2023
+import dataclasses
 import inspect
 import textwrap
 import time
 import typing
 import warnings
+from collections.abc import AsyncGenerator, Collection, Sequence, Sized
 from dataclasses import dataclass
 from pathlib import PurePosixPath
 from typing import (
     TYPE_CHECKING,
     Any,
-    AsyncGenerator,
     Callable,
-    Collection,
-    Dict,
-    List,
     Optional,
-    Sequence,
-    Sized,
-    Tuple,
-    Type,
     Union,
 )
 
@@ -26,6 +20,7 @@ import typing_extensions
 from google.protobuf.message import Message
 from grpclib import GRPCError, Status
 from synchronicity.combined_types import MethodWithAio
+from synchronicity.exceptions import UserCodeException
 
 from modal._utils.async_utils import aclosing
 from modal_proto import api_pb2
@@ -64,6 +59,7 @@ from .cloud_bucket_mount import _CloudBucketMount, cloud_bucket_mounts_to_proto
 from .config import config
 from .exception import (
     ExecutionError,
+    FunctionTimeoutError,
     InvalidError,
     NotFoundError,
     OutputExpiredError,
@@ -86,7 +82,7 @@ from .parallel_map import (
     _SynchronizedQueue,
 )
 from .proxy import _Proxy
-from .retries import Retries
+from .retries import Retries, RetryManager
 from .schedule import Schedule
 from .scheduler_placement import SchedulerPlacement
 from .secret import _Secret
@@ -98,15 +94,32 @@ if TYPE_CHECKING:
     import modal.partial_function
 
 
+@dataclasses.dataclass
+class _RetryContext:
+    function_call_invocation_type: "api_pb2.FunctionCallInvocationType.ValueType"
+    retry_policy: api_pb2.FunctionRetryPolicy
+    function_call_jwt: str
+    input_jwt: str
+    input_id: str
+    item: api_pb2.FunctionPutInputsItem
+
+
 class _Invocation:
     """Internal client representation of a single-input call to a Modal Function or Generator"""
 
     stub: ModalClientModal
 
-    def __init__(self, stub: ModalClientModal, function_call_id: str, client: _Client):
+    def __init__(
+        self,
+        stub: ModalClientModal,
+        function_call_id: str,
+        client: _Client,
+        retry_context: Optional[_RetryContext] = None,
+    ):
         self.stub = stub
         self.client = client  # Used by the deserializer.
         self.function_call_id = function_call_id  # TODO: remove and use only input_id
+        self._retry_context = retry_context
 
     @staticmethod
     async def create(
@@ -132,7 +145,17 @@ class _Invocation:
         function_call_id = response.function_call_id
 
         if response.pipelined_inputs:
-            return _Invocation(client.stub, function_call_id, client)
+            assert len(response.pipelined_inputs) == 1
+            input = response.pipelined_inputs[0]
+            retry_context = _RetryContext(
+                function_call_invocation_type=function_call_invocation_type,
+                retry_policy=response.retry_policy,
+                function_call_jwt=response.function_call_jwt,
+                input_jwt=input.input_jwt,
+                input_id=input.input_id,
+                item=item,
+            )
+            return _Invocation(client.stub, function_call_id, client, retry_context)
 
         request_put = api_pb2.FunctionPutInputsRequest(
             function_id=function_id, inputs=[item], function_call_id=function_call_id
@@ -144,7 +167,16 @@ class _Invocation:
         processed_inputs = inputs_response.inputs
         if not processed_inputs:
             raise Exception("Could not create function call - the input queue seems to be full")
-        return _Invocation(client.stub, function_call_id, client)
+        input = inputs_response.inputs[0]
+        retry_context = _RetryContext(
+            function_call_invocation_type=function_call_invocation_type,
+            retry_policy=response.retry_policy,
+            function_call_jwt=response.function_call_jwt,
+            input_jwt=input.input_jwt,
+            input_id=input.input_id,
+            item=item,
+        )
+        return _Invocation(client.stub, function_call_id, client, retry_context)
 
     async def pop_function_call_outputs(
         self, timeout: Optional[float], clear_on_success: bool
@@ -180,13 +212,46 @@ class _Invocation:
                     # return the last response to check for state of num_unfinished_inputs
                     return response
 
-    async def run_function(self) -> Any:
+    async def _retry_input(self) -> None:
+        ctx = self._retry_context
+        if not ctx:
+            raise ValueError("Cannot retry input when _retry_context is empty.")
+
+        item = api_pb2.FunctionRetryInputsItem(input_jwt=ctx.input_jwt, input=ctx.item.input)
+        request = api_pb2.FunctionRetryInputsRequest(function_call_jwt=ctx.function_call_jwt, inputs=[item])
+        await retry_transient_errors(
+            self.client.stub.FunctionRetryInputs,
+            request,
+        )
+
+    async def _get_single_output(self) -> Any:
         # waits indefinitely for a single result for the function, and clear the outputs buffer after
         item: api_pb2.FunctionGetOutputsItem = (
             await self.pop_function_call_outputs(timeout=None, clear_on_success=True)
         ).outputs[0]
         return await _process_result(item.result, item.data_format, self.stub, self.client)
 
+    async def run_function(self) -> Any:
+        # Use retry logic only if retry policy is specified and
+        ctx = self._retry_context
+        if (
+            not ctx
+            or not ctx.retry_policy
+            or ctx.retry_policy.retries == 0
+            or ctx.function_call_invocation_type != api_pb2.FUNCTION_CALL_INVOCATION_TYPE_SYNC
+        ):
+            return await self._get_single_output()
+
+        # User errors including timeouts are managed by the user specified retry policy.
+        user_retry_manager = RetryManager(ctx.retry_policy)
+
+        while True:
+            try:
+                return await self._get_single_output()
+            except (UserCodeException, FunctionTimeoutError) as exc:
+                await user_retry_manager.raise_or_sleep(exc)
+            await self._retry_input()
+
     async def poll_function(self, timeout: Optional[float] = None):
         """Waits up to timeout for a result from a function.
 
@@ -278,12 +343,12 @@ class _FunctionSpec:
     image: Optional[_Image]
     mounts: Sequence[_Mount]
     secrets: Sequence[_Secret]
-    network_file_systems: Dict[Union[str, PurePosixPath], _NetworkFileSystem]
-    volumes: Dict[Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]]
-    gpus: Union[GPU_T, List[GPU_T]]  # TODO(irfansharif): Somehow assert that it's the first kind, in sandboxes
+    network_file_systems: dict[Union[str, PurePosixPath], _NetworkFileSystem]
+    volumes: dict[Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]]
+    gpus: Union[GPU_T, list[GPU_T]]  # TODO(irfansharif): Somehow assert that it's the first kind, in sandboxes
     cloud: Optional[str]
     cpu: Optional[float]
-    memory: Optional[Union[int, Tuple[int, int]]]
+    memory: Optional[Union[int, tuple[int, int]]]
     ephemeral_disk: Optional[int]
     scheduler_placement: Optional[SchedulerPlacement]
 
@@ -304,7 +369,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
     # TODO: more type annotations
     _info: Optional[FunctionInfo]
-    _serve_mounts: typing.FrozenSet[_Mount]  # set at load time, only by loader
+    _serve_mounts: frozenset[_Mount]  # set at load time, only by loader
     _app: Optional["modal.app._App"] = None
     _obj: Optional["modal.cls._Obj"] = None  # only set for InstanceServiceFunctions and bound instance methods
     _web_url: Optional[str]
@@ -323,7 +388,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     _use_method_name: str = ""
 
     _class_parameter_info: Optional["api_pb2.ClassParameterInfo"] = None
-    _method_handle_metadata: Optional[Dict[str, "api_pb2.FunctionHandleMetadata"]] = None
+    _method_handle_metadata: Optional[dict[str, "api_pb2.FunctionHandleMetadata"]] = None
 
     def _bind_method(
         self,
@@ -429,14 +494,14 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         secrets: Sequence[_Secret] = (),
         schedule: Optional[Schedule] = None,
         is_generator=False,
-        gpu: Union[GPU_T, List[GPU_T]] = None,
+        gpu: Union[GPU_T, list[GPU_T]] = None,
         # TODO: maybe break this out into a separate decorator for notebooks.
         mounts: Collection[_Mount] = (),
-        network_file_systems: Dict[Union[str, PurePosixPath], _NetworkFileSystem] = {},
+        network_file_systems: dict[Union[str, PurePosixPath], _NetworkFileSystem] = {},
         allow_cross_region_volumes: bool = False,
-        volumes: Dict[Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]] = {},
+        volumes: dict[Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]] = {},
         webhook_config: Optional[api_pb2.WebhookConfig] = None,
-        memory: Optional[Union[int, Tuple[int, int]]] = None,
+        memory: Optional[Union[int, tuple[int, int]]] = None,
         proxy: Optional[_Proxy] = None,
         retries: Optional[Union[int, Retries]] = None,
         timeout: Optional[int] = None,
@@ -623,8 +688,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         if image is not None and not isinstance(image, _Image):
             raise InvalidError(f"Expected modal.Image object. Got {type(image)}.")
 
-        method_definitions: Optional[Dict[str, api_pb2.MethodDefinition]] = None
-        partial_functions: Dict[str, "modal.partial_function._PartialFunction"] = {}
+        method_definitions: Optional[dict[str, api_pb2.MethodDefinition]] = None
+        partial_functions: dict[str, "modal.partial_function._PartialFunction"] = {}
         if info.user_cls:
             method_definitions = {}
             partial_functions = _find_partial_methods_for_user_cls(info.user_cls, _PartialFunctionFlags.FUNCTION)
@@ -640,8 +705,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
         function_type = get_function_type(is_generator)
 
-        def _deps(only_explicit_mounts=False) -> List[_Object]:
-            deps: List[_Object] = list(secrets)
+        def _deps(only_explicit_mounts=False) -> list[_Object]:
+            deps: list[_Object] = list(secrets)
             if only_explicit_mounts:
                 # TODO: this is a bit hacky, but all_mounts may differ in the container vs locally
                 # We don't want the function dependencies to change, so we have this way to force it to
@@ -878,7 +943,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         raise InvalidError(f"Function {info.function_name} is too large to deploy.")
                     raise
                 function_creation_status.set_response(response)
-            serve_mounts = set(m for m in all_mounts if m.is_local())  # needed for modal.serve file watching
+            serve_mounts = {m for m in all_mounts if m.is_local()}  # needed for modal.serve file watching
             serve_mounts |= image._serve_mounts
             obj._serve_mounts = frozenset(serve_mounts)
             self._hydrate(response.function_id, resolver.client, response.handle_metadata)
@@ -897,7 +962,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         obj._spec = function_spec  # needed for modal shell
 
         # Used to check whether we should rebuild a modal.Image which uses `run_function`.
-        gpus: List[GPU_T] = gpu if isinstance(gpu, list) else [gpu]
+        gpus: list[GPU_T] = gpu if isinstance(gpu, list) else [gpu]
         obj._build_args = dict(  # See get_build_def
             secrets=repr(secrets),
             gpu_config=repr([parse_gpu_config(_gpu) for _gpu in gpus]),
@@ -919,7 +984,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         from_other_workspace: bool,
         options: Optional[api_pb2.FunctionOptions],
         args: Sized,
-        kwargs: Dict[str, Any],
+        kwargs: dict[str, Any],
     ) -> "_Function":
         """mdmd:hidden
 
@@ -1025,7 +1090,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
     @classmethod
     def from_name(
-        cls: Type["_Function"],
+        cls: type["_Function"],
         app_name: str,
         tag: str,
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
@@ -1232,13 +1297,18 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 yield item
 
     async def _call_function(self, args, kwargs) -> ReturnType:
+        if config.get("client_retries"):
+            function_call_invocation_type = api_pb2.FUNCTION_CALL_INVOCATION_TYPE_SYNC
+        else:
+            function_call_invocation_type = api_pb2.FUNCTION_CALL_INVOCATION_TYPE_SYNC_LEGACY
         invocation = await _Invocation.create(
             self,
             args,
             kwargs,
             client=self._client,
-            function_call_invocation_type=api_pb2.FUNCTION_CALL_INVOCATION_TYPE_SYNC_LEGACY,
+            function_call_invocation_type=function_call_invocation_type,
         )
+
         return await invocation.run_function()
 
     async def _call_function_nowait(
@@ -1355,12 +1425,12 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             if is_async(info.raw_f):
                 # We want to run __aenter__ and fun in the same coroutine
                 async def coro():
-                    await obj.aenter()
+                    await obj._aenter()
                     return await fun(*args, **kwargs)
 
                 return coro()  # type: ignore
             else:
-                obj.enter()
+                obj._enter()
                 return fun(*args, **kwargs)
 
     @synchronizer.no_input_translation
@@ -1476,7 +1546,7 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         async for res in self._invocation().run_generator():
             yield res
 
-    async def get_call_graph(self) -> List[InputInfo]:
+    async def get_call_graph(self) -> list[InputInfo]:
         """Returns a structure representing the call graph from a given root
         call ID, along with the status of execution for each node.