modal 1.0.6.dev58__py3-none-any.whl → 1.2.3.dev7__py3-none-any.whl

modal/cli/volume.py

@@ -7,18 +7,15 @@ from typing import Optional
 import typer
 from click import UsageError
 from grpclib import GRPCError, Status
-from rich.console import Console
 from rich.syntax import Syntax
 from typer import Argument, Option, Typer
 
 import modal
-from modal._output import OutputManager, ProgressHandler
+from modal._output import OutputManager, ProgressHandler, make_console
 from modal._utils.async_utils import synchronizer
-from modal._utils.grpc_utils import retry_transient_errors
-from modal._utils.time_utils import timestamp_to_local
+from modal._utils.time_utils import timestamp_to_localized_str
 from modal.cli._download import _volume_download
 from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table
-from modal.client import _Client
 from modal.environments import ensure_env
 from modal.volume import _AbstractVolumeUploadContextManager, _Volume
 from modal_proto import api_pb2
@@ -57,14 +54,14 @@ def create(
     version: Optional[int] = Option(default=None, help="VolumeFS version. (Experimental)"),
 ):
     env_name = ensure_env(env)
-    modal.Volume.create_deployed(name, environment_name=env, version=version)
+    modal.Volume.objects.create(name, environment_name=env, version=version)
     usage_code = f"""
 @app.function(volumes={{"/my_vol": modal.Volume.from_name("{name}")}})
 def some_func():
     os.listdir("/my_vol")
 """
 
-    console = Console()
+    console = make_console()
     console.print(f"Created Volume '{name}' in environment '{env_name}'. \n\nCode example:\n")
     usage = Syntax(usage_code, "python")
     console.print(usage)
@@ -96,10 +93,16 @@ async def get(
     ensure_env(env)
     destination = Path(local_destination)
     volume = _Volume.from_name(volume_name, environment_name=env)
-    console = Console()
+    console = make_console()
     progress_handler = ProgressHandler(type="download", console=console)
     with progress_handler.live:
-        await _volume_download(volume, remote_path, destination, force, progress_cb=progress_handler.progress)
+        await _volume_download(
+            volume=volume,
+            remote_path=remote_path,
+            local_destination=destination,
+            overwrite=force,
+            progress_cb=progress_handler.progress,
+        )
     console.print(OutputManager.step_completed("Finished downloading files to local!"))
 
 
@@ -111,14 +114,13 @@ async def get(
 @synchronizer.create_blocking
 async def list_(env: Optional[str] = ENV_OPTION, json: Optional[bool] = False):
     env = ensure_env(env)
-    client = await _Client.from_env()
-    response = await retry_transient_errors(client.stub.VolumeList, api_pb2.VolumeListRequest(environment_name=env))
-    env_part = f" in environment '{env}'" if env else ""
-    column_names = ["Name", "Created at"]
+    volumes = await _Volume.objects.list(environment_name=env)
     rows = []
-    for item in response.items:
-        rows.append([item.label, timestamp_to_local(item.created_at, json)])
-    display_table(column_names, rows, json, title=f"Volumes{env_part}")
+    for obj in volumes:
+        info = await obj.info()
+        rows.append((info.name, timestamp_to_localized_str(info.created_at.timestamp(), json), info.created_by))
+
+    display_table(["Name", "Created at", "Created by"], rows, json)
 
 
 @volume_cli.command(
@@ -164,7 +166,7 @@ async def ls(
                 (
                     entry.path.encode("unicode_escape").decode("utf-8"),
                     filetype,
-                    timestamp_to_local(entry.mtime, False),
+                    timestamp_to_localized_str(entry.mtime, False),
                     humanize_filesize(entry.size),
                 )
             )
@@ -197,7 +199,7 @@ async def put(
 
     if remote_path.endswith("/"):
         remote_path = remote_path + os.path.basename(local_path)
-    console = Console()
+    console = make_console()
     progress_handler = ProgressHandler(type="upload", console=console)
 
     if Path(local_path).is_dir():
@@ -245,7 +247,7 @@ async def rm(
 ):
     ensure_env(env)
     volume = _Volume.from_name(volume_name, environment_name=env)
-    console = Console()
+    console = make_console()
     try:
         await volume.remove_file(remote_path, recursive=recursive)
         console.print(OutputManager.step_completed(f"{remote_path} was deleted successfully!"))
@@ -278,25 +280,26 @@ async def cp(
 
 @volume_cli.command(
     name="delete",
-    help="Delete a named, persistent modal.Volume.",
+    help="Delete a named Volume and all of its data.",
     rich_help_panel="Management",
 )
 @synchronizer.create_blocking
 async def delete(
-    volume_name: str = Argument(help="Name of the modal.Volume to be deleted. Case sensitive"),
+    name: str = Argument(help="Name of the modal.Volume to be deleted. Case sensitive"),
+    *,
+    allow_missing: bool = Option(False, "--allow-missing", help="Don't error if the Volume doesn't exist."),
     yes: bool = YES_OPTION,
     env: Optional[str] = ENV_OPTION,
 ):
-    # Lookup first to validate the name, even though delete is a staticmethod
-    await _Volume.from_name(volume_name, environment_name=env).hydrate()
+    env = ensure_env(env)
     if not yes:
         typer.confirm(
-            f"Are you sure you want to irrevocably delete the modal.Volume '{volume_name}'?",
+            f"Are you sure you want to irrevocably delete the modal.Volume '{name}'?",
             default=False,
             abort=True,
         )
 
-    await _Volume.delete(volume_name, environment_name=env)
+    await _Volume.objects.delete(name, environment_name=env, allow_missing=allow_missing)
 
 
 @volume_cli.command(

modal/client.py

@@ -6,32 +6,24 @@ import sys
 import urllib.parse
 import warnings
 from collections.abc import AsyncGenerator, AsyncIterator, Collection, Mapping
-from typing import (
-    Any,
-    ClassVar,
-    Generic,
-    Optional,
-    TypeVar,
-    Union,
-)
+from typing import Any, ClassVar, Optional, TypeVar, Union
 
 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, suppress_tb_frames
+from ._traceback import print_server_warnings
 from ._utils import async_utils
 from ._utils.async_utils import TaskContext, synchronize_api
 from ._utils.auth_token_manager import _AuthTokenManager
-from ._utils.grpc_utils import ConnectionManager, retry_transient_errors
+from ._utils.grpc_utils import ConnectionManager
 from .config import _check_config, _is_remote, config, logger
-from .exception import AuthError, ClientClosed, NotFoundError
+from .exception import AuthError, ClientClosed
 
 HEARTBEAT_INTERVAL: float = config.get("heartbeat_interval")
 HEARTBEAT_TIMEOUT: float = HEARTBEAT_INTERVAL + 0.1
@@ -159,7 +151,7 @@ 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")
-        resp = await retry_transient_errors(self.stub.ClientHello, empty_pb2.Empty())
+        resp = await self.stub.ClientHello(empty_pb2.Empty())
         print_server_warnings(resp.server_warnings)
 
     async def __aenter__(self):
@@ -268,6 +260,14 @@ class _Client:
         # Just used from tests.
         cls._client_from_env = client
 
+    async def get_input_plane_metadata(self, input_plane_region: str) -> list[tuple[str, str]]:
+        assert self._auth_token_manager, "Client must have an instance of auth token manager."
+        token = await self._auth_token_manager.get_token()
+        return [
+            ("x-modal-input-plane-region", input_plane_region),
+            ("x-modal-auth-token", token),
+        ]
+
     async def _call_safely(self, coro, readable_method: str):
         """Runs coroutine wrapped in a task that's part of the client's task context
 
@@ -354,106 +354,3 @@ class _Client:
 
 
 Client = synchronize_api(_Client)
-
-
-class grpc_error_converter:
-    def __enter__(self):
-        pass
-
-    def __exit__(self, exc_type, exc, traceback) -> bool:
-        # skip all internal frames from grpclib
-        use_full_traceback = config.get("traceback")
-        with suppress_tb_frames(1):
-            if isinstance(exc, GRPCError):
-                if exc.status == Status.NOT_FOUND:
-                    if use_full_traceback:
-                        raise NotFoundError(exc.message)
-                    else:
-                        raise NotFoundError(exc.message) from None  # from None to skip the grpc-internal cause
-
-                if not use_full_traceback:
-                    # just include the frame in grpclib that actually raises the GRPCError
-                    tb = exc.__traceback__
-                    while tb.tb_next:
-                        tb = tb.tb_next
-                    exc.with_traceback(tb)
-                    raise exc from None  # from None to skip the grpc-internal cause
-                raise exc
-
-        return False
-
-
-class UnaryUnaryWrapper(Generic[RequestType, ResponseType]):
-    # Calls a grpclib.UnaryUnaryMethod using a specific Client instance, respecting
-    # if that client is closed etc. and possibly introducing Modal-specific retry logic
-    wrapped_method: grpclib.client.UnaryUnaryMethod[RequestType, ResponseType]
-    client: _Client
-
-    def __init__(
-        self,
-        wrapped_method: grpclib.client.UnaryUnaryMethod[RequestType, ResponseType],
-        client: _Client,
-        server_url: str,
-    ):
-        self.wrapped_method = wrapped_method
-        self.client = client
-        self.server_url = server_url
-
-    @property
-    def name(self) -> str:
-        return self.wrapped_method.name
-
-    async def __call__(
-        self,
-        req: RequestType,
-        *,
-        timeout: Optional[float] = None,
-        metadata: Optional[_MetadataLike] = None,
-    ) -> ResponseType:
-        if self.client._snapshotted:
-            logger.debug(f"refreshing client after snapshot for {self.name.rsplit('/', 1)[1]}")
-            self.client = await _Client.from_env()
-
-        # Note: We override the grpclib method's channel (see grpclib's code [1]). I think this is fine
-        # since grpclib's code doesn't seem to change very much, but we could also recreate the
-        # grpclib stub if we aren't comfortable with this. The downside is then we need to cache
-        # the grpclib stub so the rest of our code becomes a bit more complicated.
-        #
-        # We need to override the channel because after the process is forked or the client is
-        # snapshotted, the existing channel may be stale / unusable.
-        #
-        # [1]: https://github.com/vmagamedov/grpclib/blob/62f968a4c84e3f64e6966097574ff0a59969ea9b/grpclib/client.py#L844
-        self.wrapped_method.channel = await self.client._get_channel(self.server_url)
-        with suppress_tb_frames(1), grpc_error_converter():
-            return await self.client._call_unary(self.wrapped_method, req, timeout=timeout, metadata=metadata)
-
-
-class UnaryStreamWrapper(Generic[RequestType, ResponseType]):
-    wrapped_method: grpclib.client.UnaryStreamMethod[RequestType, ResponseType]
-
-    def __init__(
-        self,
-        wrapped_method: grpclib.client.UnaryStreamMethod[RequestType, ResponseType],
-        client: _Client,
-        server_url: str,
-    ):
-        self.wrapped_method = wrapped_method
-        self.client = client
-        self.server_url = server_url
-
-    @property
-    def name(self) -> str:
-        return self.wrapped_method.name
-
-    async def unary_stream(
-        self,
-        request,
-        metadata: Optional[Any] = None,
-    ):
-        if self.client._snapshotted:
-            logger.debug(f"refreshing client after snapshot for {self.name.rsplit('/', 1)[1]}")
-            self.client = await _Client.from_env()
-        self.wrapped_method.channel = await self.client._get_channel(self.server_url)
-        async for response in self.client._call_stream(self.wrapped_method, request, metadata=metadata):
-            yield response
-

modal/client.pyi

@@ -33,7 +33,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.0.6.dev58",
+        version: str = "1.2.3.dev7",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -112,6 +112,7 @@ class _Client:
         """mdmd:hidden"""
         ...
 
+    async def get_input_plane_metadata(self, input_plane_region: str) -> list[tuple[str, str]]: ...
     async def _call_safely(self, coro, readable_method: str):
         """Runs coroutine wrapped in a task that's part of the client's task context
 
@@ -163,7 +164,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.0.6.dev58",
+        version: str = "1.2.3.dev7",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -275,6 +276,12 @@ class Client:
         """mdmd:hidden"""
         ...
 
+    class __get_input_plane_metadata_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, /, input_plane_region: str) -> list[tuple[str, str]]: ...
+        async def aio(self, /, input_plane_region: str) -> list[tuple[str, str]]: ...
+
+    get_input_plane_metadata: __get_input_plane_metadata_spec[typing_extensions.Self]
+
     class ___call_safely_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /, coro, readable_method: str):
             """Runs coroutine wrapped in a task that's part of the client's task context
@@ -332,95 +339,6 @@ class Client:
         ],
     ) -> collections.abc.AsyncGenerator[typing.Any, None]: ...
 
-class grpc_error_converter:
-    def __enter__(self): ...
-    def __exit__(self, exc_type, exc, traceback) -> bool: ...
-
-class UnaryUnaryWrapper(typing.Generic[RequestType, ResponseType]):
-    """Abstract base class for generic types.
-
-    A generic type is typically declared by inheriting from
-    this class parameterized with one or more type variables.
-    For example, a generic mapping type might be defined as::
-
-      class Mapping(Generic[KT, VT]):
-          def __getitem__(self, key: KT) -> VT:
-              ...
-          # Etc.
-
-    This class can then be used as follows::
-
-      def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
-          try:
-              return mapping[key]
-          except KeyError:
-              return default
-    """
-
-    wrapped_method: grpclib.client.UnaryUnaryMethod[RequestType, ResponseType]
-    client: _Client
-
-    def __init__(
-        self,
-        wrapped_method: grpclib.client.UnaryUnaryMethod[RequestType, ResponseType],
-        client: _Client,
-        server_url: str,
-    ):
-        """Initialize self.  See help(type(self)) for accurate signature."""
-        ...
-
-    @property
-    def name(self) -> str: ...
-    async def __call__(
-        self,
-        req: RequestType,
-        *,
-        timeout: typing.Optional[float] = None,
-        metadata: typing.Union[
-            collections.abc.Mapping[str, typing.Union[str, bytes]],
-            collections.abc.Collection[tuple[str, typing.Union[str, bytes]]],
-            None,
-        ] = None,
-    ) -> ResponseType:
-        """Call self as a function."""
-        ...
-
-class UnaryStreamWrapper(typing.Generic[RequestType, ResponseType]):
-    """Abstract base class for generic types.
-
-    A generic type is typically declared by inheriting from
-    this class parameterized with one or more type variables.
-    For example, a generic mapping type might be defined as::
-
-      class Mapping(Generic[KT, VT]):
-          def __getitem__(self, key: KT) -> VT:
-              ...
-          # Etc.
-
-    This class can then be used as follows::
-
-      def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
-          try:
-              return mapping[key]
-          except KeyError:
-              return default
-    """
-
-    wrapped_method: grpclib.client.UnaryStreamMethod[RequestType, ResponseType]
-
-    def __init__(
-        self,
-        wrapped_method: grpclib.client.UnaryStreamMethod[RequestType, ResponseType],
-        client: _Client,
-        server_url: str,
-    ):
-        """Initialize self.  See help(type(self)) for accurate signature."""
-        ...
-
-    @property
-    def name(self) -> str: ...
-    def unary_stream(self, request, metadata: typing.Optional[typing.Any] = None): ...
-
 HEARTBEAT_INTERVAL: float
 
 HEARTBEAT_TIMEOUT: float

modal/cloud_bucket_mount.py

@@ -1,6 +1,6 @@
 # Copyright Modal Labs 2022
 from dataclasses import dataclass
-from typing import Optional
+from typing import Optional, Sequence
 from urllib.parse import urlparse
 
 from modal_proto import api_pb2
@@ -117,9 +117,10 @@ class _CloudBucketMount:
 
     read_only: bool = False
     requester_pays: bool = False
+    force_path_style: bool = False
 
 
-def cloud_bucket_mounts_to_proto(mounts: list[tuple[str, _CloudBucketMount]]) -> list[api_pb2.CloudBucketMount]:
+def cloud_bucket_mounts_to_proto(mounts: Sequence[tuple[str, _CloudBucketMount]]) -> list[api_pb2.CloudBucketMount]:
     """Helper function to convert `CloudBucketMount` to a list of protobufs that can be passed to the server."""
     cloud_bucket_mounts: list[api_pb2.CloudBucketMount] = []
 
@@ -132,7 +133,7 @@ def cloud_bucket_mounts_to_proto(mounts: list[tuple[str, _CloudBucketMount]]) ->
             elif parse_result.hostname.endswith("storage.googleapis.com"):
                 bucket_type = api_pb2.CloudBucketMount.BucketType.GCP
             else:
-                logger.warning(
+                logger.info(
                     "CloudBucketMount received unrecognized bucket endpoint URL. "
                     "Assuming AWS S3 configuration as fallback."
                 )
@@ -159,6 +160,7 @@ def cloud_bucket_mounts_to_proto(mounts: list[tuple[str, _CloudBucketMount]]) ->
             requester_pays=mount.requester_pays,
             key_prefix=key_prefix,
             oidc_auth_role_arn=mount.oidc_auth_role_arn,
+            force_path_style=mount.force_path_style,
         )
         cloud_bucket_mounts.append(cloud_bucket_mount)
 

modal/cloud_bucket_mount.pyi

@@ -99,6 +99,7 @@ class _CloudBucketMount:
     oidc_auth_role_arn: typing.Optional[str]
     read_only: bool
     requester_pays: bool
+    force_path_style: bool
 
     def __init__(
         self,
@@ -109,6 +110,7 @@ class _CloudBucketMount:
         oidc_auth_role_arn: typing.Optional[str] = None,
         read_only: bool = False,
         requester_pays: bool = False,
+        force_path_style: bool = False,
     ) -> None:
         """Initialize self.  See help(type(self)) for accurate signature."""
         ...
@@ -122,7 +124,7 @@ class _CloudBucketMount:
         ...
 
 def cloud_bucket_mounts_to_proto(
-    mounts: list[tuple[str, _CloudBucketMount]],
+    mounts: typing.Sequence[tuple[str, _CloudBucketMount]],
 ) -> list[modal_proto.api_pb2.CloudBucketMount]:
     """Helper function to convert `CloudBucketMount` to a list of protobufs that can be passed to the server."""
     ...
@@ -224,6 +226,7 @@ class CloudBucketMount:
     oidc_auth_role_arn: typing.Optional[str]
     read_only: bool
     requester_pays: bool
+    force_path_style: bool
 
     def __init__(
         self,
@@ -234,6 +237,7 @@ class CloudBucketMount:
         oidc_auth_role_arn: typing.Optional[str] = None,
         read_only: bool = False,
         requester_pays: bool = False,
+        force_path_style: bool = False,
     ) -> None: ...
     def __repr__(self): ...
     def __eq__(self, other): ...