modal 0.72.4__py3-none-any.whl → 0.72.48__py3-none-any.whl

modal/dict.py

@@ -7,6 +7,7 @@ from synchronicity.async_wrap import asynccontextmanager
 
 from modal_proto import api_pb2
 
+from ._object import EPHEMERAL_OBJECT_HEARTBEAT_SLEEP, _get_environment_name, _Object, live_method, live_method_gen
 from ._resolver import Resolver
 from ._serialization import deserialize, serialize
 from ._utils.async_utils import TaskContext, synchronize_api
@@ -16,7 +17,6 @@ from ._utils.name_utils import check_object_name
 from .client import _Client
 from .config import logger
 from .exception import RequestSizeError
-from .object import EPHEMERAL_OBJECT_HEARTBEAT_SLEEP, _get_environment_name, _Object, live_method, live_method_gen
 
 
 def _serialize_dict(data):

modal/dict.pyi

@@ -1,4 +1,5 @@
 import collections.abc
+import modal._object
 import modal.client
 import modal.object
 import synchronicity.combined_types
@@ -7,7 +8,7 @@ import typing_extensions
 
 def _serialize_dict(data): ...
 
-class _Dict(modal.object._Object):
+class _Dict(modal._object._Object):
     def __init__(self, data={}): ...
     @classmethod
     def ephemeral(
@@ -56,6 +57,8 @@ class _Dict(modal.object._Object):
     def values(self) -> collections.abc.AsyncIterator[typing.Any]: ...
     def items(self) -> collections.abc.AsyncIterator[tuple[typing.Any, typing.Any]]: ...
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class Dict(modal.object.Object):
     def __init__(self, data={}): ...
     @classmethod
@@ -115,86 +118,86 @@ class Dict(modal.object.Object):
 
     delete: __delete_spec
 
-    class __clear_spec(typing_extensions.Protocol):
+    class __clear_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> None: ...
         async def aio(self) -> None: ...
 
-    clear: __clear_spec
+    clear: __clear_spec[typing_extensions.Self]
 
-    class __get_spec(typing_extensions.Protocol):
+    class __get_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any, default: typing.Optional[typing.Any] = None) -> typing.Any: ...
         async def aio(self, key: typing.Any, default: typing.Optional[typing.Any] = None) -> typing.Any: ...
 
-    get: __get_spec
+    get: __get_spec[typing_extensions.Self]
 
-    class __contains_spec(typing_extensions.Protocol):
+    class __contains_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any) -> bool: ...
         async def aio(self, key: typing.Any) -> bool: ...
 
-    contains: __contains_spec
+    contains: __contains_spec[typing_extensions.Self]
 
-    class __len_spec(typing_extensions.Protocol):
+    class __len_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> int: ...
         async def aio(self) -> int: ...
 
-    len: __len_spec
+    len: __len_spec[typing_extensions.Self]
 
-    class ____getitem___spec(typing_extensions.Protocol):
+    class ____getitem___spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any) -> typing.Any: ...
         async def aio(self, key: typing.Any) -> typing.Any: ...
 
-    __getitem__: ____getitem___spec
+    __getitem__: ____getitem___spec[typing_extensions.Self]
 
-    class __update_spec(typing_extensions.Protocol):
+    class __update_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, **kwargs) -> None: ...
         async def aio(self, **kwargs) -> None: ...
 
-    update: __update_spec
+    update: __update_spec[typing_extensions.Self]
 
-    class __put_spec(typing_extensions.Protocol):
+    class __put_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any, value: typing.Any) -> None: ...
         async def aio(self, key: typing.Any, value: typing.Any) -> None: ...
 
-    put: __put_spec
+    put: __put_spec[typing_extensions.Self]
 
-    class ____setitem___spec(typing_extensions.Protocol):
+    class ____setitem___spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any, value: typing.Any) -> None: ...
         async def aio(self, key: typing.Any, value: typing.Any) -> None: ...
 
-    __setitem__: ____setitem___spec
+    __setitem__: ____setitem___spec[typing_extensions.Self]
 
-    class __pop_spec(typing_extensions.Protocol):
+    class __pop_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any) -> typing.Any: ...
         async def aio(self, key: typing.Any) -> typing.Any: ...
 
-    pop: __pop_spec
+    pop: __pop_spec[typing_extensions.Self]
 
-    class ____delitem___spec(typing_extensions.Protocol):
+    class ____delitem___spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any) -> typing.Any: ...
         async def aio(self, key: typing.Any) -> typing.Any: ...
 
-    __delitem__: ____delitem___spec
+    __delitem__: ____delitem___spec[typing_extensions.Self]
 
-    class ____contains___spec(typing_extensions.Protocol):
+    class ____contains___spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any) -> bool: ...
         async def aio(self, key: typing.Any) -> bool: ...
 
-    __contains__: ____contains___spec
+    __contains__: ____contains___spec[typing_extensions.Self]
 
-    class __keys_spec(typing_extensions.Protocol):
+    class __keys_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> typing.Iterator[typing.Any]: ...
         def aio(self) -> collections.abc.AsyncIterator[typing.Any]: ...
 
-    keys: __keys_spec
+    keys: __keys_spec[typing_extensions.Self]
 
-    class __values_spec(typing_extensions.Protocol):
+    class __values_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> typing.Iterator[typing.Any]: ...
         def aio(self) -> collections.abc.AsyncIterator[typing.Any]: ...
 
-    values: __values_spec
+    values: __values_spec[typing_extensions.Self]
 
-    class __items_spec(typing_extensions.Protocol):
+    class __items_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> typing.Iterator[tuple[typing.Any, typing.Any]]: ...
         def aio(self) -> collections.abc.AsyncIterator[tuple[typing.Any, typing.Any]]: ...
 
-    items: __items_spec
+    items: __items_spec[typing_extensions.Self]

modal/environments.py

@@ -8,6 +8,7 @@ from google.protobuf.wrappers_pb2 import StringValue
 
 from modal_proto import api_pb2
 
+from ._object import _Object
 from ._resolver import Resolver
 from ._utils.async_utils import synchronize_api, synchronizer
 from ._utils.deprecation import renamed_parameter
@@ -15,7 +16,6 @@ from ._utils.grpc_utils import retry_transient_errors
 from ._utils.name_utils import check_object_name
 from .client import _Client
 from .config import config, logger
-from .object import _Object
 
 
 @dataclass(frozen=True)

modal/environments.pyi

@@ -1,4 +1,5 @@
 import google.protobuf.message
+import modal._object
 import modal.client
 import modal.object
 import modal_proto.api_pb2
@@ -16,7 +17,7 @@ class EnvironmentSettings:
     def __delattr__(self, name): ...
     def __hash__(self): ...
 
-class _Environment(modal.object._Object):
+class _Environment(modal._object._Object):
     _settings: EnvironmentSettings
 
     def __init__(self): ...

modal/experimental.py

@@ -1,16 +1,16 @@
 # Copyright Modal Labs 2022
-from typing import (
-    Any,
-    Callable,
-)
+from dataclasses import dataclass
+from typing import Any, Callable, Optional
 
-import modal._clustered_functions
-from modal.functions import _Function
+from modal_proto import api_pb2
 
+from ._clustered_functions import ClusterInfo, get_cluster_info as _get_cluster_info
+from ._object import _get_environment_name
 from ._runtime.container_io_manager import _ContainerIOManager
-from .exception import (
-    InvalidError,
-)
+from ._utils.async_utils import synchronizer
+from .client import _Client
+from .exception import InvalidError
+from .functions import _Function
 from .partial_function import _PartialFunction, _PartialFunctionFlags
 
 
@@ -65,5 +65,41 @@ def clustered(size: int, broadcast: bool = True):
     return wrapper
 
 
-def get_cluster_info() -> modal._clustered_functions.ClusterInfo:
-    return modal._clustered_functions.get_cluster_info()
+def get_cluster_info() -> ClusterInfo:
+    return _get_cluster_info()
+
+
+@dataclass
+class AppInfo:
+    app_id: str
+    name: str
+    containers: int
+
+
+@synchronizer.create_blocking
+async def list_deployed_apps(environment_name: str = "", client: Optional[_Client] = None) -> list[AppInfo]:
+    """List deployed Apps along with the number of containers currently running."""
+    # This function exists to provide backwards compatibility for some users who had been
+    # calling into the private function that previously backed the `modal app list` CLI command.
+    # We plan to add more Python API for exposing this sort of information, but we haven't
+    # settled on a design we're happy with yet. In the meantime, this function will continue
+    # to support existing codebases. It's likely that the final API will be different
+    # (e.g. more oriented around the App object). This function should be gracefully deprecated
+    # one the new API is released.
+    client = client or await _Client.from_env()
+
+    resp: api_pb2.AppListResponse = await client.stub.AppList(
+        api_pb2.AppListRequest(environment_name=_get_environment_name(environment_name))
+    )
+
+    app_infos = []
+    for app_stats in resp.apps:
+        if app_stats.state == api_pb2.APP_STATE_DEPLOYED:
+            app_infos.append(
+                AppInfo(
+                    app_id=app_stats.app_id,
+                    name=app_stats.description,
+                    containers=app_stats.n_running_tasks,
+                )
+            )
+    return app_infos

modal/experimental.pyi

@@ -0,0 +1,29 @@
+import modal._clustered_functions
+import modal.client
+import typing
+import typing_extensions
+
+def stop_fetching_inputs(): ...
+def get_local_input_concurrency(): ...
+def set_local_input_concurrency(concurrency: int): ...
+def clustered(size: int, broadcast: bool = True): ...
+def get_cluster_info() -> modal._clustered_functions.ClusterInfo: ...
+
+class AppInfo:
+    app_id: str
+    name: str
+    containers: int
+
+    def __init__(self, app_id: str, name: str, containers: int) -> None: ...
+    def __repr__(self): ...
+    def __eq__(self, other): ...
+
+class __list_deployed_apps_spec(typing_extensions.Protocol):
+    def __call__(
+        self, environment_name: str = "", client: typing.Optional[modal.client.Client] = None
+    ) -> list[AppInfo]: ...
+    async def aio(
+        self, environment_name: str = "", client: typing.Optional[modal.client.Client] = None
+    ) -> list[AppInfo]: ...
+
+list_deployed_apps: __list_deployed_apps_spec

modal/file_io.pyi

@@ -100,6 +100,8 @@ class __replace_bytes_spec(typing_extensions.Protocol):
 
 replace_bytes: __replace_bytes_spec
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 T_INNER = typing.TypeVar("T_INNER", covariant=True)
 
 class FileIO(typing.Generic[T]):
@@ -112,37 +114,37 @@ class FileIO(typing.Generic[T]):
     def _validate_mode(self, mode: str) -> None: ...
     def _handle_error(self, error: modal_proto.api_pb2.SystemErrorMessage) -> None: ...
 
-    class ___consume_output_spec(typing_extensions.Protocol):
+    class ___consume_output_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, exec_id: str) -> typing.Iterator[typing.Optional[bytes]]: ...
         def aio(self, exec_id: str) -> typing.AsyncIterator[typing.Optional[bytes]]: ...
 
-    _consume_output: ___consume_output_spec
+    _consume_output: ___consume_output_spec[typing_extensions.Self]
 
-    class ___consume_watch_output_spec(typing_extensions.Protocol):
+    class ___consume_watch_output_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, exec_id: str) -> None: ...
         async def aio(self, exec_id: str) -> None: ...
 
-    _consume_watch_output: ___consume_watch_output_spec
+    _consume_watch_output: ___consume_watch_output_spec[typing_extensions.Self]
 
-    class ___parse_watch_output_spec(typing_extensions.Protocol):
+    class ___parse_watch_output_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, event: bytes) -> typing.Optional[FileWatchEvent]: ...
         async def aio(self, event: bytes) -> typing.Optional[FileWatchEvent]: ...
 
-    _parse_watch_output: ___parse_watch_output_spec
+    _parse_watch_output: ___parse_watch_output_spec[typing_extensions.Self]
 
-    class ___wait_spec(typing_extensions.Protocol):
+    class ___wait_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, exec_id: str) -> bytes: ...
         async def aio(self, exec_id: str) -> bytes: ...
 
-    _wait: ___wait_spec
+    _wait: ___wait_spec[typing_extensions.Self]
 
     def _validate_type(self, data: typing.Union[bytes, str]) -> None: ...
 
-    class ___open_file_spec(typing_extensions.Protocol):
+    class ___open_file_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, path: str, mode: str) -> None: ...
         async def aio(self, path: str, mode: str) -> None: ...
 
-    _open_file: ___open_file_spec
+    _open_file: ___open_file_spec[typing_extensions.Self]
 
     @classmethod
     def create(
@@ -153,49 +155,49 @@ class FileIO(typing.Generic[T]):
         task_id: str,
     ) -> FileIO: ...
 
-    class ___make_read_request_spec(typing_extensions.Protocol):
+    class ___make_read_request_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, n: typing.Optional[int]) -> bytes: ...
         async def aio(self, n: typing.Optional[int]) -> bytes: ...
 
-    _make_read_request: ___make_read_request_spec
+    _make_read_request: ___make_read_request_spec[typing_extensions.Self]
 
-    class __read_spec(typing_extensions.Protocol[T_INNER]):
+    class __read_spec(typing_extensions.Protocol[T_INNER, SUPERSELF]):
         def __call__(self, n: typing.Optional[int] = None) -> T_INNER: ...
         async def aio(self, n: typing.Optional[int] = None) -> T_INNER: ...
 
-    read: __read_spec[T]
+    read: __read_spec[T, typing_extensions.Self]
 
-    class __readline_spec(typing_extensions.Protocol[T_INNER]):
+    class __readline_spec(typing_extensions.Protocol[T_INNER, SUPERSELF]):
         def __call__(self) -> T_INNER: ...
         async def aio(self) -> T_INNER: ...
 
-    readline: __readline_spec[T]
+    readline: __readline_spec[T, typing_extensions.Self]
 
-    class __readlines_spec(typing_extensions.Protocol[T_INNER]):
+    class __readlines_spec(typing_extensions.Protocol[T_INNER, SUPERSELF]):
         def __call__(self) -> typing.Sequence[T_INNER]: ...
         async def aio(self) -> typing.Sequence[T_INNER]: ...
 
-    readlines: __readlines_spec[T]
+    readlines: __readlines_spec[T, typing_extensions.Self]
 
-    class __write_spec(typing_extensions.Protocol):
+    class __write_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, data: typing.Union[bytes, str]) -> None: ...
         async def aio(self, data: typing.Union[bytes, str]) -> None: ...
 
-    write: __write_spec
+    write: __write_spec[typing_extensions.Self]
 
-    class __flush_spec(typing_extensions.Protocol):
+    class __flush_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> None: ...
         async def aio(self) -> None: ...
 
-    flush: __flush_spec
+    flush: __flush_spec[typing_extensions.Self]
 
     def _get_whence(self, whence: int): ...
 
-    class __seek_spec(typing_extensions.Protocol):
+    class __seek_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, offset: int, whence: int = 0) -> None: ...
         async def aio(self, offset: int, whence: int = 0) -> None: ...
 
-    seek: __seek_spec
+    seek: __seek_spec[typing_extensions.Self]
 
     @classmethod
     def ls(cls, path: str, client: modal.client.Client, task_id: str) -> list[str]: ...
@@ -214,17 +216,17 @@ class FileIO(typing.Generic[T]):
         timeout: typing.Optional[int] = None,
     ) -> typing.Iterator[FileWatchEvent]: ...
 
-    class ___close_spec(typing_extensions.Protocol):
+    class ___close_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> None: ...
         async def aio(self) -> None: ...
 
-    _close: ___close_spec
+    _close: ___close_spec[typing_extensions.Self]
 
-    class __close_spec(typing_extensions.Protocol):
+    class __close_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> None: ...
         async def aio(self) -> None: ...
 
-    close: __close_spec
+    close: __close_spec[typing_extensions.Self]
 
     def _check_writable(self) -> None: ...
     def _check_readable(self) -> None: ...

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,24 @@ 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
@@ -95,18 +112,26 @@ class FilePatternMatcher(_AbstractPatternMatcher):
         self._set_patterns(pattern)
 
     @classmethod
-    def from_file(cls, file_path: Path) -> "FilePatternMatcher":
+    def from_file(cls, file_path: Union[str, 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 modal import FilePatternMatcher
+
+        matcher = FilePatternMatcher.from_file("/path/to/ignorefile")
+        ```
+
         """
         uninitialized = cls.__new__(cls)
 
         def _delayed_init():
-            uninitialized._set_patterns(file_path.read_text("utf8").splitlines())
+            uninitialized._set_patterns(Path(file_path).read_text("utf8").splitlines())
             uninitialized._delayed_init = None
 
         uninitialized._delayed_init = _delayed_init
@@ -151,33 +176,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]: