modal 0.66.17__py3-none-any.whl → 0.66.44__py3-none-any.whl

modal/image.py

@@ -273,12 +273,24 @@ class _Image(_Object, type_prefix="im"):
 
     force_build: bool
     inside_exceptions: List[Exception]
-    _used_local_mounts: typing.FrozenSet[_Mount]  # used for mounts watching
+    _serve_mounts: typing.FrozenSet[_Mount]  # used for mounts watching in `modal serve`
+    _deferred_mounts: Sequence[
+        _Mount
+    ]  # added as mounts on any container referencing the Image, see `def _mount_layers`
     _metadata: Optional[api_pb2.ImageMetadata] = None  # set on hydration, private for now
 
     def _initialize_from_empty(self):
         self.inside_exceptions = []
-        self._used_local_mounts = frozenset()
+        self._serve_mounts = frozenset()
+        self._deferred_mounts = ()
+        self.force_build = False
+
+    def _initialize_from_other(self, other: "_Image"):
+        # used by .clone()
+        self.inside_exceptions = other.inside_exceptions
+        self.force_build = other.force_build
+        self._serve_mounts = other._serve_mounts
+        self._deferred_mounts = other._deferred_mounts
 
     def _hydrate_metadata(self, message: Optional[Message]):
         env_image_id = config.get("image_id")  # set as an env var in containers
@@ -292,6 +304,51 @@ class _Image(_Object, type_prefix="im"):
             assert isinstance(message, api_pb2.ImageMetadata)
             self._metadata = message
 
+    def _add_mount_layer_or_copy(self, mount: _Mount, copy: bool = False):
+        if copy:
+            return self.copy_mount(mount, remote_path="/")
+
+        base_image = self
+
+        async def _load(self2: "_Image", resolver: Resolver, existing_object_id: Optional[str]):
+            self2._hydrate_from_other(base_image)  # same image id as base image as long as it's lazy
+            self2._deferred_mounts = tuple(base_image._deferred_mounts) + (mount,)
+            self2._serve_mounts = base_image._serve_mounts | ({mount} if mount.is_local() else set())
+
+        return _Image._from_loader(_load, "Image(local files)", deps=lambda: [base_image, mount])
+
+    @property
+    def _mount_layers(self) -> typing.Tuple[_Mount]:
+        """Non-evaluated mount layers on the image
+
+        When the image is used by a Modal container, these mounts need to be attached as well to
+        represent the full image content, as they haven't yet been represented as a layer in the
+        image.
+
+        When the image is used as a base image for a new layer (that is not itself a mount layer)
+        these mounts need to first be inserted as a copy operation (.copy_mount) into the image.
+        """
+        return self._deferred_mounts
+
+    def _assert_no_mount_layers(self):
+        if self._mount_layers:
+            raise InvalidError(
+                "An image tried to run a build step after using `image.add_local_*` to include local files.\n"
+                "\n"
+                "Run `image.add_local_*` commands last in your image build to avoid rebuilding images with every local "
+                "file change. Modal will then add these files to containers on startup instead, saving build time.\n"
+                "If you need to run other build steps after adding local files, set `copy=True` to copy the files"
+                "directly into the image, at the expense of some added build time.\n"
+                "\n"
+                "Example:\n"
+                "\n"
+                "my_image = (\n"
+                "    Image.debian_slim()\n"
+                '    .add_local_file("data.json", copy=True)\n'
+                '    .run_commands("python -m mypak")  # this now works!\n'
+                ")\n"
+            )
+
     @staticmethod
     def _from_args(
         *,
@@ -306,9 +363,11 @@ class _Image(_Object, type_prefix="im"):
         force_build: bool = False,
         # For internal use only.
         _namespace: int = api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
+        _do_assert_no_mount_layers: bool = True,
     ):
         if base_images is None:
             base_images = {}
+
         if secrets is None:
             secrets = []
         if gpu_config is None:
@@ -334,6 +393,11 @@ class _Image(_Object, type_prefix="im"):
             return deps
 
         async def _load(self: _Image, resolver: Resolver, existing_object_id: Optional[str]):
+            if _do_assert_no_mount_layers:
+                for image in base_images.values():
+                    # base images can't have
+                    image._assert_no_mount_layers()
+
             environment = await _get_environment_cached(resolver.environment_name or "", resolver.client)
             # A bit hacky,but assume that the environment provides a valid builder version
             image_builder_version = cast(ImageBuilderVersion, environment._settings.image_builder_version)
@@ -349,7 +413,9 @@ class _Image(_Object, type_prefix="im"):
                     "No commands were provided for the image — have you tried using modal.Image.debian_slim()?"
                 )
             if dockerfile.commands and build_function:
-                raise InvalidError("Cannot provide both a build function and Dockerfile commands!")
+                raise InvalidError(
+                    "Cannot provide both build function and Dockerfile commands in the same image layer!"
+                )
 
             base_images_pb2s = [
                 api_pb2.BaseImage(
@@ -482,12 +548,12 @@ class _Image(_Object, type_prefix="im"):
             self._hydrate(image_id, resolver.client, result_response.metadata)
             local_mounts = set()
             for base in base_images.values():
-                local_mounts |= base._used_local_mounts
+                local_mounts |= base._serve_mounts
             if context_mount and context_mount.is_local():
                 local_mounts.add(context_mount)
-            self._used_local_mounts = frozenset(local_mounts)
+            self._serve_mounts = frozenset(local_mounts)
 
-        rep = "Image()"
+        rep = f"Image({dockerfile_function})"
         obj = _Image._from_loader(_load, rep, deps=_deps)
         obj.force_build = force_build
         return obj
@@ -535,12 +601,59 @@ class _Image(_Object, type_prefix="im"):
             context_mount=mount,
         )
 
+    def add_local_file(self, local_path: Union[str, Path], remote_path: str, *, copy: bool = False) -> "_Image":
+        """Adds a local file to the image at `remote_path` within the container
+
+        By default (`copy=False`), the files are added to containers on startup and are not built into the actual Image,
+        which speeds up deployment.
+
+        Set `copy=True` to copy the files into an Image layer at build time instead, similar to how
+        [`COPY`](https://docs.docker.com/engine/reference/builder/#copy) works in a `Dockerfile`.
+
+        copy=True can slow down iteration since it requires a rebuild of the Image and any subsequent
+        build steps whenever the included files change, but it is required if you want to run additional
+        build steps after this one.
+        """
+        if not PurePosixPath(remote_path).is_absolute():
+            # TODO(elias): implement relative to absolute resolution using image workdir metadata
+            #  + make default remote_path="./"
+            #  This requires deferring the Mount creation until after "self" (the base image) has been resolved
+            #  so we know the workdir of the operation.
+            raise InvalidError("image.add_local_file() currently only supports absolute remote_path values")
+
+        if remote_path.endswith("/"):
+            remote_path = remote_path + Path(local_path).name
+
+        mount = _Mount.from_local_file(local_path, remote_path)
+        return self._add_mount_layer_or_copy(mount, copy=copy)
+
+    def add_local_dir(self, local_path: Union[str, Path], remote_path: str, *, copy: bool = False) -> "_Image":
+        """Adds a local directory's content to the image at `remote_path` within the container
+
+        By default (`copy=False`), the files are added to containers on startup and are not built into the actual Image,
+        which speeds up deployment.
+
+        Set `copy=True` to copy the files into an Image layer at build time instead, similar to how
+        [`COPY`](https://docs.docker.com/engine/reference/builder/#copy) works in a `Dockerfile`.
+
+        copy=True can slow down iteration since it requires a rebuild of the Image and any subsequent
+        build steps whenever the included files change, but it is required if you want to run additional
+        build steps after this one.
+        """
+        if not PurePosixPath(remote_path).is_absolute():
+            # TODO(elias): implement relative to absolute resolution using image workdir metadata
+            #  + make default remote_path="./"
+            raise InvalidError("image.add_local_dir() currently only supports absolute remote_path values")
+        mount = _Mount.from_local_dir(local_path, remote_path=remote_path)
+        return self._add_mount_layer_or_copy(mount, copy=copy)
+
     def copy_local_file(self, local_path: Union[str, Path], remote_path: Union[str, Path] = "./") -> "_Image":
         """Copy a file into the image as a part of building it.
 
         This works in a similar way to [`COPY`](https://docs.docker.com/engine/reference/builder/#copy)
         works in a `Dockerfile`.
         """
+        # TODO(elias): add pending deprecation with suggestion to use add_* instead
         basename = str(Path(local_path).name)
         mount = _Mount.from_local_file(local_path, remote_path=f"/{basename}")
 
@@ -553,6 +666,27 @@ class _Image(_Object, type_prefix="im"):
             context_mount=mount,
         )
 
+    def _add_local_python_packages(self, *packages: Union[str, Path], copy: bool = False) -> "_Image":
+        """Adds Python package files to containers
+
+        Adds all files from the specified Python packages to containers running the Image.
+
+        Packages are added to the `/root` directory of containers, which is on the `PYTHONPATH`
+        of any executed Modal Functions.
+
+        By default (`copy=False`), the files are added to containers on startup and are not built into the actual Image,
+        which speeds up deployment.
+
+        Set `copy=True` to copy the files into an Image layer at build time instead. This can slow down iteration since
+        it requires a rebuild of the Image and any subsequent build steps whenever the included files change, but it is
+        required if you want to run additional build steps after this one.
+
+        **Note:** This excludes all dot-prefixed subdirectories or files and all `.pyc`/`__pycache__` files.
+        To add full directories with finer control, use `.add_local_dir()` instead.
+        """
+        mount = _Mount.from_local_python_packages(*packages)
+        return self._add_mount_layer_or_copy(mount, copy=copy)
+
     def copy_local_dir(self, local_path: Union[str, Path], remote_path: Union[str, Path] = ".") -> "_Image":
         """Copy a directory into the image as a part of building the image.
 
@@ -1550,7 +1684,7 @@ class _Image(_Object, type_prefix="im"):
             dockerfile_function=build_dockerfile,
         )
 
-    def workdir(self, path: str) -> "_Image":
+    def workdir(self, path: Union[str, PurePosixPath]) -> "_Image":
         """Set the working directory for subsequent image build steps and function execution.
 
         **Example**

modal/image.pyi

@@ -58,11 +58,17 @@ class DockerfileSpec:
 class _Image(modal.object._Object):
     force_build: bool
     inside_exceptions: typing.List[Exception]
-    _used_local_mounts: typing.FrozenSet[modal.mount._Mount]
+    _serve_mounts: typing.FrozenSet[modal.mount._Mount]
+    _deferred_mounts: typing.Sequence[modal.mount._Mount]
     _metadata: typing.Optional[modal_proto.api_pb2.ImageMetadata]
 
     def _initialize_from_empty(self): ...
+    def _initialize_from_other(self, other: _Image): ...
     def _hydrate_metadata(self, message: typing.Optional[google.protobuf.message.Message]): ...
+    def _add_mount_layer_or_copy(self, mount: modal.mount._Mount, copy: bool = False): ...
+    @property
+    def _mount_layers(self) -> typing.Tuple[modal.mount._Mount]: ...
+    def _assert_no_mount_layers(self): ...
     @staticmethod
     def _from_args(
         *,
@@ -78,6 +84,7 @@ class _Image(modal.object._Object):
         context_mount: typing.Optional[modal.mount._Mount] = None,
         force_build: bool = False,
         _namespace: int = 1,
+        _do_assert_no_mount_layers: bool = True,
     ): ...
     def extend(
         self,
@@ -90,11 +97,19 @@ class _Image(modal.object._Object):
         context_mount: typing.Optional[modal.mount._Mount] = None,
         force_build: bool = False,
         _namespace: int = 1,
+        _do_assert_no_mount_layers: bool = True,
     ) -> _Image: ...
     def copy_mount(self, mount: modal.mount._Mount, remote_path: typing.Union[str, pathlib.Path] = ".") -> _Image: ...
+    def add_local_file(
+        self, local_path: typing.Union[str, pathlib.Path], remote_path: str, *, copy: bool = False
+    ) -> _Image: ...
+    def add_local_dir(
+        self, local_path: typing.Union[str, pathlib.Path], remote_path: str, *, copy: bool = False
+    ) -> _Image: ...
     def copy_local_file(
         self, local_path: typing.Union[str, pathlib.Path], remote_path: typing.Union[str, pathlib.Path] = "./"
     ) -> _Image: ...
+    def _add_local_python_packages(self, *module_names, copy: bool = False) -> _Image: ...
     def copy_local_dir(
         self, local_path: typing.Union[str, pathlib.Path], remote_path: typing.Union[str, pathlib.Path] = "."
     ) -> _Image: ...
@@ -292,19 +307,25 @@ class _Image(modal.object._Object):
         kwargs: typing.Dict[str, typing.Any] = {},
     ) -> _Image: ...
     def env(self, vars: typing.Dict[str, str]) -> _Image: ...
-    def workdir(self, path: str) -> _Image: ...
+    def workdir(self, path: typing.Union[str, pathlib.PurePosixPath]) -> _Image: ...
     def imports(self): ...
     def _logs(self) -> typing.AsyncGenerator[str, None]: ...
 
 class Image(modal.object.Object):
     force_build: bool
     inside_exceptions: typing.List[Exception]
-    _used_local_mounts: typing.FrozenSet[modal.mount.Mount]
+    _serve_mounts: typing.FrozenSet[modal.mount.Mount]
+    _deferred_mounts: typing.Sequence[modal.mount.Mount]
     _metadata: typing.Optional[modal_proto.api_pb2.ImageMetadata]
 
     def __init__(self, *args, **kwargs): ...
     def _initialize_from_empty(self): ...
+    def _initialize_from_other(self, other: Image): ...
     def _hydrate_metadata(self, message: typing.Optional[google.protobuf.message.Message]): ...
+    def _add_mount_layer_or_copy(self, mount: modal.mount.Mount, copy: bool = False): ...
+    @property
+    def _mount_layers(self) -> typing.Tuple[modal.mount.Mount]: ...
+    def _assert_no_mount_layers(self): ...
     @staticmethod
     def _from_args(
         *,
@@ -320,6 +341,7 @@ class Image(modal.object.Object):
         context_mount: typing.Optional[modal.mount.Mount] = None,
         force_build: bool = False,
         _namespace: int = 1,
+        _do_assert_no_mount_layers: bool = True,
     ): ...
     def extend(
         self,
@@ -332,11 +354,19 @@ class Image(modal.object.Object):
         context_mount: typing.Optional[modal.mount.Mount] = None,
         force_build: bool = False,
         _namespace: int = 1,
+        _do_assert_no_mount_layers: bool = True,
     ) -> Image: ...
     def copy_mount(self, mount: modal.mount.Mount, remote_path: typing.Union[str, pathlib.Path] = ".") -> Image: ...
+    def add_local_file(
+        self, local_path: typing.Union[str, pathlib.Path], remote_path: str, *, copy: bool = False
+    ) -> Image: ...
+    def add_local_dir(
+        self, local_path: typing.Union[str, pathlib.Path], remote_path: str, *, copy: bool = False
+    ) -> Image: ...
     def copy_local_file(
         self, local_path: typing.Union[str, pathlib.Path], remote_path: typing.Union[str, pathlib.Path] = "./"
     ) -> Image: ...
+    def _add_local_python_packages(self, *module_names, copy: bool = False) -> Image: ...
     def copy_local_dir(
         self, local_path: typing.Union[str, pathlib.Path], remote_path: typing.Union[str, pathlib.Path] = "."
     ) -> Image: ...
@@ -534,7 +564,7 @@ class Image(modal.object.Object):
         kwargs: typing.Dict[str, typing.Any] = {},
     ) -> Image: ...
     def env(self, vars: typing.Dict[str, str]) -> Image: ...
-    def workdir(self, path: str) -> Image: ...
+    def workdir(self, path: typing.Union[str, pathlib.PurePosixPath]) -> Image: ...
     def imports(self): ...
 
     class ___logs_spec(typing_extensions.Protocol):

modal/io_streams.py

@@ -66,9 +66,10 @@ T = TypeVar("T", str, bytes)
 
 
 class _StreamReader(Generic[T]):
-    """Provides an interface to buffer and fetch logs from a stream (`stdout` or `stderr`).
+    """Retrieve logs from a stream (`stdout` or `stderr`).
 
-    As an asynchronous iterable, the object supports the async for statement.
+    As an asynchronous iterable, the object supports the `for` and `async for`
+    statements. Just loop over the object to read in chunks.
 
     **Usage**
 
@@ -140,12 +141,12 @@ class _StreamReader(Generic[T]):
             self._consume_container_process_task = asyncio.create_task(self._consume_container_process_stream())
 
     @property
-    def file_descriptor(self):
+    def file_descriptor(self) -> int:
+        """Possible values are `1` for stdout and `2` for stderr."""
         return self._file_descriptor
 
     async def read(self) -> T:
-        """Fetch and return contents of the entire stream. If EOF was received,
-        return an empty string.
+        """Fetch the entire contents of the stream until EOF.
 
         **Usage**
 
@@ -157,7 +158,6 @@ class _StreamReader(Generic[T]):
 
         print(sandbox.stdout.read())
         ```
-
         """
         data_str = ""
         data_bytes = b""
@@ -175,9 +175,7 @@ class _StreamReader(Generic[T]):
             return cast(T, data_bytes)
 
     async def _consume_container_process_stream(self):
-        """
-        Consumes the container process stream and stores the messages in the buffer.
-        """
+        """Consume the container process stream and store messages in the buffer."""
         if self._stream_type == StreamType.DEVNULL:
             return
 
@@ -211,9 +209,7 @@ class _StreamReader(Generic[T]):
                 raise exc
 
     async def _stream_container_process(self) -> AsyncGenerator[Tuple[Optional[bytes], str], None]:
-        """mdmd:hidden
-        Streams the container process buffer to the reader.
-        """
+        """Streams the container process buffer to the reader."""
         entry_id = 0
         if self._last_entry_id:
             entry_id = int(self._last_entry_id) + 1
@@ -232,8 +228,7 @@ class _StreamReader(Generic[T]):
             entry_id += 1
 
     async def _get_logs(self) -> AsyncGenerator[Optional[bytes], None]:
-        """mdmd:hidden
-        Streams sandbox or process logs from the server to the reader.
+        """Streams sandbox or process logs from the server to the reader.
 
         Logs returned by this method may contain partial or multiple lines at a time.
 
@@ -278,9 +273,7 @@ class _StreamReader(Generic[T]):
                 raise
 
     async def _get_logs_by_line(self) -> AsyncGenerator[Optional[bytes], None]:
-        """mdmd:hidden
-        Processes logs from the server and yields complete lines only.
-        """
+        """Process logs from the server and yield complete lines only."""
         async for message in self._get_logs():
             if message is None:
                 if self._line_buffer:
@@ -325,7 +318,8 @@ MAX_BUFFER_SIZE = 2 * 1024 * 1024
 class _StreamWriter:
     """Provides an interface to buffer and write logs to a sandbox or container process stream (`stdin`)."""
 
-    def __init__(self, object_id: str, object_type: Literal["sandbox", "container_process"], client: _Client):
+    def __init__(self, object_id: str, object_type: Literal["sandbox", "container_process"], client: _Client) -> None:
+        """mdmd:hidden"""
         self._index = 1
         self._object_id = object_id
         self._object_type = object_type
@@ -333,17 +327,16 @@ class _StreamWriter:
         self._is_closed = False
         self._buffer = bytearray()
 
-    def get_next_index(self):
-        """mdmd:hidden"""
+    def _get_next_index(self) -> int:
         index = self._index
         self._index += 1
         return index
 
-    def write(self, data: Union[bytes, bytearray, memoryview, str]):
-        """
-        Writes data to stream's internal buffer, but does not drain/flush the write.
+    def write(self, data: Union[bytes, bytearray, memoryview, str]) -> None:
+        """Write data to the stream but does not send it immediately.
 
-        This method needs to be used along with the `drain()` method which flushes the buffer.
+        This is non-blocking and queues the data to an internal buffer. Must be
+        used along with the `drain()` method, which flushes the buffer.
 
         **Usage**
 
@@ -375,22 +368,36 @@ class _StreamWriter:
         else:
             raise TypeError(f"data argument must be a bytes-like object, not {type(data).__name__}")
 
-    def write_eof(self):
-        """
-        Closes the write end of the stream after the buffered write data is drained.
-        If the process was blocked on input, it will become unblocked after `write_eof()`.
+    def write_eof(self) -> None:
+        """Close the write end of the stream after the buffered data is drained.
 
-        This method needs to be used along with the `drain()` method which flushes the EOF to the process.
+        If the process was blocked on input, it will become unblocked after
+        `write_eof()`. This method needs to be used along with the `drain()`
+        method, which flushes the EOF to the process.
         """
         self._is_closed = True
 
-    async def drain(self):
-        """
-        Flushes the write buffer to the running process. Flushes the EOF if the writer is closed.
+    async def drain(self) -> None:
+        """Flush the write buffer and send data to the running process.
+
+        This is a flow control method that blocks until data is sent. It returns
+        when it is appropriate to continue writing data to the stream.
+
+        **Usage**
+
+        ```python
+        # Synchronous
+        writer.write(data)
+        writer.drain()
+
+        # Async
+        writer.write(data)
+        await writer.drain.aio()
+        ```
         """
         data = bytes(self._buffer)
         self._buffer.clear()
-        index = self.get_next_index()
+        index = self._get_next_index()
 
         try:
             if self._object_type == "sandbox":

modal/io_streams.pyi

@@ -26,7 +26,7 @@ class _StreamReader(typing.Generic[T]):
         by_line: bool = False,
     ) -> None: ...
     @property
-    def file_descriptor(self): ...
+    def file_descriptor(self) -> int: ...
     async def read(self) -> T: ...
     async def _consume_container_process_stream(self): ...
     def _stream_container_process(self) -> typing.AsyncGenerator[typing.Tuple[typing.Optional[bytes], str], None]: ...
@@ -38,11 +38,11 @@ class _StreamReader(typing.Generic[T]):
 class _StreamWriter:
     def __init__(
         self, object_id: str, object_type: typing.Literal["sandbox", "container_process"], client: modal.client._Client
-    ): ...
-    def get_next_index(self): ...
-    def write(self, data: typing.Union[bytes, bytearray, memoryview, str]): ...
-    def write_eof(self): ...
-    async def drain(self): ...
+    ) -> None: ...
+    def _get_next_index(self) -> int: ...
+    def write(self, data: typing.Union[bytes, bytearray, memoryview, str]) -> None: ...
+    def write_eof(self) -> None: ...
+    async def drain(self) -> None: ...
 
 T_INNER = typing.TypeVar("T_INNER", covariant=True)
 
@@ -60,7 +60,7 @@ class StreamReader(typing.Generic[T]):
         by_line: bool = False,
     ) -> None: ...
     @property
-    def file_descriptor(self): ...
+    def file_descriptor(self) -> int: ...
 
     class __read_spec(typing_extensions.Protocol[T_INNER]):
         def __call__(self) -> T_INNER: ...
@@ -100,13 +100,13 @@ class StreamReader(typing.Generic[T]):
 class StreamWriter:
     def __init__(
         self, object_id: str, object_type: typing.Literal["sandbox", "container_process"], client: modal.client.Client
-    ): ...
-    def get_next_index(self): ...
-    def write(self, data: typing.Union[bytes, bytearray, memoryview, str]): ...
-    def write_eof(self): ...
+    ) -> None: ...
+    def _get_next_index(self) -> int: ...
+    def write(self, data: typing.Union[bytes, bytearray, memoryview, str]) -> None: ...
+    def write_eof(self) -> None: ...
 
     class __drain_spec(typing_extensions.Protocol):
-        def __call__(self): ...
-        async def aio(self): ...
+        def __call__(self) -> None: ...
+        async def aio(self) -> None: ...
 
     drain: __drain_spec

modal/mount.py

@@ -377,7 +377,9 @@ class _Mount(_Object, type_prefix="mo"):
         )
 
     def add_local_file(
-        self, local_path: Union[str, Path], remote_path: Union[str, PurePosixPath, None] = None
+        self,
+        local_path: Union[str, Path],
+        remote_path: Union[str, PurePosixPath, None] = None,
     ) -> "_Mount":
         """
         Add a local file to the `Mount` object.
@@ -622,12 +624,13 @@ 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
         if client is None:
             client = await _Client.from_env()
-        resolver = Resolver(client=client)
+        resolver = Resolver(client=client, environment_name=environment_name)
         await resolver.load(self)
 
     def _get_metadata(self) -> api_pb2.MountHandleMetadata:

modal/network_file_system.py

@@ -171,34 +171,6 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
             tc.infinite_loop(lambda: client.stub.SharedVolumeHeartbeat(request), sleep=_heartbeat_sleep)
             yield cls._new_hydrated(response.shared_volume_id, client, None, is_another_app=True)
 
-    @staticmethod
-    def persisted(
-        label: str,
-        namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
-        environment_name: Optional[str] = None,
-        cloud: Optional[str] = None,
-    ):
-        """mdmd:hidden"""
-        message = (
-            "`NetworkFileSystem.persisted` is deprecated."
-            " Please use `NetworkFileSystem.from_name(name, create_if_missing=True)` instead."
-        )
-        deprecation_error((2024, 3, 1), message)
-
-    def persist(
-        self,
-        label: str,
-        namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
-        environment_name: Optional[str] = None,
-        cloud: Optional[str] = None,
-    ):
-        """mdmd:hidden"""
-        message = (
-            "`NetworkFileSystem().persist('my-volume')` is deprecated."
-            " Please use `NetworkFileSystem.from_name('my-volume', create_if_missing=True)` instead."
-        )
-        deprecation_error((2024, 2, 29), message)
-
     @staticmethod
     async def lookup(
         label: str,

modal/network_file_system.pyi

@@ -26,13 +26,6 @@ class _NetworkFileSystem(modal.object._Object):
         _heartbeat_sleep: float = 300,
     ) -> typing.AsyncContextManager[_NetworkFileSystem]: ...
     @staticmethod
-    def persisted(
-        label: str, namespace=1, environment_name: typing.Optional[str] = None, cloud: typing.Optional[str] = None
-    ): ...
-    def persist(
-        self, label: str, namespace=1, environment_name: typing.Optional[str] = None, cloud: typing.Optional[str] = None
-    ): ...
-    @staticmethod
     async def lookup(
         label: str,
         namespace=1,
@@ -85,13 +78,6 @@ class NetworkFileSystem(modal.object.Object):
         environment_name: typing.Optional[str] = None,
         _heartbeat_sleep: float = 300,
     ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[NetworkFileSystem]: ...
-    @staticmethod
-    def persisted(
-        label: str, namespace=1, environment_name: typing.Optional[str] = None, cloud: typing.Optional[str] = None
-    ): ...
-    def persist(
-        self, label: str, namespace=1, environment_name: typing.Optional[str] = None, cloud: typing.Optional[str] = None
-    ): ...
 
     class __lookup_spec(typing_extensions.Protocol):
         def __call__(