modal 0.66.25__py3-none-any.whl → 0.66.35__py3-none-any.whl

modal/_runtime/user_code_imports.py

@@ -0,0 +1,361 @@
+# Copyright Modal Labs 2024
+import importlib
+import typing
+from abc import ABCMeta, abstractmethod
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, List, Optional
+
+import modal._runtime.container_io_manager
+import modal.cls
+import modal.object
+from modal import Function
+from modal._runtime.asgi import (
+    LifespanManager,
+    asgi_app_wrapper,
+    get_ip_address,
+    wait_for_web_server,
+    web_server_proxy,
+    webhook_asgi_app,
+    wsgi_app_wrapper,
+)
+from modal._utils.async_utils import synchronizer
+from modal._utils.function_utils import LocalFunctionError, is_async as get_is_async, is_global_object
+from modal.exception import ExecutionError, InvalidError
+from modal.functions import _Function
+from modal.partial_function import _find_partial_methods_for_user_cls, _PartialFunctionFlags
+from modal_proto import api_pb2
+
+if typing.TYPE_CHECKING:
+    import modal.app
+    import modal.partial_function
+
+
+@dataclass
+class FinalizedFunction:
+    callable: Callable[..., Any]
+    is_async: bool
+    is_generator: bool
+    data_format: int  # api_pb2.DataFormat
+    lifespan_manager: Optional[LifespanManager] = None
+
+
+class Service(metaclass=ABCMeta):
+    """Common interface for singular functions and class-based "services"
+
+    There are differences in the importing/finalization logic, and this
+    "protocol"/abc basically defines a common interface for the two types
+    of "Services" after the point of import.
+    """
+
+    user_cls_instance: Any
+    app: Optional["modal.app._App"]
+    code_deps: Optional[List["modal.object._Object"]]
+
+    @abstractmethod
+    def get_finalized_functions(
+        self, fun_def: api_pb2.Function, container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager"
+    ) -> Dict[str, "FinalizedFunction"]:
+        ...
+
+
+def construct_webhook_callable(
+    user_defined_callable: Callable,
+    webhook_config: api_pb2.WebhookConfig,
+    container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
+):
+    # For webhooks, the user function is used to construct an asgi app:
+    if webhook_config.type == api_pb2.WEBHOOK_TYPE_ASGI_APP:
+        # Function returns an asgi_app, which we can use as a callable.
+        return asgi_app_wrapper(user_defined_callable(), container_io_manager)
+
+    elif webhook_config.type == api_pb2.WEBHOOK_TYPE_WSGI_APP:
+        # Function returns an wsgi_app, which we can use as a callable.
+        return wsgi_app_wrapper(user_defined_callable(), container_io_manager)
+
+    elif webhook_config.type == api_pb2.WEBHOOK_TYPE_FUNCTION:
+        # Function is a webhook without an ASGI app. Create one for it.
+        return asgi_app_wrapper(
+            webhook_asgi_app(user_defined_callable, webhook_config.method, webhook_config.web_endpoint_docs),
+            container_io_manager,
+        )
+
+    elif webhook_config.type == api_pb2.WEBHOOK_TYPE_WEB_SERVER:
+        # Function spawns an HTTP web server listening at a port.
+        user_defined_callable()
+
+        # We intentionally try to connect to the external interface instead of the loopback
+        # interface here so users are forced to expose the server. This allows us to potentially
+        # change the implementation to use an external bridge in the future.
+        host = get_ip_address(b"eth0")
+        port = webhook_config.web_server_port
+        startup_timeout = webhook_config.web_server_startup_timeout
+        wait_for_web_server(host, port, timeout=startup_timeout)
+        return asgi_app_wrapper(web_server_proxy(host, port), container_io_manager)
+    else:
+        raise InvalidError(f"Unrecognized web endpoint type {webhook_config.type}")
+
+
+@dataclass
+class ImportedFunction(Service):
+    user_cls_instance: Any
+    app: Optional["modal.app._App"]
+    code_deps: Optional[List["modal.object._Object"]]
+
+    _user_defined_callable: Callable[..., Any]
+
+    def get_finalized_functions(
+        self, fun_def: api_pb2.Function, container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager"
+    ) -> Dict[str, "FinalizedFunction"]:
+        # Check this property before we turn it into a method (overriden by webhooks)
+        is_async = get_is_async(self._user_defined_callable)
+        # Use the function definition for whether this is a generator (overriden by webhooks)
+        is_generator = fun_def.function_type == api_pb2.Function.FUNCTION_TYPE_GENERATOR
+
+        webhook_config = fun_def.webhook_config
+        if not webhook_config.type:
+            # for non-webhooks, the runnable is straight forward:
+            return {
+                "": FinalizedFunction(
+                    callable=self._user_defined_callable,
+                    is_async=is_async,
+                    is_generator=is_generator,
+                    data_format=api_pb2.DATA_FORMAT_PICKLE,
+                )
+            }
+
+        web_callable, lifespan_manager = construct_webhook_callable(
+            self._user_defined_callable, fun_def.webhook_config, container_io_manager
+        )
+
+        return {
+            "": FinalizedFunction(
+                callable=web_callable,
+                lifespan_manager=lifespan_manager,
+                is_async=True,
+                is_generator=True,
+                data_format=api_pb2.DATA_FORMAT_ASGI,
+            )
+        }
+
+
+@dataclass
+class ImportedClass(Service):
+    user_cls_instance: Any
+    app: Optional["modal.app._App"]
+    code_deps: Optional[List["modal.object._Object"]]
+
+    _partial_functions: Dict[str, "modal.partial_function._PartialFunction"]
+
+    def get_finalized_functions(
+        self, fun_def: api_pb2.Function, container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager"
+    ) -> Dict[str, "FinalizedFunction"]:
+        finalized_functions = {}
+        for method_name, partial in self._partial_functions.items():
+            partial = synchronizer._translate_in(partial)  # ugly
+            user_func = partial.raw_f
+            # Check this property before we turn it into a method (overriden by webhooks)
+            is_async = get_is_async(user_func)
+            # Use the function definition for whether this is a generator (overriden by webhooks)
+            is_generator = partial.is_generator
+            webhook_config = partial.webhook_config
+
+            bound_func = user_func.__get__(self.user_cls_instance)
+
+            if not webhook_config or webhook_config.type == api_pb2.WEBHOOK_TYPE_UNSPECIFIED:
+                # for non-webhooks, the runnable is straight forward:
+                finalized_function = FinalizedFunction(
+                    callable=bound_func,
+                    is_async=is_async,
+                    is_generator=is_generator,
+                    data_format=api_pb2.DATA_FORMAT_PICKLE,
+                )
+            else:
+                web_callable, lifespan_manager = construct_webhook_callable(
+                    bound_func, webhook_config, container_io_manager
+                )
+                finalized_function = FinalizedFunction(
+                    callable=web_callable,
+                    lifespan_manager=lifespan_manager,
+                    is_async=True,
+                    is_generator=True,
+                    data_format=api_pb2.DATA_FORMAT_ASGI,
+                )
+            finalized_functions[method_name] = finalized_function
+        return finalized_functions
+
+
+def get_user_class_instance(
+    cls: typing.Union[type, modal.cls.Cls], args: typing.Tuple, kwargs: Dict[str, Any]
+) -> typing.Any:
+    """Returns instance of the underlying class to be used as the `self`
+
+    The input `cls` can either be the raw Python class the user has declared ("user class"),
+    or an @app.cls-decorated version of it which is a modal.Cls-instance wrapping the user class.
+    """
+    if isinstance(cls, modal.cls.Cls):
+        # globally @app.cls-decorated class
+        modal_obj: modal.cls.Obj = cls(*args, **kwargs)
+        modal_obj.entered = True  # ugly but prevents .local() from triggering additional enter-logic
+        # TODO: unify lifecycle logic between .local() and container_entrypoint
+        user_cls_instance = modal_obj._get_user_cls_instance()
+    else:
+        # undecorated class (non-global decoration or serialized)
+        user_cls_instance = cls(*args, **kwargs)
+
+    return user_cls_instance
+
+
+def import_single_function_service(
+    function_def: api_pb2.Function,
+    ser_cls,  # used only for @build functions
+    ser_fun,
+    cls_args,  #  used only for @build functions
+    cls_kwargs,  #  used only for @build functions
+) -> Service:
+    """Imports a function dynamically, and locates the app.
+
+    This is somewhat complex because we're dealing with 3 quite different type of functions:
+    1. Functions defined in global scope and decorated in global scope (Function objects)
+    2. Functions defined in global scope but decorated elsewhere (these will be raw callables)
+    3. Serialized functions
+
+    In addition, we also need to handle
+    * Normal functions
+    * Methods on classes (in which case we need to instantiate the object)
+
+    This helper also handles web endpoints, ASGI/WSGI servers, and HTTP servers.
+
+    In order to locate the app, we try two things:
+    * If the function is a Function, we can get the app directly from it
+    * Otherwise, use the app name and look it up from a global list of apps: this
+      typically only happens in case 2 above, or in sometimes for case 3
+
+    Note that `import_function` is *not* synchronized, because we need it to run on the main
+    thread. This is so that any user code running in global scope (which executes as a part of
+    the import) runs on the right thread.
+    """
+    user_defined_callable: Callable
+    function: Optional[_Function] = None
+    code_deps: Optional[List["modal.object._Object"]] = None
+    active_app: Optional[modal.app._App] = None
+
+    if ser_fun is not None:
+        # This is a serialized function we already fetched from the server
+        cls, user_defined_callable = ser_cls, ser_fun
+    else:
+        # Load the module dynamically
+        module = importlib.import_module(function_def.module_name)
+        qual_name: str = function_def.function_name
+
+        if not is_global_object(qual_name):
+            raise LocalFunctionError("Attempted to load a function defined in a function scope")
+
+        parts = qual_name.split(".")
+        if len(parts) == 1:
+            # This is a function
+            cls = None
+            f = getattr(module, qual_name)
+            if isinstance(f, Function):
+                function = synchronizer._translate_in(f)
+                user_defined_callable = function.get_raw_f()
+                active_app = function._app
+            else:
+                user_defined_callable = f
+        elif len(parts) == 2:
+            # As of v0.63 - this path should only be triggered by @build class builder methods
+            assert not function_def.use_method_name  # new "placeholder methods" should not be invoked directly!
+            assert function_def.is_builder_function
+            cls_name, fun_name = parts
+            cls = getattr(module, cls_name)
+            if isinstance(cls, modal.cls.Cls):
+                # The cls decorator is in global scope
+                _cls = synchronizer._translate_in(cls)
+                user_defined_callable = _cls._callables[fun_name]
+                function = _cls._method_functions.get(fun_name)
+                active_app = _cls._app
+            else:
+                # This is a raw class
+                user_defined_callable = getattr(cls, fun_name)
+        else:
+            raise InvalidError(f"Invalid function qualname {qual_name}")
+
+    # Instantiate the class if it's defined
+    if cls:
+        # This code is only used for @build methods on classes
+        user_cls_instance = get_user_class_instance(cls, cls_args, cls_kwargs)
+        # Bind the function to the instance as self (using the descriptor protocol!)
+        user_defined_callable = user_defined_callable.__get__(user_cls_instance)
+    else:
+        user_cls_instance = None
+
+    if function:
+        code_deps = function.deps(only_explicit_mounts=True)
+
+    return ImportedFunction(
+        user_cls_instance,
+        active_app,
+        code_deps,
+        user_defined_callable,
+    )
+
+
+def import_class_service(
+    function_def: api_pb2.Function,
+    ser_cls,
+    cls_args,
+    cls_kwargs,
+) -> Service:
+    """
+    This imports a full class to be able to execute any @method or webhook decorated methods.
+
+    See import_function.
+    """
+    active_app: Optional["modal.app._App"]
+    code_deps: Optional[List["modal.object._Object"]]
+    cls: typing.Union[type, modal.cls.Cls]
+
+    if function_def.definition_type == api_pb2.Function.DEFINITION_TYPE_SERIALIZED:
+        assert ser_cls is not None
+        cls = ser_cls
+    else:
+        # Load the module dynamically
+        module = importlib.import_module(function_def.module_name)
+        qual_name: str = function_def.function_name
+
+        if not is_global_object(qual_name):
+            raise LocalFunctionError("Attempted to load a class defined in a function scope")
+
+        parts = qual_name.split(".")
+        if not (
+            len(parts) == 2 and parts[1] == "*"
+        ):  # the "function name" of a class service "function placeholder" is expected to be "ClassName.*"
+            raise ExecutionError(
+                f"Internal error: Invalid 'service function' identifier {qual_name}. Please contact Modal support"
+            )
+
+        assert not function_def.use_method_name  # new "placeholder methods" should not be invoked directly!
+        cls_name = parts[0]
+        cls = getattr(module, cls_name)
+
+    if isinstance(cls, modal.cls.Cls):
+        # The cls decorator is in global scope
+        _cls = synchronizer._translate_in(cls)
+        method_partials = _cls._get_partial_functions()
+        service_function: _Function = _cls._class_service_function
+        code_deps = service_function.deps(only_explicit_mounts=True)
+        active_app = service_function.app
+    else:
+        # Undecorated user class - find all methods
+        method_partials = _find_partial_methods_for_user_cls(cls, _PartialFunctionFlags.all())
+        code_deps = None
+        active_app = None
+
+    user_cls_instance = get_user_class_instance(cls, cls_args, cls_kwargs)
+
+    return ImportedClass(
+        user_cls_instance,
+        active_app,
+        code_deps,
+        # TODO (elias/deven): instead of using method_partials here we should use a set of api_pb2.MethodDefinition
+        method_partials,
+    )

modal/app.py

@@ -1,6 +1,5 @@
 # Copyright Modal Labs 2022
 import inspect
-import os
 import typing
 import warnings
 from pathlib import PurePosixPath
@@ -42,7 +41,6 @@ from .image import _Image
 from .mount import _Mount
 from .network_file_system import _NetworkFileSystem
 from .object import _get_environment_name, _Object
-from .output import _get_output_manager, enable_output
 from .partial_function import (
     PartialFunction,
     _find_partial_methods_for_user_cls,
@@ -141,21 +139,6 @@ def f(x, y):
 ```
 """
 
-_enable_output_warning = """\
-Note that output will soon not be be printed with `app.run`.
-
-If you want to print output, use `modal.enable_output()`:
-
-```python
-with modal.enable_output():
-    with app.run():
-        ...
-```
-
-If you don't want output, and you want to to suppress this warning,
-use `app.run(..., show_progress=False)`.
-"""
-
 
 class _App:
     """A Modal App is a group of functions and classes that are deployed together.
@@ -446,32 +429,16 @@ class _App:
 
         # See Github discussion here: https://github.com/modal-labs/modal-client/pull/2030#issuecomment-2237266186
 
-        auto_enable_output = False
-
-        if "MODAL_DISABLE_APP_RUN_OUTPUT_WARNING" not in os.environ:
-            if show_progress is None:
-                if _get_output_manager() is None:
-                    deprecation_warning((2024, 7, 18), _enable_output_warning)
-                    auto_enable_output = True
-            elif show_progress is True:
-                if _get_output_manager() is None:
-                    deprecation_warning((2024, 7, 18), _enable_output_warning)
-                    auto_enable_output = True
-                else:
-                    deprecation_warning((2024, 7, 18), "`show_progress=True` is deprecated and no longer needed.")
-            elif show_progress is False:
-                if _get_output_manager() is not None:
-                    deprecation_warning(
-                        (2024, 7, 18), "`show_progress=False` will have no effect since output is enabled."
-                    )
+        if show_progress is True:
+            deprecation_error(
+                (2024, 11, 20),
+                "`show_progress=True` is no longer supported. Use `with modal.enable_output():` instead.",
+            )
+        elif show_progress is False:
+            deprecation_warning((2024, 11, 20), "`show_progress=False` is deprecated (and has no effect)")
 
-        if auto_enable_output:
-            with enable_output():
-                async with _run_app(self, client=client, detach=detach, interactive=interactive):
-                    yield self
-        else:
-            async with _run_app(self, client=client, detach=detach, interactive=interactive):
-                yield self
+        async with _run_app(self, client=client, detach=detach, interactive=interactive):
+            yield self
 
     def _get_default_image(self):
         if self._image:
@@ -487,7 +454,7 @@ class _App:
             *self._mounts,
         ]
         for function in self.registered_functions.values():
-            all_mounts.extend(function._used_local_mounts)
+            all_mounts.extend(function._serve_mounts)
 
         return [m for m in all_mounts if m.is_local()]
 

modal/client.pyi

@@ -31,7 +31,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[typing.Tuple[str, str]],
-        version: str = "0.66.25",
+        version: str = "0.66.35",
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -90,7 +90,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[typing.Tuple[str, str]],
-        version: str = "0.66.25",
+        version: str = "0.66.35",
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/experimental.py

@@ -17,7 +17,6 @@ from .partial_function import _PartialFunction, _PartialFunctionFlags
 def stop_fetching_inputs():
     """Don't fetch any more inputs from the server, after the current one.
     The container will exit gracefully after the current input is processed."""
-
     _ContainerIOManager.stop_fetching_inputs()
 
 
@@ -25,7 +24,6 @@ def get_local_input_concurrency():
     """Get the container's local input concurrency.
     If recently reduced to particular value, it can return a larger number than
     set due to in-progress inputs."""
-
     return _ContainerIOManager.get_input_concurrency()
 
 
@@ -33,7 +31,6 @@ def set_local_input_concurrency(concurrency: int):
     """Set the container's local input concurrency. Dynamic concurrency will be disabled.
     When setting to a smaller value, this method will not interrupt in-progress inputs.
     """
-
     _ContainerIOManager.set_input_concurrency(concurrency)
 
 

modal/functions.py

@@ -304,7 +304,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
     # TODO: more type annotations
     _info: Optional[FunctionInfo]
-    _used_local_mounts: typing.FrozenSet[_Mount]  # set at load time, only by loader
+    _serve_mounts: typing.FrozenSet[_Mount]  # set at load time, only by loader
     _app: Optional["modal.app._App"] = None
     _obj: Optional["modal.cls._Obj"] = None  # only set for InstanceServiceFunctions and bound instance methods
     _web_url: Optional[str]
@@ -579,6 +579,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
         if is_local():
             entrypoint_mounts = info.get_entrypoint_mount()
+
             all_mounts = [
                 _get_client_mount(),
                 *explicit_mounts,
@@ -611,6 +612,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         if proxy:
             # HACK: remove this once we stop using ssh tunnels for this.
             if image:
+                # TODO(elias): this will cause an error if users use prior `.add_local_*` commands without copy=True
                 image = image.apt_install("autossh")
 
         function_spec = _FunctionSpec(
@@ -827,7 +829,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     )
                     for path, volume in validated_volumes
                 ]
-                loaded_mount_ids = {m.object_id for m in all_mounts}
+                loaded_mount_ids = {m.object_id for m in all_mounts} | {m.object_id for m in image._mount_layers}
 
                 # Get object dependencies
                 object_dependencies = []
@@ -969,9 +971,9 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         raise InvalidError(f"Function {info.function_name} is too large to deploy.")
                     raise
                 function_creation_status.set_response(response)
-            local_mounts = set(m for m in all_mounts if m.is_local())  # needed for modal.serve file watching
-            local_mounts |= image._used_local_mounts
-            obj._used_local_mounts = frozenset(local_mounts)
+            serve_mounts = set(m for m in all_mounts if m.is_local())  # needed for modal.serve file watching
+            serve_mounts |= image._serve_mounts
+            obj._serve_mounts = frozenset(serve_mounts)
             self._hydrate(response.function_id, resolver.client, response.handle_metadata)
 
         rep = f"Function({tag})"
@@ -1222,7 +1224,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         self._function_name = None
         self._info = None
         self._use_function_id = ""
-        self._used_local_mounts = frozenset()
+        self._serve_mounts = frozenset()
 
     def _hydrate_metadata(self, metadata: Optional[Message]):
         # Overridden concrete implementation of base class method

modal/functions.pyi

@@ -110,7 +110,7 @@ OriginalReturnType = typing.TypeVar("OriginalReturnType", covariant=True)
 
 class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object._Object):
     _info: typing.Optional[modal._utils.function_utils.FunctionInfo]
-    _used_local_mounts: typing.FrozenSet[modal.mount._Mount]
+    _serve_mounts: typing.FrozenSet[modal.mount._Mount]
     _app: typing.Optional[modal.app._App]
     _obj: typing.Optional[modal.cls._Obj]
     _web_url: typing.Optional[str]
@@ -286,7 +286,7 @@ P_INNER = typing_extensions.ParamSpec("P_INNER")
 
 class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.Object):
     _info: typing.Optional[modal._utils.function_utils.FunctionInfo]
-    _used_local_mounts: typing.FrozenSet[modal.mount.Mount]
+    _serve_mounts: typing.FrozenSet[modal.mount.Mount]
     _app: typing.Optional[modal.app.App]
     _obj: typing.Optional[modal.cls.Obj]
     _web_url: typing.Optional[str]