modal 1.1.1.dev41__py3-none-any.whl → 1.1.2__py3-none-any.whl

modal/network_file_system.py

@@ -136,7 +136,7 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
         cls: type["_NetworkFileSystem"],
         client: Optional[_Client] = None,
         environment_name: Optional[str] = None,
-        _heartbeat_sleep: float = EPHEMERAL_OBJECT_HEARTBEAT_SLEEP,
+        _heartbeat_sleep: float = EPHEMERAL_OBJECT_HEARTBEAT_SLEEP,  # mdmd:line-hidden
     ) -> AsyncIterator["_NetworkFileSystem"]:
         """Creates a new ephemeral network filesystem within a context manager:
 
@@ -161,7 +161,13 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
         async with TaskContext() as tc:
             request = api_pb2.SharedVolumeHeartbeatRequest(shared_volume_id=response.shared_volume_id)
             tc.infinite_loop(lambda: client.stub.SharedVolumeHeartbeat(request), sleep=_heartbeat_sleep)
-            yield cls._new_hydrated(response.shared_volume_id, client, None, is_another_app=True)
+            yield cls._new_hydrated(
+                response.shared_volume_id,
+                client,
+                None,
+                is_another_app=True,
+                rep="modal.NetworkFileSystem.ephemeral()",
+            )
 
     @staticmethod
     async def lookup(

modal/object.pyi

@@ -117,12 +117,15 @@ class Object:
     @classmethod
     def _is_id_type(cls, object_id) -> bool: ...
     @classmethod
+    def _repr(cls, name: str, environment_name: typing.Optional[str] = None) -> str: ...
+    @classmethod
     def _new_hydrated(
         cls,
         object_id: str,
         client: modal.client.Client,
         handle_metadata: typing.Optional[google.protobuf.message.Message],
         is_another_app: bool = False,
+        rep: typing.Optional[str] = None,
     ) -> typing_extensions.Self: ...
     def _hydrate_from_other(self, other: typing_extensions.Self): ...
     def __repr__(self): ...

modal/parallel_map.py

@@ -86,6 +86,274 @@ if typing.TYPE_CHECKING:
     import modal.functions
 
 
+class InputPreprocessor:
+    """
+    Constructs FunctionPutInputsItem objects from the raw-input queue, and puts them in the processed-input queue.
+    """
+
+    def __init__(
+        self,
+        client: "modal.client._Client",
+        *,
+        raw_input_queue: _SynchronizedQueue,
+        processed_input_queue: asyncio.Queue,
+        function: "modal.functions._Function",
+        created_callback: Callable[[int], None],
+        done_callback: Callable[[], None],
+    ):
+        self.client = client
+        self.function = function
+        self.inputs_created = 0
+        self.raw_input_queue = raw_input_queue
+        self.processed_input_queue = processed_input_queue
+        self.created_callback = created_callback
+        self.done_callback = done_callback
+
+    async def input_iter(self):
+        while 1:
+            raw_input = await self.raw_input_queue.get()
+            if raw_input is None:  # end of input sentinel
+                break
+            yield raw_input  # args, kwargs
+
+    def create_input_factory(self):
+        async def create_input(argskwargs):
+            idx = self.inputs_created
+            self.inputs_created += 1
+            self.created_callback(self.inputs_created)
+            (args, kwargs) = argskwargs
+            return await _create_input(
+                args,
+                kwargs,
+                self.client.stub,
+                max_object_size_bytes=self.function._max_object_size_bytes,
+                idx=idx,
+                method_name=self.function._use_method_name,
+            )
+
+        return create_input
+
+    async def drain_input_generator(self):
+        # Parallelize uploading blobs
+        async with aclosing(
+            async_map_ordered(self.input_iter(), self.create_input_factory(), concurrency=BLOB_MAX_PARALLELISM)
+        ) as streamer:
+            async for item in streamer:
+                await self.processed_input_queue.put(item)
+
+        # close queue iterator
+        await self.processed_input_queue.put(None)
+        self.done_callback()
+        yield
+
+
+class InputPumper:
+    """
+    Reads inputs from a queue of FunctionPutInputsItems, and sends them to the server.
+    """
+
+    def __init__(
+        self,
+        client: "modal.client._Client",
+        *,
+        input_queue: asyncio.Queue,
+        function: "modal.functions._Function",
+        function_call_id: str,
+        map_items_manager: Optional["_MapItemsManager"] = None,
+    ):
+        self.client = client
+        self.function = function
+        self.map_items_manager = map_items_manager
+        self.input_queue = input_queue
+        self.inputs_sent = 0
+        self.function_call_id = function_call_id
+
+    async def pump_inputs(self):
+        assert self.client.stub
+        async for items in queue_batch_iterator(self.input_queue, max_batch_size=MAP_INVOCATION_CHUNK_SIZE):
+            # Add items to the manager. Their state will be SENDING.
+            if self.map_items_manager is not None:
+                await self.map_items_manager.add_items(items)
+            request = api_pb2.FunctionPutInputsRequest(
+                function_id=self.function.object_id,
+                inputs=items,
+                function_call_id=self.function_call_id,
+            )
+            logger.debug(
+                f"Pushing {len(items)} inputs to server. Num queued inputs awaiting"
+                f" push is {self.input_queue.qsize()}. "
+            )
+
+            resp = await self._send_inputs(self.client.stub.FunctionPutInputs, request)
+            self.inputs_sent += len(items)
+            # Change item state to WAITING_FOR_OUTPUT, and set the input_id and input_jwt which are in the response.
+            if self.map_items_manager is not None:
+                self.map_items_manager.handle_put_inputs_response(resp.inputs)
+            logger.debug(
+                f"Successfully pushed {len(items)} inputs to server. "
+                f"Num queued inputs awaiting push is {self.input_queue.qsize()}."
+            )
+        yield
+
+    async def _send_inputs(
+        self,
+        fn: "modal.client.UnaryUnaryWrapper",
+        request: typing.Union[api_pb2.FunctionPutInputsRequest, api_pb2.FunctionRetryInputsRequest],
+    ) -> typing.Union[api_pb2.FunctionPutInputsResponse, api_pb2.FunctionRetryInputsResponse]:
+        # with 8 retries we log the warning below about every 30 seconds which isn't too spammy.
+        retry_warning_message = RetryWarningMessage(
+            message=f"Warning: map progress for function {self.function._function_name} is limited."
+            " Common bottlenecks include slow iteration over results, or function backlogs.",
+            warning_interval=8,
+            errors_to_warn_for=[Status.RESOURCE_EXHAUSTED],
+        )
+        return await retry_transient_errors(
+            fn,
+            request,
+            max_retries=None,
+            max_delay=PUMP_INPUTS_MAX_RETRY_DELAY,
+            additional_status_codes=[Status.RESOURCE_EXHAUSTED],
+            retry_warning_message=retry_warning_message,
+        )
+
+
+class SyncInputPumper(InputPumper):
+    def __init__(
+        self,
+        client: "modal.client._Client",
+        *,
+        input_queue: asyncio.Queue,
+        retry_queue: TimestampPriorityQueue,
+        function: "modal.functions._Function",
+        function_call_jwt: str,
+        function_call_id: str,
+        map_items_manager: "_MapItemsManager",
+    ):
+        super().__init__(
+            client,
+            input_queue=input_queue,
+            function=function,
+            function_call_id=function_call_id,
+            map_items_manager=map_items_manager,
+        )
+        self.retry_queue = retry_queue
+        self.inputs_retried = 0
+        self.function_call_jwt = function_call_jwt
+
+    async def retry_inputs(self):
+        async for retriable_idxs in queue_batch_iterator(self.retry_queue, max_batch_size=MAP_INVOCATION_CHUNK_SIZE):
+            # For each index, use the context in the manager to create a FunctionRetryInputsItem.
+            # This will also update the context state to RETRYING.
+            inputs: list[api_pb2.FunctionRetryInputsItem] = await self.map_items_manager.prepare_items_for_retry(
+                retriable_idxs
+            )
+            request = api_pb2.FunctionRetryInputsRequest(
+                function_call_jwt=self.function_call_jwt,
+                inputs=inputs,
+            )
+            resp = await self._send_inputs(self.client.stub.FunctionRetryInputs, request)
+            # Update the state to WAITING_FOR_OUTPUT, and update the input_jwt in the context
+            # to the new value in the response.
+            self.map_items_manager.handle_retry_response(resp.input_jwts)
+            logger.debug(f"Successfully pushed retry for {len(inputs)} to server.")
+            self.inputs_retried += len(inputs)
+        yield
+
+
+class AsyncInputPumper(InputPumper):
+    def __init__(
+        self,
+        client: "modal.client._Client",
+        *,
+        input_queue: asyncio.Queue,
+        function: "modal.functions._Function",
+        function_call_id: str,
+    ):
+        super().__init__(client, input_queue=input_queue, function=function, function_call_id=function_call_id)
+
+    async def pump_inputs(self):
+        async for _ in super().pump_inputs():
+            pass
+        request = api_pb2.FunctionFinishInputsRequest(
+            function_id=self.function.object_id,
+            function_call_id=self.function_call_id,
+            num_inputs=self.inputs_sent,
+        )
+        await retry_transient_errors(self.client.stub.FunctionFinishInputs, request, max_retries=None)
+        yield
+
+
+async def _spawn_map_invocation(
+    function: "modal.functions._Function", raw_input_queue: _SynchronizedQueue, client: "modal.client._Client"
+) -> tuple[str, int]:
+    assert client.stub
+    request = api_pb2.FunctionMapRequest(
+        function_id=function.object_id,
+        parent_input_id=current_input_id() or "",
+        function_call_type=api_pb2.FUNCTION_CALL_TYPE_MAP,
+        function_call_invocation_type=api_pb2.FUNCTION_CALL_INVOCATION_TYPE_ASYNC,
+    )
+    response: api_pb2.FunctionMapResponse = await retry_transient_errors(client.stub.FunctionMap, request)
+    function_call_id = response.function_call_id
+
+    have_all_inputs = False
+    inputs_created = 0
+
+    def set_inputs_created(set_inputs_created):
+        nonlocal inputs_created
+        assert set_inputs_created is None or set_inputs_created > inputs_created
+        inputs_created = set_inputs_created
+
+    def set_have_all_inputs():
+        nonlocal have_all_inputs
+        have_all_inputs = True
+
+    input_queue: asyncio.Queue[api_pb2.FunctionPutInputsItem | None] = asyncio.Queue()
+    input_preprocessor = InputPreprocessor(
+        client=client,
+        raw_input_queue=raw_input_queue,
+        processed_input_queue=input_queue,
+        function=function,
+        created_callback=set_inputs_created,
+        done_callback=set_have_all_inputs,
+    )
+
+    input_pumper = AsyncInputPumper(
+        client=client,
+        input_queue=input_queue,
+        function=function,
+        function_call_id=function_call_id,
+    )
+
+    def log_stats():
+        logger.debug(
+            f"have_all_inputs={have_all_inputs} inputs_created={inputs_created} inputs_sent={input_pumper.inputs_sent} "
+        )
+
+    async def log_task():
+        while True:
+            log_stats()
+            try:
+                await asyncio.sleep(10)
+            except asyncio.CancelledError:
+                # Log final stats before exiting
+                log_stats()
+                break
+
+    async def consume_generator(gen):
+        async for _ in gen:
+            pass
+
+    log_debug_stats_task = asyncio.create_task(log_task())
+    await asyncio.gather(
+        consume_generator(input_preprocessor.drain_input_generator()),
+        consume_generator(input_pumper.pump_inputs()),
+    )
+    log_debug_stats_task.cancel()
+    await log_debug_stats_task
+    return function_call_id, inputs_created
+
+
 async def _map_invocation(
     function: "modal.functions._Function",
     raw_input_queue: _SynchronizedQueue,
@@ -117,8 +385,6 @@ async def _map_invocation(
     have_all_inputs = False
     map_done_event = asyncio.Event()
     inputs_created = 0
-    inputs_sent = 0
-    inputs_retried = 0
     outputs_completed = 0
     outputs_received = 0
     retried_outputs = 0
@@ -135,25 +401,24 @@ async def _map_invocation(
         retry_policy, function_call_invocation_type, retry_queue, sync_client_retries_enabled, max_inputs_outstanding
     )
 
-    async def create_input(argskwargs):
-        idx = inputs_created
-        update_state(set_inputs_created=inputs_created + 1)
-        (args, kwargs) = argskwargs
-        return await _create_input(
-            args,
-            kwargs,
-            client.stub,
-            max_object_size_bytes=function._max_object_size_bytes,
-            idx=idx,
-            method_name=function._use_method_name,
-        )
+    input_preprocessor = InputPreprocessor(
+        client=client,
+        raw_input_queue=raw_input_queue,
+        processed_input_queue=input_queue,
+        function=function,
+        created_callback=lambda x: update_state(set_inputs_created=x),
+        done_callback=lambda: update_state(set_have_all_inputs=True),
+    )
 
-    async def input_iter():
-        while 1:
-            raw_input = await raw_input_queue.get()
-            if raw_input is None:  # end of input sentinel
-                break
-            yield raw_input  # args, kwargs
+    input_pumper = SyncInputPumper(
+        client=client,
+        input_queue=input_queue,
+        retry_queue=retry_queue,
+        function=function,
+        map_items_manager=map_items_manager,
+        function_call_jwt=function_call_jwt,
+        function_call_id=function_call_id,
+    )
 
     def update_state(set_have_all_inputs=None, set_inputs_created=None, set_outputs_completed=None):
         # This should be the only method that needs nonlocal of the following vars
@@ -175,84 +440,6 @@ async def _map_invocation(
             # map is done
             map_done_event.set()
 
-    async def drain_input_generator():
-        # Parallelize uploading blobs
-        async with aclosing(
-            async_map_ordered(input_iter(), create_input, concurrency=BLOB_MAX_PARALLELISM)
-        ) as streamer:
-            async for item in streamer:
-                await input_queue.put(item)
-
-        # close queue iterator
-        await input_queue.put(None)
-        update_state(set_have_all_inputs=True)
-        yield
-
-    async def pump_inputs():
-        assert client.stub
-        nonlocal inputs_sent
-        async for items in queue_batch_iterator(input_queue, max_batch_size=MAP_INVOCATION_CHUNK_SIZE):
-            # Add items to the manager. Their state will be SENDING.
-            await map_items_manager.add_items(items)
-            request = api_pb2.FunctionPutInputsRequest(
-                function_id=function.object_id,
-                inputs=items,
-                function_call_id=function_call_id,
-            )
-            logger.debug(
-                f"Pushing {len(items)} inputs to server. Num queued inputs awaiting push is {input_queue.qsize()}."
-            )
-
-            resp = await send_inputs(client.stub.FunctionPutInputs, request)
-            inputs_sent += len(items)
-            # Change item state to WAITING_FOR_OUTPUT, and set the input_id and input_jwt which are in the response.
-            map_items_manager.handle_put_inputs_response(resp.inputs)
-            logger.debug(
-                f"Successfully pushed {len(items)} inputs to server. "
-                f"Num queued inputs awaiting push is {input_queue.qsize()}."
-            )
-        yield
-
-    async def retry_inputs():
-        nonlocal inputs_retried
-        async for retriable_idxs in queue_batch_iterator(retry_queue, max_batch_size=MAP_INVOCATION_CHUNK_SIZE):
-            # For each index, use the context in the manager to create a FunctionRetryInputsItem.
-            # This will also update the context state to RETRYING.
-            inputs: list[api_pb2.FunctionRetryInputsItem] = await map_items_manager.prepare_items_for_retry(
-                retriable_idxs
-            )
-            request = api_pb2.FunctionRetryInputsRequest(
-                function_call_jwt=function_call_jwt,
-                inputs=inputs,
-            )
-            resp = await send_inputs(client.stub.FunctionRetryInputs, request)
-            # Update the state to WAITING_FOR_OUTPUT, and update the input_jwt in the context
-            # to the new value in the response.
-            map_items_manager.handle_retry_response(resp.input_jwts)
-            logger.debug(f"Successfully pushed retry for {len(inputs)} to server.")
-            inputs_retried += len(inputs)
-        yield
-
-    async def send_inputs(
-        fn: "modal.client.UnaryUnaryWrapper",
-        request: typing.Union[api_pb2.FunctionPutInputsRequest, api_pb2.FunctionRetryInputsRequest],
-    ) -> typing.Union[api_pb2.FunctionPutInputsResponse, api_pb2.FunctionRetryInputsResponse]:
-        # with 8 retries we log the warning below about every 30 seconds which isn't too spammy.
-        retry_warning_message = RetryWarningMessage(
-            message=f"Warning: map progress for function {function._function_name} is limited."
-            " Common bottlenecks include slow iteration over results, or function backlogs.",
-            warning_interval=8,
-            errors_to_warn_for=[Status.RESOURCE_EXHAUSTED],
-        )
-        return await retry_transient_errors(
-            fn,
-            request,
-            max_retries=None,
-            max_delay=PUMP_INPUTS_MAX_RETRY_DELAY,
-            additional_status_codes=[Status.RESOURCE_EXHAUSTED],
-            retry_warning_message=retry_warning_message,
-        )
-
     async def get_all_outputs():
         assert client.stub
         nonlocal \
@@ -395,8 +582,11 @@ async def _map_invocation(
         def log_stats():
             logger.debug(
                 f"Map stats: sync_client_retries_enabled={sync_client_retries_enabled} "
-                f"have_all_inputs={have_all_inputs} inputs_created={inputs_created} input_sent={inputs_sent} "
-                f"inputs_retried={inputs_retried} outputs_received={outputs_received} "
+                f"have_all_inputs={have_all_inputs} "
+                f"inputs_created={inputs_created} "
+                f"input_sent={input_pumper.inputs_sent} "
+                f"inputs_retried={input_pumper.inputs_retried} "
+                f"outputs_received={outputs_received} "
                 f"successful_completions={successful_completions} failed_completions={failed_completions} "
                 f"no_context_duplicates={no_context_duplicates} old_retry_duplicates={stale_retry_duplicates} "
                 f"already_complete_duplicates={already_complete_duplicates} "
@@ -415,7 +605,12 @@ async def _map_invocation(
 
     log_debug_stats_task = asyncio.create_task(log_debug_stats())
     async with aclosing(
-        async_merge(drain_input_generator(), pump_inputs(), poll_outputs(), retry_inputs())
+        async_merge(
+            input_preprocessor.drain_input_generator(),
+            input_pumper.pump_inputs(),
+            input_pumper.retry_inputs(),
+            poll_outputs(),
+        )
     ) as streamer:
         async for response in streamer:
             if response is not None:  # type: ignore[unreachable]
@@ -962,6 +1157,56 @@ def _map_sync(
     )
 
 
+async def _experimental_spawn_map_async(self, *input_iterators, kwargs={}) -> "modal.functions._FunctionCall":
+    async_input_gen = async_zip(*[sync_or_async_iter(it) for it in input_iterators])
+    return await _spawn_map_helper(self, async_input_gen, kwargs)
+
+
+async def _spawn_map_helper(
+    self: "modal.functions.Function", async_input_gen, kwargs={}
+) -> "modal.functions._FunctionCall":
+    raw_input_queue: Any = SynchronizedQueue()  # type: ignore
+    await raw_input_queue.init.aio()
+
+    async def feed_queue():
+        async with aclosing(async_input_gen) as streamer:
+            async for args in streamer:
+                await raw_input_queue.put.aio((args, kwargs))
+        await raw_input_queue.put.aio(None)  # end-of-input sentinel
+
+    fc, _ = await asyncio.gather(self._spawn_map.aio(raw_input_queue), feed_queue())
+    return fc
+
+
+def _experimental_spawn_map_sync(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])
+    ```
+
+    """
+
+    return run_coroutine_in_temporary_event_loop(
+        _experimental_spawn_map_async(self, *input_iterators, kwargs=kwargs),
+        "You can't run Function.spawn_map() from an async function. Use Function.spawn_map.aio() instead.",
+    )
+
+
 async def _spawn_map_async(self, *input_iterators, kwargs={}) -> None:
     """This runs in an event loop on the main thread. It consumes inputs from the input iterators and creates async
     function calls for each.

modal/parallel_map.pyi

@@ -1,5 +1,6 @@
 import asyncio
 import asyncio.events
+import asyncio.queues
 import collections.abc
 import enum
 import modal._functions
@@ -60,6 +61,86 @@ class _OutputValue:
         """Return self==value."""
         ...
 
+class InputPreprocessor:
+    """Constructs FunctionPutInputsItem objects from the raw-input queue, and puts them in the processed-input queue."""
+    def __init__(
+        self,
+        client: modal.client._Client,
+        *,
+        raw_input_queue: _SynchronizedQueue,
+        processed_input_queue: asyncio.queues.Queue,
+        function: modal._functions._Function,
+        created_callback: collections.abc.Callable[[int], None],
+        done_callback: collections.abc.Callable[[], None],
+    ):
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    def input_iter(self): ...
+    def create_input_factory(self): ...
+    def drain_input_generator(self): ...
+
+class InputPumper:
+    """Reads inputs from a queue of FunctionPutInputsItems, and sends them to the server."""
+    def __init__(
+        self,
+        client: modal.client._Client,
+        *,
+        input_queue: asyncio.queues.Queue,
+        function: modal._functions._Function,
+        function_call_id: str,
+        map_items_manager: typing.Optional[_MapItemsManager] = None,
+    ):
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    def pump_inputs(self): ...
+    async def _send_inputs(
+        self,
+        fn: modal.client.UnaryUnaryWrapper,
+        request: typing.Union[
+            modal_proto.api_pb2.FunctionPutInputsRequest, modal_proto.api_pb2.FunctionRetryInputsRequest
+        ],
+    ) -> typing.Union[
+        modal_proto.api_pb2.FunctionPutInputsResponse, modal_proto.api_pb2.FunctionRetryInputsResponse
+    ]: ...
+
+class SyncInputPumper(InputPumper):
+    """Reads inputs from a queue of FunctionPutInputsItems, and sends them to the server."""
+    def __init__(
+        self,
+        client: modal.client._Client,
+        *,
+        input_queue: asyncio.queues.Queue,
+        retry_queue: modal._utils.async_utils.TimestampPriorityQueue,
+        function: modal._functions._Function,
+        function_call_jwt: str,
+        function_call_id: str,
+        map_items_manager: _MapItemsManager,
+    ):
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    def retry_inputs(self): ...
+
+class AsyncInputPumper(InputPumper):
+    """Reads inputs from a queue of FunctionPutInputsItems, and sends them to the server."""
+    def __init__(
+        self,
+        client: modal.client._Client,
+        *,
+        input_queue: asyncio.queues.Queue,
+        function: modal._functions._Function,
+        function_call_id: str,
+    ):
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    def pump_inputs(self): ...
+
+async def _spawn_map_invocation(
+    function: modal._functions._Function, raw_input_queue: _SynchronizedQueue, client: modal.client._Client
+) -> tuple[str, int]: ...
 def _map_invocation(
     function: modal._functions._Function,
     raw_input_queue: _SynchronizedQueue,
@@ -179,6 +260,33 @@ def _map_sync(
     """
     ...
 
+async def _experimental_spawn_map_async(self, *input_iterators, kwargs={}) -> modal._functions._FunctionCall: ...
+async def _spawn_map_helper(
+    self: modal.functions.Function, async_input_gen, kwargs={}
+) -> modal._functions._FunctionCall: ...
+def _experimental_spawn_map_sync(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 _spawn_map_async(self, *input_iterators, kwargs={}) -> None:
     """This runs in an event loop on the main thread. It consumes inputs from the input iterators and creates async
     function calls for each.

modal/proxy.py

@@ -36,7 +36,8 @@ class _Proxy(_Object, type_prefix="pr"):
             response: api_pb2.ProxyGetResponse = await resolver.client.stub.ProxyGet(req)
             self._hydrate(response.proxy.proxy_id, resolver.client, None)
 
-        return _Proxy._from_loader(_load, "Proxy()", is_another_app=True)
+        rep = _Proxy._repr(name, environment_name)
+        return _Proxy._from_loader(_load, rep, is_another_app=True)
 
 
 Proxy = synchronize_api(_Proxy, target_module=__name__)