modal 1.5.2.dev19__tar.gz → 1.5.2.dev21__tar.gz

{modal-1.5.2.dev19 → modal-1.5.2.dev21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.5.2.dev19
+Version: 1.5.2.dev21
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0

{modal-1.5.2.dev19 → modal-1.5.2.dev21}/modal/_environments.py

@@ -103,9 +103,6 @@ class _EnvironmentManager:
         await client.stub.EnvironmentDelete(api_pb2.EnvironmentDeleteRequest(name=name))
 
 
-MemberRole = Literal["viewer", "contributor"]
-
-
 def _role_to_proto(role: str) -> "api_pb2.EnvironmentRole.ValueType":
     match role:
         case "viewer":
@@ -116,7 +113,7 @@ def _role_to_proto(role: str) -> "api_pb2.EnvironmentRole.ValueType":
             raise InvalidError(f"Invalid Environment role: {role!r} (expected 'viewer' or 'contributor')")
 
 
-def _role_from_proto(proto_value: int) -> MemberRole:
+def _role_from_proto(proto_value: int) -> str:
     match proto_value:
         case api_pb2.ENVIRONMENT_ROLE_VIEWER:
             return "viewer"
@@ -137,7 +134,7 @@ class _EnvironmentMembersManager:
         """mdmd:hidden"""
         self._environment = environment
 
-    async def list(self) -> dict[Literal["users", "service_users"], dict[str, MemberRole]]:
+    async def list(self) -> dict[Literal["users", "service_users"], dict[str, str]]:
         """Return the members of a restricted Environment with their roles.
 
         **Examples:**
@@ -155,8 +152,8 @@ class _EnvironmentMembersManager:
         req = api_pb2.EnvironmentGetManagedRequest(environment_id=self._environment.object_id)
         resp = await self._environment.client.stub.EnvironmentGetManaged(req)
 
-        users: dict[str, MemberRole] = {}
-        service_users: dict[str, MemberRole] = {}
+        users: dict[str, str] = {}
+        service_users: dict[str, str] = {}
         for principal in resp.principal_roles:
             role = _role_from_proto(principal.role)
             if principal.user_id:
@@ -169,8 +166,8 @@ class _EnvironmentMembersManager:
     async def update(
         self,
         *,
-        users: Mapping[str, MemberRole] | None = None,
-        service_users: Mapping[str, MemberRole] | None = None,
+        users: Mapping[str, str] | None = None,
+        service_users: Mapping[str, str] | None = None,
     ) -> None:
         """Add or modify roles for members of a restricted Environment.
 

{modal-1.5.2.dev19 → modal-1.5.2.dev21}/modal/_image.py

@@ -117,13 +117,34 @@ def _validate_image_tag(tag: str) -> None:
     check_object_name(tag, "Image tag")
 
 
-def _parse_named_image_ref(name: str) -> str:
+def _parse_named_image_ref(name: str) -> tuple[str, str]:
+    """Parse an image reference, returning (namespace_prefix, name_tag).
+
+    If the name contains a '/', the part before the last '/' is extracted as
+    a namespace prefix (intended for environment/name or workspace/env/name
+    syntax). The actual image name (after the last '/') is validated as a
+    standard object name.
+
+    Returns a tuple of (prefix, "full_name:tag") where prefix is empty string
+    if no '/' is present.
+    """
     image_name, sep, tag = name.partition(":")
     if not sep:
         tag = "latest"
+
+    prefix = ""
+    if "/" in image_name:
+        prefix, image_name = image_name.rsplit("/", 1)
+        if not prefix:
+            raise InvalidError("Invalid Image name: '/' prefix must be non-empty.")
+        if not image_name:
+            raise InvalidError("Invalid Image name: name after '/' must be non-empty.")
+
     _validate_image_name(image_name)
     _validate_image_tag(tag)
-    return f"{image_name}:{tag}"
+
+    full_name = f"{prefix}/{image_name}" if prefix else image_name
+    return prefix, f"{full_name}:{tag}"
 
 
 def _validate_python_version(
@@ -2923,12 +2944,15 @@ class _Image(_Object, type_prefix="im"):
             ...
         ```
         """
-        tag = _parse_named_image_ref(name)
+        namespace_prefix, tag = _parse_named_image_ref(name)
+
+        if namespace_prefix and environment_name:
+            raise InvalidError("Cannot specify 'environment_name' when the image name contains a '/'.")
 
         async def _load(self: _Image, resolver: Resolver, load_context: LoadContext, existing_object_id: str | None):
             req = api_pb2.ImageGetByTagRequest(
                 tag=tag,
-                environment_name=load_context.environment_name,
+                environment_name="" if namespace_prefix else load_context.environment_name,
             )
             response = await load_context.client.stub.ImageGetByTag(req)
             self._hydrate(response.image_id, load_context.client, None)
@@ -2963,15 +2987,20 @@ class _Image(_Object, type_prefix="im"):
         image.publish("my-image-with-numpy:v1")
         ```
         """
-        tag = _parse_named_image_ref(name)
+        namespace_prefix, tag = _parse_named_image_ref(name)
+
+        if namespace_prefix:
+            if environment_name:
+                raise InvalidError("Cannot specify 'environment_name' when the image name contains a '/'.")
+            resolved_env = ""
+        else:
+            resolved_env = environment_name or config.get("environment") or ""
 
         if self._object_id is None:
             raise InvalidError("Cannot publish an image that has not been created yet. Call `.build()` first.")
 
         _client = client or await _Client.from_env()
 
-        resolved_env = environment_name or config.get("environment") or ""
-
         await _client.stub.ImagePublish(
             api_pb2.ImagePublishRequest(
                 image_id=self._object_id,

{modal-1.5.2.dev19 → modal-1.5.2.dev21}/modal/_workspace.py

@@ -13,13 +13,19 @@ from ._object import _Object
 from ._resolver import Resolver
 from ._utils.time_utils import timestamp_to_localized_dt
 from .client import _Client
-from .types import BillingReportItem, MemberRole, ProxyTokenInfo, TokenData, WorkspaceMemberInfo, WorkspaceSettings
+from .types import (
+    BillingReportItem,
+    ProxyTokenInfo,
+    TokenData,
+    WorkspaceMemberInfo,
+    WorkspaceSettings,
+)
 
 
-def _member_role_from_proto(proto_value: int) -> MemberRole:
+def _member_role_from_proto(proto_value: int) -> str:
     match proto_value:
         case api_pb2.MEMBER_ROLE_USER:
-            return "user"
+            return "member"
         case api_pb2.MEMBER_ROLE_MANAGER:
             return "manager"
         case api_pb2.MEMBER_ROLE_OWNER:

{modal-1.5.2.dev19 → modal-1.5.2.dev21}/modal/cli/container.py

@@ -202,20 +202,20 @@ async def logs(
         task_info_resp = await client.stub.TaskGetInfo(api_pb2.TaskGetInfoRequest(task_id=task_id))
         app_id = task_info_resp.app_id
 
-        if not task_info_resp.info.started_at:
-            # Unlikely race or Modal backend issue, don't treat as a usage exception
+        if not task_info_resp.info.enqueued_at:
             return
-        container_started_dt = datetime.fromtimestamp(task_info_resp.info.started_at, timezone.utc)
+
+        container_enqueued_dt = datetime.fromtimestamp(task_info_resp.info.enqueued_at, timezone.utc)
 
         now = datetime.now(timezone.utc)
         if all_logs:
-            since_dt = container_started_dt
+            since_dt = container_enqueued_dt
             if task_info_resp.info.finished_at:
                 until_dt = datetime.fromtimestamp(task_info_resp.info.finished_at, timezone.utc)
             else:
                 until_dt = now
         else:
-            since_dt = _parse_time_arg(since, default=container_started_dt)
+            since_dt = _parse_time_arg(since, default=container_enqueued_dt)
             if task_info_resp.info.finished_at:
                 default_until_dt = datetime.fromtimestamp(task_info_resp.info.finished_at, timezone.utc)
             else:
@@ -269,15 +269,23 @@ async def _exec_impl(
     pty: bool | None = None,
     container_id: str = "",
     command: tuple[str, ...] = (),
+    object_id_for_v2: str | None = None,
 ):
-    """Execute a command in a container (implementation)."""
+    """Execute a command in a container (implementation).
+
+    For tasks belonging to V2 sandboxes, `object_id_for_v2` must be set to the
+    sandbox ID.
+    """
 
     if pty is None:
         pty = is_tty()
 
     client = await _Client.from_env()
 
-    command_router_client = await TaskCommandRouterClient.init(client, container_id)
+    if object_id_for_v2 is not None:
+        command_router_client = await TaskCommandRouterClient.init_v2(client, object_id_for_v2, container_id)
+    else:
+        command_router_client = await TaskCommandRouterClient.init(client, container_id)
 
     process_id = str(uuid.uuid4())
 

{modal-1.5.2.dev19 → modal-1.5.2.dev21}/modal/cli/curl.py

@@ -117,10 +117,12 @@ async def curl(curl_args: tuple[str, ...]):
     All arguments are passed directly to `curl`, which must be installed locally.
 
     Examples:
-        ```bash
-        modal curl https://user--my-app.us-west.modal.direct
-        modal curl -X GET https://user--my-app.us-west.modal.direct
-        ```
+
+    ```bash
+    modal curl https://user--my-app.us-west.modal.direct
+    modal curl -X GET https://user--my-app.us-west.modal.direct
+    ```
+
     """
     url = find_url(curl_args)
     if url is None:

{modal-1.5.2.dev19 → modal-1.5.2.dev21}/modal/cli/environment.py

@@ -7,7 +7,7 @@ from click import UsageError
 from rich.text import Text
 
 from modal import environments
-from modal._environments import MemberRole, _Environment
+from modal._environments import _Environment
 from modal._utils.async_utils import synchronizer
 from modal._utils.name_utils import check_environment_name
 from modal._utils.time_utils import format_interval
@@ -158,7 +158,7 @@ def members_list(environment: str, json: bool = False):
     "--role", type=click.Choice(["contributor", "viewer"]), required=True, help="Role to assign to the member"
 )
 @service_user_option
-def members_update(environment: str, member: str, role: MemberRole, service_user: bool = False):
+def members_update(environment: str, member: str, role: str, service_user: bool = False):
     env = Environment.from_name(environment)
     if service_user:
         env.members.update(service_users={member: role})

{modal-1.5.2.dev19 → modal-1.5.2.dev21}/modal/cli/image.py

@@ -168,11 +168,18 @@ async def history(
     env: Optional[str] = None,
     json: bool = False,
 ):
+    explicit_env = env  # None when --env is not passed by the user
     env = ensure_env(env)
     try:
-        name_tag = _parse_named_image_ref(name)
+        namespace_prefix, name_tag = _parse_named_image_ref(name)
     except InvalidError as exc:
         raise click.UsageError(str(exc)) from exc
+
+    if namespace_prefix:
+        if explicit_env is not None:
+            raise click.UsageError("Cannot specify '--env' when the image name contains a '/'.")
+        env = ""
+
     client = await _Client.from_env()
 
     first_page = await _fetch_history_page(client, env, name_tag, "")

{modal-1.5.2.dev19 → modal-1.5.2.dev21}/modal/cli/shell.py

@@ -17,7 +17,7 @@ from ..functions import Function
 from ..image import Image
 from ..mount import _Mount
 from ..runner import interactive_shell
-from ..sandbox import _MAIN_CONTAINER_NAME, Sandbox
+from ..sandbox import _MAIN_CONTAINER_NAME, Sandbox, _is_v2_sandbox_id
 from ..secret import Secret
 from ..stream_type import StreamType
 from ..volume import Volume
@@ -135,6 +135,8 @@ def _start_shell_in_running_container(ref: str, cmd: str, pty: bool) -> None:
     if container_name is not None and container_name != _MAIN_CONTAINER_NAME:
         return _start_shell_in_sidecar_container(sandbox_id, container_name, cmd, pty)
 
+    object_id_for_v2: str | None = None
+
     if _is_valid_modal_id(sandbox_id, "sb-"):
         try:
             sandbox = Sandbox.from_id(sandbox_id)
@@ -143,10 +145,12 @@ def _start_shell_in_running_container(ref: str, cmd: str, pty: bool) -> None:
             raise ClickException(f"Sandbox '{sandbox_id}' not found (is it still running?)")
         except Exception as e:
             raise ClickException(f"Error connecting to Sandbox '{sandbox_id}': {str(e)}")
+        if _is_v2_sandbox_id(sandbox_id):
+            object_id_for_v2 = sandbox_id
 
     assert _is_valid_modal_id(ref, "ta-")
     try:
-        _exec_impl(container_id=ref, command=shlex.split(cmd), pty=pty)
+        _exec_impl(container_id=ref, command=shlex.split(cmd), pty=pty, object_id_for_v2=object_id_for_v2)
     except NotFoundError:
         raise ClickException(f"Container '{ref}' not found (is it still running?)")
     except Exception as e:

{modal-1.5.2.dev19 → modal-1.5.2.dev21}/modal/client.pyi

@@ -35,7 +35,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.2.dev19",
+        version: str = "1.5.2.dev21",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -205,7 +205,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.2.dev19",
+        version: str = "1.5.2.dev21",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.5.2.dev19 → modal-1.5.2.dev21}/modal/environments.pyi

@@ -112,9 +112,7 @@ class EnvironmentMembersManager:
         ...
 
     class __list_spec(typing_extensions.Protocol):
-        def __call__(
-            self, /
-        ) -> dict[typing.Literal["users", "service_users"], dict[str, typing.Literal["viewer", "contributor"]]]:
+        def __call__(self, /) -> dict[typing.Literal["users", "service_users"], dict[str, str]]:
             """Return the members of a restricted Environment with their roles.
 
             **Examples:**
@@ -130,9 +128,7 @@ class EnvironmentMembersManager:
             """
             ...
 
-        async def aio(
-            self, /
-        ) -> dict[typing.Literal["users", "service_users"], dict[str, typing.Literal["viewer", "contributor"]]]:
+        async def aio(self, /) -> dict[typing.Literal["users", "service_users"], dict[str, str]]:
             """Return the members of a restricted Environment with their roles.
 
             **Examples:**
@@ -155,10 +151,8 @@ class EnvironmentMembersManager:
             self,
             /,
             *,
-            users: typing.Optional[collections.abc.Mapping[str, typing.Literal["viewer", "contributor"]]] = None,
-            service_users: typing.Optional[
-                collections.abc.Mapping[str, typing.Literal["viewer", "contributor"]]
-            ] = None,
+            users: typing.Optional[collections.abc.Mapping[str, str]] = None,
+            service_users: typing.Optional[collections.abc.Mapping[str, str]] = None,
         ) -> None:
             """Add or modify roles for members of a restricted Environment.
 
@@ -181,10 +175,8 @@ class EnvironmentMembersManager:
             self,
             /,
             *,
-            users: typing.Optional[collections.abc.Mapping[str, typing.Literal["viewer", "contributor"]]] = None,
-            service_users: typing.Optional[
-                collections.abc.Mapping[str, typing.Literal["viewer", "contributor"]]
-            ] = None,
+            users: typing.Optional[collections.abc.Mapping[str, str]] = None,
+            service_users: typing.Optional[collections.abc.Mapping[str, str]] = None,
         ) -> None:
             """Add or modify roles for members of a restricted Environment.
 

{modal-1.5.2.dev19 → modal-1.5.2.dev21}/modal/functions.pyi

@@ -491,7 +491,7 @@ class Function(
 
     _call_generator: ___call_generator_spec
 
-    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER:
             """Calls the function remotely, executing it with the given arguments and returning the execution's result.
 
@@ -516,7 +516,7 @@ class Function(
             """
             ...
 
-    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType]
+    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P]
 
     class __remote_gen_spec(typing_extensions.Protocol):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -566,7 +566,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """[Experimental] Calls the function with the given arguments, without waiting for the results.
 
@@ -599,7 +599,7 @@ class Function(
             """
             ...
 
-    _experimental_spawn: ___experimental_spawn_spec[modal._functions.P, modal._functions.ReturnType]
+    _experimental_spawn: ___experimental_spawn_spec[modal._functions.ReturnType, modal._functions.P]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> None: ...
@@ -607,7 +607,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P]
 
-    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """Calls the function with the given arguments, without waiting for the results.
 
@@ -640,7 +640,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType]
+    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]:
         """Return the inner Python object wrapped by this Modal Function.

{modal-1.5.2.dev19 → modal-1.5.2.dev21}/modal/sandbox.py

@@ -861,9 +861,10 @@ class _Sandbox(_Object, type_prefix="sb"):
         (e.g. `region="us-east-1"`).
 
         V2 sandboxes created with this method are not currently returned by
-        `Sandbox.list()` and cannot be looked up with `Sandbox.from_name()`.
-        Store `sandbox.object_id` if you need to retrieve the sandbox later, and
-        use `Sandbox.from_id(sandbox.object_id)` to reattach.
+        `Sandbox.list()`. A named sandbox can be looked up with
+        `Sandbox._experimental_from_name(app_name, name)`; otherwise store
+        `sandbox.object_id` and use `Sandbox.from_id(sandbox.object_id)` to
+        reattach.
         """
         from .app import _App
 
@@ -1186,6 +1187,44 @@ class _Sandbox(_Object, type_prefix="sb"):
         resp = await client.stub.SandboxGetFromName(req)
         return _Sandbox._new_hydrated(resp.sandbox_id, client, None)
 
+    @staticmethod
+    async def _experimental_from_name(
+        app_name: str,
+        name: str,
+        *,
+        environment_name: str | None = None,
+        client: _Client | None = None,
+    ) -> "_Sandbox":
+        """Get a running V2 Sandbox by name from a deployed App.
+
+        This looks up V2 sandboxes, ie sandboxes created via `modal.Sandbox._experimental_create`.
+
+        Args:
+            app_name: Name of the deployed app to look up the sandbox under.
+            name: Sandbox name to resolve.
+            environment_name: Optional environment name for the lookup; defaults to the configured environment.
+            client: Modal client to use for the RPC; defaults to `Client.from_env()` when omitted.
+
+        Returns:
+            A `Sandbox` handle for the running sandbox.
+
+        Raises:
+            NotFoundError: If no running sandbox exists with the given name.
+        """
+        if client is None:
+            client = await _Client.from_env()
+        env_name = _get_environment_name(environment_name)
+
+        req = api_pb2.SandboxGetFromNameRequest(sandbox_name=name, app_name=app_name, environment_name=env_name)
+        assert client._auth_token_manager
+        auth_token = await client._auth_token_manager.get_token()
+        resp = await client.stub.SandboxGetFromNameV2(req, metadata=[("x-modal-auth-token", auth_token)])
+
+        obj = _Sandbox._new_hydrated(resp.sandbox_id, client, None)
+        obj._is_v2 = True
+        obj._hydrate_metadata_v2()
+        return obj
+
     @staticmethod
     async def from_id(sandbox_id: str, client: _Client | None = None) -> "_Sandbox":
         """Construct a Sandbox from an id and look up the Sandbox result.
@@ -2279,15 +2318,15 @@ class _Sandbox(_Object, type_prefix="sb"):
 
     @staticmethod
     async def _experimental_list(
-        *, app_id: str | None = None, client: _Client | None = None
+        *, app_id: str | None = None, tags: dict[str, str] | None = None, client: _Client | None = None
     ) -> AsyncGenerator["_Sandbox", None]:
         """List v2 Sandboxes in an App.
 
         This function lists v2 sandboxes, ie sandboxes created via modal.Sandbox._experimental_create.
-        Filtering based on tags is not yet supported.
 
         Args:
             app_id: The App to list Sandboxes under.
+            tags: If set, only sandboxes containing at least these tags are returned.
             client: Optional client to use for the session.
 
         Yields:
@@ -2304,12 +2343,15 @@ class _Sandbox(_Object, type_prefix="sb"):
         if client is None:
             client = await _Client.from_env()
 
+        tags_list = [api_pb2.SandboxTag(tag_name=name, tag_value=value) for name, value in tags.items()] if tags else []
+
         assert client._auth_token_manager
         while True:
             req = api_pb2.SandboxListRequest(
                 app_id=app_id,
                 before_timestamp=before_timestamp,
                 include_finished=False,
+                tags=tags_list,
             )
 
             # Fetches a batch of sandboxes. SandboxListV2 authenticates via the