modal 0.67.43__py3-none-any.whl → 0.68.24__py3-none-any.whl

modal/_utils/http_utils.py

@@ -1,18 +1,18 @@
 # Copyright Modal Labs 2022
 import contextlib
-import socket
-import ssl
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
-import certifi
-from aiohttp import ClientSession, ClientTimeout, TCPConnector
-from aiohttp.web import Application
-from aiohttp.web_runner import AppRunner, SockSite
+# Note: importing aiohttp seems to take about 100ms, and it's not really necessarily,
+# unless we need to work with blobs. So that's why we import it lazily instead.
+
+if TYPE_CHECKING:
+    from aiohttp import ClientSession
+    from aiohttp.web import Application
 
 from .async_utils import on_shutdown
 
 
-def _http_client_with_tls(timeout: Optional[float]) -> ClientSession:
+def _http_client_with_tls(timeout: Optional[float]) -> "ClientSession":
     """Create a new HTTP client session with standard, bundled TLS certificates.
 
     This is necessary to prevent client issues on some system where Python does
@@ -22,13 +22,18 @@ def _http_client_with_tls(timeout: Optional[float]) -> ClientSession:
     Specifically: the error "unable to get local issuer certificate" when making
     an aiohttp request.
     """
+    import ssl
+
+    import certifi
+    from aiohttp import ClientSession, ClientTimeout, TCPConnector
+
     ssl_context = ssl.create_default_context(cafile=certifi.where())
     connector = TCPConnector(ssl=ssl_context)
     return ClientSession(connector=connector, timeout=ClientTimeout(total=timeout))
 
 
 class ClientSessionRegistry:
-    _client_session: ClientSession
+    _client_session: "ClientSession"
     _client_session_active: bool = False
 
     @staticmethod
@@ -47,9 +52,13 @@ class ClientSessionRegistry:
 
 
 @contextlib.asynccontextmanager
-async def run_temporary_http_server(app: Application):
+async def run_temporary_http_server(app: "Application"):
     # Allocates a random port, runs a server in a context manager
     # This is used in various tests
+    import socket
+
+    from aiohttp.web_runner import AppRunner, SockSite
+
     sock = socket.socket()
     sock.bind(("", 0))
     port = sock.getsockname()[1]

modal/_utils/{pattern_matcher.py → pattern_utils.py}

@@ -5,7 +5,7 @@ This is the same pattern-matching logic used by Docker, except it is written in
 Python rather than Go. Also, the original Go library has a couple deprecated
 functions that we don't implement in this port.
 
-The main way to use this library is by constructing a `PatternMatcher` object,
+The main way to use this library is by constructing a `FilePatternMatcher` object,
 then asking it whether file paths match any of its patterns.
 """
 
@@ -148,75 +148,6 @@ class Pattern:
             return False
 
 
-class PatternMatcher:
-    """Allows checking paths against a list of patterns."""
-
-    def __init__(self, patterns: list[str]) -> None:
-        """Initialize a new PatternMatcher instance.
-
-        Args:
-            patterns (list): A list of pattern strings.
-
-        Raises:
-            ValueError: If an illegal exclusion pattern is provided.
-        """
-        self.patterns: list[Pattern] = []
-        self.exclusions = False
-        for pattern in patterns:
-            pattern = pattern.strip()
-            if not pattern:
-                continue
-            pattern = os.path.normpath(pattern)
-            new_pattern = Pattern()
-            if pattern[0] == "!":
-                if len(pattern) == 1:
-                    raise ValueError('Illegal exclusion pattern: "!"')
-                new_pattern.exclusion = True
-                pattern = pattern[1:]
-                self.exclusions = True
-            # In Python, we can proceed without explicit syntax checking
-            new_pattern.cleaned_pattern = pattern
-            new_pattern.dirs = pattern.split(os.path.sep)
-            self.patterns.append(new_pattern)
-
-    def matches(self, file_path: str) -> bool:
-        """Check if the file path or any of its parent directories match the patterns.
-
-        This is equivalent to `MatchesOrParentMatches()` in the original Go
-        library. The reason is that `Matches()` in the original library is
-        deprecated due to buggy behavior.
-        """
-        matched = False
-        file_path = os.path.normpath(file_path)
-        if file_path == ".":
-            # Don't let them exclude everything; kind of silly.
-            return False
-        parent_path = os.path.dirname(file_path)
-        if parent_path == "":
-            parent_path = "."
-        parent_path_dirs = parent_path.split(os.path.sep)
-
-        for pattern in self.patterns:
-            # Skip evaluation based on current match status and pattern exclusion
-            if pattern.exclusion != matched:
-                continue
-
-            match = pattern.match(file_path)
-
-            if not match and parent_path != ".":
-                # Check if the pattern matches any of the parent directories
-                for i in range(len(parent_path_dirs)):
-                    dir_path = os.path.sep.join(parent_path_dirs[: i + 1])
-                    if pattern.match(dir_path):
-                        match = True
-                        break
-
-            if match:
-                matched = not pattern.exclusion
-
-        return matched
-
-
 def read_ignorefile(reader: TextIO) -> list[str]:
     """Read an ignore file from a reader and return the list of file patterns to
     ignore, applying the following rules:

modal/_utils/shell_utils.py

@@ -19,14 +19,20 @@ def write_to_fd(fd: int, data: bytes):
     future = loop.create_future()
 
     def try_write():
+        nonlocal data
         try:
             nbytes = os.write(fd, data)
-            loop.remove_writer(fd)
-            future.set_result(nbytes)
+            data = data[nbytes:]
+            if not data:
+                loop.remove_writer(fd)
+                future.set_result(None)
         except OSError as e:
-            if e.errno != errno.EAGAIN:
-                future.set_exception(e)
-                raise
+            if e.errno == errno.EAGAIN:
+                # Wait for the next write notification
+                return
+            # Fail if it's not EAGAIN
+            loop.remove_writer(fd)
+            future.set_exception(e)
 
     loop.add_writer(fd, try_write)
     return future

modal/cli/_traceback.py

@@ -1,5 +1,6 @@
 # Copyright Modal Labs 2024
 """Helper functions related to displaying tracebacks in the CLI."""
+
 import functools
 import re
 import warnings
@@ -11,7 +12,7 @@ from rich.syntax import Syntax
 from rich.text import Text
 from rich.traceback import PathHighlighter, Stack, Traceback, install
 
-from ..exception import DeprecationError, PendingDeprecationError
+from ..exception import DeprecationError, PendingDeprecationError, ServerWarning
 
 
 @group()
@@ -165,7 +166,7 @@ def highlight_modal_deprecation_warnings() -> None:
     base_showwarning = warnings.showwarning
 
     def showwarning(warning, category, filename, lineno, file=None, line=None):
-        if issubclass(category, (DeprecationError, PendingDeprecationError)):
+        if issubclass(category, (DeprecationError, PendingDeprecationError, ServerWarning)):
             content = str(warning)
             if re.match(r"^\d{4}-\d{2}-\d{2}", content):
                 date = content[:10]
@@ -180,10 +181,16 @@ def highlight_modal_deprecation_warnings() -> None:
             except OSError:
                 # e.g., when filename is "<unknown>"; raises FileNotFoundError on posix but OSError on windows
                 pass
+            if issubclass(category, ServerWarning):
+                title = "Modal Warning"
+            else:
+                title = "Modal Deprecation Warning"
+            if date:
+                title += f" ({date})"
             panel = Panel(
                 message,
-                style="yellow",
-                title=f"Modal Deprecation Warning ({date})" if date else "Modal Deprecation Warning",
+                border_style="yellow",
+                title=title,
                 title_align="left",
             )
             Console().print(panel)

modal/cli/run.py

@@ -13,8 +13,6 @@ from typing import Any, Callable, Optional, get_type_hints
 
 import click
 import typer
-from rich.console import Console
-from rich.panel import Panel
 from typing_extensions import TypedDict
 
 from .. import Cls
@@ -135,6 +133,18 @@ def _get_clean_app_description(func_ref: str) -> str:
         return " ".join(sys.argv)
 
 
+def _write_local_result(result_path: str, res: Any):
+    if isinstance(res, str):
+        mode = "wt"
+    elif isinstance(res, bytes):
+        mode = "wb"
+    else:
+        res_type = type(res).__name__
+        raise InvalidError(f"Function must return str or bytes when using `--write-result`; got {res_type}.")
+    with open(result_path, mode) as fid:
+        fid.write(res)
+
+
 def _get_click_command_for_function(app: App, function_tag):
     function = app.registered_functions.get(function_tag)
     if not function or (isinstance(function, Function) and function.info.user_cls is not None):
@@ -179,7 +189,7 @@ def _get_click_command_for_function(app: App, function_tag):
                 interactive=ctx.obj["interactive"],
             ):
                 if cls is None:
-                    function.remote(**kwargs)
+                    res = function.remote(**kwargs)
                 else:
                     # unpool class and method arguments
                     # TODO(erikbern): this code is a bit hacky
@@ -188,7 +198,10 @@ def _get_click_command_for_function(app: App, function_tag):
 
                     instance = cls(**cls_kwargs)
                     method: Function = getattr(instance, method_name)
-                    method.remote(**fun_kwargs)
+                    res = method.remote(**fun_kwargs)
+
+            if result_path := ctx.obj["result_path"]:
+                _write_local_result(result_path, res)
 
     with_click_options = _add_click_options(f, signature)
     return click.command(with_click_options)
@@ -216,12 +229,15 @@ def _get_click_command_for_local_entrypoint(app: App, entrypoint: LocalEntrypoin
             ):
                 try:
                     if isasync:
-                        asyncio.run(func(*args, **kwargs))
+                        res = asyncio.run(func(*args, **kwargs))
                     else:
-                        func(*args, **kwargs)
+                        res = func(*args, **kwargs)
                 except Exception as exc:
                     raise _CliUserExecutionError(inspect.getsourcefile(func)) from exc
 
+            if result_path := ctx.obj["result_path"]:
+                _write_local_result(result_path, res)
+
     with_click_options = _add_click_options(f, _get_signature(func))
     return click.command(with_click_options)
 
@@ -250,12 +266,13 @@ class RunGroup(click.Group):
     cls=RunGroup,
     subcommand_metavar="FUNC_REF",
 )
+@click.option("-w", "--write-result", help="Write return value (which must be str or bytes) to this local path.")
 @click.option("-q", "--quiet", is_flag=True, help="Don't show Modal progress indicators.")
 @click.option("-d", "--detach", is_flag=True, help="Don't stop the app if the local process dies or disconnects.")
 @click.option("-i", "--interactive", is_flag=True, help="Run the app in interactive mode.")
 @click.option("-e", "--env", help=ENV_OPTION_HELP, default=None)
 @click.pass_context
-def run(ctx, detach, quiet, interactive, env):
+def run(ctx, write_result, detach, quiet, interactive, env):
     """Run a Modal function or local entrypoint.
 
     `FUNC_REF` should be of the format `{file or module}::{function name}`.
@@ -286,6 +303,7 @@ def run(ctx, detach, quiet, interactive, env):
     ```
     """
     ctx.ensure_object(dict)
+    ctx.obj["result_path"] = write_result
     ctx.obj["detach"] = detach  # if subcommand would be a click command...
     ctx.obj["show_progress"] = False if quiet else True
     ctx.obj["interactive"] = interactive
@@ -308,11 +326,6 @@ def deploy(
 
     with enable_output():
         res = deploy_app(app, name=name, environment_name=env or "", tag=tag)
-        if res.warnings:
-            console = Console()
-            for warning in res.warnings:
-                panel = Panel(warning, title="Warning", title_align="left", border_style="yellow")
-                console.print(panel, highlight=False)
 
     if stream_logs:
         stream_app_logs(app_id=res.app_id, app_logs_url=res.app_logs_url)

modal/client.py

@@ -16,23 +16,21 @@ from typing import (
 import grpclib.client
 from google.protobuf import empty_pb2
 from google.protobuf.message import Message
-from grpclib import GRPCError, Status
 from synchronicity.async_wrap import asynccontextmanager
 
 from modal._utils.async_utils import synchronizer
 from modal_proto import api_grpc, api_pb2, modal_api_grpc
 from modal_version import __version__
 
+from ._traceback import print_server_warnings
 from ._utils import async_utils
 from ._utils.async_utils import TaskContext, synchronize_api
 from ._utils.grpc_utils import connect_channel, create_channel, retry_transient_errors
 from .config import _check_config, _is_remote, config, logger
-from .exception import AuthError, ClientClosed, ConnectionError, DeprecationError, VersionError
+from .exception import AuthError, ClientClosed, ConnectionError
 
 HEARTBEAT_INTERVAL: float = config.get("heartbeat_interval")
 HEARTBEAT_TIMEOUT: float = HEARTBEAT_INTERVAL + 0.1
-CLIENT_CREATE_ATTEMPT_TIMEOUT: float = 4.0
-CLIENT_CREATE_TOTAL_TIMEOUT: float = 15.0
 
 
 def _get_metadata(client_type: int, credentials: Optional[tuple[str, str]], version: str) -> dict[str, str]:
@@ -137,32 +135,11 @@ class _Client:
     async def hello(self):
         """Connect to server and retrieve version information; raise appropriate error for various failures."""
         logger.debug(f"Client ({id(self)}): Starting")
-        try:
-            req = empty_pb2.Empty()
-            resp = await retry_transient_errors(
-                self.stub.ClientHello,
-                req,
-                attempt_timeout=CLIENT_CREATE_ATTEMPT_TIMEOUT,
-                total_timeout=CLIENT_CREATE_TOTAL_TIMEOUT,
-            )
-            if resp.warning:
-                ALARM_EMOJI = chr(0x1F6A8)
-                warnings.warn_explicit(f"{ALARM_EMOJI} {resp.warning} {ALARM_EMOJI}", DeprecationError, "<unknown>", 0)
-        except GRPCError as exc:
-            if exc.status == Status.FAILED_PRECONDITION:
-                raise VersionError(
-                    f"The client version ({self.version}) is too old. Please update (pip install --upgrade modal)."
-                )
-            else:
-                raise exc
+        resp = await retry_transient_errors(self.stub.ClientHello, empty_pb2.Empty())
+        print_server_warnings(resp.server_warnings)
 
     async def __aenter__(self):
         await self._open()
-        try:
-            await self.hello()
-        except BaseException:
-            await self._close()
-            raise
         return self
 
     async def __aexit__(self, exc_type, exc, tb):
@@ -178,7 +155,6 @@ class _Client:
         client = cls(server_url, api_pb2.CLIENT_TYPE_CLIENT, credentials=None)
         try:
             await client._open()
-            # Skip client.hello
             yield client
         finally:
             await client._close()
@@ -229,7 +205,6 @@ class _Client:
             client = _Client(server_url, client_type, credentials)
             await client._open()
             async_utils.on_shutdown(client._close())
-            await client.hello()
             cls._client_from_env = client
             return client
 
@@ -252,11 +227,6 @@ class _Client:
         credentials = (token_id, token_secret)
         client = _Client(server_url, client_type, credentials)
         await client._open()
-        try:
-            await client.hello()
-        except BaseException:
-            await client._close()
-            raise
         async_utils.on_shutdown(client._close())
         return client
 
@@ -265,8 +235,8 @@ class _Client:
         """mdmd:hidden
         Check whether can the client can connect to this server with these credentials; raise if not.
         """
-        async with cls(server_url, api_pb2.CLIENT_TYPE_CLIENT, credentials):
-            pass  # Will call ClientHello RPC and possibly raise AuthError or ConnectionError
+        async with cls(server_url, api_pb2.CLIENT_TYPE_CLIENT, credentials) as client:
+            await client.hello()  # Will call ClientHello RPC and possibly raise AuthError or ConnectionError
 
     @classmethod
     def set_env_client(cls, client: Optional["_Client"]):
@@ -316,7 +286,6 @@ class _Client:
             self.set_env_client(None)
             # TODO(elias): reset _cancellation_context in case ?
             await self._open()
-            # intentionally not doing self.hello since we should already be authenticated etc.
 
     async def _get_grpclib_method(self, method_name: str) -> Any:
         # safely get grcplib method that is bound to a valid channel

modal/client.pyi

@@ -26,7 +26,7 @@ class _Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.67.43"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.24"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -81,7 +81,7 @@ class Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.67.43"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.24"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -194,7 +194,3 @@ class UnaryStreamWrapper(typing.Generic[RequestType, ResponseType]):
 HEARTBEAT_INTERVAL: float
 
 HEARTBEAT_TIMEOUT: float
-
-CLIENT_CREATE_ATTEMPT_TIMEOUT: float
-
-CLIENT_CREATE_TOTAL_TIMEOUT: float