modal 0.67.42__py3-none-any.whl → 0.68.4__py3-none-any.whl

modal/_container_entrypoint.py

@@ -415,6 +415,9 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
 
     _client: _Client = synchronizer._translate_in(client)  # TODO(erikbern): ugly
 
+    # Call ContainerHello - currently a noop but might be used later for things
+    container_io_manager.hello()
+
     with container_io_manager.heartbeats(is_snapshotting_function), UserCodeEventLoop() as event_loop:
         # If this is a serialized function, fetch the definition from the server
         if function_def.definition_type == api_pb2.Function.DEFINITION_TYPE_SERIALIZED:

modal/_runtime/container_io_manager.py

@@ -335,6 +335,9 @@ class _ContainerIOManager:
         """Only used for tests."""
         cls._singleton = None
 
+    async def hello(self):
+        await self._client.stub.ContainerHello(Empty())
+
     async def _run_heartbeat_loop(self):
         while 1:
             t0 = time.monotonic()

modal/_traceback.py

@@ -1,16 +1,21 @@
 # Copyright Modal Labs 2022
-"""Helper functions related to operating on traceback objects.
+"""Helper functions related to operating on exceptions, warnings, and traceback objects.
 
 Functions related to *displaying* tracebacks should go in `modal/cli/_traceback.py`
 so that Rich is not a dependency of the container Client.
 """
+
 import re
 import sys
 import traceback
+import warnings
 from types import TracebackType
-from typing import Any, Optional
+from typing import Any, Iterable, Optional
+
+from modal_proto import api_pb2
 
 from ._vendor.tblib import Traceback as TBLibTraceback
+from .exception import ServerWarning
 
 TBDictType = dict[str, Any]
 LineCacheType = dict[tuple[str, str], str]
@@ -109,3 +114,12 @@ def print_exception(exc: Optional[type[BaseException]], value: Optional[BaseExce
     if sys.version_info < (3, 11) and value is not None:
         notes = getattr(value, "__notes__", [])
         print(*notes, sep="\n", file=sys.stderr)
+
+
+def print_server_warnings(server_warnings: Iterable[api_pb2.Warning]):
+    """Issue a warning originating from the server with empty metadata about local origin.
+
+    When using the Modal CLI, these warnings should get caught and coerced into Rich panels.
+    """
+    for warning in server_warnings:
+        warnings.warn_explicit(warning.message, ServerWarning, "<modal-server>", 0)

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/container.py

@@ -1,5 +1,4 @@
 # Copyright Modal Labs 2022
-
 from typing import Optional, Union
 
 import typer
@@ -8,12 +7,13 @@ from rich.text import Text
 from modal._pty import get_pty_info
 from modal._utils.async_utils import synchronizer
 from modal._utils.grpc_utils import retry_transient_errors
-from modal.cli.utils import ENV_OPTION, display_table, stream_app_logs, timestamp_to_local
+from modal.cli.utils import ENV_OPTION, display_table, is_tty, stream_app_logs, timestamp_to_local
 from modal.client import _Client
 from modal.config import config
 from modal.container_process import _ContainerProcess
 from modal.environments import ensure_env
 from modal.object import _get_environment_name
+from modal.stream_type import StreamType
 from modal_proto import api_pb2
 
 container_cli = typer.Typer(name="container", help="Manage and connect to running containers.", no_args_is_help=True)
@@ -55,12 +55,19 @@ def logs(container_id: str = typer.Argument(help="Container ID")):
 @container_cli.command("exec")
 @synchronizer.create_blocking
 async def exec(
+    pty: Optional[bool] = typer.Option(default=None, help="Run the command using a PTY."),
     container_id: str = typer.Argument(help="Container ID"),
-    command: list[str] = typer.Argument(help="A command to run inside the container."),
-    pty: bool = typer.Option(default=True, help="Run the command using a PTY."),
+    command: list[str] = typer.Argument(
+        help="A command to run inside the container.\n\n"
+        "To pass command-line flags or options, add `--` before the start of your commands. "
+        "For example: `modal container exec <id> -- /bin/bash -c 'echo hi'`"
+    ),
 ):
     """Execute a command in a container."""
 
+    if pty is None:
+        pty = is_tty()
+
     client = await _Client.from_env()
 
     req = api_pb2.ContainerExecRequest(
@@ -71,7 +78,11 @@ async def exec(
     )
     res: api_pb2.ContainerExecResponse = await client.stub.ContainerExec(req)
 
-    await _ContainerProcess(res.exec_id, client).attach(pty=pty)
+    if pty:
+        await _ContainerProcess(res.exec_id, client).attach()
+    else:
+        # TODO: redirect stderr to its own stream?
+        await _ContainerProcess(res.exec_id, client, stdout=StreamType.STDOUT, stderr=StreamType.STDOUT).wait()
 
 
 @container_cli.command("stop")

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
@@ -29,7 +27,7 @@ from ..runner import deploy_app, interactive_shell, run_app
 from ..serving import serve_app
 from ..volume import Volume
 from .import_refs import import_app, import_function
-from .utils import ENV_OPTION, ENV_OPTION_HELP, stream_app_logs
+from .utils import ENV_OPTION, ENV_OPTION_HELP, is_tty, stream_app_logs
 
 
 class ParameterMetadata(TypedDict):
@@ -306,14 +304,7 @@ def deploy(
     if name is None:
         name = app.name
 
-    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)
-
+    res = deploy_app(app, name=name, environment_name=env or "", tag=tag)
     if stream_logs:
         stream_app_logs(app_id=res.app_id, app_logs_url=res.app_logs_url)
 
@@ -392,40 +383,47 @@ def shell(
             "Can be a single region or a comma-separated list to choose from (if not using REF)."
         ),
     ),
+    pty: Optional[bool] = typer.Option(default=None, help="Run the command using a PTY."),
 ):
-    """Run an interactive shell inside a Modal container.
+    """Run a command or interactive shell inside a Modal container.
 
-    **Examples:**
+    \b**Examples:**
 
-    Start a shell inside the default Debian-based image:
+    \bStart an interactive shell inside the default Debian-based image:
 
-    ```
+    \b```
     modal shell
     ```
 
-    Start a bash shell using the spec for `my_function` in your App:
+    \bStart an interactive shell with the spec for `my_function` in your App
+    (uses the same image, volumes, mounts, etc.):
 
-    ```
+    \b```
     modal shell hello_world.py::my_function
     ```
 
-    Or, if you're using a [modal.Cls](/docs/reference/modal.Cls), you can refer to a `@modal.method` directly:
+    \bOr, if you're using a [modal.Cls](/docs/reference/modal.Cls), you can refer to a `@modal.method` directly:
 
-    ```
+    \b```
     modal shell hello_world.py::MyClass.my_method
     ```
 
     Start a `python` shell:
 
-    ```
+    \b```
     modal shell hello_world.py --cmd=python
     ```
+
+    \bRun a command with your function's spec and pipe the output to a file:
+
+    \b```
+    modal shell hello_world.py -c 'uv pip list' > env.txt
+    ```
     """
     env = ensure_env(env)
 
-    console = Console()
-    if not console.is_terminal:
-        raise click.UsageError("`modal shell` can only be run from a terminal.")
+    if pty is None:
+        pty = is_tty()
 
     if platform.system() == "Windows":
         raise InvalidError("`modal shell` is currently not supported on Windows")
@@ -441,7 +439,7 @@ def shell(
         ):
             from .container import exec
 
-            exec(container_id=container_or_function, command=shlex.split(cmd), pty=True)
+            exec(container_id=container_or_function, command=shlex.split(cmd))
             return
 
         function = import_function(
@@ -461,6 +459,7 @@ def shell(
             memory=function_spec.memory,
             volumes=function_spec.volumes,
             region=function_spec.scheduler_placement.proto.regions if function_spec.scheduler_placement else None,
+            pty=pty,
         )
     else:
         modal_image = Image.from_registry(image, add_python=add_python) if image else None
@@ -474,6 +473,7 @@ def shell(
             cloud=cloud,
             volumes=volumes,
             region=region.split(",") if region else [],
+            pty=pty,
         )
 
     # NB: invoking under bash makes --cmd a lot more flexible.

modal/cli/utils.py

@@ -77,6 +77,10 @@ def _plain(text: Union[Text, str]) -> str:
     return text.plain if isinstance(text, Text) else text
 
 
+def is_tty() -> bool:
+    return Console().is_terminal
+
+
 def display_table(
     columns: Sequence[Union[Column, str]],
     rows: Sequence[Sequence[Union[Text, str]]],

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:
+            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.42"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.4"
     ): ...
     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.42"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.68.4"
     ): ...
     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

modal/cls.py

@@ -14,15 +14,13 @@ from modal_proto import api_pb2
 from ._resolver import Resolver
 from ._resources import convert_fn_config_to_resources_config
 from ._serialization import check_valid_cls_constructor_arg
+from ._traceback import print_server_warnings
 from ._utils.async_utils import synchronize_api, synchronizer
 from ._utils.grpc_utils import retry_transient_errors
 from ._utils.mount_utils import validate_volumes
 from .client import _Client
 from .exception import InvalidError, NotFoundError, VersionError
-from .functions import (
-    _Function,
-    _parse_retries,
-)
+from .functions import _Function, _parse_retries
 from .gpu import GPU_T
 from .object import _get_environment_name, _Object
 from .partial_function import (
@@ -486,6 +484,8 @@ class _Cls(_Object, type_prefix="cs"):
                 else:
                     raise
 
+            print_server_warnings(response.server_warnings)
+
             class_function_tag = f"{tag}.*"  # special name of the base service function for the class
 
             class_service_function = _Function.from_name(

modal/container_process.py

@@ -9,7 +9,7 @@ from ._utils.async_utils import TaskContext, synchronize_api
 from ._utils.grpc_utils import retry_transient_errors
 from ._utils.shell_utils import stream_from_stdin, write_to_fd
 from .client import _Client
-from .exception import InteractiveTimeoutError, InvalidError
+from .exception import InteractiveTimeoutError, InvalidError, deprecation_error
 from .io_streams import _StreamReader, _StreamWriter
 from .stream_type import StreamType
 
@@ -114,11 +114,18 @@ class _ContainerProcess(Generic[T]):
                 self._returncode = resp.exit_code
                 return self._returncode
 
-    async def attach(self, *, pty: bool):
+    async def attach(self, *, pty: Optional[bool] = None):
         if platform.system() == "Windows":
             print("interactive exec is not currently supported on Windows.")
             return
 
+        if pty is not None:
+            deprecation_error(
+                (2024, 12, 9),
+                "The `pty` argument to `modal.container_process.attach(pty=...)` is deprecated, "
+                "as only PTY mode is supported. Please remove the argument.",
+            )
+
         from rich.console import Console
 
         console = Console()
@@ -151,7 +158,7 @@ class _ContainerProcess(Generic[T]):
                 # time out if we can't connect to the server fast enough
                 await asyncio.wait_for(on_connect.wait(), timeout=60)
 
-                async with stream_from_stdin(_handle_input, use_raw_terminal=pty):
+                async with stream_from_stdin(_handle_input, use_raw_terminal=True):
                     await stdout_task
                     await stderr_task
 

modal/container_process.pyi

@@ -34,7 +34,7 @@ class _ContainerProcess(typing.Generic[T]):
     def returncode(self) -> int: ...
     async def poll(self) -> typing.Optional[int]: ...
     async def wait(self) -> int: ...
-    async def attach(self, *, pty: bool): ...
+    async def attach(self, *, pty: typing.Optional[bool] = None): ...
 
 class ContainerProcess(typing.Generic[T]):
     _process_id: typing.Optional[str]
@@ -76,7 +76,7 @@ class ContainerProcess(typing.Generic[T]):
     wait: __wait_spec
 
     class __attach_spec(typing_extensions.Protocol):
-        def __call__(self, *, pty: bool): ...
-        async def aio(self, *, pty: bool): ...
+        def __call__(self, *, pty: typing.Optional[bool] = None): ...
+        async def aio(self, *, pty: typing.Optional[bool] = None): ...
 
     attach: __attach_spec

modal/exception.py

@@ -4,6 +4,9 @@ import signal
 import sys
 import warnings
 from datetime import date
+from typing import Iterable
+
+from modal_proto import api_pb2
 
 
 class Error(Exception):
@@ -107,6 +110,10 @@ 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 _CliUserExecutionError(Exception):
     """mdmd:hidden
     Private wrapper for exceptions during when importing or running stubs from the CLI.
@@ -213,3 +220,16 @@ class ModuleNotMountable(Exception):
 
 class ClientClosed(Error):
     pass
+
+
+class FilesystemExecutionError(Error):
+    """Raised when an unknown error is thrown during a container filesystem operation."""
+
+
+def print_server_warnings(server_warnings: Iterable[api_pb2.Warning]):
+    # TODO(erikbern): move this to modal._utils.deprecation
+    for warning in server_warnings:
+        if warning.type == api_pb2.Warning.WARNING_TYPE_CLIENT_DEPRECATION:
+            warnings.warn_explicit(warning.message, DeprecationError, "<unknown>", 0)
+        else:
+            warnings.warn_explicit(warning.message, UserWarning, "<unknown>", 0)