modal 0.66.44__py3-none-any.whl → 0.67.0__py3-none-any.whl

modal/functions.py

@@ -118,7 +118,7 @@ class _Invocation:
         function_call_invocation_type: "api_pb2.FunctionCallInvocationType.ValueType",
     ) -> "_Invocation":
         assert client.stub
-        function_id = function._invocation_function_id()
+        function_id = function.object_id
         item = await _create_input(args, kwargs, client, method_name=function._use_method_name)
 
         request = api_pb2.FunctionMapRequest(
@@ -319,8 +319,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     _cluster_size: Optional[int] = None
 
     # when this is the method of a class/object function, invocation of this function
-    # should be using another function id and supply the method name in the FunctionInput:
-    _use_function_id: str  # The function to invoke
+    # should supply the method name in the FunctionInput:
     _use_method_name: str = ""
 
     _class_parameter_info: Optional["api_pb2.ClassParameterInfo"] = None
@@ -360,94 +359,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         fun._is_method = True
         return fun
 
-    def _bind_method_old(
-        self,
-        user_cls,
-        method_name: str,
-        partial_function: "modal.partial_function._PartialFunction",
-    ):
-        """mdmd:hidden
-
-        Creates a function placeholder function that binds a specific method name to
-        this function for use when invoking the function.
-
-        Should only be used on "class service functions". For "instance service functions",
-        we don't create an actual backend function, and instead do client-side "fake-hydration"
-        only, see _bind_instance_method.
-
-        """
-        class_service_function = self
-        assert class_service_function._info  # has to be a local function to be able to "bind" it
-        assert not class_service_function._is_method  # should not be used on an already bound method placeholder
-        assert not class_service_function._obj  # should only be used on base function / class service function
-        full_name = f"{user_cls.__name__}.{method_name}"
-        function_type = get_function_type(partial_function.is_generator)
-
-        async def _load(method_bound_function: "_Function", resolver: Resolver, existing_object_id: Optional[str]):
-            function_definition = api_pb2.Function(
-                function_name=full_name,
-                webhook_config=partial_function.webhook_config,
-                function_type=function_type,
-                is_method=True,
-                use_function_id=class_service_function.object_id,
-                use_method_name=method_name,
-                batch_max_size=partial_function.batch_max_size or 0,
-                batch_linger_ms=partial_function.batch_wait_ms or 0,
-            )
-            assert resolver.app_id
-            request = api_pb2.FunctionCreateRequest(
-                app_id=resolver.app_id,
-                function=function_definition,
-                #  method_bound_function.object_id usually gets set by preload
-                existing_function_id=existing_object_id or method_bound_function.object_id or "",
-                defer_updates=True,
-            )
-            assert resolver.client.stub is not None  # client should be connected when load is called
-            with FunctionCreationStatus(resolver, full_name) as function_creation_status:
-                response = await resolver.client.stub.FunctionCreate(request)
-                method_bound_function._hydrate(
-                    response.function_id,
-                    resolver.client,
-                    response.handle_metadata,
-                )
-                function_creation_status.set_response(response)
-
-        async def _preload(method_bound_function: "_Function", resolver: Resolver, existing_object_id: Optional[str]):
-            if class_service_function._use_method_name:
-                raise ExecutionError(f"Can't bind method to already bound {class_service_function}")
-            assert resolver.app_id
-            req = api_pb2.FunctionPrecreateRequest(
-                app_id=resolver.app_id,
-                function_name=full_name,
-                function_type=function_type,
-                webhook_config=partial_function.webhook_config,
-                use_function_id=class_service_function.object_id,
-                use_method_name=method_name,
-                existing_function_id=existing_object_id or "",
-            )
-            assert resolver.client.stub  # client should be connected at this point
-            response = await retry_transient_errors(resolver.client.stub.FunctionPrecreate, req)
-            method_bound_function._hydrate(response.function_id, resolver.client, response.handle_metadata)
-
-        def _deps():
-            return [class_service_function]
-
-        rep = f"Method({full_name})"
-
-        fun = _Function._from_loader(_load, rep, preload=_preload, deps=_deps)
-        fun._tag = full_name
-        fun._raw_f = partial_function.raw_f
-        fun._info = FunctionInfo(
-            partial_function.raw_f, user_cls=user_cls, serialized=class_service_function.info.is_serialized()
-        )  # needed for .local()
-        fun._use_method_name = method_name
-        fun._app = class_service_function._app
-        fun._is_generator = partial_function.is_generator
-        fun._cluster_size = partial_function.cluster_size
-        fun._spec = class_service_function._spec
-        fun._is_method = True
-        return fun
-
     def _bind_instance_method(self, class_bound_method: "_Function"):
         """mdmd:hidden
 
@@ -475,7 +386,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             method_placeholder_fun._is_generator = class_bound_method._is_generator
             method_placeholder_fun._cluster_size = class_bound_method._cluster_size
             method_placeholder_fun._use_method_name = method_name
-            method_placeholder_fun._use_function_id = instance_service_function.object_id
             method_placeholder_fun._is_method = True
 
         async def _load(fun: "_Function", resolver: Resolver, existing_object_id: Optional[str]):
@@ -848,6 +758,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     class_serialized=class_serialized or b"",
                     function_type=function_type,
                     webhook_config=webhook_config,
+                    method_definitions=method_definitions,
+                    method_definitions_set=True,
                     shared_volume_mounts=network_file_system_mount_protos(
                         validated_network_file_systems, allow_cross_region_volumes
                     ),
@@ -1224,7 +1136,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         self._web_url = None
         self._function_name = None
         self._info = None
-        self._use_function_id = ""
         self._serve_mounts = frozenset()
 
     def _hydrate_metadata(self, metadata: Optional[Message]):
@@ -1234,15 +1145,11 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         self._web_url = metadata.web_url
         self._function_name = metadata.function_name
         self._is_method = metadata.is_method
-        self._use_function_id = metadata.use_function_id
         self._use_method_name = metadata.use_method_name
         self._class_parameter_info = metadata.class_parameter_info
         self._method_handle_metadata = dict(metadata.method_handle_metadata)
         self._definition_id = metadata.definition_id
 
-    def _invocation_function_id(self) -> str:
-        return self._use_function_id or self.object_id
-
     def _get_metadata(self):
         # Overridden concrete implementation of base class method
         assert self._function_name, f"Function name must be set before metadata can be retrieved for {self}"
@@ -1251,7 +1158,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             function_type=get_function_type(self._is_generator),
             web_url=self._web_url or "",
             use_method_name=self._use_method_name,
-            use_function_id=self._use_function_id,
             is_method=self._is_method,
             class_parameter_info=self._class_parameter_info,
             definition_id=self._definition_id,

modal/functions.pyi

@@ -122,15 +122,11 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.
     _build_args: dict
     _is_generator: typing.Optional[bool]
     _cluster_size: typing.Optional[int]
-    _use_function_id: str
     _use_method_name: str
     _class_parameter_info: typing.Optional[modal_proto.api_pb2.ClassParameterInfo]
     _method_handle_metadata: typing.Optional[typing.Dict[str, modal_proto.api_pb2.FunctionHandleMetadata]]
 
     def _bind_method(self, user_cls, method_name: str, partial_function: modal.partial_function._PartialFunction): ...
-    def _bind_method_old(
-        self, user_cls, method_name: str, partial_function: modal.partial_function._PartialFunction
-    ): ...
     def _bind_instance_method(self, class_bound_method: _Function): ...
     @staticmethod
     def from_args(
@@ -212,7 +208,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.
     def get_build_def(self) -> str: ...
     def _initialize_from_empty(self): ...
     def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
-    def _invocation_function_id(self) -> str: ...
     def _get_metadata(self): ...
     def _check_no_web_url(self, fn_name: str): ...
     @property
@@ -296,16 +291,12 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
     _build_args: dict
     _is_generator: typing.Optional[bool]
     _cluster_size: typing.Optional[int]
-    _use_function_id: str
     _use_method_name: str
     _class_parameter_info: typing.Optional[modal_proto.api_pb2.ClassParameterInfo]
     _method_handle_metadata: typing.Optional[typing.Dict[str, modal_proto.api_pb2.FunctionHandleMetadata]]
 
     def __init__(self, *args, **kwargs): ...
     def _bind_method(self, user_cls, method_name: str, partial_function: modal.partial_function.PartialFunction): ...
-    def _bind_method_old(
-        self, user_cls, method_name: str, partial_function: modal.partial_function.PartialFunction
-    ): ...
     def _bind_instance_method(self, class_bound_method: Function): ...
     @staticmethod
     def from_args(
@@ -406,7 +397,6 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
     def get_build_def(self) -> str: ...
     def _initialize_from_empty(self): ...
     def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
-    def _invocation_function_id(self) -> str: ...
     def _get_metadata(self): ...
     def _check_no_web_url(self, fn_name: str): ...
     @property

modal/image.py

@@ -19,7 +19,6 @@ from typing import (
     Optional,
     Sequence,
     Set,
-    Tuple,
     Union,
     cast,
     get_args,
@@ -36,6 +35,7 @@ from ._utils.async_utils import synchronize_api
 from ._utils.blob_utils import MAX_OBJECT_SIZE_BYTES
 from ._utils.function_utils import FunctionInfo
 from ._utils.grpc_utils import RETRYABLE_GRPC_STATUS_CODES, retry_transient_errors
+from .client import _Client
 from .cloud_bucket_mount import _CloudBucketMount
 from .config import config, logger, user_config_path
 from .environments import _get_environment_cached
@@ -52,7 +52,6 @@ from .volume import _Volume
 if typing.TYPE_CHECKING:
     import modal.functions
 
-
 # This is used for both type checking and runtime validation
 ImageBuilderVersion = Literal["2023.12", "2024.04", "2024.10"]
 
@@ -147,8 +146,8 @@ def _get_modal_requirements_command(version: ImageBuilderVersion) -> str:
     return f"{prefix} -r {CONTAINER_REQUIREMENTS_PATH}"
 
 
-def _flatten_str_args(function_name: str, arg_name: str, args: Tuple[Union[str, List[str]], ...]) -> List[str]:
-    """Takes a tuple of strings, or string lists, and flattens it.
+def _flatten_str_args(function_name: str, arg_name: str, args: Sequence[Union[str, List[str]]]) -> List[str]:
+    """Takes a sequence of strings, or string lists, and flattens it.
 
     Raises an error if any of the elements are not strings or string lists.
     """
@@ -244,7 +243,7 @@ class _ImageRegistryConfig:
     def __init__(
         self,
         # TODO: change to _PUBLIC after worker starts handling it.
-        registry_auth_type: int = api_pb2.REGISTRY_AUTH_TYPE_UNSPECIFIED,
+        registry_auth_type: "api_pb2.RegistryAuthType.ValueType" = api_pb2.REGISTRY_AUTH_TYPE_UNSPECIFIED,
         secret: Optional[_Secret] = None,
     ):
         self.registry_auth_type = registry_auth_type
@@ -253,7 +252,7 @@ class _ImageRegistryConfig:
     def get_proto(self) -> api_pb2.ImageRegistryConfig:
         return api_pb2.ImageRegistryConfig(
             registry_auth_type=self.registry_auth_type,
-            secret_id=(self.secret.object_id if self.secret else None),
+            secret_id=(self.secret.object_id if self.secret else ""),
         )
 
 
@@ -264,6 +263,45 @@ class DockerfileSpec:
     context_files: Dict[str, str]
 
 
+async def _image_await_build_result(image_id: str, client: _Client) -> api_pb2.ImageJoinStreamingResponse:
+    last_entry_id: str = ""
+    result_response: Optional[api_pb2.ImageJoinStreamingResponse] = None
+
+    async def join():
+        nonlocal last_entry_id, result_response
+
+        request = api_pb2.ImageJoinStreamingRequest(image_id=image_id, timeout=55, last_entry_id=last_entry_id)
+        async for response in client.stub.ImageJoinStreaming.unary_stream(request):
+            if response.entry_id:
+                last_entry_id = response.entry_id
+            if response.result.status:
+                result_response = response
+                # can't return yet, since there may still be logs streaming back in subsequent responses
+            for task_log in response.task_logs:
+                if task_log.task_progress.pos or task_log.task_progress.len:
+                    assert task_log.task_progress.progress_type == api_pb2.IMAGE_SNAPSHOT_UPLOAD
+                    if output_mgr := _get_output_manager():
+                        output_mgr.update_snapshot_progress(image_id, task_log.task_progress)
+                elif task_log.data:
+                    if output_mgr := _get_output_manager():
+                        await output_mgr.put_log_content(task_log)
+        if output_mgr := _get_output_manager():
+            output_mgr.flush_lines()
+
+    # Handle up to n exceptions while fetching logs
+    retry_count = 0
+    while result_response is None:
+        try:
+            await join()
+        except (StreamTerminatedError, GRPCError) as exc:
+            if isinstance(exc, GRPCError) and exc.status not in RETRYABLE_GRPC_STATUS_CODES:
+                raise exc
+            retry_count += 1
+            if retry_count >= 3:
+                raise exc
+    return result_response
+
+
 class _Image(_Object, type_prefix="im"):
     """Base class for container images to run functions in.
 
@@ -292,7 +330,7 @@ class _Image(_Object, type_prefix="im"):
         self._serve_mounts = other._serve_mounts
         self._deferred_mounts = other._deferred_mounts
 
-    def _hydrate_metadata(self, message: Optional[Message]):
+    def _hydrate_metadata(self, metadata: Optional[Message]):
         env_image_id = config.get("image_id")  # set as an env var in containers
         if env_image_id == self.object_id:
             for exc in self.inside_exceptions:
@@ -300,9 +338,9 @@ class _Image(_Object, type_prefix="im"):
                 # if the hydrated image is the one used by the container
                 raise exc
 
-        if message:
-            assert isinstance(message, api_pb2.ImageMetadata)
-            self._metadata = message
+        if metadata:
+            assert isinstance(metadata, api_pb2.ImageMetadata)
+            self._metadata = metadata
 
     def _add_mount_layer_or_copy(self, mount: _Mount, copy: bool = False):
         if copy:
@@ -318,7 +356,7 @@ class _Image(_Object, type_prefix="im"):
         return _Image._from_loader(_load, "Image(local files)", deps=lambda: [base_image, mount])
 
     @property
-    def _mount_layers(self) -> typing.Tuple[_Mount]:
+    def _mount_layers(self) -> typing.Sequence[_Mount]:
         """Non-evaluated mount layers on the image
 
         When the image is used by a Modal container, these mounts need to be attached as well to
@@ -362,7 +400,7 @@ class _Image(_Object, type_prefix="im"):
         context_mount: Optional[_Mount] = None,
         force_build: bool = False,
         # For internal use only.
-        _namespace: int = api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
+        _namespace: "api_pb2.DeploymentNamespace.ValueType" = api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE,
         _do_assert_no_mount_layers: bool = True,
     ):
         if base_images is None:
@@ -382,14 +420,14 @@ class _Image(_Object, type_prefix="im"):
         if build_function and len(base_images) != 1:
             raise InvalidError("Cannot run a build function with multiple base images!")
 
-        def _deps() -> List[_Object]:
-            deps: List[_Object] = list(base_images.values()) + list(secrets)
+        def _deps() -> Sequence[_Object]:
+            deps = tuple(base_images.values()) + tuple(secrets)
             if build_function:
-                deps.append(build_function)
+                deps += (build_function,)
             if context_mount:
-                deps.append(context_mount)
-            if image_registry_config.secret:
-                deps.append(image_registry_config.secret)
+                deps += (context_mount,)
+            if image_registry_config and image_registry_config.secret:
+                deps += (image_registry_config.secret,)
             return deps
 
         async def _load(self: _Image, resolver: Resolver, existing_object_id: Optional[str]):
@@ -398,6 +436,7 @@ class _Image(_Object, type_prefix="im"):
                     # base images can't have
                     image._assert_no_mount_layers()
 
+            assert resolver.app_id  # type narrowing
             environment = await _get_environment_cached(resolver.environment_name or "", resolver.client)
             # A bit hacky,but assume that the environment provides a valid builder version
             image_builder_version = cast(ImageBuilderVersion, environment._settings.image_builder_version)
@@ -432,7 +471,6 @@ class _Image(_Object, type_prefix="im"):
 
             if build_function:
                 build_function_id = build_function.object_id
-
                 globals = build_function._get_info().get_globals()
                 attrs = build_function._get_info().get_cls_var_attrs()
                 globals = {**globals, **attrs}
@@ -454,14 +492,14 @@ class _Image(_Object, type_prefix="im"):
 
                 # Cloudpickle function serialization produces unstable values.
                 # TODO: better way to filter out types that don't have a stable hash?
-                build_function_globals = serialize(filtered_globals) if filtered_globals else None
+                build_function_globals = serialize(filtered_globals) if filtered_globals else b""
                 _build_function = api_pb2.BuildFunction(
                     definition=build_function.get_build_def(),
                     globals=build_function_globals,
                     input=build_function_input,
                 )
             else:
-                build_function_id = None
+                build_function_id = ""
                 _build_function = None
 
             image_definition = api_pb2.Image(
@@ -470,7 +508,7 @@ class _Image(_Object, type_prefix="im"):
                 context_files=context_file_pb2s,
                 secret_ids=[secret.object_id for secret in secrets],
                 gpu=bool(gpu_config.type),  # Note: as of 2023-01-27, server still uses this
-                context_mount_id=(context_mount.object_id if context_mount else None),
+                context_mount_id=(context_mount.object_id if context_mount else ""),
                 gpu_config=gpu_config,  # Note: as of 2023-01-27, server ignores this
                 image_registry_config=image_registry_config.get_proto(),
                 runtime=config.get("function_runtime"),
@@ -481,7 +519,7 @@ class _Image(_Object, type_prefix="im"):
             req = api_pb2.ImageGetOrCreateRequest(
                 app_id=resolver.app_id,
                 image=image_definition,
-                existing_image_id=existing_object_id,  # TODO: ignored
+                existing_image_id=existing_object_id or "",  # TODO: ignored
                 build_function_id=build_function_id,
                 force_build=config.get("force_build") or force_build,
                 namespace=_namespace,
@@ -492,46 +530,22 @@ class _Image(_Object, type_prefix="im"):
             )
             resp = await retry_transient_errors(resolver.client.stub.ImageGetOrCreate, req)
             image_id = resp.image_id
+            result: api_pb2.GenericResult
+            metadata: Optional[api_pb2.ImageMetadata] = None
+
+            if resp.result.status:
+                # image already built
+                result = resp.result
+                if resp.HasField("metadata"):
+                    metadata = resp.metadata
+            else:
+                # not built or in the process of building - wait for build
+                logger.debug("Waiting for image %s" % image_id)
+                resp = await _image_await_build_result(image_id, resolver.client)
+                result = resp.result
+                if resp.HasField("metadata"):
+                    metadata = resp.metadata
 
-            logger.debug("Waiting for image %s" % image_id)
-            last_entry_id: Optional[str] = None
-            result_response: Optional[api_pb2.ImageJoinStreamingResponse] = None
-
-            async def join():
-                nonlocal last_entry_id, result_response
-
-                request = api_pb2.ImageJoinStreamingRequest(image_id=image_id, timeout=55, last_entry_id=last_entry_id)
-
-                async for response in resolver.client.stub.ImageJoinStreaming.unary_stream(request):
-                    if response.entry_id:
-                        last_entry_id = response.entry_id
-                    if response.result.status:
-                        result_response = response
-                        # can't return yet, since there may still be logs streaming back in subsequent responses
-                    for task_log in response.task_logs:
-                        if task_log.task_progress.pos or task_log.task_progress.len:
-                            assert task_log.task_progress.progress_type == api_pb2.IMAGE_SNAPSHOT_UPLOAD
-                            if output_mgr := _get_output_manager():
-                                output_mgr.update_snapshot_progress(image_id, task_log.task_progress)
-                        elif task_log.data:
-                            if output_mgr := _get_output_manager():
-                                await output_mgr.put_log_content(task_log)
-                if output_mgr := _get_output_manager():
-                    output_mgr.flush_lines()
-
-            # Handle up to n exceptions while fetching logs
-            retry_count = 0
-            while result_response is None:
-                try:
-                    await join()
-                except (StreamTerminatedError, GRPCError) as exc:
-                    if isinstance(exc, GRPCError) and exc.status not in RETRYABLE_GRPC_STATUS_CODES:
-                        raise exc
-                    retry_count += 1
-                    if retry_count >= 3:
-                        raise exc
-
-            result = result_response.result
             if result.status == api_pb2.GenericResult.GENERIC_STATUS_FAILURE:
                 raise RemoteError(f"Image build for {image_id} failed with the exception:\n{result.exception}")
             elif result.status == api_pb2.GenericResult.GENERIC_STATUS_TERMINATED:
@@ -545,7 +559,7 @@ class _Image(_Object, type_prefix="im"):
             else:
                 raise RemoteError("Unknown status %s!" % result.status)
 
-            self._hydrate(image_id, resolver.client, result_response.metadata)
+            self._hydrate(image_id, resolver.client, metadata)
             local_mounts = set()
             for base in base_images.values():
                 local_mounts |= base._serve_mounts
@@ -666,7 +680,7 @@ class _Image(_Object, type_prefix="im"):
             context_mount=mount,
         )
 
-    def _add_local_python_packages(self, *packages: Union[str, Path], copy: bool = False) -> "_Image":
+    def _add_local_python_packages(self, *packages: str, copy: bool = False) -> "_Image":
         """Adds Python package files to containers
 
         Adds all files from the specified Python packages to containers running the Image.
@@ -1632,7 +1646,7 @@ class _Image(_Object, type_prefix="im"):
         function = _Function.from_args(
             info,
             app=None,
-            image=self,
+            image=self,  # type: ignore[reportArgumentType]  # TODO: probably conflict with type stub?
             secrets=secrets,
             gpu=gpu,
             mounts=mounts,
@@ -1700,7 +1714,7 @@ class _Image(_Object, type_prefix="im"):
         """
 
         def build_dockerfile(version: ImageBuilderVersion) -> DockerfileSpec:
-            commands = ["FROM base", f"WORKDIR {shlex.quote(path)}"]
+            commands = ["FROM base", f"WORKDIR {shlex.quote(str(path))}"]
             return DockerfileSpec(commands=commands, context_files={})
 
         return _Image._from_args(
@@ -1744,7 +1758,7 @@ class _Image(_Object, type_prefix="im"):
 
         This method is considered private since its interface may change - use it at your own risk!
         """
-        last_entry_id: Optional[str] = None
+        last_entry_id: str = ""
 
         request = api_pb2.ImageJoinStreamingRequest(
             image_id=self._object_id, timeout=55, last_entry_id=last_entry_id, include_logs_for_finished=True

modal/image.pyi

@@ -1,4 +1,5 @@
 import google.protobuf.message
+import modal.client
 import modal.cloud_bucket_mount
 import modal.functions
 import modal.gpu
@@ -28,7 +29,7 @@ def _get_modal_requirements_path(
 ) -> str: ...
 def _get_modal_requirements_command(version: typing.Literal["2023.12", "2024.04", "2024.10"]) -> str: ...
 def _flatten_str_args(
-    function_name: str, arg_name: str, args: typing.Tuple[typing.Union[str, typing.List[str]], ...]
+    function_name: str, arg_name: str, args: typing.Sequence[typing.Union[str, typing.List[str]]]
 ) -> typing.List[str]: ...
 def _validate_packages(packages: typing.List[str]) -> bool: ...
 def _warn_invalid_packages(old_command: str) -> None: ...
@@ -55,6 +56,10 @@ class DockerfileSpec:
     def __repr__(self): ...
     def __eq__(self, other): ...
 
+async def _image_await_build_result(
+    image_id: str, client: modal.client._Client
+) -> modal_proto.api_pb2.ImageJoinStreamingResponse: ...
+
 class _Image(modal.object._Object):
     force_build: bool
     inside_exceptions: typing.List[Exception]
@@ -64,10 +69,10 @@ class _Image(modal.object._Object):
 
     def _initialize_from_empty(self): ...
     def _initialize_from_other(self, other: _Image): ...
-    def _hydrate_metadata(self, message: typing.Optional[google.protobuf.message.Message]): ...
+    def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
     def _add_mount_layer_or_copy(self, mount: modal.mount._Mount, copy: bool = False): ...
     @property
-    def _mount_layers(self) -> typing.Tuple[modal.mount._Mount]: ...
+    def _mount_layers(self) -> typing.Sequence[modal.mount._Mount]: ...
     def _assert_no_mount_layers(self): ...
     @staticmethod
     def _from_args(
@@ -109,7 +114,7 @@ class _Image(modal.object._Object):
     def copy_local_file(
         self, local_path: typing.Union[str, pathlib.Path], remote_path: typing.Union[str, pathlib.Path] = "./"
     ) -> _Image: ...
-    def _add_local_python_packages(self, *module_names, copy: bool = False) -> _Image: ...
+    def _add_local_python_packages(self, *module_names: str, copy: bool = False) -> _Image: ...
     def copy_local_dir(
         self, local_path: typing.Union[str, pathlib.Path], remote_path: typing.Union[str, pathlib.Path] = "."
     ) -> _Image: ...
@@ -321,10 +326,10 @@ class Image(modal.object.Object):
     def __init__(self, *args, **kwargs): ...
     def _initialize_from_empty(self): ...
     def _initialize_from_other(self, other: Image): ...
-    def _hydrate_metadata(self, message: typing.Optional[google.protobuf.message.Message]): ...
+    def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
     def _add_mount_layer_or_copy(self, mount: modal.mount.Mount, copy: bool = False): ...
     @property
-    def _mount_layers(self) -> typing.Tuple[modal.mount.Mount]: ...
+    def _mount_layers(self) -> typing.Sequence[modal.mount.Mount]: ...
     def _assert_no_mount_layers(self): ...
     @staticmethod
     def _from_args(
@@ -366,7 +371,7 @@ class Image(modal.object.Object):
     def copy_local_file(
         self, local_path: typing.Union[str, pathlib.Path], remote_path: typing.Union[str, pathlib.Path] = "./"
     ) -> Image: ...
-    def _add_local_python_packages(self, *module_names, copy: bool = False) -> Image: ...
+    def _add_local_python_packages(self, *module_names: str, copy: bool = False) -> Image: ...
     def copy_local_dir(
         self, local_path: typing.Union[str, pathlib.Path], remote_path: typing.Union[str, pathlib.Path] = "."
     ) -> Image: ...

modal/object.py

@@ -17,7 +17,7 @@ O = TypeVar("O", bound="_Object")
 
 _BLOCKING_O = synchronize_api(O)
 
-EPHEMERAL_OBJECT_HEARTBEAT_SLEEP = 300
+EPHEMERAL_OBJECT_HEARTBEAT_SLEEP: int = 300
 
 
 def _get_environment_name(environment_name: Optional[str] = None, resolver: Optional[Resolver] = None) -> Optional[str]:
@@ -205,7 +205,7 @@ class _Object:
         return self._local_uuid
 
     @property
-    def object_id(self):
+    def object_id(self) -> str:
         """mdmd:hidden"""
         return self._object_id
 

modal/object.pyi

@@ -86,7 +86,7 @@ class _Object:
     @property
     def local_uuid(self): ...
     @property
-    def object_id(self): ...
+    def object_id(self) -> str: ...
     @property
     def is_hydrated(self) -> bool: ...
     @property
@@ -188,7 +188,7 @@ class Object:
     @property
     def local_uuid(self): ...
     @property
-    def object_id(self): ...
+    def object_id(self) -> str: ...
     @property
     def is_hydrated(self) -> bool: ...
     @property
@@ -202,3 +202,5 @@ class Object:
 
 def live_method(method): ...
 def live_method_gen(method): ...
+
+EPHEMERAL_OBJECT_HEARTBEAT_SLEEP: int

modal/parallel_map.py

@@ -78,7 +78,7 @@ async def _map_invocation(
 ):
     assert client.stub
     request = api_pb2.FunctionMapRequest(
-        function_id=function._invocation_function_id(),
+        function_id=function.object_id,
         parent_input_id=current_input_id() or "",
         function_call_type=api_pb2.FUNCTION_CALL_TYPE_MAP,
         return_exceptions=return_exceptions,
@@ -131,7 +131,7 @@ async def _map_invocation(
         nonlocal have_all_inputs, num_inputs
         async for items in queue_batch_iterator(input_queue, MAP_INVOCATION_CHUNK_SIZE):
             request = api_pb2.FunctionPutInputsRequest(
-                function_id=function._invocation_function_id(), inputs=items, function_call_id=function_call_id
+                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()}."