modal 0.62.115__py3-none-any.whl → 0.72.13__py3-none-any.whl

modal/{execution_context.py → _runtime/execution_context.py}

@@ -2,10 +2,11 @@
 from contextvars import ContextVar
 from typing import Callable, Optional
 
-from modal._container_io_manager import _ContainerIOManager
 from modal._utils.async_utils import synchronize_api
 from modal.exception import InvalidError
 
+from .container_io_manager import _ContainerIOManager
+
 
 def is_local() -> bool:
     """Returns if we are currently on the machine launching/deploying a Modal app
@@ -17,6 +18,11 @@ def is_local() -> bool:
 
 
 async def _interact() -> None:
+    """Enable interactivity with user input inside a Modal container.
+
+    See the [interactivity guide](https://modal.com/docs/guide/developing-debugging#interactivity)
+    for more information on how to use this function.
+    """
     container_io_manager = _ContainerIOManager._singleton
     if not container_io_manager:
         raise InvalidError("Interactivity only works inside a Modal container.")
@@ -65,7 +71,10 @@ def current_function_call_id() -> Optional[str]:
         return None
 
 
-def _set_current_context_ids(input_id: str, function_call_id: str) -> Callable[[], None]:
+def _set_current_context_ids(input_ids: list[str], function_call_ids: list[str]) -> Callable[[], None]:
+    assert len(input_ids) == len(function_call_ids) and len(input_ids) > 0
+    input_id = input_ids[0]
+    function_call_id = function_call_ids[0]
     input_token = _current_input_id.set(input_id)
     function_call_token = _current_function_call_id.set(function_call_id)
 

modal/_runtime/telemetry.py

@@ -0,0 +1,169 @@
+# Copyright Modal Labs 2024
+
+import importlib.abc
+import json
+import queue
+import socket
+import sys
+import threading
+import time
+import uuid
+from importlib.util import find_spec, module_from_spec
+from struct import pack
+
+from modal.config import logger
+
+MODULE_LOAD_START = "module_load_start"
+MODULE_LOAD_END = "module_load_end"
+
+MESSAGE_HEADER_FORMAT = "<I"
+MESSAGE_HEADER_LEN = 4
+
+
+class InterceptedModuleLoader(importlib.abc.Loader):
+    def __init__(self, name, loader, interceptor):
+        self.name = name
+        self.loader = loader
+        self.interceptor = interceptor
+
+    def exec_module(self, module):
+        if self.loader is None:
+            return
+        try:
+            self.loader.exec_module(module)
+        finally:
+            self.interceptor.load_end(self.name)
+
+    def create_module(self, spec):
+        spec.loader = self.loader
+        module = module_from_spec(spec)
+        spec.loader = self
+        return module
+
+    def get_data(self, path: str) -> bytes:
+        """
+        Implementation is required to support pkgutil.get_data.
+
+        > If the package cannot be located or loaded, or it uses a loader which does
+        > not support get_data, then None is returned.
+
+        ref: https://docs.python.org/3/library/pkgutil.html#pkgutil.get_data
+        """
+        return self.loader.get_data(path)
+
+    def get_resource_reader(self, fullname: str):
+        """
+        Support reading a binary artifact that is shipped within a package.
+
+        > Loaders that wish to support resource reading are expected to provide a method called
+        > get_resource_reader(fullname) which returns an object implementing this ABC’s interface.
+
+        ref: docs.python.org/3.10/library/importlib.html?highlight=traversableresources#importlib.abc.ResourceReader
+        """
+        return self.loader.get_resource_reader(fullname)
+
+
+class ImportInterceptor(importlib.abc.MetaPathFinder):
+    loading: dict[str, tuple[str, float]]
+    tracing_socket: socket.socket
+    events: queue.Queue
+
+    @classmethod
+    def connect(cls, socket_filename: str) -> "ImportInterceptor":
+        tracing_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        tracing_socket.connect(socket_filename)
+        return cls(tracing_socket)
+
+    def __init__(self, tracing_socket: socket.socket):
+        self.loading = {}
+        self.tracing_socket = tracing_socket
+        self.events = queue.Queue(maxsize=16 * 1024)
+        sender = threading.Thread(target=self._send, daemon=True)
+        sender.start()
+
+    def find_spec(self, fullname, path, target=None):
+        if fullname in self.loading:
+            return None
+        self.load_start(fullname)
+        spec = find_spec(fullname)
+        if spec is None:
+            self.load_end(fullname)
+            return None
+        spec.loader = InterceptedModuleLoader(fullname, spec.loader, self)
+        return spec
+
+    def load_start(self, name):
+        t0 = time.monotonic()
+        span_id = str(uuid.uuid4())
+        self.emit(
+            {"span_id": span_id, "timestamp": time.time(), "event": MODULE_LOAD_START, "attributes": {"name": name}}
+        )
+        self.loading[name] = (span_id, t0)
+
+    def load_end(self, name):
+        span_id, t0 = self.loading.pop(name, (None, None))
+        if t0 is None:
+            return
+        latency = time.monotonic() - t0
+        self.emit(
+            {
+                "span_id": span_id,
+                "timestamp": time.time(),
+                "event": MODULE_LOAD_END,
+                "attributes": {
+                    "name": name,
+                    "latency": latency,
+                },
+            }
+        )
+
+    def emit(self, event):
+        try:
+            self.events.put_nowait(event)
+        except queue.Full:
+            logger.debug("failed to emit event: queue full")
+
+    def _send(self):
+        while True:
+            event = self.events.get()
+            try:
+                msg = json.dumps(event).encode("utf-8")
+            except BaseException as e:
+                logger.debug(f"failed to serialize event: {e}")
+                continue
+            try:
+                encoded_len = pack(MESSAGE_HEADER_FORMAT, len(msg))
+                self.tracing_socket.send(encoded_len + msg)
+            except OSError as e:
+                logger.debug(f"failed to send event: {e}")
+
+    def install(self):
+        sys.meta_path = [self] + sys.meta_path  # type: ignore
+
+    def remove(self):
+        sys.meta_path.remove(self)  # type: ignore
+
+    def __enter__(self):
+        self.install()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.remove()
+
+
+def _instrument_imports(socket_filename: str):
+    if not supported_platform():
+        logger.debug("unsupported platform, not instrumenting imports")
+        return
+    interceptor = ImportInterceptor.connect(socket_filename)
+    interceptor.install()
+
+
+def instrument_imports(socket_filename: str):
+    try:
+        _instrument_imports(socket_filename)
+    except BaseException as e:
+        logger.warning(f"failed to instrument imports: {e}")
+
+
+def supported_platform():
+    return sys.platform in ("linux", "darwin")

modal/_runtime/user_code_imports.py

@@ -0,0 +1,356 @@
+# Copyright Modal Labs 2024
+import importlib
+import typing
+from abc import ABCMeta, abstractmethod
+from dataclasses import dataclass
+from typing import Any, Callable, Optional
+
+import modal._runtime.container_io_manager
+import modal.cls
+import modal.object
+from modal import Function
+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
+    from modal._runtime.asgi import LifespanManager
+
+
+@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",
+):
+    # Note: aiohttp is a significant dependency of the `asgi` module, so we import it locally
+    from modal._runtime import asgi
+
+    # 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.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 asgi.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.asgi_app_wrapper(
+            asgi.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 = asgi.get_ip_address(b"eth0")
+        port = webhook_config.web_server_port
+        startup_timeout = webhook_config.web_server_startup_timeout
+        asgi.wait_for_web_server(host, port, timeout=startup_timeout)
+        return asgi.asgi_app_wrapper(asgi.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: 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._cached_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
+                )  # bound to the class service function - there is no instance
+                active_app = _cls._app
+            else:
+                # This is non-decorated 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,
+    )