modal 1.4.4.dev15__tar.gz → 1.4.4.dev17__tar.gz

{modal-1.4.4.dev15 → modal-1.4.4.dev17}/PKG-INFO

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

{modal-1.4.4.dev15 → modal-1.4.4.dev17}/modal/_container_entrypoint.py

@@ -14,7 +14,6 @@ if telemetry_socket:
     from ._runtime.telemetry import instrument_imports
 
     instrument_imports(telemetry_socket)
-
 import asyncio
 import queue
 import signal
@@ -41,10 +40,11 @@ from ._runtime.container_io_manager import (
     ContainerIOManager,
     IOContext,
 )
-from ._runtime.task_lifecycle_manager import UserException
+from ._runtime.task_lifecycle_manager import TaskLifecycleManager, UserException
 
 if TYPE_CHECKING:
     import modal._runtime.container_io_manager
+    import modal._runtime.task_lifecycle_manager
     import modal._runtime.user_code_imports
 
 
@@ -287,12 +287,146 @@ def get_serialized_user_class_and_function(
     return ser_usr_cls, ser_fun
 
 
-def main(container_args: api_pb2.ContainerArguments, client: Client):
-    # This is a bit weird but we need both the blocking and async versions of ContainerIOManager.
-    # At some point, we should fix that by having built-in support for running "user code"
-    container_io_manager = ContainerIOManager(container_args, client)
+def get_server_service(
+    container_args: api_pb2.ContainerArguments, function_def: api_pb2.Function, _client: _Client, client: Client
+) -> Service:
+    ser_usr_cls, ser_fun = get_serialized_user_class_and_function(function_def, _client)
+    service_base_function_id = container_args.app_layout.function_ids[function_def.function_name]
+    service_function_hydration_data = [
+        o for o in container_args.app_layout.objects if o.object_id == service_base_function_id
+    ][0]
+    service = import_server_service(
+        function_def,
+        service_function_hydration_data,
+        client,
+        ser_usr_cls,
+    )
+    return service
+
+
+def get_class_service(
+    container_args: api_pb2.ContainerArguments, function_def: api_pb2.Function, _client: _Client, client: Client
+) -> Service:
+    ser_usr_cls, ser_fun = get_serialized_user_class_and_function(function_def, _client)
+    if container_args.serialized_params:
+        param_args, param_kwargs = deserialize_params(container_args.serialized_params, function_def, _client)
+    else:
+        param_args = ()
+        param_kwargs = {}
+    # this is a bit ugly - match the function and class based on function name to get metadata
+    # This metadata is required in order to hydrate the class in case it's not globally
+    # decorated (or serialized)
+    service_base_function_id = container_args.app_layout.function_ids[function_def.function_name]
+    service_function_hydration_data = [
+        o for o in container_args.app_layout.objects if o.object_id == service_base_function_id
+    ][0]
+    class_id = container_args.app_layout.class_ids[function_def.function_name.removesuffix(".*")]
+
+    service = import_class_service(
+        function_def,
+        service_function_hydration_data,
+        class_id,
+        client,
+        ser_usr_cls,
+        param_args,
+        param_kwargs,
+    )
+    return service
+
+
+def get_function_service(function_def: api_pb2.Function, _client: _Client) -> Service:
+    ser_usr_cls, ser_fun = get_serialized_user_class_and_function(function_def, _client)
+    assert ser_usr_cls is None
+    service = import_single_function_service(
+        function_def,
+        ser_fun,
+    )
+    return service
+
+
+def hydrate_function(
+    container_args: api_pb2.ContainerArguments,
+    task_lifecycle_manager: TaskLifecycleManager,
+    function_def: api_pb2.Function,
+    _client: _Client,
+    client: Client,
+) -> Service:
     active_app: _App
     service: Service
+    with task_lifecycle_manager.handle_task_lifecycle_exception():
+        with execution_context._import_context():
+            if function_def.is_server:
+                service = get_server_service(container_args, function_def, _client, client)
+            elif function_def.is_class:
+                service = get_class_service(container_args, function_def, _client, client)
+            else:
+                service = get_function_service(function_def, _client)
+
+        active_app = service.app
+
+    # Get ids and metadata for objects (primarily functions and classes) on the app
+    container_app: RunningApp = running_app_from_layout(container_args.app_id, container_args.app_layout)
+
+    # Initialize objects on the app.
+    # This is basically only functions and classes - anything else is deprecated and will be unsupported soon
+    app: App = cast(App, synchronizer._translate_out(active_app))
+    app._init_container(client, container_app)
+
+    # Hydrate all function dependencies.
+    # TODO(erikbern): we an remove this once we
+    # 1. Enable lazy hydration for all objects
+    # 2. Fully deprecate .new() objects
+    if service.service_deps is not None:  # this is not set for serialized or non-global scope functions
+        dep_object_ids: list[str] = [dep.object_id for dep in function_def.object_dependencies]
+        if len(service.service_deps) != len(dep_object_ids):
+            raise ExecutionError(
+                f"Function has {len(service.service_deps)} dependencies"
+                f" but container got {len(dep_object_ids)} object ids.\n"
+                f"Code deps: {service.service_deps}\n"
+                f"Object ids: {dep_object_ids}\n"
+                "\n"
+                "This can happen if you are defining Modal objects under a conditional statement "
+                "that evaluates differently in the local and remote environments."
+            )
+        for object_id, obj in zip(dep_object_ids, service.service_deps):
+            metadata: Message | None = container_app.object_handle_metadata[object_id]
+            obj._hydrate(object_id, _client, metadata)
+
+    return service
+
+
+def run_server(container_args: api_pb2.ContainerArguments, client: Client):
+    function_def = container_args.function_def
+    _client: _Client = cast(_Client, synchronizer._translate_in(client))  # TODO(erikbern): ugly
+    task_lifecycle_manager = TaskLifecycleManager(
+        container_args.task_id,
+        container_args.function_id,
+        container_args.function_def,
+        container_args.checkpoint_id or None,
+        client,
+    )
+
+    service: Service = hydrate_function(container_args, task_lifecycle_manager, function_def, _client, client)
+    # Initialize clustered functions.
+    if function_def._experimental_group_size > 0:
+        initialize_clustered_function(
+            client,
+            container_args.task_id,
+            function_def._experimental_group_size,
+        )
+
+    with UserCodeEventLoop() as event_loop:
+        with service.lifecycle_context(
+            event_loop,
+            task_lifecycle_manager=task_lifecycle_manager,
+        ):
+            call_server(event_loop)
+
+
+def run_function(container_args: api_pb2.ContainerArguments, client: Client):
+    # This is a bit weird but we need both the blocking and async versions of ContainerIOManager.
+    # At some point, we should fix that by having built-in support for running "user code"
+    container_io_manager: Any = ContainerIOManager(container_args, client)
     function_def = container_args.function_def
     # The worker sets this flag to "1" for snapshot and restore tasks. Otherwise, this flag is unset,
     # in which case snapshots should be disabled.
@@ -306,92 +440,17 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
     container_io_manager.hello()
 
     with container_io_manager.heartbeats(is_snapshotting_function), UserCodeEventLoop() as event_loop:
-        # If this is a serialized function, fetch the definition from the server
-        ser_usr_cls, ser_fun = get_serialized_user_class_and_function(function_def, _client)
-
         # Initialize the function, importing user code.
-        with container_io_manager.get_task_lifecycle_manager().handle_task_lifecycle_exception():
-            if container_args.serialized_params:
-                param_args, param_kwargs = deserialize_params(container_args.serialized_params, function_def, _client)
-            else:
-                param_args = ()
-                param_kwargs = {}
-
-            with execution_context._import_context():
-                if function_def.is_server:
-                    service_base_function_id = container_args.app_layout.function_ids[function_def.function_name]
-                    service_function_hydration_data = [
-                        o for o in container_args.app_layout.objects if o.object_id == service_base_function_id
-                    ][0]
-                    service = import_server_service(
-                        function_def,
-                        service_function_hydration_data,
-                        client,
-                        ser_usr_cls,
-                    )
-                elif function_def.is_class:
-                    # this is a bit ugly - match the function and class based on function name to get metadata
-                    # This metadata is required in order to hydrate the class in case it's not globally
-                    # decorated (or serialized)
-                    service_base_function_id = container_args.app_layout.function_ids[function_def.function_name]
-                    service_function_hydration_data = [
-                        o for o in container_args.app_layout.objects if o.object_id == service_base_function_id
-                    ][0]
-                    class_id = container_args.app_layout.class_ids[function_def.function_name.removesuffix(".*")]
-
-                    service = import_class_service(
-                        function_def,
-                        service_function_hydration_data,
-                        class_id,
-                        client,
-                        ser_usr_cls,
-                        param_args,
-                        param_kwargs,
-                    )
-                else:
-                    assert ser_usr_cls is None
-                    service = import_single_function_service(
-                        function_def,
-                        ser_fun,
-                    )
-
-            active_app = service.app
-
-            if function_def.pty_info.pty_type == api_pb2.PTYInfo.PTY_TYPE_SHELL:
-                # Concurrency and batching doesn't apply for `modal shell`.
-                batch_max_size = 0
-                batch_wait_ms = 0
-            else:
-                batch_max_size = function_def.batch_max_size or 0
-                batch_wait_ms = function_def.batch_linger_ms or 0
-
-        # Get ids and metadata for objects (primarily functions and classes) on the app
-        container_app: RunningApp = running_app_from_layout(container_args.app_id, container_args.app_layout)
-
-        # Initialize objects on the app.
-        # This is basically only functions and classes - anything else is deprecated and will be unsupported soon
-        app: App = cast(App, synchronizer._translate_out(active_app))
-        app._init_container(client, container_app)
-
-        # Hydrate all function dependencies.
-        # TODO(erikbern): we an remove this once we
-        # 1. Enable lazy hydration for all objects
-        # 2. Fully deprecate .new() objects
-        if service.service_deps is not None:  # this is not set for serialized or non-global scope functions
-            dep_object_ids: list[str] = [dep.object_id for dep in function_def.object_dependencies]
-            if len(service.service_deps) != len(dep_object_ids):
-                raise ExecutionError(
-                    f"Function has {len(service.service_deps)} dependencies"
-                    f" but container got {len(dep_object_ids)} object ids.\n"
-                    f"Code deps: {service.service_deps}\n"
-                    f"Object ids: {dep_object_ids}\n"
-                    "\n"
-                    "This can happen if you are defining Modal objects under a conditional statement "
-                    "that evaluates differently in the local and remote environments."
-                )
-            for object_id, obj in zip(dep_object_ids, service.service_deps):
-                metadata: Message | None = container_app.object_handle_metadata[object_id]
-                obj._hydrate(object_id, _client, metadata)
+        service: Service = hydrate_function(
+            container_args, container_io_manager.get_task_lifecycle_manager(), function_def, _client, client
+        )
+        if function_def.pty_info.pty_type == api_pb2.PTYInfo.PTY_TYPE_SHELL:
+            # Concurrency and batching doesn't apply for `modal shell`.
+            batch_max_size = 0
+            batch_wait_ms = 0
+        else:
+            batch_max_size = function_def.batch_max_size or 0
+            batch_wait_ms = function_def.batch_linger_ms or 0
 
         # Initialize clustered functions.
         if function_def._experimental_group_size > 0:
@@ -407,10 +466,14 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
         ) as finalized_functions:
             # This context managers handles pre/post snapshot lifecycle of the user code,
             # finalized functions, ASGI/WSGI lifespan, and volume commit.
-            if function_def.is_server:
-                call_server(event_loop)
-            else:
-                call_function(event_loop, container_io_manager, finalized_functions, batch_max_size, batch_wait_ms)
+            call_function(event_loop, container_io_manager, finalized_functions, batch_max_size, batch_wait_ms)
+
+
+def main(container_args: api_pb2.ContainerArguments, client: Client):
+    if container_args.function_def.is_server:
+        run_server(container_args, client)
+    else:
+        run_function(container_args, client)
 
 
 if __name__ == "__main__":

{modal-1.4.4.dev15 → modal-1.4.4.dev17}/modal/_functions.py

@@ -1208,6 +1208,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         app_name: str,
         name: str,
         *,
+        version: int | None = None,
         load_context_overrides: LoadContext,
     ):
         # internal function lookup implementation that allows lookup of class "service functions"
@@ -1219,6 +1220,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 app_name=app_name,
                 object_tag=name,
                 environment_name=load_context.environment_name,
+                app_version=version or 0,
             )
             try:
                 response = await load_context.client.stub.FunctionGet(request)
@@ -1251,6 +1253,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         app_name: str,
         name: str,
         *,
+        version: int | None = None,
         environment_name: str | None = None,
         client: _Client | None = None,
     ) -> "_Function":
@@ -1273,6 +1276,12 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             ```python
             f = modal.Function.from_name("other-app", "function")
             ```
+
+            The `version` parameter allows you to invoke a version-pinned function:
+
+            ```python
+            f_v3 = modal.Function.from_name("other-app", "function", version=3)
+            ```
         """
         if "." in name:
             raise InvalidError(
@@ -1281,7 +1290,10 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             )
 
         return cls._from_name(
-            app_name, name, load_context_overrides=LoadContext(environment_name=environment_name, client=client)
+            app_name,
+            name,
+            load_context_overrides=LoadContext(environment_name=environment_name, client=client),
+            version=version,
         )
 
     @property

{modal-1.4.4.dev15 → modal-1.4.4.dev17}/modal/_image.py

@@ -60,6 +60,7 @@ from .secret import _Secret
 from .volume import _Volume, _volume_to_mount_proto
 
 if typing.TYPE_CHECKING:
+    import modal
     import modal._functions
     import modal.client
 
@@ -531,7 +532,7 @@ class _Image(_Object, type_prefix="im"):
 
         for secret in secrets:
             if not isinstance(secret, _Secret):
-                raise InvalidError("All secrets of an image needs to be modal.Secret/AioSecret instances")
+                raise InvalidError("All secrets of an Image need to be modal.Secret instances.")
 
         if build_function and len(base_images) != 1:
             raise InvalidError("Cannot run a build function with multiple base images!")
@@ -2763,7 +2764,7 @@ class _Image(_Object, type_prefix="im"):
 
     def pipe(
         self,
-        func: Callable[Concatenate["_Image", P], "_Image"],
+        func: Callable[Concatenate["modal.Image", P], "modal.Image"],
         *args: P.args,
         **kwargs: P.kwargs,
     ) -> "_Image":
@@ -2785,7 +2786,11 @@ class _Image(_Object, type_prefix="im"):
         )
         ```
         """
-        return func(self, *args, **kwargs)
+        # Typing here is complicated because user callables accept the public
+        # Image type, but `self` is an instance of the internal _Image type.
+        self_ = synchronizer._translate_out(self)
+        res = func(self_, *args, **kwargs)  # type: ignore[reportUnknownReturnType]
+        return typing.cast(_Image, synchronizer._translate_in(res))
 
     # Live handle methods
 

{modal-1.4.4.dev15 → modal-1.4.4.dev17}/modal/_object.py

@@ -14,7 +14,6 @@ from modal._traceback import suppress_tb_frame
 from ._load_context import LoadContext
 from ._resolver import Resolver
 from ._utils.async_utils import TaskContext, aclosing
-from ._utils.deprecation import deprecation_warning
 from .client import _Client
 from .config import config, logger
 from .exception import ExecutionError, InvalidError
@@ -196,23 +195,6 @@ class _Object:
                 f"{object_type} has not been hydrated with the metadata it needs to run on Modal{reason}."
             )
 
-    def clone(self) -> Self:
-        """mdmd:hidden Clone a given hydrated object.
-
-        Note: This is not intended to be public API and has no public use. It will be removed in a future release.
-        """
-        object_class = self.__class__.__name__.strip("_")
-        deprecation_warning(
-            (2025, 6, 30),
-            f"{object_class}.clone() is not intended to be public API and will be removed in a future release.",
-        )
-
-        # Object to clone must already be hydrated, otherwise from_loader is more suitable.
-        self._validate_is_hydrated()
-        obj = type(self).__new__(type(self))
-        obj._initialize_from_other(self)
-        return obj
-
     @classmethod
     def _from_loader(
         cls,

{modal-1.4.4.dev15 → modal-1.4.4.dev17}/modal/_utils/grpc_utils.py

@@ -153,7 +153,10 @@ class CustomProtoStatusDetailsCodec(StatusDetailsCodecBase):
         if details is not None:
             for detail in details:
                 detail_container = details_proto.details.add()
-                detail_container.Pack(detail)
+                if detail.DESCRIPTOR.full_name.startswith("modal."):
+                    detail_container.Pack(detail, type_url_prefix="type.modal.com/")
+                else:
+                    detail_container.Pack(detail)
         return details_proto.SerializeToString()
 
     def decode(

{modal-1.4.4.dev15 → modal-1.4.4.dev17}/modal/cli/entry_point.py

@@ -25,6 +25,7 @@ from .network_file_system import nfs_cli
 from .profile import profile_cli
 from .queues import queue_cli
 from .secret import secret_cli
+from .skills import skills_cli
 from .token import _new_token, token_cli
 from .volume import volume_cli
 
@@ -117,6 +118,7 @@ entrypoint_cli.add_command(bootstrap, panel="Onboarding")
 entrypoint_cli.add_command(config_cli, panel="Configuration")
 entrypoint_cli.add_command(environment_cli, panel="Configuration")
 entrypoint_cli.add_command(profile_cli, panel="Configuration")
+entrypoint_cli.add_command(skills_cli, panel="Configuration")
 entrypoint_cli.add_command(token_cli, panel="Configuration")
 
 entrypoint_cli.add_command(billing_cli, panel="Observability")