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

modal/environments.py

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

modal/environments.pyi

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

modal/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

@@ -22,7 +22,6 @@ from grpclib import GRPCError, Status
 from synchronicity.combined_types import MethodWithAio
 from synchronicity.exceptions import UserCodeException
 
-from modal._utils.async_utils import aclosing
 from modal_proto import api_pb2
 from modal_proto.modal_api_grpc import ModalClientModal
 
@@ -35,12 +34,14 @@ from ._serialization import serialize, serialize_proto_params
 from ._traceback import print_server_warnings
 from ._utils.async_utils import (
     TaskContext,
+    aclosing,
     async_merge,
     callable_to_agen,
     synchronize_api,
     synchronizer,
     warn_if_generator_is_not_consumed,
 )
+from ._utils.deprecation import deprecation_warning, renamed_parameter
 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
@@ -352,6 +346,7 @@ class _FunctionSpec:
     memory: Optional[Union[int, tuple[int, int]]]
     ephemeral_disk: Optional[int]
     scheduler_placement: Optional[SchedulerPlacement]
+    proxy: Optional[_Proxy]
 
 
 P = typing_extensions.ParamSpec("P")
@@ -536,6 +531,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             memory=memory,
             ephemeral_disk=ephemeral_disk,
             scheduler_placement=scheduler_placement,
+            proxy=proxy,
         )
 
         if info.user_cls and not is_auto_snapshot:
@@ -1028,10 +1024,11 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         await retry_transient_errors(self._client.stub.FunctionUpdateSchedulingParams, request)
 
     @classmethod
+    @renamed_parameter((2024, 12, 18), "tag", "name")
     def from_name(
         cls: type["_Function"],
         app_name: str,
-        tag: str,
+        name: str,
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         environment_name: Optional[str] = None,
     ) -> "_Function":
@@ -1050,7 +1047,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             assert resolver.client and resolver.client.stub
             request = api_pb2.FunctionGetRequest(
                 app_name=app_name,
-                object_tag=tag,
+                object_tag=name,
                 namespace=namespace,
                 environment_name=_get_environment_name(environment_name, resolver) or "",
             )
@@ -1070,9 +1067,10 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         return cls._from_loader(_load_remote, rep, is_another_app=True, hydrate_lazily=True)
 
     @staticmethod
+    @renamed_parameter((2024, 12, 18), "tag", "name")
     async def lookup(
         app_name: str,
-        tag: str,
+        name: str,
         namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         client: Optional[_Client] = None,
         environment_name: Optional[str] = None,
@@ -1086,7 +1084,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         f = modal.Function.lookup("other-app", "function")
         ```
         """
-        obj = _Function.from_name(app_name, tag, namespace=namespace, environment_name=environment_name)
+        obj = _Function.from_name(app_name, name, namespace=namespace, environment_name=environment_name)
         if client is None:
             client = await _Client.from_env()
         resolver = Resolver(client=client)

modal/functions.pyi

@@ -100,6 +100,7 @@ class _FunctionSpec:
     memory: typing.Union[int, tuple[int, int], None]
     ephemeral_disk: typing.Optional[int]
     scheduler_placement: typing.Optional[modal.scheduler_placement.SchedulerPlacement]
+    proxy: typing.Optional[modal.proxy._Proxy]
 
     def __init__(
         self,
@@ -121,6 +122,7 @@ class _FunctionSpec:
         memory: typing.Union[int, tuple[int, int], None],
         ephemeral_disk: typing.Optional[int],
         scheduler_placement: typing.Optional[modal.scheduler_placement.SchedulerPlacement],
+        proxy: typing.Optional[modal.proxy._Proxy],
     ) -> None: ...
     def __repr__(self): ...
     def __eq__(self, other): ...
@@ -206,12 +208,12 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.
     async def keep_warm(self, warm_pool_size: int) -> None: ...
     @classmethod
     def from_name(
-        cls: type[_Function], app_name: str, tag: str, namespace=1, environment_name: typing.Optional[str] = None
+        cls: type[_Function], app_name: str, name: str, namespace=1, environment_name: typing.Optional[str] = None
     ) -> _Function: ...
     @staticmethod
     async def lookup(
         app_name: str,
-        tag: str,
+        name: str,
         namespace=1,
         client: typing.Optional[modal.client._Client] = None,
         environment_name: typing.Optional[str] = None,
@@ -381,14 +383,14 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
 
     @classmethod
     def from_name(
-        cls: type[Function], app_name: str, tag: str, namespace=1, environment_name: typing.Optional[str] = None
+        cls: type[Function], app_name: str, name: str, namespace=1, environment_name: typing.Optional[str] = None
     ) -> Function: ...
 
     class __lookup_spec(typing_extensions.Protocol):
         def __call__(
             self,
             app_name: str,
-            tag: str,
+            name: str,
             namespace=1,
             client: typing.Optional[modal.client.Client] = None,
             environment_name: typing.Optional[str] = None,
@@ -396,7 +398,7 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
         async def aio(
             self,
             app_name: str,
-            tag: str,
+            name: str,
             namespace=1,
             client: typing.Optional[modal.client.Client] = None,
             environment_name: typing.Optional[str] = None,
@@ -448,7 +450,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 +462,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 +479,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
@@ -570,21 +571,6 @@ class _Image(_Object, type_prefix="im"):
         obj.force_build = force_build
         return obj
 
-    def extend(self, **kwargs) -> "_Image":
-        """mdmd:hidden"""
-        deprecation_error(
-            (2024, 3, 7),
-            "`Image.extend` is deprecated; please use a higher-level method, such as `Image.dockerfile_commands`.",
-        )
-
-        def build_dockerfile(version: ImageBuilderVersion) -> DockerfileSpec:
-            return DockerfileSpec(
-                commands=kwargs.pop("dockerfile_commands", []),
-                context_files=kwargs.pop("context_files", {}),
-            )
-
-        return _Image._from_args(base_images={"base": self}, dockerfile_function=build_dockerfile, **kwargs)
-
     def copy_mount(self, mount: _Mount, remote_path: Union[str, Path] = ".") -> "_Image":
         """Copy the entire contents of a `modal.Mount` into an image.
         Useful when files only available locally are required during the image
@@ -720,7 +706,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 +726,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(