modal 1.1.5.dev66__py3-none-any.whl → 1.3.1.dev8__py3-none-any.whl

modal/mount.py

@@ -13,19 +13,18 @@ from pathlib import Path, PurePosixPath
 from typing import Callable, Optional, Sequence, Union
 
 from google.protobuf.message import Message
-from grpclib import GRPCError
 
 import modal.exception
 import modal.file_pattern_matcher
 from modal_proto import api_pb2
 from modal_version import __version__
 
-from ._object import _get_environment_name, _Object
+from ._load_context import LoadContext
+from ._object import _Object
 from ._resolver import Resolver
 from ._utils.async_utils import TaskContext, aclosing, async_map, synchronize_api
 from ._utils.blob_utils import FileUploadSpec, blob_upload_file, get_file_upload_spec_from_path
-from ._utils.deprecation import deprecation_warning
-from ._utils.grpc_utils import retry_transient_errors
+from ._utils.grpc_utils import Retry
 from ._utils.name_utils import check_object_name
 from ._utils.package_utils import get_module_mount_info
 from .client import _Client
@@ -41,11 +40,11 @@ MOUNT_PUT_FILE_CLIENT_TIMEOUT = 10 * 60  # 10 min max for transferring files
 # These can be updated safely, but changes will trigger a rebuild for all images
 # that rely on `add_python()` in their constructor.
 PYTHON_STANDALONE_VERSIONS: dict[str, tuple[str, str]] = {
-    "3.9": ("20230826", "3.9.18"),
     "3.10": ("20230826", "3.10.13"),
     "3.11": ("20230826", "3.11.5"),
     "3.12": ("20240107", "3.12.1"),
     "3.13": ("20241008", "3.13.0"),
+    "3.14": ("20251205", "3.14.2"),
 }
 
 MOUNT_DEPRECATION_MESSAGE_PATTERN = """modal.Mount usage will soon be deprecated.
@@ -311,7 +310,7 @@ class _Mount(_Object, type_prefix="mo"):
     _entries: Optional[list[_MountEntry]] = None
     _deployment_name: Optional[str] = None
     _namespace: Optional[int] = None
-    _environment_name: Optional[str] = None
+
     _allow_overwrite: bool = False
     _content_checksum_sha256_hex: Optional[str] = None
 
@@ -326,7 +325,12 @@ class _Mount(_Object, type_prefix="mo"):
                 return None
             return (_Mount._type_prefix, "local", frozenset(included_files))
 
-        obj = _Mount._from_loader(_Mount._load_mount, rep, deduplication_key=mount_content_deduplication_key)
+        obj = _Mount._from_loader(
+            _Mount._load_mount,
+            rep,
+            deduplication_key=mount_content_deduplication_key,
+            load_context_overrides=LoadContext.empty(),
+        )
         obj._entries = entries
         obj._is_local = True
         return obj
@@ -461,16 +465,18 @@ class _Mount(_Object, type_prefix="mo"):
         loop = asyncio.get_event_loop()
         with concurrent.futures.ThreadPoolExecutor() as exe:
             all_files = await loop.run_in_executor(exe, _select_files, entries)
+            logger.debug(f"Computing checksums for {len(all_files)} files using {exe._max_workers} worker threads")
 
-            futs = []
+            # Yield FileUploadSpec objects lazily as they're consumed by async_map downstream.
+            # async_map's concurrency limit provides natural backpressure, so we don't need
+            # a separate semaphore here. This keeps memory bounded without creating all tasks upfront.
             for local_filename, remote_filename in all_files:
-                logger.debug(f"Mounting {local_filename} as {remote_filename}")
-                futs.append(loop.run_in_executor(exe, get_file_upload_spec_from_path, local_filename, remote_filename))
-
-            logger.debug(f"Computing checksums for {len(futs)} files using {exe._max_workers} worker threads")
-            for fut in asyncio.as_completed(futs):
                 try:
-                    yield await fut
+                    logger.debug(f"Mounting {local_filename} as {remote_filename}")
+                    file_spec = await loop.run_in_executor(
+                        exe, get_file_upload_spec_from_path, local_filename, remote_filename
+                    )
+                    yield file_spec
                 except FileNotFoundError as exc:
                     # Can happen with temporary files (e.g. emacs will write temp files and delete them quickly)
                     logger.info(f"Ignoring file not found: {exc}")
@@ -478,6 +484,7 @@ class _Mount(_Object, type_prefix="mo"):
     async def _load_mount(
         self: "_Mount",
         resolver: Resolver,
+        load_context: LoadContext,
         existing_object_id: Optional[str],
     ):
         t0 = time.monotonic()
@@ -519,7 +526,7 @@ class _Mount(_Object, type_prefix="mo"):
 
             request = api_pb2.MountPutFileRequest(sha256_hex=file_spec.sha256_hex)
             accounted_hashes.add(file_spec.sha256_hex)
-            response = await retry_transient_errors(resolver.client.stub.MountPutFile, request, base_delay=1)
+            response = await load_context.client.stub.MountPutFile(request, retry=Retry(base_delay=1))
 
             if response.exists:
                 n_finished += 1
@@ -533,7 +540,7 @@ class _Mount(_Object, type_prefix="mo"):
                 async with blob_upload_concurrency:
                     with file_spec.source() as fp:
                         blob_id = await blob_upload_file(
-                            fp, resolver.client.stub, sha256_hex=file_spec.sha256_hex, md5_hex=file_spec.md5_hex
+                            fp, load_context.client.stub, sha256_hex=file_spec.sha256_hex, md5_hex=file_spec.md5_hex
                         )
                 logger.debug(f"Uploading blob file {file_spec.source_description} as {remote_filename}")
                 request2 = api_pb2.MountPutFileRequest(data_blob_id=blob_id, sha256_hex=file_spec.sha256_hex)
@@ -541,11 +548,15 @@ class _Mount(_Object, type_prefix="mo"):
                 logger.debug(
                     f"Uploading file {file_spec.source_description} to {remote_filename} ({file_spec.size} bytes)"
                 )
-                request2 = api_pb2.MountPutFileRequest(data=file_spec.content, sha256_hex=file_spec.sha256_hex)
+                if file_spec.content is None:
+                    content = await asyncio.to_thread(file_spec.read_content)
+                else:
+                    content = file_spec.content
+                request2 = api_pb2.MountPutFileRequest(data=content, sha256_hex=file_spec.sha256_hex)
 
             start_time = time.monotonic()
             while time.monotonic() - start_time < MOUNT_PUT_FILE_CLIENT_TIMEOUT:
-                response = await retry_transient_errors(resolver.client.stub.MountPutFile, request2, base_delay=1)
+                response = await load_context.client.stub.MountPutFile(request2, retry=Retry(base_delay=1))
                 if response.exists:
                     n_finished += 1
                     return mount_file
@@ -553,7 +564,7 @@ class _Mount(_Object, type_prefix="mo"):
             raise modal.exception.MountUploadTimeoutError(f"Mounting of {file_spec.source_description} timed out")
 
         # Upload files, or check if they already exist.
-        n_concurrent_uploads = 512
+        n_concurrent_uploads = 64
         files: list[api_pb2.MountFile] = []
         async with aclosing(
             async_map(_Mount._get_files(self._entries), _put_file, concurrency=n_concurrent_uploads)
@@ -575,28 +586,28 @@ class _Mount(_Object, type_prefix="mo"):
             req = api_pb2.MountGetOrCreateRequest(
                 deployment_name=self._deployment_name,
                 namespace=self._namespace,
-                environment_name=self._environment_name,
+                environment_name=load_context.environment_name,
                 object_creation_type=creation_type,
                 files=files,
             )
-        elif resolver.app_id is not None:
+        elif load_context.app_id is not None:
             req = api_pb2.MountGetOrCreateRequest(
                 object_creation_type=api_pb2.OBJECT_CREATION_TYPE_ANONYMOUS_OWNED_BY_APP,
                 files=files,
-                app_id=resolver.app_id,
+                app_id=load_context.app_id,
             )
         else:
             req = api_pb2.MountGetOrCreateRequest(
                 object_creation_type=api_pb2.OBJECT_CREATION_TYPE_EPHEMERAL,
                 files=files,
-                environment_name=resolver.environment_name,
+                environment_name=load_context.environment_name,
             )
 
-        resp = await retry_transient_errors(resolver.client.stub.MountGetOrCreate, req, base_delay=1)
+        resp = await load_context.client.stub.MountGetOrCreate(req, retry=Retry(base_delay=1))
         status_row.finish(f"Created mount {message_label}")
 
         logger.debug(f"Uploaded {total_uploads} new files and {total_bytes} bytes in {time.monotonic() - t0}s")
-        self._hydrate(resp.mount_id, resolver.client, resp.handle_metadata)
+        self._hydrate(resp.mount_id, load_context.client, resp.handle_metadata)
 
     @staticmethod
     def _from_local_python_packages(
@@ -629,19 +640,25 @@ class _Mount(_Object, type_prefix="mo"):
         *,
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         environment_name: Optional[str] = None,
+        client: Optional[_Client] = None,
     ) -> "_Mount":
         """mdmd:hidden"""
 
-        async def _load(provider: _Mount, resolver: Resolver, existing_object_id: Optional[str]):
+        async def _load(provider: _Mount, resolver: Resolver, load_context, existing_object_id: Optional[str]):
             req = api_pb2.MountGetOrCreateRequest(
                 deployment_name=name,
                 namespace=namespace,
-                environment_name=_get_environment_name(environment_name, resolver),
+                environment_name=load_context.environment_name,
             )
-            response = await resolver.client.stub.MountGetOrCreate(req)
-            provider._hydrate(response.mount_id, resolver.client, response.handle_metadata)
-
-        return _Mount._from_loader(_load, "Mount()", hydrate_lazily=True)
+            response = await load_context.client.stub.MountGetOrCreate(req)
+            provider._hydrate(response.mount_id, load_context.client, response.handle_metadata)
+
+        return _Mount._from_loader(
+            _load,
+            "Mount()",
+            hydrate_lazily=True,
+            load_context_overrides=LoadContext(environment_name=environment_name, client=client),
+        )
 
     async def _deploy(
         self: "_Mount",
@@ -653,15 +670,12 @@ class _Mount(_Object, type_prefix="mo"):
         client: Optional[_Client] = None,
     ) -> None:
         check_object_name(deployment_name, "Mount")
-        environment_name = _get_environment_name(environment_name, resolver=None)
         self._deployment_name = deployment_name
         self._namespace = namespace
-        self._environment_name = environment_name
         self._allow_overwrite = allow_overwrite
-        if client is None:
-            client = await _Client.from_env()
-        resolver = Resolver(client=client, environment_name=environment_name)
-        await resolver.load(self)
+        resolver = Resolver()
+        root_metadata = LoadContext(client=client, environment_name=environment_name)
+        await resolver.load(self, root_metadata)
 
     def _get_metadata(self) -> api_pb2.MountHandleMetadata:
         if self._content_checksum_sha256_hex is None:
@@ -760,13 +774,13 @@ async def _create_single_client_dependency_mount(
     if check_if_exists:
         try:
             await Mount.from_name(mount_name, namespace=api_pb2.DEPLOYMENT_NAMESPACE_GLOBAL).hydrate.aio(client)
-            print(f"➖ Found existing mount {mount_name} in global namespace.")
+            print(f"➖ Found existing mount {mount_name} in global namespace.")  # noqa: T201
             return
         except modal.exception.NotFoundError:
             pass
 
     with tempfile.TemporaryDirectory(ignore_cleanup_errors=True) as tmpd:
-        print(f"📦 Building {mount_name}.")
+        print(f"📦 Building {mount_name}.")  # noqa: T201
         requirements = os.path.join(os.path.dirname(__file__), f"builder/{builder_version}.txt")
         cmd = " ".join(
             [
@@ -795,11 +809,11 @@ async def _create_single_client_dependency_mount(
         await proc.wait()
         if proc.returncode:
             stdout, stderr = await proc.communicate()
-            print(stdout.decode("utf-8"))
-            print(stderr.decode("utf-8"))
+            print(stdout.decode("utf-8"))  # noqa: T201
+            print(stderr.decode("utf-8"))  # noqa: T201
             raise RuntimeError(f"Subprocess failed with {proc.returncode}")
 
-        print(f"🌐 Downloaded and unpacked {mount_name} packages to {tmpd}.")
+        print(f"🌐 Downloaded and unpacked {mount_name} packages to {tmpd}.")  # noqa: T201
 
         python_mount = Mount._from_local_dir(tmpd, remote_path=REMOTE_PACKAGES_PATH)
 
@@ -823,11 +837,11 @@ async def _create_single_client_dependency_mount(
                         allow_overwrite=allow_overwrite,
                         client=client,
                     )
-                    print(f"✅ Deployed mount {mount_name} to global namespace.")
-                except GRPCError as e:
-                    print(f"⚠️ Mount creation failed with {e.status}: {e.message}")
+                    print(f"✅ Deployed mount {mount_name} to global namespace.")  # noqa: T201
+                except modal.exception.Error as e:
+                    print(f"⚠️ Mount creation failed with {type(e).__name__}: {e}")  # noqa: T201
             else:
-                print(f"Dry run - skipping deployment of mount {mount_name}")
+                print(f"Dry run - skipping deployment of mount {mount_name}")  # noqa: T201
 
 
 async def _create_client_dependency_mounts(

modal/mount.pyi

@@ -1,5 +1,6 @@
 import collections.abc
 import google.protobuf.message
+import modal._load_context
 import modal._object
 import modal._resolver
 import modal._utils.blob_utils
@@ -154,7 +155,6 @@ class _Mount(modal._object._Object):
     _entries: typing.Optional[list[_MountEntry]]
     _deployment_name: typing.Optional[str]
     _namespace: typing.Optional[int]
-    _environment_name: typing.Optional[str]
     _allow_overwrite: bool
     _content_checksum_sha256_hex: typing.Optional[str]
 
@@ -216,7 +216,10 @@ class _Mount(modal._object._Object):
         entries: list[_MountEntry],
     ) -> collections.abc.AsyncGenerator[modal._utils.blob_utils.FileUploadSpec, None]: ...
     async def _load_mount(
-        self: _Mount, resolver: modal._resolver.Resolver, existing_object_id: typing.Optional[str]
+        self: _Mount,
+        resolver: modal._resolver.Resolver,
+        load_context: modal._load_context.LoadContext,
+        existing_object_id: typing.Optional[str],
     ): ...
     @staticmethod
     def _from_local_python_packages(
@@ -226,7 +229,13 @@ class _Mount(modal._object._Object):
         ignore: typing.Union[typing.Sequence[str], collections.abc.Callable[[pathlib.Path], bool], None] = None,
     ) -> _Mount: ...
     @staticmethod
-    def from_name(name: str, *, namespace=1, environment_name: typing.Optional[str] = None) -> _Mount:
+    def from_name(
+        name: str,
+        *,
+        namespace=1,
+        environment_name: typing.Optional[str] = None,
+        client: typing.Optional[modal.client._Client] = None,
+    ) -> _Mount:
         """mdmd:hidden"""
         ...
 
@@ -241,8 +250,6 @@ class _Mount(modal._object._Object):
     ) -> None: ...
     def _get_metadata(self) -> modal_proto.api_pb2.MountHandleMetadata: ...
 
-SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
-
 class Mount(modal.object.Object):
     """**Deprecated**: Mounts should not be used explicitly anymore, use `Image.add_local_*` commands instead.
 
@@ -269,7 +276,6 @@ class Mount(modal.object.Object):
     _entries: typing.Optional[list[_MountEntry]]
     _deployment_name: typing.Optional[str]
     _namespace: typing.Optional[int]
-    _environment_name: typing.Optional[str]
     _allow_overwrite: bool
     _content_checksum_sha256_hex: typing.Optional[str]
 
@@ -339,13 +345,25 @@ class Mount(modal.object.Object):
             self, /, entries: list[_MountEntry]
         ) -> collections.abc.AsyncGenerator[modal._utils.blob_utils.FileUploadSpec, None]: ...
 
-    _get_files: ___get_files_spec
+    _get_files: typing.ClassVar[___get_files_spec]
 
-    class ___load_mount_spec(typing_extensions.Protocol[SUPERSELF]):
-        def __call__(self, /, resolver: modal._resolver.Resolver, existing_object_id: typing.Optional[str]): ...
-        async def aio(self, /, resolver: modal._resolver.Resolver, existing_object_id: typing.Optional[str]): ...
+    class ___load_mount_spec(typing_extensions.Protocol):
+        def __call__(
+            self,
+            /,
+            resolver: modal._resolver.Resolver,
+            load_context: modal._load_context.LoadContext,
+            existing_object_id: typing.Optional[str],
+        ): ...
+        async def aio(
+            self,
+            /,
+            resolver: modal._resolver.Resolver,
+            load_context: modal._load_context.LoadContext,
+            existing_object_id: typing.Optional[str],
+        ): ...
 
-    _load_mount: ___load_mount_spec[typing_extensions.Self]
+    _load_mount: ___load_mount_spec
 
     @staticmethod
     def _from_local_python_packages(
@@ -355,11 +373,17 @@ class Mount(modal.object.Object):
         ignore: typing.Union[typing.Sequence[str], collections.abc.Callable[[pathlib.Path], bool], None] = None,
     ) -> Mount: ...
     @staticmethod
-    def from_name(name: str, *, namespace=1, environment_name: typing.Optional[str] = None) -> Mount:
+    def from_name(
+        name: str,
+        *,
+        namespace=1,
+        environment_name: typing.Optional[str] = None,
+        client: typing.Optional[modal.client.Client] = None,
+    ) -> Mount:
         """mdmd:hidden"""
         ...
 
-    class ___deploy_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___deploy_spec(typing_extensions.Protocol):
         def __call__(
             self,
             /,
@@ -381,7 +405,7 @@ class Mount(modal.object.Object):
             client: typing.Optional[modal.client.Client] = None,
         ) -> None: ...
 
-    _deploy: ___deploy_spec[typing_extensions.Self]
+    _deploy: ___deploy_spec
 
     def _get_metadata(self) -> modal_proto.api_pb2.MountHandleMetadata: ...
 
@@ -402,7 +426,7 @@ async def _create_single_client_dependency_mount(
 ): ...
 async def _create_client_dependency_mounts(
     client=None,
-    python_versions: list[str] = ["3.9", "3.10", "3.11", "3.12", "3.13"],
+    python_versions: list[str] = ["3.10", "3.11", "3.12", "3.13", "3.14"],
     builder_versions: list[str] = ["2025.06"],
     check_if_exists=True,
     dry_run=False,
@@ -413,7 +437,7 @@ class __create_client_dependency_mounts_spec(typing_extensions.Protocol):
         self,
         /,
         client=None,
-        python_versions: list[str] = ["3.9", "3.10", "3.11", "3.12", "3.13"],
+        python_versions: list[str] = ["3.10", "3.11", "3.12", "3.13", "3.14"],
         builder_versions: list[str] = ["2025.06"],
         check_if_exists=True,
         dry_run=False,
@@ -422,7 +446,7 @@ class __create_client_dependency_mounts_spec(typing_extensions.Protocol):
         self,
         /,
         client=None,
-        python_versions: list[str] = ["3.9", "3.10", "3.11", "3.12", "3.13"],
+        python_versions: list[str] = ["3.10", "3.11", "3.12", "3.13", "3.14"],
         builder_versions: list[str] = ["2025.06"],
         check_if_exists=True,
         dry_run=False,

modal/network_file_system.py

@@ -11,6 +11,7 @@ from synchronicity.async_wrap import asynccontextmanager
 import modal
 from modal_proto import api_pb2
 
+from ._load_context import LoadContext
 from ._object import (
     EPHEMERAL_OBJECT_HEARTBEAT_SLEEP,
     _get_environment_name,
@@ -22,7 +23,6 @@ from ._resolver import Resolver
 from ._utils.async_utils import TaskContext, aclosing, async_map, sync_or_async_iter, synchronize_api
 from ._utils.blob_utils import LARGE_FILE_LIMIT, blob_iter, blob_upload_file
 from ._utils.deprecation import warn_if_passing_namespace
-from ._utils.grpc_utils import retry_transient_errors
 from ._utils.hash_utils import get_sha256_hex
 from ._utils.name_utils import check_object_name
 from .client import _Client
@@ -96,6 +96,7 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
         namespace=None,  # mdmd:line-hidden
         environment_name: Optional[str] = None,
         create_if_missing: bool = False,
+        client: Optional[_Client] = None,
     ) -> "_NetworkFileSystem":
         """Reference a NetworkFileSystem by its name, creating if necessary.
 
@@ -114,15 +115,17 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
         check_object_name(name, "NetworkFileSystem")
         warn_if_passing_namespace(namespace, "modal.NetworkFileSystem.from_name")
 
-        async def _load(self: _NetworkFileSystem, resolver: Resolver, existing_object_id: Optional[str]):
+        async def _load(
+            self: _NetworkFileSystem, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]
+        ):
             req = api_pb2.SharedVolumeGetOrCreateRequest(
                 deployment_name=name,
-                environment_name=_get_environment_name(environment_name, resolver),
+                environment_name=load_context.environment_name,
                 object_creation_type=(api_pb2.OBJECT_CREATION_TYPE_CREATE_IF_MISSING if create_if_missing else None),
             )
             try:
-                response = await resolver.client.stub.SharedVolumeGetOrCreate(req)
-                self._hydrate(response.shared_volume_id, resolver.client, None)
+                response = await load_context.client.stub.SharedVolumeGetOrCreate(req)
+                self._hydrate(response.shared_volume_id, load_context.client, None)
             except modal.exception.NotFoundError as exc:
                 if exc.args[0] == "App has wrong entity vo":
                     raise InvalidError(
@@ -130,7 +133,12 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
                     )
                 raise
 
-        return _NetworkFileSystem._from_loader(_load, "NetworkFileSystem()", hydrate_lazily=True)
+        return _NetworkFileSystem._from_loader(
+            _load,
+            "NetworkFileSystem()",
+            hydrate_lazily=True,
+            load_context_overrides=LoadContext(environment_name=environment_name, client=client),
+        )
 
     @classmethod
     @asynccontextmanager
@@ -188,14 +196,14 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
             environment_name=_get_environment_name(environment_name),
             object_creation_type=api_pb2.OBJECT_CREATION_TYPE_CREATE_FAIL_IF_EXISTS,
         )
-        resp = await retry_transient_errors(client.stub.SharedVolumeGetOrCreate, request)
+        resp = await client.stub.SharedVolumeGetOrCreate(request)
         return resp.shared_volume_id
 
     @staticmethod
     async def delete(name: str, client: Optional[_Client] = None, environment_name: Optional[str] = None):
         obj = await _NetworkFileSystem.from_name(name, environment_name=environment_name).hydrate(client)
         req = api_pb2.SharedVolumeDeleteRequest(shared_volume_id=obj.object_id)
-        await retry_transient_errors(obj._client.stub.SharedVolumeDelete, req)
+        await obj._client.stub.SharedVolumeDelete(req)
 
     @live_method
     async def write_file(self, remote_path: str, fp: BinaryIO, progress_cb: Optional[Callable[..., Any]] = None) -> int:
@@ -235,7 +243,7 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
 
         t0 = time.monotonic()
         while time.monotonic() - t0 < NETWORK_FILE_SYSTEM_PUT_FILE_CLIENT_TIMEOUT:
-            response = await retry_transient_errors(self._client.stub.SharedVolumePutFile, req)
+            response = await self._client.stub.SharedVolumePutFile(req)
             if response.exists:
                 break
         else:
@@ -248,7 +256,7 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
         """Read a file from the network file system"""
         req = api_pb2.SharedVolumeGetFileRequest(shared_volume_id=self.object_id, path=path)
         try:
-            response = await retry_transient_errors(self._client.stub.SharedVolumeGetFile, req)
+            response = await self._client.stub.SharedVolumeGetFile(req)
         except modal.exception.NotFoundError as exc:
             raise FileNotFoundError(exc.args[0])
 
@@ -333,7 +341,7 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
         """Remove a file in a network file system."""
         req = api_pb2.SharedVolumeRemoveFileRequest(shared_volume_id=self.object_id, path=path, recursive=recursive)
         try:
-            await retry_transient_errors(self._client.stub.SharedVolumeRemoveFile, req)
+            await self._client.stub.SharedVolumeRemoveFile(req)
         except modal.exception.NotFoundError as exc:
             raise FileNotFoundError(exc.args[0])