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

modal/__init__.py

@@ -1,26 +1,29 @@
 # Copyright Modal Labs 2022
 import sys
 
-if sys.version_info[:2] < (3, 8):
-    raise RuntimeError("This version of Modal requires at least Python 3.8")
-if sys.version_info[:2] >= (3, 13):
-    raise RuntimeError("This version of Modal does not support Python 3.13+")
+if sys.version_info[:2] < (3, 9):
+    raise RuntimeError("This version of Modal requires at least Python 3.9")
+if sys.version_info[:2] >= (3, 14):
+    raise RuntimeError("This version of Modal does not support Python 3.14+")
 
 from modal_version import __version__
 
 try:
+    from ._runtime.execution_context import current_function_call_id, current_input_id, interact, is_local
     from ._tunnel import Tunnel, forward
-    from .app import container_app, interact, is_local
+    from .app import App, Stub
     from .client import Client
     from .cloud_bucket_mount import CloudBucketMount
-    from .cls import Cls
+    from .cls import Cls, parameter
     from .dict import Dict
     from .exception import Error
-    from .functions import Function, current_function_call_id, current_input_id
+    from .file_pattern_matcher import FilePatternMatcher
+    from .functions import Function
     from .image import Image
     from .mount import Mount
     from .network_file_system import NetworkFileSystem
-    from .partial_function import asgi_app, build, enter, exit, method, web_endpoint, web_server, wsgi_app
+    from .output import enable_output
+    from .partial_function import asgi_app, batched, build, enter, exit, method, web_endpoint, web_server, wsgi_app
     from .proxy import Proxy
     from .queue import Queue
     from .retries import Retries
@@ -28,8 +31,6 @@ try:
     from .schedule import Cron, Period
     from .scheduler_placement import SchedulerPlacement
     from .secret import Secret
-    from .shared_volume import SharedVolume
-    from .stub import Stub
     from .volume import Volume
 except Exception:
     print()
@@ -42,11 +43,13 @@ except Exception:
 
 __all__ = [
     "__version__",
+    "App",
     "Client",
     "Cls",
     "Cron",
     "Dict",
     "Error",
+    "FilePatternMatcher",
     "Function",
     "Image",
     "Mount",
@@ -59,22 +62,23 @@ __all__ = [
     "Sandbox",
     "SchedulerPlacement",
     "Secret",
-    "SharedVolume",
     "Stub",
     "Tunnel",
     "Volume",
     "asgi_app",
+    "batched",
     "build",
-    "container_app",
     "current_function_call_id",
     "current_input_id",
+    "enable_output",
     "enter",
     "exit",
     "forward",
     "is_local",
+    "interact",
     "method",
+    "parameter",
     "web_endpoint",
     "web_server",
     "wsgi_app",
-    "interact",
 ]

modal/__main__.py

@@ -1,7 +1,8 @@
 # Copyright Modal Labs 2022
 import sys
 
-from ._traceback import highlight_modal_deprecation_warnings, reduce_traceback_to_user_code, setup_rich_traceback
+from ._traceback import reduce_traceback_to_user_code
+from .cli._traceback import highlight_modal_deprecation_warnings, setup_rich_traceback
 from .cli.entry_point import entrypoint_cli
 from .cli.import_refs import _CliUserExecutionError
 from .config import config
@@ -19,19 +20,56 @@ def main():
         if config.get("traceback"):
             raise
 
+        assert exc.__cause__  # We should always raise this class from another error
         tb = reduce_traceback_to_user_code(exc.__cause__.__traceback__, exc.user_source)
         sys.excepthook(type(exc.__cause__), exc.__cause__, tb)
         sys.exit(1)
 
     except Exception as exc:
-        if config.get("traceback"):
+        if (
+            # User has asked to alway see full tracebacks
+            config.get("traceback")
+            # The exception message is empty, so we need to provide _some_ actionable information
+            or not str(exc)
+        ):
             raise
 
+        from grpclib import GRPCError, Status
         from rich.console import Console
         from rich.panel import Panel
+        from rich.text import Text
+
+        if isinstance(exc, GRPCError):
+            status_map = {
+                Status.ABORTED: "Aborted",
+                Status.ALREADY_EXISTS: "Already exists",
+                Status.CANCELLED: "Cancelled",
+                Status.DATA_LOSS: "Data loss",
+                Status.DEADLINE_EXCEEDED: "Deadline exceeded",
+                Status.FAILED_PRECONDITION: "Failed precondition",
+                Status.INTERNAL: "Internal",
+                Status.INVALID_ARGUMENT: "Invalid",
+                Status.NOT_FOUND: "Not found",
+                Status.OUT_OF_RANGE: "Out of range",
+                Status.PERMISSION_DENIED: "Permission denied",
+                Status.RESOURCE_EXHAUSTED: "Resource exhausted",
+                Status.UNAUTHENTICATED: "Unauthenticaed",
+                Status.UNAVAILABLE: "Unavailable",
+                Status.UNIMPLEMENTED: "Unimplemented",
+                Status.UNKNOWN: "Unknown",
+            }
+            title = f"Error: {status_map.get(exc.status, 'Unknown')}"
+            content = str(exc.message)
+            if exc.details:
+                content += f"\n\nDetails: {exc.details}"
+        else:
+            title = "Error"
+            content = str(exc)
+            if notes := getattr(exc, "__notes__", []):
+                content = f"{content}\n\nNote: {' ' .join(notes)}"
 
         console = Console(stderr=True)
-        panel = Panel(str(exc), border_style="red", title="Error", title_align="left")
+        panel = Panel(Text(content), title=title, title_align="left", border_style="red")
         console.print(panel, highlight=False)
         sys.exit(1)
 

modal/_clustered_functions.py

@@ -0,0 +1,80 @@
+# Copyright Modal Labs 2024
+import os
+import socket
+from dataclasses import dataclass
+from typing import Optional
+
+from modal._utils.async_utils import synchronize_api
+from modal._utils.grpc_utils import retry_transient_errors
+from modal.client import _Client
+from modal.exception import InvalidError
+from modal_proto import api_pb2
+
+
+@dataclass
+class ClusterInfo:
+    rank: int
+    container_ips: list[str]
+
+
+cluster_info: Optional[ClusterInfo] = None
+
+
+def get_cluster_info() -> ClusterInfo:
+    if cluster_info is None:
+        raise InvalidError(
+            "Cluster info not initialized. Please ensure that you are "
+            "calling get_cluster_info() from a clustered function."
+        )
+    return cluster_info
+
+
+async def _initialize_clustered_function(client: _Client, task_id: str, world_size: int):
+    global cluster_info
+
+    def get_i6pn():
+        """Returns the ipv6 address assigned to this container."""
+        return socket.getaddrinfo("i6pn.modal.local", None, socket.AF_INET6)[0][4][0]
+
+    hostname = socket.gethostname()
+    container_ip = get_i6pn()
+
+    # nccl's default host ID is $(hostname)$(cat /proc/sys/kernel/random/boot_id).
+    # on runc, if two i6pn-linked containers get scheduled on the same worker,
+    # their boot ID and hostname will both be identical, causing nccl to break.
+    # As a workaround, we can explicitly specify a unique host ID here.
+    # See MOD-4067.
+    os.environ["NCCL_HOSTID"] = f"{hostname}{container_ip}"
+
+    # We found these settings to work well in most cases. You may be able to achieve
+    # better performance by tuning these settings.
+    if os.environ["MODAL_CLOUD_PROVIDER"] in ("CLOUD_PROVIDER_GCP", "CLOUD_PROVIDER_OCI"):
+        os.environ["NCCL_SOCKET_NTHREADS"] = "4"
+        os.environ["NCCL_NSOCKS_PERTHREAD"] = "1"
+    elif os.environ["MODAL_CLOUD_PROVIDER"] == "CLOUD_PROVIDER_AWS":
+        os.environ["NCCL_SOCKET_NTHREADS"] = "2"
+        os.environ["NCCL_NSOCKS_PERTHREAD"] = "8"
+    else:
+        os.environ["NCCL_SOCKET_NTHREADS"] = "1"
+        os.environ["NCCL_NSOCKS_PERTHREAD"] = "1"
+
+    if world_size > 1:
+        resp: api_pb2.TaskClusterHelloResponse = await retry_transient_errors(
+            client.stub.TaskClusterHello,
+            api_pb2.TaskClusterHelloRequest(
+                task_id=task_id,
+                container_ip=container_ip,
+            ),
+        )
+        cluster_info = ClusterInfo(
+            rank=resp.cluster_rank,
+            container_ips=resp.container_ips,
+        )
+    else:
+        cluster_info = ClusterInfo(
+            rank=0,
+            container_ips=[container_ip],
+        )
+
+
+initialize_clustered_function = synchronize_api(_initialize_clustered_function)

modal/_clustered_functions.pyi

@@ -0,0 +1,22 @@
+import modal.client
+import typing
+import typing_extensions
+
+class ClusterInfo:
+    rank: int
+    container_ips: list[str]
+
+    def __init__(self, rank: int, container_ips: list[str]) -> None: ...
+    def __repr__(self): ...
+    def __eq__(self, other): ...
+
+def get_cluster_info() -> ClusterInfo: ...
+async def _initialize_clustered_function(client: modal.client._Client, task_id: str, world_size: int): ...
+
+class __initialize_clustered_function_spec(typing_extensions.Protocol):
+    def __call__(self, client: modal.client.Client, task_id: str, world_size: int): ...
+    async def aio(self, client: modal.client.Client, task_id: str, world_size: int): ...
+
+initialize_clustered_function: __initialize_clustered_function_spec
+
+cluster_info: typing.Optional[ClusterInfo]