modal 1.5.3.dev13__tar.gz → 1.5.4__tar.gz

{modal-1.5.3.dev13 → modal-1.5.4}/PKG-INFO

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

{modal-1.5.3.dev13 → modal-1.5.4}/modal/_clustered_functions.py

@@ -2,6 +2,7 @@
 import os
 import socket
 from dataclasses import dataclass
+from typing import cast
 
 from modal._utils.async_utils import synchronize_api
 from modal.client import _Client
@@ -15,6 +16,7 @@ class ClusterInfo:
     cluster_id: str
     container_ips: list[str]
     container_ipv4_ips: list[str]
+    fabric_ids: list[str]
 
 
 cluster_info: ClusterInfo | None = None
@@ -29,12 +31,22 @@ def get_cluster_info() -> ClusterInfo:
     return cluster_info
 
 
+def get_fabric_peers() -> list[int]:
+    info = get_cluster_info()
+    if info.rank >= len(info.fabric_ids) or not info.fabric_ids[info.rank]:
+        return [info.rank]
+    own_fabric_id = info.fabric_ids[info.rank]
+    return [rank for rank, fabric_id in enumerate(info.fabric_ids) if fabric_id == own_fabric_id]
+
+
 async def _initialize_clustered_function(client: _Client, task_id: str, world_size: int):
     global cluster_info
 
-    def get_i6pn():
+    def get_i6pn() -> str:
         """Returns the ipv6 address assigned to this container."""
-        return socket.getaddrinfo("i6pn.modal.local", None, socket.AF_INET6)[0][4][0]
+        # An AF_INET6 result always carries a (host, port, flowinfo, scope_id) sockaddr,
+        # but getaddrinfo is typed for every address family, some of which lead with an int
+        return cast(str, socket.getaddrinfo("i6pn.modal.local", None, socket.AF_INET6)[0][4][0])
 
     hostname = socket.gethostname()
     container_ip = get_i6pn()
@@ -68,8 +80,9 @@ async def _initialize_clustered_function(client: _Client, task_id: str, world_si
         cluster_info = ClusterInfo(
             rank=resp.cluster_rank,
             cluster_id=resp.cluster_id,
-            container_ips=resp.container_ips,
-            container_ipv4_ips=resp.container_ipv4_ips,
+            container_ips=list(resp.container_ips),
+            container_ipv4_ips=list(resp.container_ipv4_ips),
+            fabric_ids=list(resp.fabric_ids),
         )
     else:
         cluster_info = ClusterInfo(
@@ -77,6 +90,7 @@ async def _initialize_clustered_function(client: _Client, task_id: str, world_si
             cluster_id="",  # No cluster ID for single-node  # TODO(irfansharif): Is this right?
             container_ips=[container_ip],
             container_ipv4_ips=[],  # No IPv4 IPs for single-node
+            fabric_ids=[],
         )
 
 

{modal-1.5.3.dev13 → modal-1.5.4}/modal/_clustered_functions.pyi

@@ -3,14 +3,17 @@ import types
 import typing_extensions
 
 class ClusterInfo:
-    """ClusterInfo(rank: int, cluster_id: str, container_ips: list[str], container_ipv4_ips: list[str])"""
+    """ClusterInfo(rank: int, cluster_id: str, container_ips: list[str], container_ipv4_ips: list[str], fabric_ids: list[str])"""
 
     rank: int
     cluster_id: str
     container_ips: list[str]
     container_ipv4_ips: list[str]
+    fabric_ids: list[str]
 
-    def __init__(self, rank: int, cluster_id: str, container_ips: list[str], container_ipv4_ips: list[str]) -> None:
+    def __init__(
+        self, rank: int, cluster_id: str, container_ips: list[str], container_ipv4_ips: list[str], fabric_ids: list[str]
+    ) -> None:
         """Initialize self.  See help(type(self)) for accurate signature."""
         ...
 
@@ -23,6 +26,7 @@ class ClusterInfo:
         ...
 
 def get_cluster_info() -> ClusterInfo: ...
+def get_fabric_peers() -> list[int]: ...
 async def _initialize_clustered_function(client: modal.client._Client, task_id: str, world_size: int): ...
 
 class __initialize_clustered_function_spec(typing_extensions.Protocol):

{modal-1.5.3.dev13 → modal-1.5.4}/modal/_environments.py

@@ -4,7 +4,7 @@ import builtins
 from collections.abc import Iterable, Mapping
 from dataclasses import dataclass
 from datetime import datetime, timezone
-from typing import Literal
+from typing import Any, Literal
 
 from google.protobuf.empty_pb2 import Empty
 from google.protobuf.message import Message
@@ -16,6 +16,7 @@ from modal_proto import api_pb2
 from ._load_context import LoadContext
 from ._object import _Object
 from ._resolver import Resolver
+from ._utils.deprecation import deprecation_warning
 from ._utils.name_utils import check_environment_name
 from ._utils.time_utils import is_utc_month_aligned, parse_billing_cycle
 from .client import _Client
@@ -38,6 +39,7 @@ class _EnvironmentManager:
         name: str,  # Name to use for the new Environment
         *,
         restricted: bool = False,  # If True, enable RBAC restrictions on the Environment
+        experimental_options: dict[str, Any] | None = None,  # Experimental options for Environment creation
         client: _Client | None = None,  # Optional client with Modal credentials
     ) -> None:
         """Create a new Environment.
@@ -50,7 +52,10 @@ class _EnvironmentManager:
         """
         check_environment_name(name)
         client = await _Client.from_env() if client is None else client
-        await client.stub.EnvironmentCreate(api_pb2.EnvironmentCreateRequest(name=name, is_managed=restricted))
+        request = api_pb2.EnvironmentCreateRequest(name=name, is_managed=restricted)
+        if (experimental_options or {}).get("is_public", False):
+            request.environment_type = api_pb2.ENVIRONMENT_TYPE_PUBLIC
+        await client.stub.EnvironmentCreate(request)
 
     async def list(
         self,
@@ -104,7 +109,7 @@ class _EnvironmentManager:
         await client.stub.EnvironmentDelete(api_pb2.EnvironmentDeleteRequest(name=name))
 
 
-class _EnvironmentMembersManager:
+class _EnvironmentRolesManager:
     """mdmd:namespace"""
 
     def __init__(self, environment: "_Environment"):
@@ -112,13 +117,13 @@ class _EnvironmentMembersManager:
         self._environment = environment
 
     async def list(self) -> dict[Literal["users", "service_users"], dict[str, str]]:
-        """Enumerate the environment roles for each user and service user in the workspace.
+        """Enumerate the Environment Role for each user and service user in the workspace.
 
         **Examples:**
 
         ```python notest
-        members = modal.Environment.from_name("my-env").members.list()
-        print(members)
+        roles = modal.Environment.from_name("my-env").roles.list()
+        print(roles)
         # {
         #     "users": {"alice": "contributor", "bob": "viewer", "carol": "contributor"},
         #     "service_users": {"alice-bot": "contributor", "ops-bot": "viewer", "ci-bot": "no-access"},
@@ -145,16 +150,17 @@ class _EnvironmentMembersManager:
         users: Mapping[str, str] | None = None,
         service_users: Mapping[str, str] | None = None,
     ) -> None:
-        """Add or modify roles for members of a restricted Environment.
+        """Update the Environment Role of users and service users.
 
-        Each user or service user will be added to the Environment if not currently a member;
-        if already a member, the user or service user's role will be updated.
+        Each role is one of 'contributor', 'viewer', or 'no-access'. Service users can be
+        assigned a role on any Environment, while workspace members can only be assigned a
+        role on restricted Environments.
 
         **Examples:**
 
         ```python notest
         env = modal.Environment.from_name("my-restricted-env")
-        env.members.update(
+        env.roles.update(
             users={"alice": "contributor", "bob": "viewer"},
             service_users={"alice-bot": "contributor"},
         )
@@ -196,24 +202,59 @@ class _EnvironmentMembersManager:
 
         await self._dispatch_role_updates(requests)
 
+    async def _dispatch_role_updates(self, requests: dict[str, api_pb2.EnvironmentRoleSetRequest]) -> None:
+        """Send batched EnvironmentRoleSet RPCs and report all errors encountered."""
+        results = await asyncio.gather(
+            *(self._environment.client.stub.EnvironmentRoleSet(req) for req in requests.values()),
+            return_exceptions=True,
+        )
+        errors = [(label, result) for label, result in zip(requests.keys(), results) if isinstance(result, Exception)]
+        if errors:
+            n = len(errors)
+            header = f"{n} error{'s' if n != 1 else ''} occurred while updating Environment roles:"
+            details = "\n".join(f"  - {label}: {e}" for label, e in errors)
+            raise WorkspaceManagementError(f"{header}\n{details}")
+
+
+# Deprecated alias for `_EnvironmentRolesManager`; each method warns and delegates.
+class _EnvironmentMembersManager:
+    """mdmd:hidden"""
+
+    def __init__(self, environment: "_Environment"):
+        """mdmd:hidden"""
+        self._environment = environment
+
+    async def list(self) -> dict[Literal["users", "service_users"], dict[str, str]]:
+        deprecation_warning(
+            (2026, 7, 23),
+            "`Environment.members.list()` is deprecated; use `Environment.roles.list()` instead.",
+        )
+        return await _EnvironmentRolesManager(self._environment).list()
+
+    async def update(
+        self,
+        *,
+        users: Mapping[str, str] | None = None,
+        service_users: Mapping[str, str] | None = None,
+    ) -> None:
+        deprecation_warning(
+            (2026, 7, 23),
+            "`Environment.members.update()` is deprecated; use `Environment.roles.update()` instead.",
+        )
+        await _EnvironmentRolesManager(self._environment).update(users=users, service_users=service_users)
+
     async def remove(
         self,
         *,
         users: Iterable[str] | None = None,
         service_users: Iterable[str] | None = None,
     ) -> None:
-        """Remove members from a restricted Environment.
-
-        **Examples:**
-
-        ```python notest
-        env = modal.Environment.from_name("my-restricted-env")
-        env.members.remove(
-            users=["alice"],
-            service_users=["alice-bot"],
+        """Remove the Environment Role of users and service users, reverting them to the default."""
+        deprecation_warning(
+            (2026, 7, 23),
+            "`Environment.members.remove()` is deprecated. Environment Roles are now explicit; "
+            "set a role (e.g. 'no-access') with `Environment.roles.update()` instead.",
         )
-        ```
-        """
         await self._environment.hydrate()
         users = users or []
         service_users = service_users or []
@@ -247,20 +288,7 @@ class _EnvironmentMembersManager:
                 role=api_pb2.ENVIRONMENT_ROLE_UNSPECIFIED,
             )
 
-        await self._dispatch_role_updates(requests)
-
-    async def _dispatch_role_updates(self, requests: dict[str, api_pb2.EnvironmentRoleSetRequest]) -> None:
-        """Send batched EnvironmentRoleSet RPCs and report all errors encountered."""
-        results = await asyncio.gather(
-            *(self._environment.client.stub.EnvironmentRoleSet(req) for req in requests.values()),
-            return_exceptions=True,
-        )
-        errors = [(label, result) for label, result in zip(requests.keys(), results) if isinstance(result, Exception)]
-        if errors:
-            n = len(errors)
-            header = f"{n} error{'s' if n != 1 else ''} occurred while updating Environment members:"
-            details = "\n".join(f"  - {label}: {e}" for label, e in errors)
-            raise WorkspaceManagementError(f"{header}\n{details}")
+        await _EnvironmentRolesManager(self._environment)._dispatch_role_updates(requests)
 
 
 class _Environment(_Object, type_prefix="en"):
@@ -284,11 +312,17 @@ class _Environment(_Object, type_prefix="en"):
         return _EnvironmentManager()
 
     @property
-    def members(self) -> "_EnvironmentMembersManager":
-        """Namespace with methods for managing the membership of a restricted Environment.
+    def roles(self) -> "_EnvironmentRolesManager":
+        """Namespace with methods for managing the Environment Roles of users and service users.
 
-        See https://modal.com/docs/guide/rbac for more information on restricted Environments.
+        See https://modal.com/docs/guide/rbac for more information on Environment Roles.
         """
+        return _EnvironmentRolesManager(self)
+
+    @property
+    def members(self) -> "_EnvironmentMembersManager":
+        """mdmd:hidden"""
+        # Deprecated alias for `Environment.roles`.
         return _EnvironmentMembersManager(self)
 
     # TODO(michael) Keeping this private for now until we decide what else should be in it

{modal-1.5.3.dev13 → modal-1.5.4}/modal/_functions.py

@@ -45,7 +45,7 @@ from ._utils.async_utils import (
     synchronizer,
     warn_if_generator_is_not_consumed,
 )
-from ._utils.blob_utils import MAX_OBJECT_SIZE_BYTES
+from ._utils.blob_utils import MAX_ASYNC_OBJECT_SIZE_BYTES, MAX_OBJECT_SIZE_BYTES
 from ._utils.function_utils import (
     ATTEMPT_TIMEOUT_GRACE_PERIOD,
     OUTPUTS_TIMEOUT,
@@ -56,7 +56,9 @@ from ._utils.function_utils import (
     _stream_function_call_data,
     get_function_type,
     is_async,
+    normalize_fractional_target_concurrency,
     parse_gpu_config,
+    validate_target_concurrency,
 )
 from ._utils.grpc_utils import Retry, RetryWarningMessage
 from ._utils.mount_utils import validate_network_file_systems, validate_volumes, validate_volumes_by_object_id
@@ -93,7 +95,7 @@ from .proxy import _Proxy
 from .retries import Retries, RetryManager
 from .schedule import Schedule
 from .secret import _Secret
-from .types import FunctionStats
+from .types import FunctionAutoscalerSettings, FunctionStats, ServerAutoscalerSettings
 from .volume import _Volume, _volume_to_mount_proto
 
 if TYPE_CHECKING:
@@ -424,6 +426,7 @@ class _InputPlaneInvocation:
         client: _Client,
         input_plane_url: str,
         input_plane_region: str,
+        function_call_invocation_type: "api_pb2.FunctionCallInvocationType.ValueType",
     ) -> "_InputPlaneInvocation":
         stub = await client.get_stub(input_plane_url)
 
@@ -435,6 +438,7 @@ class _InputPlaneInvocation:
             kwargs,
             control_plane_stub,
             function=function,
+            function_call_invocation_type=function_call_invocation_type,
         )
 
         request = api_pb2.AttemptStartRequest(
@@ -636,7 +640,12 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         await self.hydrate()
         if not self._app_id:
             raise ExecutionError("app_id should have been set during function hydration")
-        return _LogQueryData(self.client, self._app_id, LogsFilters(function_id=self.object_id))
+        return _LogQueryData(
+            self.client,
+            self._app_id,
+            LogsFilters(function_id=self.object_id),
+            source_object_id=self.object_id,
+        )
 
     @property
     def logs(self) -> _FunctionLogsManager:
@@ -679,7 +688,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         scaleup_window: int | None = None,
         scaledown_window: int | None = None,
         max_concurrent_inputs: int | None = None,
-        target_concurrent_inputs: int | None = None,
+        target_concurrent_inputs: float | None = None,
         batch_max_size: int | None = None,
         batch_wait_ms: int | None = None,
         cloud: str | None = None,
@@ -787,6 +796,17 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             scaledown_window=scaledown_window,
         )
 
+        target_concurrent_inputs_int = 0
+        if target_concurrent_inputs is not None:
+            if is_server:
+                validate_target_concurrency(target_concurrent_inputs, "target_inputs", allow_fractional=True)
+                autoscaler_settings.target_concurrency_float = normalize_fractional_target_concurrency(
+                    target_concurrent_inputs
+                )
+            else:
+                validate_target_concurrency(target_concurrent_inputs, "target_inputs", allow_fractional=False)
+                target_concurrent_inputs_int = int(target_concurrent_inputs)
+
         # For clustered functions, container settings must be multiples of cluster_size
         if cluster_size is not None and cluster_size > 1:
             for field in ["min_containers", "max_containers", "buffer_containers"]:
@@ -1012,7 +1032,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     app_name=app_name,
                     is_builder_function=is_builder_function,
                     max_concurrent_inputs=max_concurrent_inputs or 0,
-                    target_concurrent_inputs=target_concurrent_inputs or 0,
+                    target_concurrent_inputs=target_concurrent_inputs_int,
                     batch_max_size=batch_max_size or 0,
                     batch_linger_ms=batch_wait_ms or 0,
                     worker_id=config.get("worker_id"),
@@ -1172,6 +1192,25 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         return obj
 
     async def _update_autoscaler(
+        self,
+        *,
+        min_containers: int | None = None,
+        max_containers: int | None = None,
+        buffer_containers: int | None = None,
+        scaledown_window: int | None = None,
+    ) -> FunctionAutoscalerSettings:
+        settings = api_pb2.AutoscalerSettings(
+            min_containers=min_containers,
+            max_containers=max_containers,
+            buffer_containers=buffer_containers,
+            scaledown_window=scaledown_window,
+        )
+        request = api_pb2.FunctionUpdateSchedulingParamsRequest(function_id=self.object_id, settings=settings)
+        response = await self.client.stub.FunctionUpdateSchedulingParams(request)
+
+        return FunctionAutoscalerSettings._from_proto(response.current_settings)
+
+    async def _update_autoscaler_server(
         self,
         *,
         min_containers: int | None = None,
@@ -1179,21 +1218,22 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         buffer_containers: int | None = None,
         scaleup_window: int | None = None,
         scaledown_window: int | None = None,
-        target_concurrency: int | None = None,
-    ) -> None:
+        target_concurrency: float | None = None,
+    ) -> ServerAutoscalerSettings:
         settings = api_pb2.AutoscalerSettings(
             min_containers=min_containers,
             max_containers=max_containers,
             buffer_containers=buffer_containers,
             scaleup_window=scaleup_window,
             scaledown_window=scaledown_window,
-            target_concurrency=target_concurrency,
         )
+        if target_concurrency is not None:
+            validate_target_concurrency(target_concurrency, "target_concurrency", allow_fractional=True)
+            settings.target_concurrency_float = normalize_fractional_target_concurrency(target_concurrency)
         request = api_pb2.FunctionUpdateSchedulingParamsRequest(function_id=self.object_id, settings=settings)
-        await self.client.stub.FunctionUpdateSchedulingParams(request)
+        response = await self.client.stub.FunctionUpdateSchedulingParams(request)
 
-        # One idea would be for FunctionUpdateScheduleParams to return the current (coalesced) settings
-        # and then we could return them here (would need some ad hoc dataclass, which I don't love)
+        return ServerAutoscalerSettings._from_proto(response.current_settings)
 
     @live_method
     async def update_autoscaler(
@@ -1203,7 +1243,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         max_containers: int | None = None,
         buffer_containers: int | None = None,
         scaledown_window: int | None = None,
-    ) -> None:
+    ) -> FunctionAutoscalerSettings:
         """Override the current autoscaler behavior for this Function.
 
         Unspecified parameters will retain their current value, i.e. either the static value
@@ -1218,6 +1258,10 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             buffer_containers: Extra containers to keep warm beyond current demand.
             scaledown_window: Maximum duration (in seconds) idle containers wait before scaling down.
 
+        Returns:
+            A `FunctionAutoscalerSettings` dataclass which contains the current autoscaler settings
+            of this Function after the call.
+
         Examples:
             ```python notest
             f = modal.Function.from_name("my-app", "function")
@@ -1237,7 +1281,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         if self._is_method:
             raise InvalidError("Cannot call .update_autoscaler() on a method. Call it on the class instance instead.")
 
-        await self._update_autoscaler(
+        return await self._update_autoscaler(
             min_containers=min_containers,
             max_containers=max_containers,
             buffer_containers=buffer_containers,
@@ -1427,6 +1471,11 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         self._max_object_size_bytes = (
             metadata.max_object_size_bytes if metadata.HasField("max_object_size_bytes") else MAX_OBJECT_SIZE_BYTES
         )
+        self._max_async_object_size_bytes = (
+            metadata.max_async_object_size_bytes
+            if metadata.HasField("max_async_object_size_bytes")
+            else MAX_ASYNC_OBJECT_SIZE_BYTES
+        )
         self._experimental_flash_urls = metadata._experimental_flash_urls
         self._app_id = metadata.app_id or None
 
@@ -1451,6 +1500,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             input_plane_url=self._input_plane_url,
             input_plane_region=self._input_plane_region,
             max_object_size_bytes=self._max_object_size_bytes,
+            max_async_object_size_bytes=self._max_async_object_size_bytes,
             _experimental_flash_urls=self._experimental_flash_urls,
             supported_input_formats=self._metadata.supported_input_formats if self._metadata else [],
             supported_output_formats=self._metadata.supported_output_formats if self._metadata else [],
@@ -1714,6 +1764,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 client=self.client,
                 input_plane_url=self._input_plane_url,
                 input_plane_region=self._input_plane_region,
+                function_call_invocation_type=api_pb2.FUNCTION_CALL_INVOCATION_TYPE_SYNC,
             )
         else:
             invocation = await _Invocation.create(
@@ -1755,6 +1806,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 client=self.client,
                 input_plane_url=self._input_plane_url,
                 input_plane_region=self._input_plane_region,
+                function_call_invocation_type=api_pb2.FUNCTION_CALL_INVOCATION_TYPE_SYNC_LEGACY,
             )
         else:
             invocation = await _Invocation.create(
@@ -2030,7 +2082,12 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
             await self._hydrate_from_id_metadata()
         if not self._app_id:
             raise ExecutionError("app_id should have been set during function call hydration")
-        return _LogQueryData(self.client, self._app_id, LogsFilters(function_call_id=self.object_id))
+        return _LogQueryData(
+            self.client,
+            self._app_id,
+            LogsFilters(function_call_id=self.object_id),
+            source_object_id=self.object_id,
+        )
 
     @property
     def logs(self) -> _FunctionCallLogsManager: