modal 1.5.3.dev2__tar.gz → 1.5.3.dev4__tar.gz

{modal-1.5.3.dev2 → modal-1.5.3.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.5.3.dev2
+Version: 1.5.3.dev4
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0

{modal-1.5.3.dev2 → modal-1.5.3.dev4}/modal/_container_entrypoint.py

@@ -145,7 +145,7 @@ def call_function(
                             item_count += 1
 
                 await container_io_manager._send_outputs.aio(
-                    started_at, io_context.output_items_generator_done(started_at, item_count)
+                    io_context.output_items_generator_done(started_at, item_count)
                 )
             else:
                 value = await io_context.call_function_async()
@@ -182,9 +182,7 @@ def call_function(
                         container_io_manager._queue_put(generator_queue, value)
                         item_count += 1
 
-                container_io_manager._send_outputs(
-                    started_at, io_context.output_items_generator_done(started_at, item_count)
-                )
+                container_io_manager._send_outputs(io_context.output_items_generator_done(started_at, item_count))
             else:
                 values = io_context.call_function_sync()
                 container_io_manager.push_outputs(io_context, started_at, values)

{modal-1.5.3.dev2 → modal-1.5.3.dev4}/modal/_functions.py

@@ -627,6 +627,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     _metadata: api_pb2.FunctionHandleMetadata | None = None
     _options: _FunctionOptions
     _base_function: "_Function | None" = None
+    _app_id: str | None = None
 
     @staticmethod
     def from_local(
@@ -1403,6 +1404,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             metadata.max_object_size_bytes if metadata.HasField("max_object_size_bytes") else MAX_OBJECT_SIZE_BYTES
         )
         self._experimental_flash_urls = metadata._experimental_flash_urls
+        self._app_id = metadata.app_id or None
 
         # Invalidate the Function variant cache when we load new metadata, since the base Function handle
         # is now in sync with the server but any previously-cached variants may be stale.
@@ -1412,6 +1414,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         # Overridden concrete implementation of base class method
         assert self._function_name, f"Function name must be set before metadata can be retrieved for {self}"
         return api_pb2.FunctionHandleMetadata(
+            app_id=self._app_id or "",
             function_name=self._function_name,
             function_type=get_function_type(self._is_generator),
             web_url=self._web_url or "",
@@ -1673,6 +1676,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         )
         fc: _FunctionCall[ReturnType] = _FunctionCall._new_hydrated(function_call_id, self.client, None)
         fc._num_inputs = num_inputs  # set the cached value of num_inputs
+        fc._app_id = self._app_id
+        fc._function_id = self.object_id
         return fc
 
     async def _call_function(self, args, kwargs) -> ReturnType:
@@ -1884,6 +1889,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             invocation.function_call_id, invocation.client, None
         )
         fc._is_generator = self._is_generator if self._is_generator else False
+        fc._app_id = self._app_id
+        fc._function_id = self.object_id
         return fc
 
     @synchronizer.no_input_translation
@@ -1920,6 +1927,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         fc: _FunctionCall[ReturnType] = _FunctionCall._new_hydrated(
             invocation.function_call_id, invocation.client, None
         )
+        fc._app_id = self._app_id
+        fc._function_id = self.object_id
         return fc
 
     def get_raw_f(self) -> Callable[..., Any]:
@@ -1979,10 +1988,18 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
 
     _is_generator: bool = False
     _num_inputs: int | None = None
+    _app_id: str | None = None
+    _function_id: str | None = None
 
     def _invocation(self):
         return _Invocation(self.client.stub, self.object_id, self.client)
 
+    async def _hydrate_from_id_metadata(self) -> None:
+        """Hydrate metadata only when needed for FunctionCall fields."""
+        request = api_pb2.FunctionCallFromIdRequest(function_call_id=self.object_id)
+        resp = await self.client.stub.FunctionCallFromId(request)
+        self._hydrate_metadata(resp)
+
     @live_method
     async def num_inputs(self) -> int:
         """Get the number of inputs in the function call.
@@ -1991,9 +2008,8 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
             How many inputs this function call includes (e.g. `1` for `.spawn()`, more for `.spawn_map()`).
         """
         if self._num_inputs is None:
-            request = api_pb2.FunctionCallFromIdRequest(function_call_id=self.object_id)
-            resp = await self.client.stub.FunctionCallFromId(request)
-            self._num_inputs = resp.num_inputs  # cached
+            await self._hydrate_from_id_metadata()
+        assert self._num_inputs is not None
         return self._num_inputs
 
     @live_method
@@ -2135,6 +2151,13 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         )
         return typing.cast("modal.functions.FunctionCall[Any]", synchronizer._translate_out(impl_instance))
 
+    def _hydrate_metadata(self, metadata: Message | None):
+        # Overridden concrete implementation of base class method
+        if isinstance(metadata, api_pb2.FunctionCallFromIdResponse):
+            self._num_inputs = metadata.num_inputs
+            self._app_id = metadata.metadata.app_id or None
+            self._function_id = metadata.metadata.function_id or None
+
     @staticmethod
     async def gather(*function_calls: "_FunctionCall[T]") -> typing.Sequence[T]:
         """Wait until all Modal FunctionCall objects have results before returning.

{modal-1.5.3.dev2 → modal-1.5.3.dev4}/modal/_runtime/container_io_manager.py

@@ -1,7 +1,6 @@
 # Copyright Modal Labs 2024
 import asyncio
 import inspect
-import math
 import sys
 import time
 import traceback
@@ -48,8 +47,6 @@ DYNAMIC_CONCURRENCY_INTERVAL_SECS = 3
 DYNAMIC_CONCURRENCY_TIMEOUT_SECS = 10
 MAX_OUTPUT_BATCH_SIZE: int = 49
 
-RTT_S: float = 0.5  # conservative estimate of RTT in seconds.
-
 
 class Sentinel:
     """Used to get type-stubs to work with this object."""
@@ -474,8 +471,6 @@ class _ContainerIOManager:
     _task_lifecycle_manager: _TaskLifecycleManager
     input_plane_server_url: str | None
 
-    calls_completed: int
-    total_user_time: float
     current_input_id: str | None
     current_inputs: dict[str, IOContext]  # input_id -> IOContext
     current_input_started_at: float | None
@@ -510,8 +505,6 @@ class _ContainerIOManager:
 
         self.input_plane_server_url = container_args.input_plane_server_url
 
-        self.calls_completed = 0
-        self.total_user_time = 0.0
         self.current_input_id = None
         self.current_inputs = {}
         self.current_input_started_at = None
@@ -791,18 +784,6 @@ class _ContainerIOManager:
         """Put a value onto a queue, using the synchronicity event loop."""
         await queue.put(value)
 
-    def get_average_call_time(self) -> float:
-        if self.calls_completed == 0:
-            return 0
-
-        return self.total_user_time / self.calls_completed
-
-    def get_max_inputs_to_fetch(self):
-        if self.calls_completed == 0:
-            return 1
-
-        return math.ceil(RTT_S / max(self.get_average_call_time(), 1e-6))
-
     @synchronizer.no_io_translation
     async def _generate_inputs(
         self,
@@ -814,8 +795,6 @@ class _ContainerIOManager:
         while self._fetching_inputs:
             await self._input_slots.acquire()
 
-            request.average_call_time = self.get_average_call_time()
-            request.max_values = self.get_max_inputs_to_fetch()  # Deprecated; remove.
             request.input_concurrency = self.get_input_concurrency()
             request.batch_max_size, request.batch_linger_ms = batch_max_size, batch_wait_ms
 
@@ -888,7 +867,7 @@ class _ContainerIOManager:
             # collect all active input slots, meaning all inputs have wrapped up.
             await self._input_slots.close()
 
-    async def _send_outputs(self, started_at: float, outputs: list[api_pb2.FunctionPutOutputsItem]) -> None:
+    async def _send_outputs(self, outputs: list[api_pb2.FunctionPutOutputsItem]) -> None:
         """Send pre-built output items with retry and chunking."""
         # There are multiple outputs for a single IOContext in the case of @modal.batched.
         # Limit the batch size to 20 to stay within message size limits and buffer size limits.
@@ -902,7 +881,7 @@ class _ContainerIOManager:
                 ),
             )
         input_ids = [output.input_id for output in outputs]
-        self.exit_context(started_at, input_ids)
+        self.exit_context(input_ids)
 
     @asynccontextmanager
     async def handle_input_exception(
@@ -922,7 +901,7 @@ class _ContainerIOManager:
             raise
         except (InputCancellation, asyncio.CancelledError):
             outputs = await io_context.output_items_cancellation(started_at)
-            await self._send_outputs(started_at, outputs)
+            await self._send_outputs(outputs)
             logger.warning(f"Successfully canceled input {io_context.input_ids}")
             return
         except BaseException as exc:
@@ -933,12 +912,9 @@ class _ContainerIOManager:
             # print exception so it's logged
             print_exception(*sys.exc_info())
             outputs = await io_context.output_items_exception(started_at, self.task_id, exc)
-            await self._send_outputs(started_at, outputs)
-
-    def exit_context(self, started_at, input_ids: list[str]):
-        self.total_user_time += time.time() - started_at
-        self.calls_completed += 1
+            await self._send_outputs(outputs)
 
+    def exit_context(self, input_ids: list[str]):
         for input_id in input_ids:
             self.current_inputs.pop(input_id)
 
@@ -954,7 +930,7 @@ class _ContainerIOManager:
     ) -> None:
         # The standard output encoding+sending method for successful function outputs
         outputs = await io_context.output_items(started_at, output_data)
-        await self._send_outputs(started_at, outputs)
+        await self._send_outputs(outputs)
 
     @asynccontextmanager
     async def snapshot_context_manager(self) -> AsyncGenerator[None, None]:

{modal-1.5.3.dev2 → modal-1.5.3.dev4}/modal/_runtime/container_io_manager.pyi

@@ -100,8 +100,6 @@ class _ContainerIOManager:
     app_id: str
     _task_lifecycle_manager: modal._runtime.task_lifecycle_manager._TaskLifecycleManager
     input_plane_server_url: typing.Optional[str]
-    calls_completed: int
-    total_user_time: float
     current_input_id: typing.Optional[str]
     current_inputs: dict[str, IOContext]
     current_input_started_at: typing.Optional[float]
@@ -185,8 +183,6 @@ class _ContainerIOManager:
         """Put a value onto a queue, using the synchronicity event loop."""
         ...
 
-    def get_average_call_time(self) -> float: ...
-    def get_max_inputs_to_fetch(self): ...
     def _generate_inputs(
         self, batch_max_size: int, batch_wait_ms: int
     ) -> collections.abc.AsyncIterator[list[tuple[str, int, str, str, modal_proto.api_pb2.FunctionInput]]]: ...
@@ -196,7 +192,7 @@ class _ContainerIOManager:
         batch_max_size: int = 0,
         batch_wait_ms: int = 0,
     ) -> collections.abc.AsyncIterator[IOContext]: ...
-    async def _send_outputs(self, started_at: float, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
+    async def _send_outputs(self, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
         """Send pre-built output items with retry and chunking."""
         ...
 
@@ -204,7 +200,7 @@ class _ContainerIOManager:
         """Handle an exception while processing a function input."""
         ...
 
-    def exit_context(self, started_at, input_ids: list[str]): ...
+    def exit_context(self, input_ids: list[str]): ...
     async def push_outputs(self, io_context: IOContext, started_at: float, output_data: list[typing.Any]) -> None: ...
     def snapshot_context_manager(self) -> typing.AsyncContextManager[None]: ...
     async def interact(self, from_breakpoint: bool = False): ...
@@ -246,8 +242,6 @@ class ContainerIOManager:
     app_id: str
     _task_lifecycle_manager: modal._runtime.task_lifecycle_manager.TaskLifecycleManager
     input_plane_server_url: typing.Optional[str]
-    calls_completed: int
-    total_user_time: float
     current_input_id: typing.Optional[str]
     current_inputs: dict[str, IOContext]
     current_input_started_at: typing.Optional[float]
@@ -413,9 +407,6 @@ class ContainerIOManager:
 
     _queue_put: ___queue_put_spec
 
-    def get_average_call_time(self) -> float: ...
-    def get_max_inputs_to_fetch(self): ...
-
     class ___generate_inputs_spec(typing_extensions.Protocol):
         def __call__(
             self, /, batch_max_size: int, batch_wait_ms: int
@@ -445,11 +436,11 @@ class ContainerIOManager:
     run_inputs_outputs: __run_inputs_outputs_spec
 
     class ___send_outputs_spec(typing_extensions.Protocol):
-        def __call__(self, /, started_at: float, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
+        def __call__(self, /, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
             """Send pre-built output items with retry and chunking."""
             ...
 
-        async def aio(self, /, started_at: float, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
+        async def aio(self, /, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
             """Send pre-built output items with retry and chunking."""
             ...
 
@@ -468,7 +459,7 @@ class ContainerIOManager:
 
     handle_input_exception: __handle_input_exception_spec
 
-    def exit_context(self, started_at, input_ids: list[str]): ...
+    def exit_context(self, input_ids: list[str]): ...
 
     class __push_outputs_spec(typing_extensions.Protocol):
         def __call__(self, /, io_context: IOContext, started_at: float, output_data: list[typing.Any]) -> None: ...
@@ -517,5 +508,3 @@ class ContainerIOManager:
     def stop_fetching_inputs(cls): ...
 
 MAX_OUTPUT_BATCH_SIZE: int
-
-RTT_S: float

{modal-1.5.3.dev2 → modal-1.5.3.dev4}/modal/_utils/grpc_utils.py

@@ -325,7 +325,7 @@ def create_channel(
 async def create_channel_with_fallbacks(
     server_url: str,
     metadata: dict[str, str] = {},
-    stagger_delay: float = 1.0,
+    stagger_delay: float = 3.0,
 ) -> grpclib.client.Channel:
     """Create a connected channel, supporting comma-separated fallback URLs.
 

{modal-1.5.3.dev2 → modal-1.5.3.dev4}/modal/client.py

@@ -6,7 +6,7 @@ import sys
 import urllib.parse
 import warnings
 from collections.abc import AsyncGenerator, Collection, Mapping
-from typing import Any, ClassVar, TypeVar
+from typing import Any, ClassVar, Coroutine, TypeVar
 
 import grpclib.client
 from google.protobuf import empty_pb2
@@ -41,7 +41,7 @@ def _get_metadata(client_type: int, credentials: tuple[str, str] | None, version
     # sys.version_info is structured unlike sys.version or platform.python_version()
     python_version = "%d.%d.%d" % (sys.version_info.major, sys.version_info.minor, sys.version_info.micro)
 
-    metadata = {
+    metadata: dict[str, str] = {
         "x-modal-client-version": version,
         "x-modal-client-type": str(client_type),
         "x-modal-python-version": python_version,
@@ -58,9 +58,15 @@ def _get_metadata(client_type: int, credentials: tuple[str, str] | None, version
         )
     if agent_env := _agent_environment():
         metadata["x-modal-agent-harness"] = urllib.parse.quote(agent_env)
+
+    override_headers = config.get("override_headers")
+    if override_headers:
+        metadata.update(override_headers)
+
     return metadata
 
 
+T = TypeVar("T")
 ReturnType = TypeVar("ReturnType")
 _Value = str | bytes
 _MetadataLike = Mapping[str, _Value] | Collection[tuple[str, _Value]]
@@ -308,7 +314,7 @@ class _Client:
             ("x-modal-auth-token", token),
         ]
 
-    async def _call_safely(self, coro, readable_method: str):
+    async def _call_safely(self, coro: Coroutine[Any, Any, T], readable_method: str) -> T:
         """Runs coroutine wrapped in a task that's part of the client's task context
 
         * Raises ClientClosed in case the client is closed while the coroutine is executed
@@ -364,11 +370,11 @@ class _Client:
     async def _call_unary(
         self,
         grpclib_method: grpclib.client.UnaryUnaryMethod[RequestType, ResponseType],
-        request: Any,
+        request: RequestType,
         *,
         timeout: float | None = None,
         metadata: _MetadataLike | None = None,
-    ) -> Any:
+    ) -> ResponseType:
         coro = grpclib_method(request, timeout=timeout, metadata=metadata)
         return await self._call_safely(coro, grpclib_method.name)
 
@@ -376,10 +382,10 @@ class _Client:
     async def _call_stream(
         self,
         grpclib_method: grpclib.client.UnaryStreamMethod[RequestType, ResponseType],
-        request: Any,
+        request: RequestType,
         *,
         metadata: _MetadataLike | None,
-    ) -> AsyncGenerator[Any, None]:
+    ) -> AsyncGenerator[ResponseType, None]:
         stream_context = grpclib_method.open(metadata=metadata)
         stream = await self._call_safely(stream_context.__aenter__(), f"{grpclib_method.name}.open")
         try:

{modal-1.5.3.dev2 → modal-1.5.3.dev4}/modal/client.pyi

@@ -13,6 +13,8 @@ import typing_extensions
 
 def _get_metadata(client_type: int, credentials: typing.Optional[tuple[str, str]], version: str) -> dict[str, str]: ...
 
+T = typing.TypeVar("T")
+
 ReturnType = typing.TypeVar("ReturnType")
 
 RequestType = typing.TypeVar("RequestType", bound="google.protobuf.message.Message")
@@ -35,7 +37,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.3.dev2",
+        version: str = "1.5.3.dev4",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -154,7 +156,7 @@ class _Client:
         """
         ...
 
-    async def _call_safely(self, coro, readable_method: str):
+    async def _call_safely(self, coro: typing.Coroutine[typing.Any, typing.Any, T], readable_method: str) -> T:
         """Runs coroutine wrapped in a task that's part of the client's task context
 
         * Raises ClientClosed in case the client is closed while the coroutine is executed
@@ -168,7 +170,7 @@ class _Client:
     async def _call_unary(
         self,
         grpclib_method: grpclib.client.UnaryUnaryMethod[RequestType, ResponseType],
-        request: typing.Any,
+        request: RequestType,
         *,
         timeout: typing.Optional[float] = None,
         metadata: typing.Union[
@@ -176,18 +178,18 @@ class _Client:
             collections.abc.Collection[tuple[str, typing.Union[str, bytes]]],
             None,
         ] = None,
-    ) -> typing.Any: ...
+    ) -> ResponseType: ...
     def _call_stream(
         self,
         grpclib_method: grpclib.client.UnaryStreamMethod[RequestType, ResponseType],
-        request: typing.Any,
+        request: RequestType,
         *,
         metadata: typing.Union[
             collections.abc.Mapping[str, typing.Union[str, bytes]],
             collections.abc.Collection[tuple[str, typing.Union[str, bytes]]],
             None,
         ],
-    ) -> collections.abc.AsyncGenerator[typing.Any, None]: ...
+    ) -> collections.abc.AsyncGenerator[ResponseType, None]: ...
 
 class Client:
     _client_from_env: typing.ClassVar[typing.Optional[Client]]
@@ -205,7 +207,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.3.dev2",
+        version: str = "1.5.3.dev4",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -429,7 +431,7 @@ class Client:
     get_input_plane_metadata: __get_input_plane_metadata_spec
 
     class ___call_safely_spec(typing_extensions.Protocol):
-        def __call__(self, /, coro, readable_method: str):
+        def __call__(self, /, coro: T, readable_method: str) -> T:
             """Runs coroutine wrapped in a task that's part of the client's task context
 
             * Raises ClientClosed in case the client is closed while the coroutine is executed
@@ -438,7 +440,7 @@ class Client:
             """
             ...
 
-        async def aio(self, /, coro, readable_method: str):
+        async def aio(self, /, coro: typing.Coroutine[typing.Any, typing.Any, T], readable_method: str) -> T:
             """Runs coroutine wrapped in a task that's part of the client's task context
 
             * Raises ClientClosed in case the client is closed while the coroutine is executed
@@ -464,7 +466,7 @@ class Client:
     async def _call_unary(
         self,
         grpclib_method: grpclib.client.UnaryUnaryMethod[RequestType, ResponseType],
-        request: typing.Any,
+        request: RequestType,
         *,
         timeout: typing.Optional[float] = None,
         metadata: typing.Union[
@@ -472,18 +474,18 @@ class Client:
             collections.abc.Collection[tuple[str, typing.Union[str, bytes]]],
             None,
         ] = None,
-    ) -> typing.Any: ...
+    ) -> ResponseType: ...
     def _call_stream(
         self,
         grpclib_method: grpclib.client.UnaryStreamMethod[RequestType, ResponseType],
-        request: typing.Any,
+        request: RequestType,
         *,
         metadata: typing.Union[
             collections.abc.Mapping[str, typing.Union[str, bytes]],
             collections.abc.Collection[tuple[str, typing.Union[str, bytes]]],
             None,
         ],
-    ) -> collections.abc.AsyncGenerator[typing.Any, None]: ...
+    ) -> collections.abc.AsyncGenerator[ResponseType, None]: ...
 
 HEARTBEAT_INTERVAL: float
 

{modal-1.5.3.dev2 → modal-1.5.3.dev4}/modal/cls.py

@@ -86,6 +86,8 @@ def _bind_instance_method(cls: "_Cls", service_function: _Function, method_name:
 
         method_metadata = service_function._method_handle_metadata[method_name]
         new_function._hydrate(service_function.object_id, service_function.client, method_metadata)
+        if not new_function._app_id:
+            new_function._app_id = service_function._app_id
 
     async def _load(fun: "_Function", resolver: Resolver, load_context: LoadContext, existing_object_id: str | None):
         # there is currently no actual loading logic executed to create each method on
@@ -426,6 +428,7 @@ class _Obj:
                 )
             await resolver.load(method_function, load_context)  # get the appropriate method handle (lazy)
             fun._hydrate_from_other(method_function)
+            fun._app_id = method_function._app_id
 
         # The reason we don't *always* use this lazy loader is because it precludes attribute access
         # on local classes.

{modal-1.5.3.dev2 → modal-1.5.3.dev4}/modal/config.py

@@ -106,7 +106,8 @@ from modal_proto import api_pb2
 from ._utils.logger import configure_logger
 from .exception import InvalidError, NotFoundError
 
-DEFAULT_SERVER_URL = "https://api.modal.com"  # TODO(erikbern): add modal2.com
+# By default, try api.modal.com and fail over to api.modal2.com
+DEFAULT_SERVER_URL = "https://api.modal.com,https://api.modal2.com"
 
 
 # Locate config file and read it
@@ -263,6 +264,33 @@ def _enforce_suffix_rules(x: str) -> str:
     return x
 
 
+def _transform_headers(s: str) -> dict[str, str]:
+    error_msg = (
+        "Must be a comma-separated list of `<header>:<value>` pairs (whitespace is ignored). "
+        "<header> and <value> must contain at least one non-whitespace character, and may "
+        "not contain commas."
+    )
+
+    if s == "":
+        return {}
+
+    pairs = s.split(",")
+
+    headers: dict[str, str] = {}
+    for pair in pairs:
+        res = pair.split(":", maxsplit=1)
+        if len(res) != 2:
+            raise ValueError(error_msg)
+
+        header, value = res[0].strip(), res[1].strip()
+        if len(header) == 0 or len(value) == 0:
+            raise ValueError(error_msg)
+
+        headers[header] = value
+
+    return headers
+
+
 class _Setting(typing.NamedTuple):
     default: typing.Any = None
     transform: typing.Callable[[str], typing.Any] = lambda x: x  # noqa: E731
@@ -305,6 +333,7 @@ _SETTINGS = {
     "max_throttle_wait": _Setting(None, transform=lambda x: int(x) if x else None),
     "async_warnings": _Setting(True, transform=_to_boolean),  # Activate synchronicity usage warnings
     "disable_api_proxy": _Setting(False, transform=_to_boolean),
+    "override_headers": _Setting(None, transform=_transform_headers),
 }
 
 

{modal-1.5.3.dev2 → modal-1.5.3.dev4}/modal/functions.pyi

@@ -58,6 +58,7 @@ class Function(
     _metadata: typing.Optional[modal_proto.api_pb2.FunctionHandleMetadata]
     _options: modal._function_variants._FunctionOptions
     _base_function: typing.Optional[Function]
+    _app_id: typing.Optional[str]
 
     def __init__(self, *args, **kwargs):
         """mdmd:hidden"""
@@ -892,6 +893,8 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
 
     _is_generator: bool
     _num_inputs: typing.Optional[int]
+    _app_id: typing.Optional[str]
+    _function_id: typing.Optional[str]
 
     def __init__(self, *args, **kwargs):
         """mdmd:hidden"""
@@ -899,6 +902,17 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
 
     def _invocation(self): ...
 
+    class ___hydrate_from_id_metadata_spec(typing_extensions.Protocol):
+        def __call__(self, /) -> None:
+            """Hydrate metadata only when needed for FunctionCall fields."""
+            ...
+
+        async def aio(self, /) -> None:
+            """Hydrate metadata only when needed for FunctionCall fields."""
+            ...
+
+    _hydrate_from_id_metadata: ___hydrate_from_id_metadata_spec
+
     class __num_inputs_spec(typing_extensions.Protocol):
         def __call__(self, /) -> int:
             """Get the number of inputs in the function call.
@@ -1115,6 +1129,8 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
 
     from_id: typing.ClassVar[__from_id_spec]
 
+    def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
+
     class __gather_spec(typing_extensions.Protocol):
         def __call__(self, /, *function_calls: FunctionCall[modal._functions.T]) -> typing.Sequence[modal._functions.T]:
             """Wait until all Modal FunctionCall objects have results before returning.