modal 0.62.16__py3-none-any.whl → 0.72.11__py3-none-any.whl

modal/exception.py

@@ -1,10 +1,6 @@
 # Copyright Modal Labs 2022
 import random
 import signal
-import sys
-import warnings
-from datetime import date
-from typing import Tuple
 
 
 class Error(Exception):
@@ -58,6 +54,10 @@ class InteractiveTimeoutError(TimeoutError):
     """Raised when interactive frontends time out while trying to connect to a container."""
 
 
+class OutputExpiredError(TimeoutError):
+    """Raised when the Output exceeds expiration and times out."""
+
+
 class AuthError(Error):
     """Raised when a client has missing or invalid authentication."""
 
@@ -82,6 +82,18 @@ class ExecutionError(Error):
     """Raised when something unexpected happened during runtime."""
 
 
+class DeserializationError(Error):
+    """Raised to provide more context when an error is encountered during deserialization."""
+
+
+class SerializationError(Error):
+    """Raised to provide more context when an error is encountered during serialization."""
+
+
+class RequestSizeError(Error):
+    """Raised when an operation produces a gRPC request that is rejected by the server for being too large."""
+
+
 class DeprecationError(UserWarning):
     """UserWarning category emitted when a deprecated Modal feature or API is used."""
 
@@ -92,6 +104,16 @@ class PendingDeprecationError(UserWarning):
     """Soon to be deprecated feature. Only used intermittently because of multi-repo concerns."""
 
 
+class ServerWarning(UserWarning):
+    """Warning originating from the Modal server and re-issued in client code."""
+
+
+class InternalFailure(Error):
+    """
+    Retriable internal error.
+    """
+
+
 class _CliUserExecutionError(Exception):
     """mdmd:hidden
     Private wrapper for exceptions during when importing or running stubs from the CLI.
@@ -107,45 +129,6 @@ class _CliUserExecutionError(Exception):
         self.user_source = user_source
 
 
-# TODO(erikbern): we have something similready in function_utils.py
-_INTERNAL_MODULES = ["modal", "synchronicity"]
-
-
-def _is_internal_frame(frame):
-    module = frame.f_globals["__name__"].split(".")[0]
-    return module in _INTERNAL_MODULES
-
-
-def deprecation_error(deprecated_on: Tuple[int, int, int], msg: str):
-    raise DeprecationError(f"Deprecated on {date(*deprecated_on)}: {msg}")
-
-
-def deprecation_warning(
-    deprecated_on: Tuple[int, int, int], msg: str, pending: bool = False, show_source: bool = True
-) -> None:
-    """Utility for getting the proper stack entry.
-
-    See the implementation of the built-in [warnings.warn](https://docs.python.org/3/library/warnings.html#available-functions).
-    """
-    filename, lineno = "<unknown>", 0
-    if show_source:
-        # Find the last non-Modal line that triggered the warning
-        try:
-            frame = sys._getframe()
-            while frame is not None and _is_internal_frame(frame):
-                frame = frame.f_back
-            filename = frame.f_code.co_filename
-            lineno = frame.f_lineno
-        except ValueError:
-            # Use the defaults from above
-            pass
-
-    warning_cls: type = PendingDeprecationError if pending else DeprecationError
-
-    # This is a lower-level function that warnings.warn uses
-    warnings.warn_explicit(f"{date(*deprecated_on)}: {msg}", warning_cls, filename, lineno)
-
-
 def _simulate_preemption_interrupt(signum, frame):
     signal.alarm(30)  # simulate a SIGKILL after 30s
     raise KeyboardInterrupt("Simulated preemption interrupt from modal-client!")
@@ -194,3 +177,11 @@ class InputCancellation(BaseException):
 
 class ModuleNotMountable(Exception):
     pass
+
+
+class ClientClosed(Error):
+    pass
+
+
+class FilesystemExecutionError(Error):
+    """Raised when an unknown error is thrown during a container filesystem operation."""

modal/experimental.py

@@ -1,10 +1,69 @@
 # Copyright Modal Labs 2022
+from typing import (
+    Any,
+    Callable,
+)
+
+import modal._clustered_functions
+from modal.functions import _Function
+
+from ._runtime.container_io_manager import _ContainerIOManager
+from .exception import (
+    InvalidError,
+)
+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()
+
+
+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()
+
+
+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)
+
+
+def clustered(size: int, broadcast: bool = True):
+    """Provision clusters of colocated and networked containers for the Function.
+
+    Parameters:
+    size: int
+        Number of containers spun up to handle each input.
+    broadcast: bool = True
+        If True, inputs will be sent simultaneously to each container. Otherwise,
+        inputs will be sent only to the rank-0 container, which is responsible for
+        delegating to the workers.
+    """
+
+    assert broadcast, "broadcast=False has not been implemented yet!"
+
+    if size <= 0:
+        raise ValueError("cluster size must be greater than 0")
+
+    def wrapper(raw_f: Callable[..., Any]) -> _PartialFunction:
+        if isinstance(raw_f, _Function):
+            raw_f = raw_f.get_raw_f()
+            raise InvalidError(
+                f"Applying decorators for {raw_f} in the wrong order!\nUsage:\n\n"
+                "@app.function()\n@modal.clustered()\ndef clustered_function():\n    ..."
+            )
+        return _PartialFunction(
+            raw_f, _PartialFunctionFlags.FUNCTION | _PartialFunctionFlags.CLUSTERED, cluster_size=size
+        )
+
+    return wrapper
 
-    from .app import _container_app
 
-    _container_app.stop_fetching_inputs()
+def get_cluster_info() -> modal._clustered_functions.ClusterInfo:
+    return modal._clustered_functions.get_cluster_info()

modal/extensions/ipython.py

@@ -4,7 +4,7 @@ import logging
 import sys
 from typing import Any
 
-from modal import Stub
+from modal import App
 from modal._utils.async_utils import run_coro_blocking
 from modal.config import config, logger
 
@@ -18,11 +18,11 @@ def load_ipython_extension(ipython):
     logger.addHandler(logging.StreamHandler(stream=sys.stdout))
     logger.setLevel(config["loglevel"])
 
-    # Create a app and provide it in the IPython app
-    stub = Stub()
-    ipython.push({"stub": stub})
+    # Create an app and provide it in the IPython app
+    app = App()
+    ipython.push({"app": app})
 
-    app_ctx = stub.run()
+    app_ctx = app.run()
 
     # Notebooks have an event loop present, but we want this function
     # to be blocking. This is fairly hacky.