modal 0.68.31__py3-none-any.whl → 0.68.50__py3-none-any.whl

modal/environments.py

@@ -10,6 +10,7 @@ from modal_proto import api_pb2
 
 from ._resolver import Resolver
 from ._utils.async_utils import synchronize_api, synchronizer
+from ._utils.deprecation import renamed_parameter
 from ._utils.grpc_utils import retry_transient_errors
 from ._utils.name_utils import check_object_name
 from .client import _Client
@@ -52,21 +53,22 @@ class _Environment(_Object, type_prefix="en"):
         )
 
     @staticmethod
+    @renamed_parameter((2024, 12, 18), "label", "name")
     async def from_name(
-        label: str,
+        name: str,
         create_if_missing: bool = False,
     ):
-        if label:
-            # Allow null labels for the case where we want to look up the "default" environment,
+        if name:
+            # Allow null names for the case where we want to look up the "default" environment,
             # which is defined by the server. It feels messy to have "from_name" without a name, though?
             # We're adding this mostly for internal use right now. We could consider an environment-only
             # alternate constructor, like `Environment.get_default`, rather than exposing "unnamed"
             # environments as part of public API when we make this class more useful.
-            check_object_name(label, "Environment")
+            check_object_name(name, "Environment")
 
         async def _load(self: _Environment, resolver: Resolver, existing_object_id: Optional[str]):
             request = api_pb2.EnvironmentGetOrCreateRequest(
-                deployment_name=label,
+                deployment_name=name,
                 object_creation_type=(
                     api_pb2.OBJECT_CREATION_TYPE_CREATE_IF_MISSING
                     if create_if_missing
@@ -81,12 +83,13 @@ class _Environment(_Object, type_prefix="en"):
         return _Environment._from_loader(_load, "Environment()", is_another_app=True, hydrate_lazily=True)
 
     @staticmethod
+    @renamed_parameter((2024, 12, 18), "label", "name")
     async def lookup(
-        label: str,
+        name: str,
         client: Optional[_Client] = None,
         create_if_missing: bool = False,
     ):
-        obj = await _Environment.from_name(label, create_if_missing=create_if_missing)
+        obj = await _Environment.from_name(name, create_if_missing=create_if_missing)
         if client is None:
             client = await _Client.from_env()
         resolver = Resolver(client=client)

modal/environments.pyi

@@ -22,10 +22,10 @@ class _Environment(modal.object._Object):
     def __init__(self): ...
     def _hydrate_metadata(self, metadata: google.protobuf.message.Message): ...
     @staticmethod
-    async def from_name(label: str, create_if_missing: bool = False): ...
+    async def from_name(name: str, create_if_missing: bool = False): ...
     @staticmethod
     async def lookup(
-        label: str, client: typing.Optional[modal.client._Client] = None, create_if_missing: bool = False
+        name: str, client: typing.Optional[modal.client._Client] = None, create_if_missing: bool = False
     ): ...
 
 class Environment(modal.object.Object):
@@ -35,17 +35,17 @@ class Environment(modal.object.Object):
     def _hydrate_metadata(self, metadata: google.protobuf.message.Message): ...
 
     class __from_name_spec(typing_extensions.Protocol):
-        def __call__(self, label: str, create_if_missing: bool = False): ...
-        async def aio(self, label: str, create_if_missing: bool = False): ...
+        def __call__(self, name: str, create_if_missing: bool = False): ...
+        async def aio(self, name: str, create_if_missing: bool = False): ...
 
     from_name: __from_name_spec
 
     class __lookup_spec(typing_extensions.Protocol):
         def __call__(
-            self, label: str, client: typing.Optional[modal.client.Client] = None, create_if_missing: bool = False
+            self, name: str, client: typing.Optional[modal.client.Client] = None, create_if_missing: bool = False
         ): ...
         async def aio(
-            self, label: str, client: typing.Optional[modal.client.Client] = None, create_if_missing: bool = False
+            self, name: str, client: typing.Optional[modal.client.Client] = None, create_if_missing: bool = False
         ): ...
 
     lookup: __lookup_spec

modal/functions.py

@@ -22,7 +22,6 @@ 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
 from modal_proto.modal_api_grpc import ModalClientModal
 
@@ -35,13 +34,14 @@ from ._serialization import serialize, serialize_proto_params
 from ._traceback import print_server_warnings
 from ._utils.async_utils import (
     TaskContext,
+    aclosing,
     async_merge,
     callable_to_agen,
     synchronize_api,
     synchronizer,
     warn_if_generator_is_not_consumed,
 )
-from ._utils.deprecation import deprecation_warning
+from ._utils.deprecation import deprecation_warning, renamed_parameter
 from ._utils.function_utils import (
     ATTEMPT_TIMEOUT_GRACE_PERIOD,
     OUTPUTS_TIMEOUT,
@@ -346,6 +346,7 @@ class _FunctionSpec:
     memory: Optional[Union[int, tuple[int, int]]]
     ephemeral_disk: Optional[int]
     scheduler_placement: Optional[SchedulerPlacement]
+    proxy: Optional[_Proxy]
 
 
 P = typing_extensions.ParamSpec("P")
@@ -530,6 +531,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             memory=memory,
             ephemeral_disk=ephemeral_disk,
             scheduler_placement=scheduler_placement,
+            proxy=proxy,
         )
 
         if info.user_cls and not is_auto_snapshot:
@@ -751,7 +753,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     mount_ids=loaded_mount_ids,
                     secret_ids=[secret.object_id for secret in secrets],
                     image_id=(image.object_id if image else ""),
-                    definition_type=info.definition_type,
+                    definition_type=info.get_definition_type(),
                     function_serialized=function_serialized or b"",
                     class_serialized=class_serialized or b"",
                     function_type=function_type,
@@ -1022,10 +1024,11 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         await retry_transient_errors(self._client.stub.FunctionUpdateSchedulingParams, request)
 
     @classmethod
+    @renamed_parameter((2024, 12, 18), "tag", "name")
     def from_name(
         cls: type["_Function"],
         app_name: str,
-        tag: str,
+        name: str,
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         environment_name: Optional[str] = None,
     ) -> "_Function":
@@ -1044,7 +1047,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             assert resolver.client and resolver.client.stub
             request = api_pb2.FunctionGetRequest(
                 app_name=app_name,
-                object_tag=tag,
+                object_tag=name,
                 namespace=namespace,
                 environment_name=_get_environment_name(environment_name, resolver) or "",
             )
@@ -1064,9 +1067,10 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         return cls._from_loader(_load_remote, rep, is_another_app=True, hydrate_lazily=True)
 
     @staticmethod
+    @renamed_parameter((2024, 12, 18), "tag", "name")
     async def lookup(
         app_name: str,
-        tag: str,
+        name: str,
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         client: Optional[_Client] = None,
         environment_name: Optional[str] = None,
@@ -1080,7 +1084,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         f = modal.Function.lookup("other-app", "function")
         ```
         """
-        obj = _Function.from_name(app_name, tag, namespace=namespace, environment_name=environment_name)
+        obj = _Function.from_name(app_name, name, namespace=namespace, environment_name=environment_name)
         if client is None:
             client = await _Client.from_env()
         resolver = Resolver(client=client)

modal/functions.pyi

@@ -100,6 +100,7 @@ class _FunctionSpec:
     memory: typing.Union[int, tuple[int, int], None]
     ephemeral_disk: typing.Optional[int]
     scheduler_placement: typing.Optional[modal.scheduler_placement.SchedulerPlacement]
+    proxy: typing.Optional[modal.proxy._Proxy]
 
     def __init__(
         self,
@@ -121,6 +122,7 @@ class _FunctionSpec:
         memory: typing.Union[int, tuple[int, int], None],
         ephemeral_disk: typing.Optional[int],
         scheduler_placement: typing.Optional[modal.scheduler_placement.SchedulerPlacement],
+        proxy: typing.Optional[modal.proxy._Proxy],
     ) -> None: ...
     def __repr__(self): ...
     def __eq__(self, other): ...
@@ -206,12 +208,12 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.
     async def keep_warm(self, warm_pool_size: int) -> None: ...
     @classmethod
     def from_name(
-        cls: type[_Function], app_name: str, tag: str, namespace=1, environment_name: typing.Optional[str] = None
+        cls: type[_Function], app_name: str, name: str, namespace=1, environment_name: typing.Optional[str] = None
     ) -> _Function: ...
     @staticmethod
     async def lookup(
         app_name: str,
-        tag: str,
+        name: str,
         namespace=1,
         client: typing.Optional[modal.client._Client] = None,
         environment_name: typing.Optional[str] = None,
@@ -381,14 +383,14 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
 
     @classmethod
     def from_name(
-        cls: type[Function], app_name: str, tag: str, namespace=1, environment_name: typing.Optional[str] = None
+        cls: type[Function], app_name: str, name: str, namespace=1, environment_name: typing.Optional[str] = None
     ) -> Function: ...
 
     class __lookup_spec(typing_extensions.Protocol):
         def __call__(
             self,
             app_name: str,
-            tag: str,
+            name: str,
             namespace=1,
             client: typing.Optional[modal.client.Client] = None,
             environment_name: typing.Optional[str] = None,
@@ -396,7 +398,7 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
         async def aio(
             self,
             app_name: str,
-            tag: str,
+            name: str,
             namespace=1,
             client: typing.Optional[modal.client.Client] = None,
             environment_name: typing.Optional[str] = None,

modal/gpu.py

@@ -137,6 +137,27 @@ class H100(_GPUConfig):
         return f"GPU(H100, count={self.count})"
 
 
+class L40S(_GPUConfig):
+    """
+    [NVIDIA L40S](https://www.nvidia.com/en-us/data-center/l40s/) GPU class.
+
+    The L40S is a data center GPU for the Ada Lovelace architecture. It has 48 GB of on-chip
+    GDDR6 RAM and enhanced support for FP8 precision.
+    """
+
+    def __init__(
+        self,
+        *,
+        # Number of GPUs per container. Defaults to 1.
+        # Useful if you have very large models that don't fit on a single GPU.
+        count: int = 1,
+    ):
+        super().__init__(api_pb2.GPU_TYPE_L40S, count)
+
+    def __repr__(self):
+        return f"GPU(L40S, count={self.count})"
+
+
 class Any(_GPUConfig):
     """Selects any one of the GPU classes available within Modal, according to availability."""
 
@@ -154,6 +175,7 @@ STRING_TO_GPU_CONFIG: dict[str, Callable] = {
     "a100-80gb": lambda: A100(size="80GB"),
     "h100": H100,
     "a10g": A10G,
+    "l40s": L40S,
     "any": Any,
 }
 display_string_to_config = "\n".join(f'- "{key}" → `{c()}`' for key, c in STRING_TO_GPU_CONFIG.items() if key != "inf2")

modal/image.py

@@ -571,21 +571,6 @@ class _Image(_Object, type_prefix="im"):
         obj.force_build = force_build
         return obj
 
-    def extend(self, **kwargs) -> "_Image":
-        """mdmd:hidden"""
-        deprecation_error(
-            (2024, 3, 7),
-            "`Image.extend` is deprecated; please use a higher-level method, such as `Image.dockerfile_commands`.",
-        )
-
-        def build_dockerfile(version: ImageBuilderVersion) -> DockerfileSpec:
-            return DockerfileSpec(
-                commands=kwargs.pop("dockerfile_commands", []),
-                context_files=kwargs.pop("context_files", {}),
-            )
-
-        return _Image._from_args(base_images={"base": self}, dockerfile_function=build_dockerfile, **kwargs)
-
     def copy_mount(self, mount: _Mount, remote_path: Union[str, Path] = ".") -> "_Image":
         """Copy the entire contents of a `modal.Mount` into an image.
         Useful when files only available locally are required during the image

modal/image.pyi

@@ -92,19 +92,6 @@ class _Image(modal.object._Object):
         _namespace: int = 1,
         _do_assert_no_mount_layers: bool = True,
     ): ...
-    def extend(
-        self,
-        *,
-        secrets: typing.Optional[collections.abc.Sequence[modal.secret._Secret]] = None,
-        gpu_config: typing.Optional[modal_proto.api_pb2.GPUConfig] = None,
-        build_function: typing.Optional[modal.functions._Function] = None,
-        build_function_input: typing.Optional[modal_proto.api_pb2.FunctionInput] = None,
-        image_registry_config: typing.Optional[_ImageRegistryConfig] = None,
-        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
@@ -364,19 +351,6 @@ class Image(modal.object.Object):
         _namespace: int = 1,
         _do_assert_no_mount_layers: bool = True,
     ): ...
-    def extend(
-        self,
-        *,
-        secrets: typing.Optional[collections.abc.Sequence[modal.secret.Secret]] = None,
-        gpu_config: typing.Optional[modal_proto.api_pb2.GPUConfig] = None,
-        build_function: typing.Optional[modal.functions.Function] = None,
-        build_function_input: typing.Optional[modal_proto.api_pb2.FunctionInput] = None,
-        image_registry_config: typing.Optional[_ImageRegistryConfig] = None,
-        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

modal/mount.py

@@ -22,6 +22,7 @@ from modal_version import __version__
 from ._resolver import Resolver
 from ._utils.async_utils import aclosing, async_map, synchronize_api
 from ._utils.blob_utils import FileUploadSpec, blob_upload_file, get_file_upload_spec_from_path
+from ._utils.deprecation import renamed_parameter
 from ._utils.grpc_utils import retry_transient_errors
 from ._utils.name_utils import check_object_name
 from ._utils.package_utils import get_module_mount_info
@@ -104,7 +105,7 @@ class _MountFile(_MountEntry):
         return str(self.local_file)
 
     def get_files_to_upload(self):
-        local_file = self.local_file.expanduser().absolute()
+        local_file = self.local_file.resolve()
         if not local_file.exists():
             raise FileNotFoundError(local_file)
 
@@ -130,6 +131,8 @@ class _MountDir(_MountEntry):
         return str(self.local_dir.expanduser().absolute())
 
     def get_files_to_upload(self):
+        # we can't use .resolve() eagerly here since that could end up "renaming" symlinked files
+        # see test_mount_directory_with_symlinked_file
         local_dir = self.local_dir.expanduser().absolute()
 
         if not local_dir.exists():
@@ -144,10 +147,11 @@ class _MountDir(_MountEntry):
             gen = (dir_entry.path for dir_entry in os.scandir(local_dir) if dir_entry.is_file())
 
         for local_filename in gen:
-            if not self.ignore(Path(local_filename)):
-                local_relpath = Path(local_filename).expanduser().absolute().relative_to(local_dir)
+            local_path = Path(local_filename)
+            if not self.ignore(local_path):
+                local_relpath = local_path.expanduser().absolute().relative_to(local_dir)
                 mount_path = self.remote_path / local_relpath.as_posix()
-                yield local_filename, mount_path
+                yield local_path.resolve(), mount_path
 
     def watch_entry(self):
         return self.local_dir.resolve().expanduser(), None
@@ -623,8 +627,9 @@ class _Mount(_Object, type_prefix="mo"):
         return mount
 
     @staticmethod
+    @renamed_parameter((2024, 12, 18), "label", "name")
     def from_name(
-        label: str,
+        name: str,
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         environment_name: Optional[str] = None,
     ) -> "_Mount":
@@ -632,7 +637,7 @@ class _Mount(_Object, type_prefix="mo"):
 
         async def _load(provider: _Mount, resolver: Resolver, existing_object_id: Optional[str]):
             req = api_pb2.MountGetOrCreateRequest(
-                deployment_name=label,
+                deployment_name=name,
                 namespace=namespace,
                 environment_name=_get_environment_name(environment_name, resolver),
             )
@@ -642,15 +647,16 @@ class _Mount(_Object, type_prefix="mo"):
         return _Mount._from_loader(_load, "Mount()")
 
     @classmethod
+    @renamed_parameter((2024, 12, 18), "label", "name")
     async def lookup(
         cls: type["_Mount"],
-        label: str,
+        name: str,
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         client: Optional[_Client] = None,
         environment_name: Optional[str] = None,
     ) -> "_Mount":
         """mdmd:hidden"""
-        obj = _Mount.from_name(label, namespace=namespace, environment_name=environment_name)
+        obj = _Mount.from_name(name, namespace=namespace, environment_name=environment_name)
         if client is None:
             client = await _Client.from_env()
         resolver = Resolver(client=client)

modal/mount.pyi

@@ -139,11 +139,11 @@ class _Mount(modal.object._Object):
         ignore: typing.Union[typing.Sequence[str], typing.Callable[[pathlib.Path], bool], None] = None,
     ) -> _Mount: ...
     @staticmethod
-    def from_name(label: str, namespace=1, environment_name: typing.Optional[str] = None) -> _Mount: ...
+    def from_name(name: str, namespace=1, environment_name: typing.Optional[str] = None) -> _Mount: ...
     @classmethod
     async def lookup(
         cls: type[_Mount],
-        label: str,
+        name: str,
         namespace=1,
         client: typing.Optional[modal.client._Client] = None,
         environment_name: typing.Optional[str] = None,
@@ -231,11 +231,11 @@ class Mount(modal.object.Object):
         ignore: typing.Union[typing.Sequence[str], typing.Callable[[pathlib.Path], bool], None] = None,
     ) -> Mount: ...
     @staticmethod
-    def from_name(label: str, namespace=1, environment_name: typing.Optional[str] = None) -> Mount: ...
+    def from_name(name: str, namespace=1, environment_name: typing.Optional[str] = None) -> Mount: ...
     @classmethod
     def lookup(
         cls: type[Mount],
-        label: str,
+        name: str,
         namespace=1,
         client: typing.Optional[modal.client.Client] = None,
         environment_name: typing.Optional[str] = None,

modal/network_file_system.py

@@ -15,7 +15,7 @@ from modal_proto import api_pb2
 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 deprecation_error
+from ._utils.deprecation import renamed_parameter
 from ._utils.grpc_utils import retry_transient_errors
 from ._utils.hash_utils import get_sha256_hex
 from ._utils.name_utils import check_object_name
@@ -91,18 +91,9 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
     """
 
     @staticmethod
-    def new(cloud: Optional[str] = None):
-        """mdmd:hidden"""
-        message = (
-            "`NetworkFileSystem.new` is deprecated."
-            " Please use `NetworkFileSystem.from_name` (for persisted)"
-            " or `NetworkFileSystem.ephemeral` (for ephemeral) network filesystems instead."
-        )
-        deprecation_error((2024, 3, 20), message)
-
-    @staticmethod
+    @renamed_parameter((2024, 12, 18), "label", "name")
     def from_name(
-        label: str,
+        name: str,
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         environment_name: Optional[str] = None,
         create_if_missing: bool = False,
@@ -121,11 +112,11 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
             pass
         ```
         """
-        check_object_name(label, "NetworkFileSystem")
+        check_object_name(name, "NetworkFileSystem")
 
         async def _load(self: _NetworkFileSystem, resolver: Resolver, existing_object_id: Optional[str]):
             req = api_pb2.SharedVolumeGetOrCreateRequest(
-                deployment_name=label,
+                deployment_name=name,
                 namespace=namespace,
                 environment_name=_get_environment_name(environment_name, resolver),
                 object_creation_type=(api_pb2.OBJECT_CREATION_TYPE_CREATE_IF_MISSING if create_if_missing else None),
@@ -136,7 +127,7 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
             except GRPCError as exc:
                 if exc.status == Status.NOT_FOUND and exc.message == "App has wrong entity vo":
                     raise InvalidError(
-                        f"Attempted to mount: `{label}` as a NetworkFileSystem " + "which already exists as a Volume"
+                        f"Attempted to mount: `{name}` as a NetworkFileSystem " + "which already exists as a Volume"
                     )
                 raise
 
@@ -176,8 +167,9 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
             yield cls._new_hydrated(response.shared_volume_id, client, None, is_another_app=True)
 
     @staticmethod
+    @renamed_parameter((2024, 12, 18), "label", "name")
     async def lookup(
-        label: str,
+        name: str,
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         client: Optional[_Client] = None,
         environment_name: Optional[str] = None,
@@ -194,7 +186,7 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
         ```
         """
         obj = _NetworkFileSystem.from_name(
-            label, namespace=namespace, environment_name=environment_name, create_if_missing=create_if_missing
+            name, namespace=namespace, environment_name=environment_name, create_if_missing=create_if_missing
         )
         if client is None:
             client = await _Client.from_env()
@@ -223,8 +215,9 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
         return resp.shared_volume_id
 
     @staticmethod
-    async def delete(label: str, client: Optional[_Client] = None, environment_name: Optional[str] = None):
-        obj = await _NetworkFileSystem.lookup(label, client=client, environment_name=environment_name)
+    @renamed_parameter((2024, 12, 18), "label", "name")
+    async def delete(name: str, client: Optional[_Client] = None, environment_name: Optional[str] = None):
+        obj = await _NetworkFileSystem.lookup(name, client=client, environment_name=environment_name)
         req = api_pb2.SharedVolumeDeleteRequest(shared_volume_id=obj.object_id)
         await retry_transient_errors(obj._client.stub.SharedVolumeDelete, req)
 

modal/network_file_system.pyi

@@ -13,11 +13,9 @@ def network_file_system_mount_protos(
 ) -> list[modal_proto.api_pb2.SharedVolumeMount]: ...
 
 class _NetworkFileSystem(modal.object._Object):
-    @staticmethod
-    def new(cloud: typing.Optional[str] = None): ...
     @staticmethod
     def from_name(
-        label: str, namespace=1, environment_name: typing.Optional[str] = None, create_if_missing: bool = False
+        name: str, namespace=1, environment_name: typing.Optional[str] = None, create_if_missing: bool = False
     ) -> _NetworkFileSystem: ...
     @classmethod
     def ephemeral(
@@ -28,7 +26,7 @@ class _NetworkFileSystem(modal.object._Object):
     ) -> typing.AsyncContextManager[_NetworkFileSystem]: ...
     @staticmethod
     async def lookup(
-        label: str,
+        name: str,
         namespace=1,
         client: typing.Optional[modal.client._Client] = None,
         environment_name: typing.Optional[str] = None,
@@ -43,7 +41,7 @@ class _NetworkFileSystem(modal.object._Object):
     ) -> str: ...
     @staticmethod
     async def delete(
-        label: str, client: typing.Optional[modal.client._Client] = None, environment_name: typing.Optional[str] = None
+        name: str, client: typing.Optional[modal.client._Client] = None, environment_name: typing.Optional[str] = None
     ): ...
     async def write_file(
         self,
@@ -71,10 +69,8 @@ class _NetworkFileSystem(modal.object._Object):
 class NetworkFileSystem(modal.object.Object):
     def __init__(self, *args, **kwargs): ...
     @staticmethod
-    def new(cloud: typing.Optional[str] = None): ...
-    @staticmethod
     def from_name(
-        label: str, namespace=1, environment_name: typing.Optional[str] = None, create_if_missing: bool = False
+        name: str, namespace=1, environment_name: typing.Optional[str] = None, create_if_missing: bool = False
     ) -> NetworkFileSystem: ...
     @classmethod
     def ephemeral(
@@ -87,7 +83,7 @@ class NetworkFileSystem(modal.object.Object):
     class __lookup_spec(typing_extensions.Protocol):
         def __call__(
             self,
-            label: str,
+            name: str,
             namespace=1,
             client: typing.Optional[modal.client.Client] = None,
             environment_name: typing.Optional[str] = None,
@@ -95,7 +91,7 @@ class NetworkFileSystem(modal.object.Object):
         ) -> NetworkFileSystem: ...
         async def aio(
             self,
-            label: str,
+            name: str,
             namespace=1,
             client: typing.Optional[modal.client.Client] = None,
             environment_name: typing.Optional[str] = None,
@@ -125,13 +121,13 @@ class NetworkFileSystem(modal.object.Object):
     class __delete_spec(typing_extensions.Protocol):
         def __call__(
             self,
-            label: str,
+            name: str,
             client: typing.Optional[modal.client.Client] = None,
             environment_name: typing.Optional[str] = None,
         ): ...
         async def aio(
             self,
-            label: str,
+            name: str,
             client: typing.Optional[modal.client.Client] = None,
             environment_name: typing.Optional[str] = None,
         ): ...

modal/partial_function.py

@@ -138,29 +138,6 @@ PartialFunction = synchronize_api(_PartialFunction)
 def _find_partial_methods_for_user_cls(user_cls: type[Any], flags: int) -> dict[str, _PartialFunction]:
     """Grabs all method on a user class, and returns partials. Includes legacy methods."""
 
-    # Build up a list of legacy attributes to check
-    check_attrs: list[str] = []
-    if flags & _PartialFunctionFlags.BUILD:
-        check_attrs += ["__build__", "__abuild__"]
-    if flags & _PartialFunctionFlags.ENTER_POST_SNAPSHOT:
-        check_attrs += ["__enter__", "__aenter__"]
-    if flags & _PartialFunctionFlags.EXIT:
-        check_attrs += ["__exit__", "__aexit__"]
-
-    # Grab legacy lifecycle methods
-    for attr in check_attrs:
-        if hasattr(user_cls, attr):
-            suggested = attr.strip("_")
-            if is_async := suggested.startswith("a"):
-                suggested = suggested[1:]
-            async_suggestion = " (on an async method)" if is_async else ""
-            message = (
-                f"Using `{attr}` methods for class lifecycle management is deprecated."
-                f" Please try using the `modal.{suggested}` decorator{async_suggestion} instead."
-                " See https://modal.com/docs/guide/lifecycle-functions for more information."
-            )
-            deprecation_error((2024, 2, 21), message)
-
     partial_functions: dict[str, _PartialFunction] = {}
     for parent_cls in reversed(user_cls.mro()):
         if parent_cls is not object:
@@ -634,12 +611,6 @@ def _exit(_warn_parentheses_missing=None) -> Callable[[ExitHandlerType], _Partia
         if isinstance(f, _PartialFunction):
             _disallow_wrapping_method(f, "exit")
 
-        if callable_has_non_self_params(f):
-            message = (
-                "Support for decorating parameterized methods with `@exit` has been deprecated."
-                " Please update your code by removing the parameters."
-            )
-            deprecation_error((2024, 2, 23), message)
         return _PartialFunction(f, _PartialFunctionFlags.EXIT)
 
     return wrapper