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

modal/_utils/deprecation.py

@@ -0,0 +1,44 @@
+# Copyright Modal Labs 2024
+import sys
+import warnings
+from datetime import date
+
+from ..exception import DeprecationError, PendingDeprecationError
+
+_INTERNAL_MODULES = ["modal", "synchronicity"]
+
+
+def _is_internal_frame(frame):
+    module = frame.f_globals["__name__"].split(".")[0]
+    return module in _INTERNAL_MODULES
+
+
+def deprecation_error(deprecated_on: tuple[int, int, int], msg: str):
+    raise DeprecationError(f"Deprecated on {date(*deprecated_on)}: {msg}")
+
+
+def deprecation_warning(
+    deprecated_on: tuple[int, int, int], msg: str, *, pending: bool = False, show_source: bool = True
+) -> None:
+    """Issue a Modal deprecation warning with source optionally attributed to user code.
+
+    See the implementation of the built-in [warnings.warn](https://docs.python.org/3/library/warnings.html#available-functions).
+    """
+    filename, lineno = "<unknown>", 0
+    if show_source:
+        # Find the last non-Modal line that triggered the warning
+        try:
+            frame = sys._getframe()
+            while frame is not None and _is_internal_frame(frame):
+                frame = frame.f_back
+            if frame is not None:
+                filename = frame.f_code.co_filename
+                lineno = frame.f_lineno
+        except ValueError:
+            # Use the defaults from above
+            pass
+
+    warning_cls = PendingDeprecationError if pending else DeprecationError
+
+    # This is a lower-level function that warnings.warn uses
+    warnings.warn_explicit(f"{date(*deprecated_on)}: {msg}", warning_cls, filename, lineno)

modal/app.py

@@ -22,6 +22,7 @@ from modal_proto import api_pb2
 
 from ._ipython import is_notebook
 from ._utils.async_utils import synchronize_api
+from ._utils.deprecation import deprecation_error, deprecation_warning
 from ._utils.function_utils import FunctionInfo, is_global_object, is_method_fn
 from ._utils.grpc_utils import retry_transient_errors
 from ._utils.mount_utils import validate_volumes
@@ -29,7 +30,7 @@ from .client import _Client
 from .cloud_bucket_mount import _CloudBucketMount
 from .cls import _Cls, parameter
 from .config import logger
-from .exception import ExecutionError, InvalidError, deprecation_error, deprecation_warning
+from .exception import ExecutionError, InvalidError
 from .functions import Function, _Function
 from .gpu import GPU_T
 from .image import _Image
@@ -45,7 +46,6 @@ from .partial_function import (
 from .proxy import _Proxy
 from .retries import Retries
 from .running_app import RunningApp
-from .sandbox import _Sandbox
 from .schedule import Schedule
 from .scheduler_placement import SchedulerPlacement
 from .secret import _Secret
@@ -964,36 +964,16 @@ class _App:
         _experimental_scheduler_placement: Optional[
             SchedulerPlacement
         ] = None,  # Experimental controls over fine-grained scheduling (alpha).
-    ) -> _Sandbox:
-        """`App.spawn_sandbox` is deprecated in favor of `Sandbox.create(app=...)`.
-
-        See https://modal.com/docs/guide/sandbox for more info on working with sandboxes.
-        """
-        deprecation_warning((2024, 7, 5), _App.spawn_sandbox.__doc__)
-        if not self._running_app:
-            raise InvalidError("`app.spawn_sandbox` requires a running app.")
-
-        return await _Sandbox.create(
-            *entrypoint_args,
-            app=self,
-            environment_name=self._running_app.environment_name,
-            image=image or _default_image,
-            mounts=mounts,
-            secrets=secrets,
-            timeout=timeout,
-            workdir=workdir,
-            gpu=gpu,
-            cloud=cloud,
-            region=region,
-            cpu=cpu,
-            memory=memory,
-            network_file_systems=network_file_systems,
-            block_network=block_network,
-            volumes=volumes,
-            pty_info=pty_info,
-            _experimental_scheduler_placement=_experimental_scheduler_placement,
-            client=self._client,
+    ) -> None:
+        """mdmd:hidden"""
+        arglist = ", ".join(repr(s) for s in entrypoint_args)
+        message = (
+            "`App.spawn_sandbox` is deprecated.\n\n"
+            "Sandboxes can be created using the `Sandbox` object:\n\n"
+            f"```\nsb = Sandbox.create({arglist}, app=app)\n```\n\n"
+            "See https://modal.com/docs/guide/sandbox for more info on working with sandboxes."
         )
+        deprecation_error((2024, 7, 5), message)
 
     def include(self, /, other_app: "_App"):
         """Include another App's objects in this one.

modal/app.pyi

@@ -13,7 +13,6 @@ import modal.partial_function
 import modal.proxy
 import modal.retries
 import modal.running_app
-import modal.sandbox
 import modal.schedule
 import modal.scheduler_placement
 import modal.secret
@@ -261,7 +260,7 @@ class _App:
         ] = {},
         pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
         _experimental_scheduler_placement: typing.Optional[modal.scheduler_placement.SchedulerPlacement] = None,
-    ) -> modal.sandbox._Sandbox: ...
+    ) -> None: ...
     def include(self, /, other_app: _App): ...
     def _logs(
         self, client: typing.Optional[modal.client._Client] = None
@@ -491,7 +490,7 @@ class App:
             ] = {},
             pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
             _experimental_scheduler_placement: typing.Optional[modal.scheduler_placement.SchedulerPlacement] = None,
-        ) -> modal.sandbox.Sandbox: ...
+        ) -> None: ...
         async def aio(
             self,
             *entrypoint_args: str,
@@ -515,7 +514,7 @@ class App:
             ] = {},
             pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
             _experimental_scheduler_placement: typing.Optional[modal.scheduler_placement.SchedulerPlacement] = None,
-        ) -> modal.sandbox.Sandbox: ...
+        ) -> None: ...
 
     spawn_sandbox: __spawn_sandbox_spec
 

modal/cli/app.py

@@ -10,9 +10,9 @@ from rich.text import Text
 from typer import Argument
 
 from modal._utils.async_utils import synchronizer
+from modal._utils.deprecation import deprecation_warning
 from modal.client import _Client
 from modal.environments import ensure_env
-from modal.exception import deprecation_warning
 from modal.object import _get_environment_name
 from modal_proto import api_pb2
 

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.24"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.31"
     ): ...
     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.24"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.31"
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/config.py

@@ -86,8 +86,9 @@ from google.protobuf.empty_pb2 import Empty
 
 from modal_proto import api_pb2
 
+from ._utils.deprecation import deprecation_error
 from ._utils.logger import configure_logger
-from .exception import InvalidError, deprecation_error
+from .exception import InvalidError
 
 # Locate config file and read it
 

modal/container_process.py

@@ -6,10 +6,11 @@ from typing import Generic, Optional, TypeVar
 from modal_proto import api_pb2
 
 from ._utils.async_utils import TaskContext, synchronize_api
+from ._utils.deprecation import deprecation_error
 from ._utils.grpc_utils import retry_transient_errors
 from ._utils.shell_utils import stream_from_stdin, write_to_fd
 from .client import _Client
-from .exception import InteractiveTimeoutError, InvalidError, deprecation_error
+from .exception import InteractiveTimeoutError, InvalidError
 from .io_streams import _StreamReader, _StreamWriter
 from .stream_type import StreamType
 

modal/dict.py

@@ -10,11 +10,12 @@ from modal_proto import api_pb2
 from ._resolver import Resolver
 from ._serialization import deserialize, serialize
 from ._utils.async_utils import TaskContext, synchronize_api
+from ._utils.deprecation import deprecation_error
 from ._utils.grpc_utils import retry_transient_errors
 from ._utils.name_utils import check_object_name
 from .client import _Client
 from .config import logger
-from .exception import RequestSizeError, deprecation_error
+from .exception import RequestSizeError
 from .object import EPHEMERAL_OBJECT_HEARTBEAT_SLEEP, _get_environment_name, _Object, live_method, live_method_gen
 
 

modal/exception.py

@@ -1,12 +1,6 @@
 # Copyright Modal Labs 2022
 import random
 import signal
-import sys
-import warnings
-from datetime import date
-from typing import Iterable
-
-from modal_proto import api_pb2
 
 
 class Error(Exception):
@@ -129,45 +123,6 @@ class _CliUserExecutionError(Exception):
         self.user_source = user_source
 
 
-# TODO(erikbern): we have something similready in function_utils.py
-_INTERNAL_MODULES = ["modal", "synchronicity"]
-
-
-def _is_internal_frame(frame):
-    module = frame.f_globals["__name__"].split(".")[0]
-    return module in _INTERNAL_MODULES
-
-
-def deprecation_error(deprecated_on: tuple[int, int, int], msg: str):
-    raise DeprecationError(f"Deprecated on {date(*deprecated_on)}: {msg}")
-
-
-def deprecation_warning(
-    deprecated_on: tuple[int, int, int], msg: str, *, pending: bool = False, show_source: bool = True
-) -> None:
-    """Utility for getting the proper stack entry.
-
-    See the implementation of the built-in [warnings.warn](https://docs.python.org/3/library/warnings.html#available-functions).
-    """
-    filename, lineno = "<unknown>", 0
-    if show_source:
-        # Find the last non-Modal line that triggered the warning
-        try:
-            frame = sys._getframe()
-            while frame is not None and _is_internal_frame(frame):
-                frame = frame.f_back
-            filename = frame.f_code.co_filename
-            lineno = frame.f_lineno
-        except ValueError:
-            # Use the defaults from above
-            pass
-
-    warning_cls: type = PendingDeprecationError if pending else DeprecationError
-
-    # This is a lower-level function that warnings.warn uses
-    warnings.warn_explicit(f"{date(*deprecated_on)}: {msg}", warning_cls, filename, lineno)
-
-
 def _simulate_preemption_interrupt(signum, frame):
     signal.alarm(30)  # simulate a SIGKILL after 30s
     raise KeyboardInterrupt("Simulated preemption interrupt from modal-client!")
@@ -224,12 +179,3 @@ class ClientClosed(Error):
 
 class FilesystemExecutionError(Error):
     """Raised when an unknown error is thrown during a container filesystem operation."""
-
-
-def print_server_warnings(server_warnings: Iterable[api_pb2.Warning]):
-    # TODO(erikbern): move this to modal._utils.deprecation
-    for warning in server_warnings:
-        if warning.type == api_pb2.Warning.WARNING_TYPE_CLIENT_DEPRECATION:
-            warnings.warn_explicit(warning.message, DeprecationError, "<unknown>", 0)
-        else:
-            warnings.warn_explicit(warning.message, UserWarning, "<unknown>", 0)

modal/file_io.py

@@ -6,6 +6,8 @@ from typing import TYPE_CHECKING, AsyncIterator, Generic, Optional, Sequence, Ty
 if TYPE_CHECKING:
     import _typeshed
 
+import json
+
 from grpclib.exceptions import GRPCError, StreamTerminatedError
 
 from modal._utils.grpc_utils import retry_transient_errors
@@ -267,12 +269,12 @@ class _FileIO(Generic[T]):
         output = await self._make_read_request(None)
         if self._binary:
             lines_bytes = output.split(b"\n")
-            output = [line + b"\n" for line in lines_bytes[:-1]] + ([lines_bytes[-1]] if lines_bytes[-1] else [])
-            return cast(Sequence[T], output)
+            return_bytes = [line + b"\n" for line in lines_bytes[:-1]] + ([lines_bytes[-1]] if lines_bytes[-1] else [])
+            return cast(Sequence[T], return_bytes)
         else:
             lines = output.decode("utf-8").split("\n")
-            output = [line + "\n" for line in lines[:-1]] + ([lines[-1]] if lines[-1] else [])
-            return cast(Sequence[T], output)
+            return_strs = [line + "\n" for line in lines[:-1]] + ([lines[-1]] if lines[-1] else [])
+            return cast(Sequence[T], return_strs)
 
     async def write(self, data: Union[bytes, str]) -> None:
         """Write data to the current position.
@@ -337,6 +339,52 @@ class _FileIO(Generic[T]):
         )
         await self._wait(resp.exec_id)
 
+    @classmethod
+    async def ls(cls, path: str, client: _Client, task_id: str) -> list[str]:
+        """List the contents of the provided directory."""
+        self = cls.__new__(cls)
+        self._client = client
+        self._task_id = task_id
+        resp = await self._make_request(
+            api_pb2.ContainerFilesystemExecRequest(
+                file_ls_request=api_pb2.ContainerFileLsRequest(path=path),
+                task_id=task_id,
+            )
+        )
+        output = await self._wait(resp.exec_id)
+        try:
+            return json.loads(output.decode("utf-8"))["paths"]
+        except json.JSONDecodeError:
+            raise FilesystemExecutionError("failed to parse list output")
+
+    @classmethod
+    async def mkdir(cls, path: str, client: _Client, task_id: str, parents: bool = False) -> None:
+        """Create a new directory."""
+        self = cls.__new__(cls)
+        self._client = client
+        self._task_id = task_id
+        resp = await self._make_request(
+            api_pb2.ContainerFilesystemExecRequest(
+                file_mkdir_request=api_pb2.ContainerFileMkdirRequest(path=path, make_parents=parents),
+                task_id=self._task_id,
+            )
+        )
+        await self._wait(resp.exec_id)
+
+    @classmethod
+    async def rm(cls, path: str, client: _Client, task_id: str, recursive: bool = False) -> None:
+        """Remove a file or directory in the Sandbox."""
+        self = cls.__new__(cls)
+        self._client = client
+        self._task_id = task_id
+        resp = await self._make_request(
+            api_pb2.ContainerFilesystemExecRequest(
+                file_rm_request=api_pb2.ContainerFileRmRequest(path=path, recursive=recursive),
+                task_id=self._task_id,
+            )
+        )
+        await self._wait(resp.exec_id)
+
     async def _close(self) -> None:
         # Buffer is flushed by the runner on close
         resp = await self._make_request(
@@ -367,11 +415,10 @@ class _FileIO(Generic[T]):
         if self._closed:
             raise ValueError("I/O operation on closed file")
 
-    def __enter__(self) -> "_FileIO":
-        self._check_closed()
+    async def __aenter__(self) -> "_FileIO":
         return self
 
-    async def __exit__(self, exc_type, exc_value, traceback) -> None:
+    async def __aexit__(self, exc_type, exc_value, traceback) -> None:
         await self._close()
 
 

modal/file_io.pyi

@@ -43,13 +43,19 @@ class _FileIO(typing.Generic[T]):
     async def flush(self) -> None: ...
     def _get_whence(self, whence: int): ...
     async def seek(self, offset: int, whence: int = 0) -> None: ...
+    @classmethod
+    async def ls(cls, path: str, client: modal.client._Client, task_id: str) -> list[str]: ...
+    @classmethod
+    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: ...
     async def _close(self) -> None: ...
     async def close(self) -> None: ...
     def _check_writable(self) -> None: ...
     def _check_readable(self) -> None: ...
     def _check_closed(self) -> None: ...
-    def __enter__(self) -> _FileIO: ...
-    async def __exit__(self, exc_type, exc_value, traceback) -> None: ...
+    async def __aenter__(self) -> _FileIO: ...
+    async def __aexit__(self, exc_type, exc_value, traceback) -> None: ...
 
 class __delete_bytes_spec(typing_extensions.Protocol):
     def __call__(self, file: FileIO, start: typing.Optional[int] = None, end: typing.Optional[int] = None) -> None: ...
@@ -161,6 +167,13 @@ class FileIO(typing.Generic[T]):
 
     seek: __seek_spec
 
+    @classmethod
+    def ls(cls, path: str, client: modal.client.Client, task_id: str) -> list[str]: ...
+    @classmethod
+    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: ...
+
     class ___close_spec(typing_extensions.Protocol):
         def __call__(self) -> None: ...
         async def aio(self) -> None: ...
@@ -177,9 +190,6 @@ class FileIO(typing.Generic[T]):
     def _check_readable(self) -> None: ...
     def _check_closed(self) -> None: ...
     def __enter__(self) -> FileIO: ...
-
-    class ____exit___spec(typing_extensions.Protocol):
-        def __call__(self, exc_type, exc_value, traceback) -> None: ...
-        async def aio(self, exc_type, exc_value, traceback) -> None: ...
-
-    __exit__: ____exit___spec
+    async def __aenter__(self) -> FileIO: ...
+    def __exit__(self, exc_type, exc_value, traceback) -> None: ...
+    async def __aexit__(self, exc_type, exc_value, traceback) -> None: ...

modal/file_pattern_matcher.py

@@ -10,13 +10,56 @@ 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
+from typing import Callable, Optional
 
 from ._utils.pattern_utils import Pattern
 
 
-class FilePatternMatcher:
+class _AbstractPatternMatcher:
+    _custom_repr: Optional[str] = None
+
+    def __invert__(self) -> "_AbstractPatternMatcher":
+        """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 _CustomPatternMatcher(lambda path: not self(path))
+
+    def with_repr(self, custom_repr) -> "_AbstractPatternMatcher":
+        # use to give an instance of a matcher a custom name - useful for visualizing default values in signatures
+        self._custom_repr = custom_repr
+        return self
+
+    def __repr__(self) -> str:
+        if self._custom_repr:
+            return self._custom_repr
+
+        return super().__repr__()
+
+    @abstractmethod
+    def __call__(self, path: Path) -> bool:
+        ...
+
+
+class _CustomPatternMatcher(_AbstractPatternMatcher):
+    def __init__(self, predicate: Callable[[Path], bool]):
+        self._predicate = predicate
+
+    def __call__(self, path: Path) -> bool:
+        return self._predicate(path)
+
+
+class FilePatternMatcher(_AbstractPatternMatcher):
     """Allows matching file paths against a list of patterns."""
 
     def __init__(self, *pattern: str) -> None:
@@ -105,17 +148,7 @@ class FilePatternMatcher:
         """
         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)
+# 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")

modal/functions.py

@@ -41,6 +41,7 @@ from ._utils.async_utils import (
     synchronizer,
     warn_if_generator_is_not_consumed,
 )
+from ._utils.deprecation import deprecation_warning
 from ._utils.function_utils import (
     ATTEMPT_TIMEOUT_GRACE_PERIOD,
     OUTPUTS_TIMEOUT,
@@ -58,14 +59,7 @@ 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,
-    deprecation_warning,
-)
+from .exception import ExecutionError, FunctionTimeoutError, 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

modal/functions.pyi

@@ -448,7 +448,11 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
 
     _call_function_nowait: ___call_function_nowait_spec
 
-    def _call_generator(self, args, kwargs): ...
+    class ___call_generator_spec(typing_extensions.Protocol):
+        def __call__(self, args, kwargs): ...
+        def aio(self, args, kwargs): ...
+
+    _call_generator: ___call_generator_spec
 
     class ___call_generator_nowait_spec(typing_extensions.Protocol):
         def __call__(self, args, kwargs): ...
@@ -456,11 +460,11 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
 
     _call_generator_nowait: ___call_generator_nowait_spec
 
-    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_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[ReturnType, P]
+    remote: __remote_spec[P, ReturnType]
 
     class __remote_gen_spec(typing_extensions.Protocol):
         def __call__(self, *args, **kwargs) -> typing.Generator[typing.Any, None, None]: ...
@@ -473,17 +477,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[ReturnType_INNER, P_INNER]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_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[ReturnType, P]
+    _experimental_spawn: ___experimental_spawn_spec[P, ReturnType]
 
-    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_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[ReturnType, P]
+    spawn: __spawn_spec[P, ReturnType]
 
     def get_raw_f(self) -> typing.Callable[..., typing.Any]: ...
 

modal/image.py

@@ -30,14 +30,15 @@ from ._resolver import Resolver
 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.function_utils import FunctionInfo
 from ._utils.grpc_utils import RETRYABLE_GRPC_STATUS_CODES, retry_transient_errors
 from .client import _Client
 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 .exception import InvalidError, NotFoundError, RemoteError, VersionError
+from .file_pattern_matcher import NON_PYTHON_FILES
 from .gpu import GPU_T, parse_gpu_config
 from .mount import _Mount, python_standalone_mount_name
 from .network_file_system import _NetworkFileSystem
@@ -720,7 +721,9 @@ class _Image(_Object, type_prefix="im"):
             context_mount=mount,
         )
 
-    def add_local_python_source(self, *modules: str, copy: bool = False) -> "_Image":
+    def add_local_python_source(
+        self, *modules: str, copy: bool = False, ignore: Union[Sequence[str], Callable[[Path], bool]] = NON_PYTHON_FILES
+    ) -> "_Image":
         """Adds locally available Python packages/modules to containers
 
         Adds all files from the specified Python package or module to containers running the Image.
@@ -738,9 +741,22 @@ class _Image(_Object, type_prefix="im"):
         **Note:** This excludes all dot-prefixed subdirectories or files and all `.pyc`/`__pycache__` files.
         To add full directories with finer control, use `.add_local_dir()` instead and specify `/root` as
         the destination directory.
-        """
 
-        mount = _Mount.from_local_python_packages(*modules, ignore=~FilePatternMatcher("**/*.py"))
+        By default only includes `.py`-files in the source modules. Set the `ignore` argument to a list of patterns
+        or a callable to override this behavior, e.g.:
+
+        ```py
+        # includes everything except data.json
+        modal.Image.debian_slim().add_local_python_source("mymodule", ignore=["data.json"])
+
+        # exclude large files
+        modal.Image.debian_slim().add_local_python_source(
+            "mymodule",
+            ignore=lambda p: p.stat().st_size > 1e9
+        )
+        ```
+        """
+        mount = _Mount.from_local_python_packages(*modules, ignore=ignore)
         return self._add_mount_layer_or_copy(mount, copy=copy)
 
     def copy_local_dir(