modal 0.71.9__py3-none-any.whl → 0.72.5__py3-none-any.whl

modal/_utils/docker_utils.py

@@ -1,7 +1,8 @@
 # Copyright Modal Labs 2024
 import re
 import shlex
-from typing import Sequence
+from pathlib import Path
+from typing import Optional, Sequence
 
 from ..exception import InvalidError
 
@@ -62,3 +63,36 @@ def extract_copy_command_patterns(dockerfile_lines: Sequence[str]) -> list[str]:
             current_command = ""
 
     return list(copy_source_patterns)
+
+
+def find_dockerignore_file(context_directory: Path, dockerfile_path: Optional[Path] = None) -> Optional[Path]:
+    """
+    Find dockerignore file relative to current context directory
+    and if dockerfile path is provided, check if specific <dockerfile_name>.dockerignore
+    file exists in the same directory as <dockerfile_name>
+    Finds the most specific dockerignore file that exists.
+    """
+
+    def valid_dockerignore_file(fp):
+        # fp has to exist
+        if not fp.exists():
+            return False
+        # fp has to be subpath to current working directory
+        if not fp.is_relative_to(context_directory):
+            return False
+
+        return True
+
+    generic_name = ".dockerignore"
+    possible_locations = []
+    if dockerfile_path:
+        specific_name = f"{dockerfile_path.name}.dockerignore"
+        # 1. check if specific <dockerfile_name>.dockerignore file exists in the same directory as <dockerfile_name>
+        possible_locations.append(dockerfile_path.parent / specific_name)
+        # 2. check if generic .dockerignore file exists in the same directory as <dockerfile_name>
+        possible_locations.append(dockerfile_path.parent / generic_name)
+
+    # 3. check if generic .dockerignore file exists in current working directory
+    possible_locations.append(context_directory / generic_name)
+
+    return next((e for e in possible_locations if valid_dockerignore_file(e)), None)

modal/_utils/function_utils.py

@@ -326,11 +326,11 @@ class FunctionInfo:
         # make sure the function's own entrypoint is included:
         if self._type == FunctionInfoType.PACKAGE:
             if config.get("automount"):
-                return [_Mount.from_local_python_packages(self.module_name)]
+                return [_Mount._from_local_python_packages(self.module_name)]
             elif not self.is_serialized():
                 # mount only relevant file and __init__.py:s
                 return [
-                    _Mount.from_local_dir(
+                    _Mount._from_local_dir(
                         self._base_dir,
                         remote_path=self._remote_dir,
                         recursive=True,
@@ -341,7 +341,7 @@ class FunctionInfo:
             remote_path = ROOT_DIR / Path(self._file).name
             if not _is_modal_path(remote_path):
                 return [
-                    _Mount.from_local_file(
+                    _Mount._from_local_file(
                         self._file,
                         remote_path=remote_path,
                     )

modal/app.py

@@ -200,10 +200,9 @@ class _App:
 
         ```python notest
         image = modal.Image.debian_slim().pip_install(...)
-        mount = modal.Mount.from_local_dir("./config")
         secret = modal.Secret.from_name("my-secret")
         volume = modal.Volume.from_name("my-data")
-        app = modal.App(image=image, mounts=[mount], secrets=[secret], volumes={"/mnt/data": volume})
+        app = modal.App(image=image, secrets=[secret], volumes={"/mnt/data": volume})
         ```
         """
         if name is not None and not isinstance(name, str):

modal/cli/launch.py

@@ -55,7 +55,7 @@ def jupyter(
     timeout: int = 3600,
     image: str = "ubuntu:22.04",
     add_python: Optional[str] = "3.11",
-    mount: Optional[str] = None,  # Create a `modal.Mount` from a local directory.
+    mount: Optional[str] = None,  # Adds a local directory to the jupyter container
     volume: Optional[str] = None,  # Attach a persisted `modal.Volume` by name (creating if missing).
     detach: bool = False,  # Run the app in "detached" mode to persist after local client disconnects
 ):

modal/cli/programs/run_jupyter.py

@@ -10,25 +10,20 @@ import time
 import webbrowser
 from typing import Any
 
-from modal import App, Image, Mount, Queue, Secret, Volume, forward
+from modal import App, Image, Queue, Secret, Volume, forward
 
 # Passed by `modal launch` locally via CLI, plumbed to remote runner through secrets.
 args: dict[str, Any] = json.loads(os.environ.get("MODAL_LAUNCH_ARGS", "{}"))
 
-
 app = App()
-app.image = Image.from_registry(args.get("image"), add_python=args.get("add_python")).pip_install("jupyterlab")
 
+image = Image.from_registry(args.get("image"), add_python=args.get("add_python")).pip_install("jupyterlab")
 
-mount = (
-    Mount.from_local_dir(
+if args.get("mount"):
+    image = image.add_local_dir(
         args.get("mount"),
         remote_path="/root/lab/mount",
     )
-    if args.get("mount")
-    else None
-)
-mounts = [mount] if mount else []
 
 volume = (
     Volume.from_name(
@@ -55,12 +50,12 @@ def wait_for_port(url: str, q: Queue):
 
 
 @app.function(
+    image=image,
     cpu=args.get("cpu"),
     memory=args.get("memory"),
     gpu=args.get("gpu"),
     timeout=args.get("timeout"),
     secrets=[Secret.from_dict({"MODAL_LAUNCH_ARGS": json.dumps(args)})],
-    mounts=mounts,
     volumes=volumes,
     concurrency_limit=1 if volume else None,
 )

modal/cli/programs/vscode.py

@@ -10,7 +10,7 @@ import time
 import webbrowser
 from typing import Any
 
-from modal import App, Image, Mount, Queue, Secret, Volume, forward
+from modal import App, Image, Queue, Secret, Volume, forward
 
 # Passed by `modal launch` locally via CLI, plumbed to remote runner through secrets.
 args: dict[str, Any] = json.loads(os.environ.get("MODAL_LAUNCH_ARGS", "{}"))
@@ -23,7 +23,7 @@ FIXUD_INSTALLER = "https://github.com/boxboat/fixuid/releases/download/v0.6.0/fi
 
 
 app = App()
-app.image = (
+image = (
     Image.from_registry(args.get("image"), add_python="3.11")
     .apt_install("curl", "dumb-init", "git", "git-lfs")
     .run_commands(
@@ -44,16 +44,11 @@ app.image = (
     .env({"ENTRYPOINTD": ""})
 )
 
-
-mount = (
-    Mount.from_local_dir(
+if args.get("mount"):
+    image = image.add_local_dir(
         args.get("mount"),
         remote_path="/home/coder/mount",
     )
-    if args.get("mount")
-    else None
-)
-mounts = [mount] if mount else []
 
 volume = (
     Volume.from_name(
@@ -80,12 +75,12 @@ def wait_for_port(data: tuple[str, str], q: Queue):
 
 
 @app.function(
+    image=image,
     cpu=args.get("cpu"),
     memory=args.get("memory"),
     gpu=args.get("gpu"),
     timeout=args.get("timeout"),
     secrets=[Secret.from_dict({"MODAL_LAUNCH_ARGS": json.dumps(args)})],
-    mounts=mounts,
     volumes=volumes,
     concurrency_limit=1 if volume else None,
 )

modal/cli/volume.py

@@ -287,3 +287,26 @@ async def delete(
         )
 
     await _Volume.delete(volume_name, environment_name=env)
+
+
+@volume_cli.command(
+    name="rename",
+    help="Rename a modal.Volume.",
+    rich_help_panel="Management",
+)
+@synchronizer.create_blocking
+async def rename(
+    old_name: str,
+    new_name: str,
+    yes: bool = YES_OPTION,
+    env: Optional[str] = ENV_OPTION,
+):
+    if not yes:
+        typer.confirm(
+            f"Are you sure you want rename the modal.Volume '{old_name}'?"
+            " This may break any Apps currently using it.",
+            default=False,
+            abort=True,
+        )
+
+    await _Volume.rename(old_name, new_name, environment_name=env)

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

modal/file_pattern_matcher.py

@@ -35,7 +35,7 @@ class _AbstractPatternMatcher:
         """
         return _CustomPatternMatcher(lambda path: not self(path))
 
-    def with_repr(self, custom_repr) -> "_AbstractPatternMatcher":
+    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
@@ -60,7 +60,45 @@ class _CustomPatternMatcher(_AbstractPatternMatcher):
 
 
 class FilePatternMatcher(_AbstractPatternMatcher):
-    """Allows matching file paths against a list of patterns."""
+    """
+    Allows matching file Path objects against a list of patterns.
+
+    **Usage:**
+    ```python
+    from pathlib import Path
+    from modal import FilePatternMatcher
+
+    matcher = FilePatternMatcher("*.py")
+
+    assert matcher(Path("foo.py"))
+
+    # You can also negate the matcher.
+    negated_matcher = ~matcher
+
+    assert not negated_matcher(Path("foo.py"))
+    ```
+    """
+
+    patterns: list[Pattern]
+    _delayed_init: Callable[[], None] = None
+
+    def _set_patterns(self, patterns: Sequence[str]) -> None:
+        self.patterns = []
+        for pattern in list(patterns):
+            pattern = pattern.strip()
+            if not pattern:
+                continue
+            pattern = os.path.normpath(pattern)
+            new_pattern = Pattern()
+            if pattern[0] == "!":
+                if len(pattern) == 1:
+                    raise ValueError('Illegal exclusion pattern: "!"')
+                new_pattern.exclusion = True
+                pattern = pattern[1:]
+            # In Python, we can proceed without explicit syntax checking
+            new_pattern.cleaned_pattern = pattern
+            new_pattern.dirs = pattern.split(os.path.sep)
+            self.patterns.append(new_pattern)
 
     def __init__(self, *pattern: str) -> None:
         """Initialize a new FilePatternMatcher instance.
@@ -71,24 +109,34 @@ class FilePatternMatcher(_AbstractPatternMatcher):
         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)
+        self._set_patterns(pattern)
+
+    @classmethod
+    def from_file(cls, file_path: Path) -> "FilePatternMatcher":
+        """Initialize a new FilePatternMatcher instance from a file.
+
+        The patterns in the file will be read lazily when the matcher is first used.
+
+        Args:
+            file_path (Path): The path to the file containing patterns.
+
+        **Usage:**
+        ```python
+        from pathlib import Path
+        from modal import FilePatternMatcher
+
+        matcher = FilePatternMatcher.from_file(Path("/path/to/ignorefile"))
+        ```
+
+        """
+        uninitialized = cls.__new__(cls)
+
+        def _delayed_init():
+            uninitialized._set_patterns(file_path.read_text("utf8").splitlines())
+            uninitialized._delayed_init = None
+
+        uninitialized._delayed_init = _delayed_init
+        return uninitialized
 
     def _matches(self, file_path: str) -> bool:
         """Check if the file path or any of its parent directories match the patterns.
@@ -97,6 +145,7 @@ class FilePatternMatcher(_AbstractPatternMatcher):
         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 == ".":
@@ -128,31 +177,15 @@ class FilePatternMatcher(_AbstractPatternMatcher):
         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"))
-        ```
-        """
+        if self._delayed_init:
+            self._delayed_init()
         return self._matches(str(file_path))
 
 
-# with_repr allows us to use this matcher as a default value in a function signature
+# _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
+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]:

modal/functions.pyi

@@ -462,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]: ...
@@ -479,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]: ...