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

modal/file_io.pyi

@@ -1,4 +1,5 @@
 import _typeshed
+import enum
 import modal.client
 import modal_proto.api_pb2
 import typing
@@ -13,14 +14,33 @@ async def _replace_bytes(
     file: _FileIO, data: bytes, start: typing.Optional[int] = None, end: typing.Optional[int] = None
 ) -> None: ...
 
+class FileWatchEventType(enum.Enum):
+    Unknown = "Unknown"
+    Access = "Access"
+    Create = "Create"
+    Modify = "Modify"
+    Remove = "Remove"
+
+class FileWatchEvent:
+    paths: list[str]
+    type: FileWatchEventType
+
+    def __init__(self, paths: list[str], type: FileWatchEventType) -> None: ...
+    def __repr__(self): ...
+    def __eq__(self, other): ...
+
 class _FileIO(typing.Generic[T]):
     _task_id: str
     _file_descriptor: str
     _client: typing.Optional[modal.client._Client]
+    _watch_output_buffer: list[typing.Optional[bytes]]
 
     def _validate_mode(self, mode: str) -> None: ...
     def _handle_error(self, error: modal_proto.api_pb2.SystemErrorMessage) -> None: ...
     def _consume_output(self, exec_id: str) -> typing.AsyncIterator[typing.Optional[bytes]]: ...
+    async def _consume_watch_output(self, exec_id: str) -> None: ...
+    async def _parse_watch_output(self, event: bytes) -> typing.Optional[FileWatchEvent]: ...
+    def _stream_watch_output(self) -> typing.AsyncIterator[FileWatchEvent]: ...
     async def _wait(self, exec_id: str) -> bytes: ...
     def _validate_type(self, data: typing.Union[bytes, str]) -> None: ...
     async def _open_file(self, path: str, mode: str) -> None: ...
@@ -49,6 +69,16 @@ class _FileIO(typing.Generic[T]):
     async def mkdir(cls, path: str, client: modal.client._Client, task_id: str, parents: bool = False) -> None: ...
     @classmethod
     async def rm(cls, path: str, client: modal.client._Client, task_id: str, recursive: bool = False) -> None: ...
+    @classmethod
+    def watch(
+        cls,
+        path: str,
+        client: modal.client._Client,
+        task_id: str,
+        filter: typing.Optional[list[FileWatchEventType]] = None,
+        recursive: bool = False,
+        timeout: typing.Optional[int] = None,
+    ) -> typing.AsyncIterator[FileWatchEvent]: ...
     async def _close(self) -> None: ...
     async def close(self) -> None: ...
     def _check_writable(self) -> None: ...
@@ -79,6 +109,7 @@ class FileIO(typing.Generic[T]):
     _task_id: str
     _file_descriptor: str
     _client: typing.Optional[modal.client.Client]
+    _watch_output_buffer: list[typing.Optional[bytes]]
 
     def __init__(self, /, *args, **kwargs): ...
     def _validate_mode(self, mode: str) -> None: ...
@@ -90,6 +121,24 @@ class FileIO(typing.Generic[T]):
 
     _consume_output: ___consume_output_spec
 
+    class ___consume_watch_output_spec(typing_extensions.Protocol):
+        def __call__(self, exec_id: str) -> None: ...
+        async def aio(self, exec_id: str) -> None: ...
+
+    _consume_watch_output: ___consume_watch_output_spec
+
+    class ___parse_watch_output_spec(typing_extensions.Protocol):
+        def __call__(self, event: bytes) -> typing.Optional[FileWatchEvent]: ...
+        async def aio(self, event: bytes) -> typing.Optional[FileWatchEvent]: ...
+
+    _parse_watch_output: ___parse_watch_output_spec
+
+    class ___stream_watch_output_spec(typing_extensions.Protocol):
+        def __call__(self) -> typing.Iterator[FileWatchEvent]: ...
+        def aio(self) -> typing.AsyncIterator[FileWatchEvent]: ...
+
+    _stream_watch_output: ___stream_watch_output_spec
+
     class ___wait_spec(typing_extensions.Protocol):
         def __call__(self, exec_id: str) -> bytes: ...
         async def aio(self, exec_id: str) -> bytes: ...
@@ -173,6 +222,16 @@ class FileIO(typing.Generic[T]):
     def mkdir(cls, path: str, client: modal.client.Client, task_id: str, parents: bool = False) -> None: ...
     @classmethod
     def rm(cls, path: str, client: modal.client.Client, task_id: str, recursive: bool = False) -> None: ...
+    @classmethod
+    def watch(
+        cls,
+        path: str,
+        client: modal.client.Client,
+        task_id: str,
+        filter: typing.Optional[list[FileWatchEventType]] = None,
+        recursive: bool = False,
+        timeout: typing.Optional[int] = None,
+    ) -> typing.Iterator[FileWatchEvent]: ...
 
     class ___close_spec(typing_extensions.Protocol):
         def __call__(self) -> None: ...

modal/file_pattern_matcher.py

@@ -12,7 +12,7 @@ then asking it whether file paths match any of its patterns.
 import os
 from abc import abstractmethod
 from pathlib import Path
-from typing import Callable, Optional
+from typing import Callable, Optional, Sequence, Union
 
 from ._utils.pattern_utils import Pattern
 
@@ -152,3 +152,13 @@ class FilePatternMatcher(_AbstractPatternMatcher):
 # with_repr allows us to use this matcher as a default value in a function signature
 #  and get a nice repr in the docs and auto-generated type stubs:
 NON_PYTHON_FILES = (~FilePatternMatcher("**/*.py")).with_repr(f"{__name__}.NON_PYTHON_FILES")
+_NOTHING = (~FilePatternMatcher()).with_repr(f"{__name__}._NOTHING")  # match everything = ignore nothing
+
+
+def _ignore_fn(ignore: Union[Sequence[str], Callable[[Path], bool]]) -> Callable[[Path], bool]:
+    # if a callable is passed, return it
+    # otherwise, treat input as a sequence of patterns and return a callable pattern matcher for those
+    if callable(ignore):
+        return ignore
+
+    return FilePatternMatcher(*ignore)

modal/functions.py

@@ -59,7 +59,14 @@ from .call_graph import InputInfo, _reconstruct_call_graph
 from .client import _Client
 from .cloud_bucket_mount import _CloudBucketMount, cloud_bucket_mounts_to_proto
 from .config import config
-from .exception import ExecutionError, FunctionTimeoutError, InvalidError, NotFoundError, OutputExpiredError
+from .exception import (
+    ExecutionError,
+    FunctionTimeoutError,
+    InternalFailure,
+    InvalidError,
+    NotFoundError,
+    OutputExpiredError,
+)
 from .gpu import GPU_T, parse_gpu_config
 from .image import _Image
 from .mount import _get_client_mount, _Mount, get_auto_mounts
@@ -174,7 +181,7 @@ class _Invocation:
         return _Invocation(client.stub, function_call_id, client, retry_context)
 
     async def pop_function_call_outputs(
-        self, timeout: Optional[float], clear_on_success: bool
+        self, timeout: Optional[float], clear_on_success: bool, input_jwts: Optional[list[str]] = None
     ) -> api_pb2.FunctionGetOutputsResponse:
         t0 = time.time()
         if timeout is None:
@@ -190,6 +197,7 @@ class _Invocation:
                 last_entry_id="0-0",
                 clear_on_success=clear_on_success,
                 requested_at=time.time(),
+                input_jwts=input_jwts,
             )
             response: api_pb2.FunctionGetOutputsResponse = await retry_transient_errors(
                 self.stub.FunctionGetOutputs,
@@ -219,10 +227,14 @@ class _Invocation:
             request,
         )
 
-    async def _get_single_output(self) -> Any:
+    async def _get_single_output(self, expected_jwt: Optional[str] = None) -> Any:
         # waits indefinitely for a single result for the function, and clear the outputs buffer after
         item: api_pb2.FunctionGetOutputsItem = (
-            await self.pop_function_call_outputs(timeout=None, clear_on_success=True)
+            await self.pop_function_call_outputs(
+                timeout=None,
+                clear_on_success=True,
+                input_jwts=[expected_jwt] if expected_jwt else None,
+            )
         ).outputs[0]
         return await _process_result(item.result, item.data_format, self.stub, self.client)
 
@@ -242,9 +254,12 @@ class _Invocation:
 
         while True:
             try:
-                return await self._get_single_output()
+                return await self._get_single_output(ctx.input_jwt)
             except (UserCodeException, FunctionTimeoutError) as exc:
                 await user_retry_manager.raise_or_sleep(exc)
+            except InternalFailure:
+                # For system failures on the server, we retry immediately.
+                pass
             await self._retry_input()
 
     async def poll_function(self, timeout: Optional[float] = None):

modal/functions.pyi

@@ -61,10 +61,10 @@ class _Invocation:
         function: _Function, args, kwargs, *, client: modal.client._Client, function_call_invocation_type: int
     ) -> _Invocation: ...
     async def pop_function_call_outputs(
-        self, timeout: typing.Optional[float], clear_on_success: bool
+        self, timeout: typing.Optional[float], clear_on_success: bool, input_jwts: typing.Optional[list[str]] = None
     ) -> modal_proto.api_pb2.FunctionGetOutputsResponse: ...
     async def _retry_input(self) -> None: ...
-    async def _get_single_output(self) -> typing.Any: ...
+    async def _get_single_output(self, expected_jwt: typing.Optional[str] = None) -> typing.Any: ...
     async def run_function(self) -> typing.Any: ...
     async def poll_function(self, timeout: typing.Optional[float] = None): ...
     def run_generator(self): ...

modal/image.py

@@ -31,6 +31,9 @@ from ._serialization import serialize
 from ._utils.async_utils import synchronize_api
 from ._utils.blob_utils import MAX_OBJECT_SIZE_BYTES
 from ._utils.deprecation import deprecation_error, deprecation_warning
+from ._utils.docker_utils import (
+    extract_copy_command_patterns,
+)
 from ._utils.function_utils import FunctionInfo
 from ._utils.grpc_utils import RETRYABLE_GRPC_STATUS_CODES, retry_transient_errors
 from .client import _Client
@@ -38,7 +41,7 @@ from .cloud_bucket_mount import _CloudBucketMount
 from .config import config, logger, user_config_path
 from .environments import _get_environment_cached
 from .exception import InvalidError, NotFoundError, RemoteError, VersionError
-from .file_pattern_matcher import NON_PYTHON_FILES
+from .file_pattern_matcher import NON_PYTHON_FILES, FilePatternMatcher, _ignore_fn
 from .gpu import GPU_T, parse_gpu_config
 from .mount import _Mount, python_standalone_mount_name
 from .network_file_system import _NetworkFileSystem
@@ -236,6 +239,33 @@ def _get_image_builder_version(server_version: ImageBuilderVersion) -> ImageBuil
     return version
 
 
+def _create_context_mount(
+    docker_commands: Sequence[str],
+    ignore_fn: Callable[[Path], bool],
+    context_dir: Path,
+) -> Optional[_Mount]:
+    """
+    Creates a context mount from a list of docker commands.
+
+    1. Paths are evaluated relative to context_dir.
+    2. First selects inclusions based on COPY commands in the list of commands.
+    3. Then ignore any files as per the ignore predicate.
+    """
+    copy_patterns = extract_copy_command_patterns(docker_commands)
+    if not copy_patterns:
+        return None  # no mount needed
+    include_fn = FilePatternMatcher(*copy_patterns)
+
+    def ignore_with_include(source: Path) -> bool:
+        relative_source = source.relative_to(context_dir)
+        if not include_fn(relative_source) or ignore_fn(relative_source):
+            return True
+
+        return False
+
+    return _Mount._add_local_dir(Path("./"), PurePosixPath("/"), ignore=ignore_with_include)
+
+
 class _ImageRegistryConfig:
     """mdmd:hidden"""
 
@@ -396,7 +426,7 @@ class _Image(_Object, type_prefix="im"):
         build_function: Optional["modal.functions._Function"] = None,
         build_function_input: Optional[api_pb2.FunctionInput] = None,
         image_registry_config: Optional[_ImageRegistryConfig] = None,
-        context_mount: Optional[_Mount] = None,
+        context_mount_function: Optional[Callable[[], Optional[_Mount]]] = None,
         force_build: bool = False,
         # For internal use only.
         _namespace: "api_pb2.DeploymentNamespace.ValueType" = api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
@@ -423,13 +453,15 @@ class _Image(_Object, type_prefix="im"):
             deps = tuple(base_images.values()) + tuple(secrets)
             if build_function:
                 deps += (build_function,)
-            if context_mount:
-                deps += (context_mount,)
             if image_registry_config and image_registry_config.secret:
                 deps += (image_registry_config.secret,)
             return deps
 
         async def _load(self: _Image, resolver: Resolver, existing_object_id: Optional[str]):
+            context_mount = context_mount_function() if context_mount_function else None
+            if context_mount:
+                await resolver.load(context_mount)
+
             if _do_assert_no_mount_layers:
                 for image in base_images.values():
                     # base images can't have
@@ -596,7 +628,7 @@ class _Image(_Object, type_prefix="im"):
         return _Image._from_args(
             base_images={"base": self},
             dockerfile_function=build_dockerfile,
-            context_mount=mount,
+            context_mount_function=lambda: mount,
         )
 
     def add_local_file(self, local_path: Union[str, Path], remote_path: str, *, copy: bool = False) -> "_Image":
@@ -684,7 +716,7 @@ class _Image(_Object, type_prefix="im"):
             #  + make default remote_path="./"
             raise InvalidError("image.add_local_dir() currently only supports absolute remote_path values")
 
-        mount = _Mount._add_local_dir(Path(local_path), Path(remote_path), ignore)
+        mount = _Mount._add_local_dir(Path(local_path), PurePosixPath(remote_path), ignore=_ignore_fn(ignore))
         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":
@@ -695,7 +727,6 @@ class _Image(_Object, type_prefix="im"):
         """
         # 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}")
 
         def build_dockerfile(version: ImageBuilderVersion) -> DockerfileSpec:
             return DockerfileSpec(commands=["FROM base", f"COPY {basename} {remote_path}"], context_files={})
@@ -703,7 +734,7 @@ class _Image(_Object, type_prefix="im"):
         return _Image._from_args(
             base_images={"base": self},
             dockerfile_function=build_dockerfile,
-            context_mount=mount,
+            context_mount_function=lambda: _Mount.from_local_file(local_path, remote_path=f"/{basename}"),
         )
 
     def add_local_python_source(
@@ -790,15 +821,15 @@ class _Image(_Object, type_prefix="im"):
         ```
         """
 
-        mount = _Mount._add_local_dir(Path(local_path), Path("/"), ignore)
-
         def build_dockerfile(version: ImageBuilderVersion) -> DockerfileSpec:
             return DockerfileSpec(commands=["FROM base", f"COPY . {remote_path}"], context_files={})
 
         return _Image._from_args(
             base_images={"base": self},
             dockerfile_function=build_dockerfile,
-            context_mount=mount,
+            context_mount_function=lambda: _Mount._add_local_dir(
+                Path(local_path), PurePosixPath("/"), ignore=_ignore_fn(ignore)
+            ),
         )
 
     def pip_install(
@@ -1156,12 +1187,29 @@ class _Image(_Object, type_prefix="im"):
         # modal.Mount with local files to supply as build context for COPY commands
         context_mount: Optional[_Mount] = None,
         force_build: bool = False,  # Ignore cached builds, similar to 'docker build --no-cache'
+        ignore: Union[Sequence[str], Callable[[Path], bool]] = (),
     ) -> "_Image":
         """Extend an image with arbitrary Dockerfile-like commands."""
         cmds = _flatten_str_args("dockerfile_commands", "dockerfile_commands", dockerfile_commands)
         if not cmds:
             return self
 
+        if context_mount:
+            if ignore:
+                raise InvalidError("Cannot set both `context_mount` and `ignore`")
+
+            def identity_context_mount_fn() -> Optional[_Mount]:
+                return context_mount
+
+            context_mount_function = identity_context_mount_fn
+        else:
+
+            def auto_created_context_mount_fn() -> Optional[_Mount]:
+                # use COPY commands and ignore patterns to construct implicit context mount
+                return _create_context_mount(cmds, ignore_fn=_ignore_fn(ignore), context_dir=Path.cwd())
+
+            context_mount_function = auto_created_context_mount_fn
+
         def build_dockerfile(version: ImageBuilderVersion) -> DockerfileSpec:
             return DockerfileSpec(commands=["FROM base", *cmds], context_files=context_files)
 
@@ -1170,7 +1218,7 @@ class _Image(_Object, type_prefix="im"):
             dockerfile_function=build_dockerfile,
             secrets=secrets,
             gpu_config=parse_gpu_config(gpu),
-            context_mount=context_mount,
+            context_mount_function=context_mount_function,
             force_build=self.force_build or force_build,
         )
 
@@ -1400,11 +1448,15 @@ class _Image(_Object, type_prefix="im"):
         modal.Image.from_registry("nvcr.io/nvidia/pytorch:22.12-py3")
         ```
         """
-        context_mount = None
-        if add_python:
-            context_mount = _Mount.from_name(
-                python_standalone_mount_name(add_python),
-                namespace=api_pb2.DEPLOYMENT_NAMESPACE_GLOBAL,
+
+        def context_mount_function() -> Optional[_Mount]:
+            return (
+                _Mount.from_name(
+                    python_standalone_mount_name(add_python),
+                    namespace=api_pb2.DEPLOYMENT_NAMESPACE_GLOBAL,
+                )
+                if add_python
+                else None
             )
 
         if "image_registry_config" not in kwargs and secret is not None:
@@ -1417,7 +1469,7 @@ class _Image(_Object, type_prefix="im"):
 
         return _Image._from_args(
             dockerfile_function=build_dockerfile,
-            context_mount=context_mount,
+            context_mount_function=context_mount_function,
             force_build=force_build,
             **kwargs,
         )
@@ -1531,6 +1583,7 @@ class _Image(_Object, type_prefix="im"):
         secrets: Sequence[_Secret] = [],
         gpu: GPU_T = None,
         add_python: Optional[str] = None,
+        ignore: Union[Sequence[str], Callable[[Path], bool]] = (),
     ) -> "_Image":
         """Build a Modal image from a local Dockerfile.
 
@@ -1542,22 +1595,23 @@ class _Image(_Object, type_prefix="im"):
         ```python
         image = modal.Image.from_dockerfile("./Dockerfile", add_python="3.12")
         ```
+        """
 
-        If your Dockerfile uses `COPY` instructions which copy data from the local context of the
-        build into the image, this local data must be uploaded to Modal via a context mount:
+        if context_mount:
+            if ignore:
+                raise InvalidError("Cannot set both `context_mount` and `ignore`")
 
-        ```python
-        image = modal.Image.from_dockerfile(
-            "./Dockerfile",
-            context_mount=modal.Mount.from_local_dir(
-                local_path="src",
-                remote_path=".",  # to current WORKDIR
-            ),
-        )
-        ```
+            def identity_context_mount_fn() -> Optional[_Mount]:
+                return context_mount
 
-        The context mount will allow a `COPY src/ src/` instruction to succeed in Modal's remote builder.
-        """
+            context_mount_function = identity_context_mount_fn
+        else:
+
+            def auto_created_context_mount_fn() -> Optional[_Mount]:
+                lines = Path(path).read_text("utf8").splitlines()
+                return _create_context_mount(lines, ignore_fn=_ignore_fn(ignore), context_dir=Path.cwd())
+
+            context_mount_function = auto_created_context_mount_fn
 
         # --- Build the base dockerfile
 
@@ -1569,7 +1623,7 @@ class _Image(_Object, type_prefix="im"):
         gpu_config = parse_gpu_config(gpu)
         base_image = _Image._from_args(
             dockerfile_function=build_dockerfile_base,
-            context_mount=context_mount,
+            context_mount_function=context_mount_function,
             gpu_config=gpu_config,
             secrets=secrets,
         )
@@ -1578,13 +1632,15 @@ class _Image(_Object, type_prefix="im"):
         # This happening in two steps is probably a vestigial consequence of previous limitations,
         # but it will be difficult to merge them without forcing rebuilds of images.
 
-        if add_python:
-            context_mount = _Mount.from_name(
-                python_standalone_mount_name(add_python),
-                namespace=api_pb2.DEPLOYMENT_NAMESPACE_GLOBAL,
+        def add_python_mount():
+            return (
+                _Mount.from_name(
+                    python_standalone_mount_name(add_python),
+                    namespace=api_pb2.DEPLOYMENT_NAMESPACE_GLOBAL,
+                )
+                if add_python
+                else None
             )
-        else:
-            context_mount = None
 
         def build_dockerfile_python(version: ImageBuilderVersion) -> DockerfileSpec:
             commands = _Image._registry_setup_commands("base", version, [], add_python)
@@ -1595,7 +1651,7 @@ class _Image(_Object, type_prefix="im"):
         return _Image._from_args(
             base_images={"base": base_image},
             dockerfile_function=build_dockerfile_python,
-            context_mount=context_mount,
+            context_mount_function=add_python_mount,
             force_build=force_build,
         )
 

modal/image.pyi

@@ -44,6 +44,11 @@ def _make_pip_install_args(
 def _get_image_builder_version(
     server_version: typing.Literal["2023.12", "2024.04", "2024.10"],
 ) -> typing.Literal["2023.12", "2024.04", "2024.10"]: ...
+def _create_context_mount(
+    docker_commands: collections.abc.Sequence[str],
+    ignore_fn: typing.Callable[[pathlib.Path], bool],
+    context_dir: pathlib.Path,
+) -> typing.Optional[modal.mount._Mount]: ...
 
 class _ImageRegistryConfig:
     def __init__(self, registry_auth_type: int = 0, secret: typing.Optional[modal.secret._Secret] = None): ...
@@ -87,7 +92,7 @@ class _Image(modal.object._Object):
         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,
+        context_mount_function: typing.Optional[typing.Callable[[], typing.Optional[modal.mount._Mount]]] = None,
         force_build: bool = False,
         _namespace: int = 1,
         _do_assert_no_mount_layers: bool = True,
@@ -195,6 +200,7 @@ class _Image(modal.object._Object):
         gpu: typing.Union[None, bool, str, modal.gpu._GPUConfig] = None,
         context_mount: typing.Optional[modal.mount._Mount] = None,
         force_build: bool = False,
+        ignore: typing.Union[collections.abc.Sequence[str], typing.Callable[[pathlib.Path], bool]] = (),
     ) -> _Image: ...
     def entrypoint(self, entrypoint_commands: list[str]) -> _Image: ...
     def shell(self, shell_commands: list[str]) -> _Image: ...
@@ -280,6 +286,7 @@ class _Image(modal.object._Object):
         secrets: collections.abc.Sequence[modal.secret._Secret] = [],
         gpu: typing.Union[None, bool, str, modal.gpu._GPUConfig] = None,
         add_python: typing.Optional[str] = None,
+        ignore: typing.Union[collections.abc.Sequence[str], typing.Callable[[pathlib.Path], bool]] = (),
     ) -> _Image: ...
     @staticmethod
     def debian_slim(python_version: typing.Optional[str] = None, force_build: bool = False) -> _Image: ...
@@ -346,7 +353,7 @@ class Image(modal.object.Object):
         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,
+        context_mount_function: typing.Optional[typing.Callable[[], typing.Optional[modal.mount.Mount]]] = None,
         force_build: bool = False,
         _namespace: int = 1,
         _do_assert_no_mount_layers: bool = True,
@@ -454,6 +461,7 @@ class Image(modal.object.Object):
         gpu: typing.Union[None, bool, str, modal.gpu._GPUConfig] = None,
         context_mount: typing.Optional[modal.mount.Mount] = None,
         force_build: bool = False,
+        ignore: typing.Union[collections.abc.Sequence[str], typing.Callable[[pathlib.Path], bool]] = (),
     ) -> Image: ...
     def entrypoint(self, entrypoint_commands: list[str]) -> Image: ...
     def shell(self, shell_commands: list[str]) -> Image: ...
@@ -539,6 +547,7 @@ class Image(modal.object.Object):
         secrets: collections.abc.Sequence[modal.secret.Secret] = [],
         gpu: typing.Union[None, bool, str, modal.gpu._GPUConfig] = None,
         add_python: typing.Optional[str] = None,
+        ignore: typing.Union[collections.abc.Sequence[str], typing.Callable[[pathlib.Path], bool]] = (),
     ) -> Image: ...
     @staticmethod
     def debian_slim(python_version: typing.Optional[str] = None, force_build: bool = False) -> Image: ...

modal/io_streams.py

@@ -14,7 +14,8 @@ from typing import (
 from grpclib import Status
 from grpclib.exceptions import GRPCError, StreamTerminatedError
 
-from modal.exception import ClientClosed, InvalidError
+from modal.exception import InvalidError
+from modal.io_streams_helper import consume_stream_with_retries
 from modal_proto import api_pb2
 
 from ._utils.async_utils import synchronize_api
@@ -176,34 +177,21 @@ class _StreamReader(Generic[T]):
         if self._stream_type == StreamType.DEVNULL:
             return
 
-        completed = False
-        retries_remaining = 10
-        while not completed:
-            try:
-                iterator = _container_process_logs_iterator(self._object_id, self._file_descriptor, self._client)
+        def item_handler(item: Optional[bytes]):
+            if self._stream_type == StreamType.STDOUT and item is not None:
+                print(item.decode("utf-8"), end="")
+            elif self._stream_type == StreamType.PIPE:
+                self._container_process_buffer.append(item)
 
-                async for message in iterator:
-                    if self._stream_type == StreamType.STDOUT and message:
-                        print(message.decode("utf-8"), end="")
-                    elif self._stream_type == StreamType.PIPE:
-                        self._container_process_buffer.append(message)
-                    if message is None:
-                        completed = True
-                        break
+        def completion_check(item: Optional[bytes]):
+            return item is None
 
-            except (GRPCError, StreamTerminatedError, ClientClosed) as exc:
-                if retries_remaining > 0:
-                    retries_remaining -= 1
-                    if isinstance(exc, GRPCError):
-                        if exc.status in RETRYABLE_GRPC_STATUS_CODES:
-                            await asyncio.sleep(1.0)
-                            continue
-                    elif isinstance(exc, StreamTerminatedError):
-                        continue
-                    elif isinstance(exc, ClientClosed):
-                        # If the client was closed, the user has triggered a cleanup.
-                        break
-                raise exc
+        iterator = _container_process_logs_iterator(self._object_id, self._file_descriptor, self._client)
+        await consume_stream_with_retries(
+            iterator,
+            item_handler,
+            completion_check,
+        )
 
     async def _stream_container_process(self) -> AsyncGenerator[tuple[Optional[bytes], str], None]:
         """Streams the container process buffer to the reader."""

modal/io_streams_helper.py

@@ -0,0 +1,53 @@
+# Copyright Modal Labs 2024
+import asyncio
+from typing import AsyncIterator, Callable, TypeVar
+
+from grpclib.exceptions import GRPCError, StreamTerminatedError
+
+from modal.exception import ClientClosed
+
+from ._utils.grpc_utils import RETRYABLE_GRPC_STATUS_CODES
+
+T = TypeVar("T")
+
+
+async def consume_stream_with_retries(
+    stream: AsyncIterator[T],
+    item_handler: Callable[[T], None],
+    completion_check: Callable[[T], bool],
+    max_retries: int = 10,
+    retry_delay: float = 1.0,
+) -> None:
+    """mdmd:hidden
+    Helper function to consume a stream with retry logic for transient errors.
+
+    Args:
+        stream_generator: Function that returns an AsyncIterator to consume
+        item_handler: Callback function to handle each item from the stream
+        completion_check: Callback function to check if the stream is complete
+        max_retries: Maximum number of retry attempts
+        retry_delay: Delay in seconds between retries
+    """
+    completed = False
+    retries_remaining = max_retries
+
+    while not completed:
+        try:
+            async for item in stream:
+                item_handler(item)
+                if completion_check(item):
+                    completed = True
+                    break
+
+        except (GRPCError, StreamTerminatedError, ClientClosed) as exc:
+            if retries_remaining > 0:
+                retries_remaining -= 1
+                if isinstance(exc, GRPCError):
+                    if exc.status in RETRYABLE_GRPC_STATUS_CODES:
+                        await asyncio.sleep(retry_delay)
+                        continue
+                elif isinstance(exc, StreamTerminatedError):
+                    continue
+                elif isinstance(exc, ClientClosed):
+                    break
+            raise