modal 1.0.6.dev58__py3-none-any.whl → 1.2.3.dev7__py3-none-any.whl

modal/functions.pyi

@@ -1,6 +1,7 @@
 import collections.abc
 import google.protobuf.message
 import modal._functions
+import modal._load_context
 import modal._utils.async_utils
 import modal._utils.function_utils
 import modal.app
@@ -66,9 +67,10 @@ class Function(
     @staticmethod
     def from_local(
         info: modal._utils.function_utils.FunctionInfo,
-        app,
+        app: typing.Optional[modal.app.App],
         image: modal.image.Image,
-        secrets: collections.abc.Sequence[modal.secret.Secret] = (),
+        env: typing.Optional[dict[str, typing.Optional[str]]] = None,
+        secrets: typing.Optional[collections.abc.Collection[modal.secret.Secret]] = None,
         schedule: typing.Optional[modal.schedule.Schedule] = None,
         is_generator: bool = False,
         gpu: typing.Union[None, str, modal.gpu._GPUConfig, list[typing.Union[None, str, modal.gpu._GPUConfig]]] = None,
@@ -84,7 +86,8 @@ class Function(
         memory: typing.Union[int, tuple[int, int], None] = None,
         proxy: typing.Optional[modal.proxy.Proxy] = None,
         retries: typing.Union[int, modal.retries.Retries, None] = None,
-        timeout: typing.Optional[int] = None,
+        timeout: int = 300,
+        startup_timeout: typing.Optional[int] = None,
         min_containers: typing.Optional[int] = None,
         max_containers: typing.Optional[int] = None,
         buffer_containers: typing.Optional[int] = None,
@@ -105,13 +108,16 @@ class Function(
         rdma: typing.Optional[bool] = None,
         max_inputs: typing.Optional[int] = None,
         ephemeral_disk: typing.Optional[int] = None,
-        include_source: typing.Optional[bool] = None,
+        include_source: bool = True,
         experimental_options: typing.Optional[dict[str, str]] = None,
         _experimental_proxy_ip: typing.Optional[str] = None,
         _experimental_custom_scaling_factor: typing.Optional[float] = None,
-        _experimental_enable_gpu_snapshot: bool = False,
+        restrict_output: bool = False,
     ) -> Function:
-        """mdmd:hidden"""
+        """mdmd:hidden
+
+        Note: This is not intended to be public API.
+        """
         ...
 
     def _bind_parameters(
@@ -240,10 +246,16 @@ class Function(
     keep_warm: __keep_warm_spec[typing_extensions.Self]
 
     @classmethod
-    def _from_name(cls, app_name: str, name: str, namespace=None, environment_name: typing.Optional[str] = None): ...
+    def _from_name(cls, app_name: str, name: str, *, load_context_overrides: modal._load_context.LoadContext): ...
     @classmethod
     def from_name(
-        cls: type[Function], app_name: str, name: str, *, namespace=None, environment_name: typing.Optional[str] = None
+        cls: type[Function],
+        app_name: str,
+        name: str,
+        *,
+        namespace=None,
+        environment_name: typing.Optional[str] = None,
+        client: typing.Optional[modal.client.Client] = None,
     ) -> Function:
         """Reference a Function from a deployed App by its name.
 
@@ -257,55 +269,6 @@ class Function(
         """
         ...
 
-    class __lookup_spec(typing_extensions.Protocol):
-        def __call__(
-            self,
-            /,
-            app_name: str,
-            name: str,
-            namespace=None,
-            client: typing.Optional[modal.client.Client] = None,
-            environment_name: typing.Optional[str] = None,
-        ) -> Function:
-            """mdmd:hidden
-            Lookup a Function from a deployed App by its name.
-
-            DEPRECATED: This method is deprecated in favor of `modal.Function.from_name`.
-
-            In contrast to `modal.Function.from_name`, this is an eager method
-            that will hydrate the local object with metadata from Modal servers.
-
-            ```python notest
-            f = modal.Function.lookup("other-app", "function")
-            ```
-            """
-            ...
-
-        async def aio(
-            self,
-            /,
-            app_name: str,
-            name: str,
-            namespace=None,
-            client: typing.Optional[modal.client.Client] = None,
-            environment_name: typing.Optional[str] = None,
-        ) -> Function:
-            """mdmd:hidden
-            Lookup a Function from a deployed App by its name.
-
-            DEPRECATED: This method is deprecated in favor of `modal.Function.from_name`.
-
-            In contrast to `modal.Function.from_name`, this is an eager method
-            that will hydrate the local object with metadata from Modal servers.
-
-            ```python notest
-            f = modal.Function.lookup("other-app", "function")
-            ```
-            """
-            ...
-
-    lookup: __lookup_spec
-
     @property
     def tag(self) -> str:
         """mdmd:hidden"""
@@ -360,6 +323,17 @@ class Function(
 
     get_web_url: __get_web_url_spec[typing_extensions.Self]
 
+    class ___experimental_get_flash_urls_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /) -> typing.Optional[list[str]]:
+            """URL of the flash service for the function."""
+            ...
+
+        async def aio(self, /) -> typing.Optional[list[str]]:
+            """URL of the flash service for the function."""
+            ...
+
+    _experimental_get_flash_urls: ___experimental_get_flash_urls_spec[typing_extensions.Self]
+
     @property
     def is_generator(self) -> bool:
         """mdmd:hidden"""
@@ -406,6 +380,12 @@ class Function(
 
     _map: ___map_spec[typing_extensions.Self]
 
+    class ___spawn_map_spec(typing_extensions.Protocol[ReturnType_INNER, SUPERSELF]):
+        def __call__(self, /, input_queue: modal.parallel_map.SynchronizedQueue) -> FunctionCall[ReturnType_INNER]: ...
+        async def aio(self, /, input_queue: modal.parallel_map.SynchronizedQueue) -> FunctionCall[ReturnType_INNER]: ...
+
+    _spawn_map: ___spawn_map_spec[modal._functions.ReturnType, typing_extensions.Self]
+
     class ___call_function_spec(typing_extensions.Protocol[ReturnType_INNER, SUPERSELF]):
         def __call__(self, /, args, kwargs) -> ReturnType_INNER: ...
         async def aio(self, /, args, kwargs) -> ReturnType_INNER: ...
@@ -694,6 +674,34 @@ class Function(
 
     spawn_map: __spawn_map_spec[typing_extensions.Self]
 
+    class __experimental_spawn_map_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /, *input_iterators, kwargs={}) -> modal._functions._FunctionCall:
+            """mdmd:hidden
+            Spawn parallel execution over a set of inputs, returning as soon as the inputs are created.
+
+            Unlike `modal.Function.map`, this method does not block on completion of the remote execution but
+            returns a `modal.FunctionCall` object that can be used to poll status and retrieve results later.
+
+            Takes one iterator argument per argument in the function being mapped over.
+
+            Example:
+            ```python
+            @app.function()
+            def my_func(a, b):
+                return a ** b
+
+
+            @app.local_entrypoint()
+            def main():
+                fc = my_func.spawn_map([1, 2], [3, 4])
+            ```
+            """
+            ...
+
+        async def aio(self, /, *input_iterators, kwargs={}) -> modal._functions._FunctionCall: ...
+
+    experimental_spawn_map: __experimental_spawn_map_spec[typing_extensions.Self]
+
 class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Object):
     """A reference to an executed function call.
 
@@ -706,6 +714,7 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
     """
 
     _is_generator: bool
+    _num_inputs: typing.Optional[int]
 
     def __init__(self, *args, **kwargs):
         """mdmd:hidden"""
@@ -713,9 +722,22 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
 
     def _invocation(self): ...
 
+    class __num_inputs_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /) -> int:
+            """Get the number of inputs in the function call."""
+            ...
+
+        async def aio(self, /) -> int:
+            """Get the number of inputs in the function call."""
+            ...
+
+    num_inputs: __num_inputs_spec[typing_extensions.Self]
+
     class __get_spec(typing_extensions.Protocol[ReturnType_INNER, SUPERSELF]):
-        def __call__(self, /, timeout: typing.Optional[float] = None) -> ReturnType_INNER:
-            """Get the result of the function call.
+        def __call__(self, /, timeout: typing.Optional[float] = None, *, index: int = 0) -> ReturnType_INNER:
+            """Get the result of the index-th input of the function call.
+            `.spawn()` calls have a single output, so only specifying `index=0` is valid.
+            A non-zero index is useful when your function has multiple outputs, like via `.spawn_map()`.
 
             This function waits indefinitely by default. It takes an optional
             `timeout` argument that specifies the maximum number of seconds to wait,
@@ -725,8 +747,10 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
             """
             ...
 
-        async def aio(self, /, timeout: typing.Optional[float] = None) -> ReturnType_INNER:
-            """Get the result of the function call.
+        async def aio(self, /, timeout: typing.Optional[float] = None, *, index: int = 0) -> ReturnType_INNER:
+            """Get the result of the index-th input of the function call.
+            `.spawn()` calls have a single output, so only specifying `index=0` is valid.
+            A non-zero index is useful when your function has multiple outputs, like via `.spawn_map()`.
 
             This function waits indefinitely by default. It takes an optional
             `timeout` argument that specifies the maximum number of seconds to wait,
@@ -738,6 +762,55 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
 
     get: __get_spec[modal._functions.ReturnType, typing_extensions.Self]
 
+    class __iter_spec(typing_extensions.Protocol[ReturnType_INNER, SUPERSELF]):
+        def __call__(self, /, *, start: int = 0, end: typing.Optional[int] = None) -> typing.Iterator[ReturnType_INNER]:
+            """Iterate in-order over the results of the function call.
+
+            Optionally, specify a range [start, end) to iterate over.
+
+            Example:
+            ```python
+            @app.function()
+            def my_func(a):
+                return a ** 2
+
+
+            @app.local_entrypoint()
+            def main():
+                fc = my_func.spawn_map([1, 2, 3, 4])
+                assert list(fc.iter()) == [1, 4, 9, 16]
+                assert list(fc.iter(start=1, end=3)) == [4, 9]
+            ```
+
+            If `end` is not provided, it will iterate over all results.
+            """
+            ...
+
+        def aio(self, /, *, start: int = 0, end: typing.Optional[int] = None) -> typing.AsyncIterator[ReturnType_INNER]:
+            """Iterate in-order over the results of the function call.
+
+            Optionally, specify a range [start, end) to iterate over.
+
+            Example:
+            ```python
+            @app.function()
+            def my_func(a):
+                return a ** 2
+
+
+            @app.local_entrypoint()
+            def main():
+                fc = my_func.spawn_map([1, 2, 3, 4])
+                assert list(fc.iter()) == [1, 4, 9, 16]
+                assert list(fc.iter(start=1, end=3)) == [4, 9]
+            ```
+
+            If `end` is not provided, it will iterate over all results.
+            """
+            ...
+
+    iter: __iter_spec[modal._functions.ReturnType, typing_extensions.Self]
+
     class __get_call_graph_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /) -> list[modal.call_graph.InputInfo]:
             """Returns a structure representing the call graph from a given root