modal 0.68.11__py3-none-any.whl → 0.68.24__py3-none-any.whl

modal/cli/run.py

@@ -133,6 +133,18 @@ def _get_clean_app_description(func_ref: str) -> str:
         return " ".join(sys.argv)
 
 
+def _write_local_result(result_path: str, res: Any):
+    if isinstance(res, str):
+        mode = "wt"
+    elif isinstance(res, bytes):
+        mode = "wb"
+    else:
+        res_type = type(res).__name__
+        raise InvalidError(f"Function must return str or bytes when using `--write-result`; got {res_type}.")
+    with open(result_path, mode) as fid:
+        fid.write(res)
+
+
 def _get_click_command_for_function(app: App, function_tag):
     function = app.registered_functions.get(function_tag)
     if not function or (isinstance(function, Function) and function.info.user_cls is not None):
@@ -177,7 +189,7 @@ def _get_click_command_for_function(app: App, function_tag):
                 interactive=ctx.obj["interactive"],
             ):
                 if cls is None:
-                    function.remote(**kwargs)
+                    res = function.remote(**kwargs)
                 else:
                     # unpool class and method arguments
                     # TODO(erikbern): this code is a bit hacky
@@ -186,7 +198,10 @@ def _get_click_command_for_function(app: App, function_tag):
 
                     instance = cls(**cls_kwargs)
                     method: Function = getattr(instance, method_name)
-                    method.remote(**fun_kwargs)
+                    res = method.remote(**fun_kwargs)
+
+            if result_path := ctx.obj["result_path"]:
+                _write_local_result(result_path, res)
 
     with_click_options = _add_click_options(f, signature)
     return click.command(with_click_options)
@@ -214,12 +229,15 @@ def _get_click_command_for_local_entrypoint(app: App, entrypoint: LocalEntrypoin
             ):
                 try:
                     if isasync:
-                        asyncio.run(func(*args, **kwargs))
+                        res = asyncio.run(func(*args, **kwargs))
                     else:
-                        func(*args, **kwargs)
+                        res = func(*args, **kwargs)
                 except Exception as exc:
                     raise _CliUserExecutionError(inspect.getsourcefile(func)) from exc
 
+            if result_path := ctx.obj["result_path"]:
+                _write_local_result(result_path, res)
+
     with_click_options = _add_click_options(f, _get_signature(func))
     return click.command(with_click_options)
 
@@ -248,12 +266,13 @@ class RunGroup(click.Group):
     cls=RunGroup,
     subcommand_metavar="FUNC_REF",
 )
+@click.option("-w", "--write-result", help="Write return value (which must be str or bytes) to this local path.")
 @click.option("-q", "--quiet", is_flag=True, help="Don't show Modal progress indicators.")
 @click.option("-d", "--detach", is_flag=True, help="Don't stop the app if the local process dies or disconnects.")
 @click.option("-i", "--interactive", is_flag=True, help="Run the app in interactive mode.")
 @click.option("-e", "--env", help=ENV_OPTION_HELP, default=None)
 @click.pass_context
-def run(ctx, detach, quiet, interactive, env):
+def run(ctx, write_result, detach, quiet, interactive, env):
     """Run a Modal function or local entrypoint.
 
     `FUNC_REF` should be of the format `{file or module}::{function name}`.
@@ -284,6 +303,7 @@ def run(ctx, detach, quiet, interactive, env):
     ```
     """
     ctx.ensure_object(dict)
+    ctx.obj["result_path"] = write_result
     ctx.obj["detach"] = detach  # if subcommand would be a click command...
     ctx.obj["show_progress"] = False if quiet else True
     ctx.obj["interactive"] = interactive

modal/client.py

@@ -236,7 +236,7 @@ class _Client:
         Check whether can the client can connect to this server with these credentials; raise if not.
         """
         async with cls(server_url, api_pb2.CLIENT_TYPE_CLIENT, credentials) as client:
-            client.hello()  # Will call ClientHello RPC and possibly raise AuthError or ConnectionError
+            await client.hello()  # Will call ClientHello RPC and possibly raise AuthError or ConnectionError
 
     @classmethod
     def set_env_client(cls, client: Optional["_Client"]):

modal/client.pyi

@@ -26,7 +26,7 @@ class _Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.11"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.24"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -81,7 +81,7 @@ class Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.11"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.24"
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/file_pattern_matcher.py

@@ -0,0 +1,121 @@
+# Copyright Modal Labs 2024
+"""Pattern matching library ported from https://github.com/moby/patternmatcher.
+
+This is the same pattern-matching logic used by Docker, except it is written in
+Python rather than Go. Also, the original Go library has a couple deprecated
+functions that we don't implement in this port.
+
+The main way to use this library is by constructing a `FilePatternMatcher` object,
+then asking it whether file paths match any of its patterns.
+"""
+
+import os
+from pathlib import Path
+from typing import Callable
+
+from ._utils.pattern_utils import Pattern
+
+
+class FilePatternMatcher:
+    """Allows matching file paths against a list of patterns."""
+
+    def __init__(self, *pattern: str) -> None:
+        """Initialize a new FilePatternMatcher instance.
+
+        Args:
+            pattern (str): One or more pattern strings.
+
+        Raises:
+            ValueError: If an illegal exclusion pattern is provided.
+        """
+        self.patterns: list[Pattern] = []
+        self.exclusions = False
+        for p in list(pattern):
+            p = p.strip()
+            if not p:
+                continue
+            p = os.path.normpath(p)
+            new_pattern = Pattern()
+            if p[0] == "!":
+                if len(p) == 1:
+                    raise ValueError('Illegal exclusion pattern: "!"')
+                new_pattern.exclusion = True
+                p = p[1:]
+                self.exclusions = True
+            # In Python, we can proceed without explicit syntax checking
+            new_pattern.cleaned_pattern = p
+            new_pattern.dirs = p.split(os.path.sep)
+            self.patterns.append(new_pattern)
+
+    def _matches(self, file_path: str) -> bool:
+        """Check if the file path or any of its parent directories match the patterns.
+
+        This is equivalent to `MatchesOrParentMatches()` in the original Go
+        library. The reason is that `Matches()` in the original library is
+        deprecated due to buggy behavior.
+        """
+        matched = False
+        file_path = os.path.normpath(file_path)
+        if file_path == ".":
+            # Don't let them exclude everything; kind of silly.
+            return False
+        parent_path = os.path.dirname(file_path)
+        if parent_path == "":
+            parent_path = "."
+        parent_path_dirs = parent_path.split(os.path.sep)
+
+        for pattern in self.patterns:
+            # Skip evaluation based on current match status and pattern exclusion
+            if pattern.exclusion != matched:
+                continue
+
+            match = pattern.match(file_path)
+
+            if not match and parent_path != ".":
+                # Check if the pattern matches any of the parent directories
+                for i in range(len(parent_path_dirs)):
+                    dir_path = os.path.sep.join(parent_path_dirs[: i + 1])
+                    if pattern.match(dir_path):
+                        match = True
+                        break
+
+            if match:
+                matched = not pattern.exclusion
+
+        return matched
+
+    def __call__(self, file_path: Path) -> bool:
+        """Check if the path matches any of the patterns.
+
+        Args:
+            file_path (Path): The path to check.
+
+        Returns:
+            True if the path matches any of the patterns.
+
+        Usage:
+        ```python
+        from pathlib import Path
+        from modal import FilePatternMatcher
+
+        matcher = FilePatternMatcher("*.py")
+
+        assert matcher(Path("foo.py"))
+        ```
+        """
+        return self._matches(str(file_path))
+
+    def __invert__(self) -> Callable[[Path], bool]:
+        """Invert the filter. Returns a function that returns True if the path does not match any of the patterns.
+
+        Usage:
+        ```python
+        from pathlib import Path
+        from modal import FilePatternMatcher
+
+        inverted_matcher = ~FilePatternMatcher("**/*.py")
+
+        assert not inverted_matcher(Path("foo.py"))
+        ```
+        """
+        return lambda path: not self(path)

modal/functions.pyi

@@ -456,11 +456,11 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
 
     _call_generator_nowait: ___call_generator_nowait_spec
 
-    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER: ...
         async def aio(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER: ...
 
-    remote: __remote_spec[P, ReturnType]
+    remote: __remote_spec[ReturnType, P]
 
     class __remote_gen_spec(typing_extensions.Protocol):
         def __call__(self, *args, **kwargs) -> typing.Generator[typing.Any, None, None]: ...
@@ -473,17 +473,17 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
     def _get_obj(self) -> typing.Optional[modal.cls.Obj]: ...
     def local(self, *args: P.args, **kwargs: P.kwargs) -> OriginalReturnType: ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
         async def aio(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
 
-    _experimental_spawn: ___experimental_spawn_spec[P, ReturnType]
+    _experimental_spawn: ___experimental_spawn_spec[ReturnType, P]
 
-    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
         async def aio(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
 
-    spawn: __spawn_spec[P, ReturnType]
+    spawn: __spawn_spec[ReturnType, P]
 
     def get_raw_f(self) -> typing.Callable[..., typing.Any]: ...
 

modal/image.py

@@ -37,6 +37,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, deprecation_error, deprecation_warning
+from .file_pattern_matcher import FilePatternMatcher
 from .gpu import GPU_T, parse_gpu_config
 from .mount import _Mount, python_standalone_mount_name
 from .network_file_system import _NetworkFileSystem
@@ -638,7 +639,17 @@ class _Image(_Object, type_prefix="im"):
         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":
+    def add_local_dir(
+        self,
+        local_path: Union[str, Path],
+        remote_path: str,
+        *,
+        copy: bool = False,
+        # Predicate filter function for file exclusion, which should accept a filepath and return `True` for exclusion.
+        # Defaults to excluding no files. If a Sequence is provided, it will be converted to a FilePatternMatcher.
+        # Which follows dockerignore syntax.
+        ignore: Union[Sequence[str], Callable[[Path], bool]] = [],
+    ) -> "_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,
@@ -650,12 +661,44 @@ class _Image(_Object, type_prefix="im"):
         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.
+
+        **Usage:**
+
+        ```python
+        from modal import FilePatternMatcher
+
+        image = modal.Image.debian_slim().add_local_dir(
+            "~/assets",
+            remote_path="/assets",
+            ignore=["*.venv"],
+        )
+
+        image = modal.Image.debian_slim().add_local_dir(
+            "~/assets",
+            remote_path="/assets",
+            ignore=lambda p: p.is_relative_to(".venv"),
+        )
+
+        image = modal.Image.debian_slim().copy_local_dir(
+            "~/assets",
+            remote_path="/assets",
+            ignore=FilePatternMatcher("**/*.txt"),
+        )
+
+        # When including files is simpler than excluding them, you can use the `~` operator to invert the matcher.
+        image = modal.Image.debian_slim().copy_local_dir(
+            "~/assets",
+            remote_path="/assets",
+            ignore=~FilePatternMatcher("**/*.py"),
+        )
+        ```
         """
         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)
+
+        mount = _Mount._add_local_dir(Path(local_path), Path(remote_path), 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":
@@ -697,19 +740,56 @@ class _Image(_Object, type_prefix="im"):
         the destination directory.
         """
 
-        def only_py_files(filename):
-            return filename.endswith(".py")
-
-        mount = _Mount.from_local_python_packages(*modules, condition=only_py_files)
+        mount = _Mount.from_local_python_packages(*modules, ignore=~FilePatternMatcher("**/*.py"))
         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":
+    def copy_local_dir(
+        self,
+        local_path: Union[str, Path],
+        remote_path: Union[str, Path] = ".",
+        # Predicate filter function for file exclusion, which should accept a filepath and return `True` for exclusion.
+        # Defaults to excluding no files. If a Sequence is provided, it will be converted to a FilePatternMatcher.
+        # Which follows dockerignore syntax.
+        ignore: Union[Sequence[str], Callable[[Path], bool]] = [],
+    ) -> "_Image":
         """Copy a directory into the image as a part of building the image.
 
         This works in a similar way to [`COPY`](https://docs.docker.com/engine/reference/builder/#copy)
         works in a `Dockerfile`.
+
+        **Usage:**
+
+        ```python
+        from modal import FilePatternMatcher
+
+        image = modal.Image.debian_slim().copy_local_dir(
+            "~/assets",
+            remote_path="/assets",
+            ignore=["**/*.venv"],
+        )
+
+        image = modal.Image.debian_slim().copy_local_dir(
+            "~/assets",
+            remote_path="/assets",
+            ignore=lambda p: p.is_relative_to(".venv"),
+        )
+
+        image = modal.Image.debian_slim().copy_local_dir(
+            "~/assets",
+            remote_path="/assets",
+            ignore=FilePatternMatcher("**/*.txt"),
+        )
+
+        # When including files is simpler than excluding them, you can use the `~` operator to invert the matcher.
+        image = modal.Image.debian_slim().copy_local_dir(
+            "~/assets",
+            remote_path="/assets",
+            ignore=~FilePatternMatcher("**/*.py"),
+        )
+        ```
         """
-        mount = _Mount.from_local_dir(local_path, remote_path="/")
+
+        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={})

modal/image.pyi

@@ -110,14 +110,22 @@ class _Image(modal.object._Object):
         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
+        self,
+        local_path: typing.Union[str, pathlib.Path],
+        remote_path: str,
+        *,
+        copy: bool = False,
+        ignore: typing.Union[collections.abc.Sequence[str], typing.Callable[[pathlib.Path], bool]] = [],
     ) -> _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_source(self, *module_names: str, copy: bool = False) -> _Image: ...
     def copy_local_dir(
-        self, local_path: typing.Union[str, pathlib.Path], remote_path: typing.Union[str, pathlib.Path] = "."
+        self,
+        local_path: typing.Union[str, pathlib.Path],
+        remote_path: typing.Union[str, pathlib.Path] = ".",
+        ignore: typing.Union[collections.abc.Sequence[str], typing.Callable[[pathlib.Path], bool]] = [],
     ) -> _Image: ...
     def pip_install(
         self,
@@ -367,14 +375,22 @@ class Image(modal.object.Object):
         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
+        self,
+        local_path: typing.Union[str, pathlib.Path],
+        remote_path: str,
+        *,
+        copy: bool = False,
+        ignore: typing.Union[collections.abc.Sequence[str], typing.Callable[[pathlib.Path], bool]] = [],
     ) -> 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_source(self, *module_names: str, copy: bool = False) -> Image: ...
     def copy_local_dir(
-        self, local_path: typing.Union[str, pathlib.Path], remote_path: typing.Union[str, pathlib.Path] = "."
+        self,
+        local_path: typing.Union[str, pathlib.Path],
+        remote_path: typing.Union[str, pathlib.Path] = ".",
+        ignore: typing.Union[collections.abc.Sequence[str], typing.Callable[[pathlib.Path], bool]] = [],
     ) -> Image: ...
     def pip_install(
         self,

modal/mount.py

@@ -11,7 +11,7 @@ import time
 import typing
 from collections.abc import AsyncGenerator
 from pathlib import Path, PurePosixPath
-from typing import Callable, Optional, Union
+from typing import Callable, Optional, Sequence, Union
 
 from google.protobuf.message import Message
 
@@ -27,7 +27,8 @@ from ._utils.name_utils import check_object_name
 from ._utils.package_utils import get_module_mount_info
 from .client import _Client
 from .config import config, logger
-from .exception import ModuleNotMountable
+from .exception import InvalidError, ModuleNotMountable
+from .file_pattern_matcher import FilePatternMatcher
 from .object import _get_environment_name, _Object
 
 ROOT_DIR: PurePosixPath = PurePosixPath("/root")
@@ -122,7 +123,7 @@ class _MountFile(_MountEntry):
 class _MountDir(_MountEntry):
     local_dir: Path
     remote_path: PurePosixPath
-    condition: Callable[[str], bool]
+    ignore: Callable[[Path], bool]
     recursive: bool
 
     def description(self):
@@ -143,7 +144,7 @@ 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 self.condition(local_filename):
+            if not self.ignore(Path(local_filename)):
                 local_relpath = Path(local_filename).expanduser().absolute().relative_to(local_dir)
                 mount_path = self.remote_path / local_relpath.as_posix()
                 yield local_filename, mount_path
@@ -182,6 +183,10 @@ def module_mount_condition(module_base: Path):
     return condition
 
 
+def module_mount_ignore_condition(module_base: Path):
+    return lambda f: not module_mount_condition(module_base)(str(f))
+
+
 @dataclasses.dataclass
 class _MountedPythonModule(_MountEntry):
     # the purpose of this is to keep printable information about which Python package
@@ -190,7 +195,7 @@ class _MountedPythonModule(_MountEntry):
 
     module_name: str
     remote_dir: Union[PurePosixPath, str] = ROOT_DIR.as_posix()  # cast needed here for type stub generation...
-    condition: typing.Optional[typing.Callable[[str], bool]] = None
+    ignore: Optional[Callable[[Path], bool]] = None
 
     def description(self) -> str:
         return f"PythonPackage:{self.module_name}"
@@ -206,7 +211,7 @@ class _MountedPythonModule(_MountEntry):
                     _MountDir(
                         base_path,
                         remote_path=remote_dir,
-                        condition=self.condition or module_mount_condition(base_path),
+                        ignore=self.ignore or module_mount_ignore_condition(base_path),
                         recursive=True,
                     )
                 )
@@ -313,6 +318,24 @@ class _Mount(_Object, type_prefix="mo"):
         # we can't rely on it to be set. Let's clean this up later.
         return getattr(self, "_is_local", False)
 
+    @staticmethod
+    def _add_local_dir(
+        local_path: Path,
+        remote_path: Path,
+        ignore: Union[Sequence[str], Callable[[Path], bool]] = [],
+    ):
+        if isinstance(ignore, list):
+            ignore = FilePatternMatcher(*ignore)
+
+        return _Mount._new()._extend(
+            _MountDir(
+                local_dir=local_path,
+                ignore=ignore,
+                remote_path=remote_path,
+                recursive=True,
+            ),
+        )
+
     def add_local_dir(
         self,
         local_path: Union[str, Path],
@@ -339,10 +362,13 @@ class _Mount(_Object, type_prefix="mo"):
 
             condition = include_all
 
+        def converted_condition(path: Path) -> bool:
+            return not condition(str(path))
+
         return self._extend(
             _MountDir(
                 local_dir=local_path,
-                condition=condition,
+                ignore=converted_condition,
                 remote_path=remote_path,
                 recursive=recursive,
             ),
@@ -483,7 +509,9 @@ class _Mount(_Object, type_prefix="mo"):
                 logger.debug(f"Creating blob file for {file_spec.source_description} ({file_spec.size} bytes)")
                 async with blob_upload_concurrency:
                     with file_spec.source() as fp:
-                        blob_id = await blob_upload_file(fp, resolver.client.stub)
+                        blob_id = await blob_upload_file(
+                            fp, resolver.client.stub, sha256_hex=file_spec.sha256_hex, md5_hex=file_spec.md5_hex
+                        )
                 logger.debug(f"Uploading blob file {file_spec.source_description} as {remote_filename}")
                 request2 = api_pb2.MountPutFileRequest(data_blob_id=blob_id, sha256_hex=file_spec.sha256_hex)
             else:
@@ -549,6 +577,7 @@ class _Mount(_Object, type_prefix="mo"):
         # Predicate filter function for file selection, which should accept a filepath and return `True` for inclusion.
         # Defaults to including all files.
         condition: Optional[Callable[[str], bool]] = None,
+        ignore: Optional[Union[Sequence[str], Callable[[Path], bool]]] = None,
     ) -> "_Mount":
         """
         Returns a `modal.Mount` that makes local modules listed in `module_names` available inside the container.
@@ -573,13 +602,24 @@ class _Mount(_Object, type_prefix="mo"):
 
         # Don't re-run inside container.
 
+        if condition is not None:
+            if ignore is not None:
+                raise InvalidError("Cannot specify both `ignore` and `condition`")
+
+            def converted_condition(path: Path) -> bool:
+                return not condition(str(path))
+
+            ignore = converted_condition
+        elif isinstance(ignore, list):
+            ignore = FilePatternMatcher(*ignore)
+
         mount = _Mount._new()
         from ._runtime.execution_context import is_local
 
         if not is_local():
             return mount  # empty/non-mountable mount in case it's used from within a container
         for module_name in module_names:
-            mount = mount._extend(_MountedPythonModule(module_name, remote_dir, condition))
+            mount = mount._extend(_MountedPythonModule(module_name, remote_dir, ignore))
         return mount
 
     @staticmethod