modal 1.4.4.dev16__tar.gz → 1.4.4.dev18__tar.gz

{modal-1.4.4.dev16 → modal-1.4.4.dev18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.4.4.dev16
+Version: 1.4.4.dev18
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0

{modal-1.4.4.dev16 → modal-1.4.4.dev18}/modal/_container_entrypoint.py

@@ -28,7 +28,7 @@ from modal._clustered_functions import initialize_clustered_function
 from modal._runtime.user_code_event_loop import UserCodeEventLoop
 from modal._serialization import deserialize, deserialize_params
 from modal._utils.async_utils import TaskContext, aclosing, synchronizer
-from modal.app import App, _App
+from modal.app import _App
 from modal.client import Client, _Client
 from modal.config import logger
 from modal.exception import ExecutionError, InputCancellation
@@ -288,7 +288,7 @@ def get_serialized_user_class_and_function(
 
 
 def get_server_service(
-    container_args: api_pb2.ContainerArguments, function_def: api_pb2.Function, _client: _Client, client: Client
+    container_args: api_pb2.ContainerArguments, function_def: api_pb2.Function, _client: _Client
 ) -> Service:
     ser_usr_cls, ser_fun = get_serialized_user_class_and_function(function_def, _client)
     service_base_function_id = container_args.app_layout.function_ids[function_def.function_name]
@@ -298,14 +298,14 @@ def get_server_service(
     service = import_server_service(
         function_def,
         service_function_hydration_data,
-        client,
+        _client,
         ser_usr_cls,
     )
     return service
 
 
 def get_class_service(
-    container_args: api_pb2.ContainerArguments, function_def: api_pb2.Function, _client: _Client, client: Client
+    container_args: api_pb2.ContainerArguments, function_def: api_pb2.Function, _client: _Client
 ) -> Service:
     ser_usr_cls, ser_fun = get_serialized_user_class_and_function(function_def, _client)
     if container_args.serialized_params:
@@ -326,7 +326,7 @@ def get_class_service(
         function_def,
         service_function_hydration_data,
         class_id,
-        client,
+        _client,
         ser_usr_cls,
         param_args,
         param_kwargs,
@@ -349,16 +349,15 @@ def hydrate_function(
     task_lifecycle_manager: TaskLifecycleManager,
     function_def: api_pb2.Function,
     _client: _Client,
-    client: Client,
 ) -> Service:
     active_app: _App
     service: Service
     with task_lifecycle_manager.handle_task_lifecycle_exception():
         with execution_context._import_context():
             if function_def.is_server:
-                service = get_server_service(container_args, function_def, _client, client)
+                service = get_server_service(container_args, function_def, _client)
             elif function_def.is_class:
-                service = get_class_service(container_args, function_def, _client, client)
+                service = get_class_service(container_args, function_def, _client)
             else:
                 service = get_function_service(function_def, _client)
 
@@ -369,8 +368,7 @@ def hydrate_function(
 
     # Initialize objects on the app.
     # This is basically only functions and classes - anything else is deprecated and will be unsupported soon
-    app: App = cast(App, synchronizer._translate_out(active_app))
-    app._init_container(client, container_app)
+    active_app._init_container(_client, container_app)
 
     # Hydrate all function dependencies.
     # TODO(erikbern): we an remove this once we
@@ -406,7 +404,7 @@ def run_server(container_args: api_pb2.ContainerArguments, client: Client):
         client,
     )
 
-    service: Service = hydrate_function(container_args, task_lifecycle_manager, function_def, _client, client)
+    service: Service = hydrate_function(container_args, task_lifecycle_manager, function_def, _client)
     # Initialize clustered functions.
     if function_def._experimental_group_size > 0:
         initialize_clustered_function(
@@ -442,7 +440,7 @@ def run_function(container_args: api_pb2.ContainerArguments, client: Client):
     with container_io_manager.heartbeats(is_snapshotting_function), UserCodeEventLoop() as event_loop:
         # Initialize the function, importing user code.
         service: Service = hydrate_function(
-            container_args, container_io_manager.get_task_lifecycle_manager(), function_def, _client, client
+            container_args, container_io_manager.get_task_lifecycle_manager(), function_def, _client
         )
         if function_def.pty_info.pty_type == api_pb2.PTYInfo.PTY_TYPE_SHELL:
             # Concurrency and batching doesn't apply for `modal shell`.

{modal-1.4.4.dev16 → modal-1.4.4.dev18}/modal/_function_variants.py

@@ -185,6 +185,48 @@ class _FunctionOptions:
         )
 
 
+async def _function_bind_params_cached(
+    base_function: "_Function",
+    req: api_pb2.FunctionBindParamsRequest,
+) -> api_pb2.FunctionBindParamsResponse:
+    """Cache layer for FunctionBindParams RPCs, scoped to a base Function handle.
+
+    We have this because users probably do not realize that Function invocations structured as
+
+        res = f.with_options(...).remote(...)
+
+    would always need to do two sequential RPCs (bind params / call function variant).
+
+    The bound Function ID from FunctionBindParams is deterministic with respect to the full request,
+    so we can avoid the unnecessary call and hydrate the new instance from a cached response.
+
+    The cache is stored on the base Function handle so that the variant cache behaves similarly to
+    the local reference to the base Function metadata.
+
+    """
+    cache = base_function._bind_params_cache
+    cache_key = req.SerializeToString(deterministic=True)
+
+    cached_response = cache.get(cache_key)
+    if cached_response is not None:
+        cache.move_to_end(cache_key)
+        response = api_pb2.FunctionBindParamsResponse()
+        response.ParseFromString(cached_response)
+        return response
+
+    assert base_function._client and base_function._client.stub
+    response = await base_function._client.stub.FunctionBindParams(req)
+
+    cache[cache_key] = response.SerializeToString(deterministic=True)
+    cache.move_to_end(cache_key)
+
+    max_cache_size = 32
+    while len(cache) > max_cache_size:
+        cache.popitem(last=False)
+
+    return response
+
+
 def _make_function_variant(
     base_function: "_Function",
     options: _FunctionOptions | None,
@@ -229,7 +271,7 @@ def _make_function_variant(
             or "",  # TODO: investigate shouldn't environment name always be specified here?
         )
 
-        response = await base_function._client.stub.FunctionBindParams(req)
+        response = await _function_bind_params_cached(base_function, req)
         function_variant._hydrate(response.bound_function_id, base_function._client, response.handle_metadata)
 
     def _deps():

{modal-1.4.4.dev16 → modal-1.4.4.dev18}/modal/_functions.py

@@ -5,6 +5,7 @@ import inspect
 import time
 import typing
 import warnings
+from collections import OrderedDict
 from collections.abc import AsyncGenerator, AsyncIterator, Callable, Collection, Sequence
 from dataclasses import dataclass
 from pathlib import PurePosixPath
@@ -1208,6 +1209,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         app_name: str,
         name: str,
         *,
+        version: int | None = None,
         load_context_overrides: LoadContext,
     ):
         # internal function lookup implementation that allows lookup of class "service functions"
@@ -1219,6 +1221,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 app_name=app_name,
                 object_tag=name,
                 environment_name=load_context.environment_name,
+                app_version=version or 0,
             )
             try:
                 response = await load_context.client.stub.FunctionGet(request)
@@ -1251,6 +1254,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         app_name: str,
         name: str,
         *,
+        version: int | None = None,
         environment_name: str | None = None,
         client: _Client | None = None,
     ) -> "_Function":
@@ -1273,6 +1277,12 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             ```python
             f = modal.Function.from_name("other-app", "function")
             ```
+
+            The `version` parameter allows you to invoke a version-pinned function:
+
+            ```python
+            f_v3 = modal.Function.from_name("other-app", "function", version=3)
+            ```
         """
         if "." in name:
             raise InvalidError(
@@ -1281,7 +1291,10 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             )
 
         return cls._from_name(
-            app_name, name, load_context_overrides=LoadContext(environment_name=environment_name, client=client)
+            app_name,
+            name,
+            load_context_overrides=LoadContext(environment_name=environment_name, client=client),
+            version=version,
         )
 
     @property
@@ -1342,6 +1355,11 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         self._options = _FunctionOptions()
         self._base_function = None
 
+        # An OrderedDict[bytes, bytes] LRU of FunctionBindParams responses for
+        # variants derived from this base Function. Omitted from class-level annotations because
+        # Synchronicity doesn't understand OrderedDict as a type hint.
+        self._bind_params_cache = OrderedDict()
+
     def _hydrate_metadata(self, metadata: Message | None):
         # Overridden concrete implementation of base class method
         assert metadata and isinstance(metadata, api_pb2.FunctionHandleMetadata), (
@@ -1370,6 +1388,10 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         )
         self._experimental_flash_urls = metadata._experimental_flash_urls
 
+        # Invalidate the Function variant cache when we load new metadata, since the base Function handle
+        # is now in sync with the server but any previously-cached variants may be stale.
+        self._bind_params_cache.clear()
+
     def _get_metadata(self):
         # Overridden concrete implementation of base class method
         assert self._function_name, f"Function name must be set before metadata can be retrieved for {self}"

{modal-1.4.4.dev16 → modal-1.4.4.dev18}/modal/_image.py

@@ -60,6 +60,7 @@ from .secret import _Secret
 from .volume import _Volume, _volume_to_mount_proto
 
 if typing.TYPE_CHECKING:
+    import modal
     import modal._functions
     import modal.client
 
@@ -531,7 +532,7 @@ class _Image(_Object, type_prefix="im"):
 
         for secret in secrets:
             if not isinstance(secret, _Secret):
-                raise InvalidError("All secrets of an image needs to be modal.Secret/AioSecret instances")
+                raise InvalidError("All secrets of an Image need to be modal.Secret instances.")
 
         if build_function and len(base_images) != 1:
             raise InvalidError("Cannot run a build function with multiple base images!")
@@ -2763,7 +2764,7 @@ class _Image(_Object, type_prefix="im"):
 
     def pipe(
         self,
-        func: Callable[Concatenate["_Image", P], "_Image"],
+        func: Callable[Concatenate["modal.Image", P], "modal.Image"],
         *args: P.args,
         **kwargs: P.kwargs,
     ) -> "_Image":
@@ -2785,7 +2786,11 @@ class _Image(_Object, type_prefix="im"):
         )
         ```
         """
-        return func(self, *args, **kwargs)
+        # Typing here is complicated because user callables accept the public
+        # Image type, but `self` is an instance of the internal _Image type.
+        self_ = synchronizer._translate_out(self)
+        res = func(self_, *args, **kwargs)  # type: ignore[reportUnknownReturnType]
+        return typing.cast(_Image, synchronizer._translate_in(res))
 
     # Live handle methods
 

{modal-1.4.4.dev16 → modal-1.4.4.dev18}/modal/_object.py

@@ -14,7 +14,6 @@ from modal._traceback import suppress_tb_frame
 from ._load_context import LoadContext
 from ._resolver import Resolver
 from ._utils.async_utils import TaskContext, aclosing
-from ._utils.deprecation import deprecation_warning
 from .client import _Client
 from .config import config, logger
 from .exception import ExecutionError, InvalidError
@@ -196,23 +195,6 @@ class _Object:
                 f"{object_type} has not been hydrated with the metadata it needs to run on Modal{reason}."
             )
 
-    def clone(self) -> Self:
-        """mdmd:hidden Clone a given hydrated object.
-
-        Note: This is not intended to be public API and has no public use. It will be removed in a future release.
-        """
-        object_class = self.__class__.__name__.strip("_")
-        deprecation_warning(
-            (2025, 6, 30),
-            f"{object_class}.clone() is not intended to be public API and will be removed in a future release.",
-        )
-
-        # Object to clone must already be hydrated, otherwise from_loader is more suitable.
-        self._validate_is_hydrated()
-        obj = type(self).__new__(type(self))
-        obj._initialize_from_other(self)
-        return obj
-
     @classmethod
     def _from_loader(
         cls,

{modal-1.4.4.dev16 → modal-1.4.4.dev18}/modal/_runtime/user_code_imports.py

@@ -571,7 +571,7 @@ def import_class_service(
     function_def: api_pb2.Function,
     service_function_hydration_data: api_pb2.Object,
     class_id: str,
-    client: "modal.client.Client",
+    _client: "modal.client._Client",
     ser_user_cls: type | None,
     cls_args,
     cls_kwargs,
@@ -599,7 +599,6 @@ def import_class_service(
         # Undecorated user class (serialized or local scope-decoration).
         service_deps = None  # we can't infer service deps for now
         active_app = get_active_app_fallback(function_def)
-        _client = typing.cast("modal.client._Client", synchronizer._translate_in(client))
         _service_function: modal._functions._Function[Any, Any, Any] = modal._functions._Function._new_hydrated(
             service_function_hydration_data.object_id,
             _client,
@@ -627,7 +626,7 @@ def import_class_service(
 def import_server_service(
     function_def: api_pb2.Function,
     service_function_hydration_data: api_pb2.Object,
-    client: "modal.client.Client",
+    _client: "modal.client._Client",
     ser_user_cls: type | None,
 ) -> Service:
     """
@@ -654,7 +653,6 @@ def import_server_service(
         # Undecorated user class (serialized or local scope-decoration).
         service_deps = None  # we can't infer service deps for now
         active_app = get_active_app_fallback(function_def)
-        _client = typing.cast("modal.client._Client", synchronizer._translate_in(client))
         _service_function: modal._functions._Function[Any, Any, Any] = modal._functions._Function._new_hydrated(
             service_function_hydration_data.object_id,
             _client,

{modal-1.4.4.dev16 → modal-1.4.4.dev18}/modal/_utils/grpc_utils.py

@@ -153,7 +153,10 @@ class CustomProtoStatusDetailsCodec(StatusDetailsCodecBase):
         if details is not None:
             for detail in details:
                 detail_container = details_proto.details.add()
-                detail_container.Pack(detail)
+                if detail.DESCRIPTOR.full_name.startswith("modal."):
+                    detail_container.Pack(detail, type_url_prefix="type.modal.com/")
+                else:
+                    detail_container.Pack(detail)
         return details_proto.SerializeToString()
 
     def decode(

{modal-1.4.4.dev16 → modal-1.4.4.dev18}/modal/_utils/sandbox_fs_utils.py

@@ -285,6 +285,53 @@ def make_stat_command(remote_path: str) -> str:
     return json.dumps({"Stat": {"path": remote_path}})
 
 
+def raise_watch_error(returncode: int, stderr: str | bytes, remote_path: str) -> NoReturn:
+    if payload := try_parse_error_payload(stderr):
+        logger.debug(
+            f"sandbox-fs-tools watch error: path={remote_path}, "
+            f"error_kind={payload.error_kind}, message={payload.message}, detail={payload.detail}"
+        )
+        if payload.error_kind == "NotFound":
+            raise SandboxFilesystemNotFoundError(f"{payload.message}: {remote_path}")
+        if payload.error_kind == "PermissionDenied":
+            raise SandboxFilesystemPermissionError(f"{payload.message}: {remote_path}")
+        if payload.error_kind == "NotSupported":
+            raise InvalidError(
+                f"{payload.message}: {remote_path} - this operation is not supported for CloudBucketMounts"
+            )
+        raise SandboxFilesystemError(payload.message)
+
+    if stderr_text := _stderr_to_text(stderr):
+        logger.debug(f"Unstructured modal-sandbox-fs-tools stderr: {stderr_text}")
+    raise SandboxFilesystemError(f"Operation on '{remote_path}' failed with exit code {returncode}")
+
+
+def make_watch_command(
+    remote_path: str,
+    *,
+    recursive: bool,
+    filter: list[str] | None,
+    timeout: int | None,
+) -> str:
+    """Build the JSON command string for a Watch operation.
+
+    The returned JSON must match the `Command` enum in the modal-sandbox-fs-tools
+    Rust crate (crates/modal-sandbox-fs-tools/src/lib.rs). Treat changes to
+    this schema like protobuf changes: fields must not be removed or renamed,
+    only added with backwards-compatible defaults.
+    """
+    return json.dumps(
+        {
+            "Watch": {
+                "path": remote_path,
+                "recursive": recursive,
+                "filter": filter,
+                "timeout_secs": timeout,
+            }
+        }
+    )
+
+
 def validate_absolute_remote_path(remote_path: str, operation: str) -> None:
     if not PurePosixPath(remote_path).is_absolute():
         raise InvalidError(f"Sandbox.filesystem.{operation}() currently only supports absolute remote_path values")

{modal-1.4.4.dev16 → modal-1.4.4.dev18}/modal/billing.py

@@ -3,4 +3,8 @@ from ._billing import WorkspaceBillingReportItem, _workspace_billing_report
 from ._utils.async_utils import synchronize_api
 
 workspace_billing_report = synchronize_api(_workspace_billing_report)
-assert WorkspaceBillingReportItem
+
+__all__ = [
+    "workspace_billing_report",
+    "WorkspaceBillingReportItem",
+]

{modal-1.4.4.dev16 → modal-1.4.4.dev18}/modal/client.pyi

@@ -35,7 +35,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.4.4.dev16",
+        version: str = "1.4.4.dev18",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -205,7 +205,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.4.4.dev16",
+        version: str = "1.4.4.dev18",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.4.4.dev16 → modal-1.4.4.dev18}/modal/cls.py

@@ -641,6 +641,7 @@ More information on class parameterization can be found here: https://modal.com/
         app_name: str,
         name: str,
         *,
+        version: int | None = None,
         environment_name: str | None = None,
         client: "_Client | None" = None,
     ) -> "_Cls":
@@ -663,6 +664,12 @@ More information on class parameterization can be found here: https://modal.com/
             ```python
             Model = modal.Cls.from_name("other-app", "Model")
             ```
+
+            The `version` parameter constructs a version-pinned Cls:
+
+            ```python
+            Modelv3 = modal.Cls.from_name("other-app", "Model", version=3)
+            ```
         """
 
         async def _load_remote(
@@ -705,6 +712,7 @@ More information on class parameterization can be found here: https://modal.com/
             app_name,
             class_service_name,
             load_context_overrides=load_context_overrides,
+            version=version,
         )
         cls._name = name
         return cls

{modal-1.4.4.dev16 → modal-1.4.4.dev18}/modal/cls.pyi

@@ -291,6 +291,7 @@ class _Cls(modal._object._Object):
         app_name: str,
         name: str,
         *,
+        version: typing.Optional[int] = None,
         environment_name: typing.Optional[str] = None,
         client: typing.Optional[modal.client._Client] = None,
     ) -> _Cls:
@@ -313,6 +314,12 @@ class _Cls(modal._object._Object):
             ```python
             Model = modal.Cls.from_name("other-app", "Model")
             ```
+
+            The `version` parameter constructs a version-pinned Cls:
+
+            ```python
+            Modelv3 = modal.Cls.from_name("other-app", "Model", version=3)
+            ```
         """
         ...
 
@@ -498,6 +505,7 @@ class Cls(modal.object.Object):
         app_name: str,
         name: str,
         *,
+        version: typing.Optional[int] = None,
         environment_name: typing.Optional[str] = None,
         client: typing.Optional[modal.client.Client] = None,
     ) -> Cls:
@@ -520,6 +528,12 @@ class Cls(modal.object.Object):
             ```python
             Model = modal.Cls.from_name("other-app", "Model")
             ```
+
+            The `version` parameter constructs a version-pinned Cls:
+
+            ```python
+            Modelv3 = modal.Cls.from_name("other-app", "Model", version=3)
+            ```
         """
         ...
 

{modal-1.4.4.dev16 → modal-1.4.4.dev18}/modal/dict.py

@@ -23,7 +23,6 @@ from ._object import (
 from ._resolver import Resolver
 from ._serialization import deserialize, serialize
 from ._utils.async_utils import TaskContext, synchronize_api
-from ._utils.deprecation import deprecation_warning
 from ._utils.name_utils import check_object_name
 from ._utils.time_utils import as_timestamp, timestamp_to_localized_dt
 from .client import _Client
@@ -482,26 +481,6 @@ class _Dict(_Object, type_prefix="di"):
             load_context_overrides=LoadContext(client=client),
         )
 
-    @staticmethod
-    async def delete(
-        name: str,
-        *,
-        client: _Client | None = None,
-        environment_name: str | None = None,
-    ):
-        """mdmd:hidden
-        Delete a named Dict object.
-
-        Warning: This deletes an *entire Dict*, not just a specific key.
-        Deletion is irreversible and will affect any Apps currently using the Dict.
-
-        DEPRECATED: This method is deprecated; we recommend using `modal.Dict.objects.delete` instead.
-        """
-        deprecation_warning(
-            (2025, 8, 6), "`modal.Dict.delete` is deprecated; we recommend using `modal.Dict.objects.delete` instead."
-        )
-        await _Dict.objects.delete(name, environment_name=environment_name, client=client)
-
     @live_method
     async def info(self) -> DictInfo:
         """Return information about the Dict object."""

{modal-1.4.4.dev16 → modal-1.4.4.dev18}/modal/dict.pyi

@@ -576,23 +576,6 @@ class _Dict(modal._object._Object):
         """
         ...
 
-    @staticmethod
-    async def delete(
-        name: str,
-        *,
-        client: typing.Optional[modal.client._Client] = None,
-        environment_name: typing.Optional[str] = None,
-    ):
-        """mdmd:hidden
-        Delete a named Dict object.
-
-        Warning: This deletes an *entire Dict*, not just a specific key.
-        Deletion is irreversible and will affect any Apps currently using the Dict.
-
-        DEPRECATED: This method is deprecated; we recommend using `modal.Dict.objects.delete` instead.
-        """
-        ...
-
     async def info(self) -> DictInfo:
         """Return information about the Dict object."""
         ...
@@ -877,45 +860,6 @@ class Dict(modal.object.Object):
         """
         ...
 
-    class __delete_spec(typing_extensions.Protocol):
-        def __call__(
-            self,
-            /,
-            name: str,
-            *,
-            client: typing.Optional[modal.client.Client] = None,
-            environment_name: typing.Optional[str] = None,
-        ):
-            """mdmd:hidden
-            Delete a named Dict object.
-
-            Warning: This deletes an *entire Dict*, not just a specific key.
-            Deletion is irreversible and will affect any Apps currently using the Dict.
-
-            DEPRECATED: This method is deprecated; we recommend using `modal.Dict.objects.delete` instead.
-            """
-            ...
-
-        async def aio(
-            self,
-            /,
-            name: str,
-            *,
-            client: typing.Optional[modal.client.Client] = None,
-            environment_name: typing.Optional[str] = None,
-        ):
-            """mdmd:hidden
-            Delete a named Dict object.
-
-            Warning: This deletes an *entire Dict*, not just a specific key.
-            Deletion is irreversible and will affect any Apps currently using the Dict.
-
-            DEPRECATED: This method is deprecated; we recommend using `modal.Dict.objects.delete` instead.
-            """
-            ...
-
-    delete: typing.ClassVar[__delete_spec]
-
     class __info_spec(typing_extensions.Protocol):
         def __call__(self, /) -> DictInfo:
             """Return information about the Dict object."""

{modal-1.4.4.dev16 → modal-1.4.4.dev18}/modal/file_io.py

@@ -1,10 +1,8 @@
 # Copyright Modal Labs 2024
 import asyncio
-import enum
 import io
 from collections.abc import AsyncIterator, Sequence
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Generic, TypeVar, Union, cast
+from typing import TYPE_CHECKING, Generic, Optional, TypeVar, Union, cast
 
 if TYPE_CHECKING:
     import _typeshed
@@ -15,6 +13,7 @@ from grpclib.exceptions import StreamTerminatedError
 
 from modal._utils.async_utils import TaskContext
 from modal.exception import ClientClosed
+from modal.sandbox_fs import FileWatchEvent, FileWatchEventType
 from modal_proto import api_pb2
 
 from ._utils.async_utils import synchronize_api
@@ -60,21 +59,7 @@ async def _replace_bytes(file: "_FileIO", data: bytes, start: int | None = None,
     deprecation_error((2025, 12, 3), "replace_bytes has been removed.")
 
 
-class FileWatchEventType(enum.Enum):
-    Unknown = "Unknown"
-    Access = "Access"
-    Create = "Create"
-    Modify = "Modify"
-    Remove = "Remove"
-
-
-@dataclass
-class FileWatchEvent:
-    paths: list[str]
-    type: FileWatchEventType
-
-
-async def _consume_output(client: _Client, exec_id: str) -> AsyncIterator[bytes | None | Exception]:
+async def _consume_output(client: _Client, exec_id: str) -> AsyncIterator[Optional[bytes] | Exception]:
     req = api_pb2.ContainerFilesystemExecGetOutputRequest(
         exec_id=exec_id,
         timeout=55,
@@ -424,7 +409,7 @@ class _FileIO(Generic[T]):
     ) -> AsyncIterator[FileWatchEvent]:
         deprecation_warning(
             (2026, 3, 9),
-            "`FileIO.watch()` is deprecated. Use `Sandbox.watch()` instead.",
+            "`FileIO.watch()` is deprecated. Use `Sandbox.filesystem.watch()` instead.",
         )
         async for event in watch(path, client, task_id, filter, recursive, timeout):
             yield event