modal 1.5.6.dev25__tar.gz → 1.5.6.dev26__tar.gz

{modal-1.5.6.dev25 → modal-1.5.6.dev26}/PKG-INFO

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

{modal-1.5.6.dev25 → modal-1.5.6.dev26}/modal/__init__.py

@@ -23,11 +23,11 @@ try:
     from .functions import Function, FunctionCall
     from .image import Image
     from .network_file_system import NetworkFileSystem
-    from .outbound_policy import OutboundPolicy
     from .output import enable_output
     from .partial_function import (
         asgi_app,
         batched,
+        clustered,
         concurrent,
         enter,
         exit,
@@ -72,7 +72,6 @@ __all__ = [
     "FunctionCall",
     "Image",
     "NetworkFileSystem",
-    "OutboundPolicy",
     "Period",
     "Probe",
     "Proxy",
@@ -90,6 +89,7 @@ __all__ = [
     "asgi_app",
     "batched",
     "billing",
+    "clustered",
     "concurrent",
     "current_function_call_id",
     "current_input_id",

{modal-1.5.6.dev25 → modal-1.5.6.dev26}/modal/_clustered_functions.py

@@ -71,7 +71,7 @@ async def _initialize_clustered_function(client: _Client, task_id: str, world_si
         os.environ["NCCL_NSOCKS_PERTHREAD"] = "1"
 
     if world_size > 1:
-        resp = await client.stub.TaskClusterHello(
+        resp = await client._stub.TaskClusterHello(
             api_pb2.TaskClusterHelloRequest(
                 task_id=task_id,
                 container_ip=container_ip,

{modal-1.5.6.dev25 → modal-1.5.6.dev26}/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 Any, Literal
+from typing import TYPE_CHECKING, Any, Literal
 
 from google.protobuf.empty_pb2 import Empty
 from google.protobuf.message import Message
@@ -24,6 +24,9 @@ from .config import config, logger
 from .exception import InvalidError, WorkspaceManagementError
 from .types import BillingReportItem, EnvironmentBillingSummary
 
+if TYPE_CHECKING:
+    import modal
+
 
 @dataclass(frozen=True)
 class EnvironmentSettings:
@@ -59,7 +62,7 @@ class _EnvironmentManager:
             request.default_member_role_str = default_role
         if (experimental_options or {}).get("is_public", False):
             request.environment_type = api_pb2.ENVIRONMENT_TYPE_PUBLIC
-        await client.stub.EnvironmentCreate(request)
+        await client._stub.EnvironmentCreate(request)
 
     async def list(
         self,
@@ -76,7 +79,7 @@ class _EnvironmentManager:
         ```
         """
         client = await _Client.from_env() if client is None else client
-        resp = await client.stub.EnvironmentList(Empty())
+        resp = await client._stub.EnvironmentList(Empty())
         environments = []
         for item in resp.items:
             metadata = api_pb2.EnvironmentMetadata(
@@ -110,7 +113,7 @@ class _EnvironmentManager:
         ```
         """
         client = await _Client.from_env() if client is None else client
-        await client.stub.EnvironmentDelete(api_pb2.EnvironmentDeleteRequest(name=name))
+        await client._stub.EnvironmentDelete(api_pb2.EnvironmentDeleteRequest(name=name))
 
 
 class _EnvironmentRolesManager:
@@ -139,7 +142,7 @@ class _EnvironmentRolesManager:
         """
         await self._environment.hydrate()
         req = api_pb2.EnvironmentGetRolesRequest(environment_id=self._environment.object_id)
-        resp = await self._environment.client.stub.EnvironmentGetRoles(req)
+        resp = await self._environment.client._stub.EnvironmentGetRoles(req)
 
         users: dict[str, str] = {}
         service_users: dict[str, str] = {}
@@ -180,7 +183,7 @@ class _EnvironmentRolesManager:
         service_users = service_users or {}
 
         req = api_pb2.EnvironmentGetRolesRequest(environment_id=self._environment.object_id)
-        resp = await self._environment.client.stub.EnvironmentGetRoles(req)
+        resp = await self._environment.client._stub.EnvironmentGetRoles(req)
 
         # EnvironmentGetRoles returns every workspace principal
         user_name_to_id: dict[str, str] = {}
@@ -214,7 +217,7 @@ class _EnvironmentRolesManager:
     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()),
+            *(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)]
@@ -269,7 +272,7 @@ class _EnvironmentMembersManager:
         service_users = service_users or []
 
         req = api_pb2.EnvironmentGetRolesRequest(environment_id=self._environment.object_id)
-        resp = await self._environment.client.stub.EnvironmentGetRoles(req)
+        resp = await self._environment.client._stub.EnvironmentGetRoles(req)
 
         user_name_to_id: dict[str, str] = {}
         service_user_name_to_id: dict[str, str] = {}
@@ -300,6 +303,55 @@ class _EnvironmentMembersManager:
         await _EnvironmentRolesManager(self._environment)._dispatch_role_updates(requests)
 
 
+class _EnvironmentAppsManager:
+    """mdmd:namespace"""
+
+    def __init__(self, environment: "_Environment"):
+        """mdmd:hidden"""
+        self._environment = environment
+
+    async def list(self) -> builtins.list["modal.app._App"]:
+        """Return handles for live Apps in this Environment.
+
+        The returned handles reference existing remote Apps and can be used with APIs such as
+        [`App.info()`](https://modal.com/docs/sdk/py/latest/App#info),
+        [`App.logs`](https://modal.com/docs/sdk/py/latest/App#logs), and
+        [`Sandbox.create()`](https://modal.com/docs/sdk/py/latest/Sandbox#create). Listing Apps does not create
+        Apps.
+
+        Examples:
+
+        ```python notest
+        environment = modal.Environment.from_name("prod")
+        apps = environment.apps.list()
+        print([app.name for app in apps])
+        ```
+        """
+        from .app import _App
+
+        await self._environment.hydrate()
+        assert self._environment.name is not None
+
+        response = await self._environment.client._stub.AppList(
+            api_pb2.AppListRequest(environment_name=self._environment.name)
+        )
+        stopped_app_states = (
+            api_pb2.APP_STATE_STOPPED,
+            api_pb2.APP_STATE_DISABLED,
+        )
+        return [
+            _App._new_remote(
+                item.name or None,
+                item.app_id,
+                self._environment.name,
+                self._environment.client,
+                description=item.description or None,
+            )
+            for item in response.apps
+            if item.state not in stopped_app_states
+        ]
+
+
 class _Environment(_Object, type_prefix="en"):
     _name: str | None = None
     _settings: EnvironmentSettings
@@ -334,6 +386,11 @@ class _Environment(_Object, type_prefix="en"):
         # Deprecated alias for `Environment.roles`.
         return _EnvironmentMembersManager(self)
 
+    @property
+    def apps(self) -> "_EnvironmentAppsManager":
+        """Namespace for accessing Apps deployed in this Environment."""
+        return _EnvironmentAppsManager(self)
+
     # TODO(michael) Keeping this private for now until we decide what else should be in it
     # And what the rules should be about updates / mutability
     # @property
@@ -366,7 +423,7 @@ class _Environment(_Object, type_prefix="en"):
                     else api_pb2.OBJECT_CREATION_TYPE_UNSPECIFIED
                 ),
             )
-            response = await load_context.client.stub.EnvironmentGetOrCreate(request)
+            response = await load_context.client._stub.EnvironmentGetOrCreate(request)
             logger.debug(f"Created environment with id {response.environment_id}")
             self._hydrate(response.environment_id, load_context.client, response.metadata)
 
@@ -491,7 +548,7 @@ class _EnvironmentBillingManager:
 
         return [
             BillingReportItem._from_proto(pb_item)
-            async for pb_item in self._environment.client.stub.WorkspaceBillingReport.unary_stream(request)
+            async for pb_item in self._environment.client._stub.WorkspaceBillingReport.unary_stream(request)
         ]
 
     async def summary(
@@ -556,7 +613,7 @@ class _EnvironmentBillingManager:
         request.start_timestamp.FromDatetime(cycle)
 
         return EnvironmentBillingSummary._from_proto(
-            await self._environment.client.stub.EnvironmentBillingSummary(request)
+            await self._environment.client._stub.EnvironmentBillingSummary(request)
         )
 
 
@@ -582,7 +639,7 @@ async def _get_environment_cached(name: str, client: _Client) -> _Environment:
 async def _delete_environment(name: str, client: _Client | None = None):
     if client is None:
         client = await _Client.from_env()
-    await client.stub.EnvironmentDelete(api_pb2.EnvironmentDeleteRequest(name=name))
+    await client._stub.EnvironmentDelete(api_pb2.EnvironmentDeleteRequest(name=name))
 
 
 async def _update_environment(
@@ -608,19 +665,19 @@ async def _update_environment(
     )
     if client is None:
         client = await _Client.from_env()
-    await client.stub.EnvironmentUpdate(update_payload)
+    await client._stub.EnvironmentUpdate(update_payload)
 
 
 async def _create_environment(name: str, client: _Client | None = None):
     if client is None:
         client = await _Client.from_env()
-    await client.stub.EnvironmentCreate(api_pb2.EnvironmentCreateRequest(name=name))
+    await client._stub.EnvironmentCreate(api_pb2.EnvironmentCreateRequest(name=name))
 
 
 async def _list_environments(client: _Client | None = None) -> list[api_pb2.EnvironmentListItem]:
     if client is None:
         client = await _Client.from_env()
-    resp = await client.stub.EnvironmentList(Empty())
+    resp = await client._stub.EnvironmentList(Empty())
     return list(resp.items)
 
 

{modal-1.5.6.dev25 → modal-1.5.6.dev26}/modal/_function_variants.py

@@ -335,7 +335,7 @@ async def _list_function_variants(
     cursor = None
     while True:
         request = api_pb2.FunctionListVariantsRequest(function_id=function_id, cursor=cursor, limit=limit or 0)
-        response = await client.stub.FunctionListVariants(request)
+        response = await client._stub.FunctionListVariants(request)
         # An ordered listing arrives as a single response, so there is nothing to reconcile across
         # pages: every response of a multi-page listing reports itself unordered.
         ordered_by_task_count = response.ordered_by_task_count
@@ -376,8 +376,8 @@ async def _function_bind_params_cached(
         response.ParseFromString(cached_response)
         return response
 
-    assert base_function._client and base_function._client.stub
-    response = await base_function._client.stub.FunctionBindParams(req)
+    assert base_function._client and base_function._client._stub
+    response = await base_function._client._stub.FunctionBindParams(req)
 
     cache[cache_key] = response.SerializeToString(deterministic=True)
     cache.move_to_end(cache_key)
@@ -407,7 +407,7 @@ def _make_function_variant(
         if not base_function._is_hydrated:
             await base_function.hydrate(load_context.client)
 
-        assert base_function._client and base_function._client.stub
+        assert base_function._client and base_function._client._stub
 
         if parameter_schema is None:
             # This branch is about backwards compatibility.

{modal-1.5.6.dev25 → modal-1.5.6.dev26}/modal/_functions.py

@@ -158,8 +158,8 @@ class _Invocation:
         function_call_invocation_type: "api_pb2.FunctionCallInvocationType.ValueType",
         from_spawn_map: bool = False,
     ) -> "_Invocation":
-        assert client.stub
-        stub = client.stub
+        assert client._stub
+        stub = client._stub
 
         function_id = function.object_id
         item = await _create_input(
@@ -180,7 +180,7 @@ class _Invocation:
 
         if from_spawn_map:
             request.from_spawn_map = True
-            response = await client.stub.FunctionMap(
+            response = await client._stub.FunctionMap(
                 request,
                 retry=Retry(
                     max_retries=None,
@@ -195,7 +195,7 @@ class _Invocation:
                 ),
             )
         else:
-            response = await client.stub.FunctionMap(request)
+            response = await client._stub.FunctionMap(request)
 
         function_call_id = response.function_call_id
         if response.pipelined_inputs:
@@ -215,7 +215,7 @@ class _Invocation:
         request_put = api_pb2.FunctionPutInputsRequest(
             function_id=function_id, inputs=[item], function_call_id=function_call_id
         )
-        inputs_response: api_pb2.FunctionPutInputsResponse = await client.stub.FunctionPutInputs(request_put)
+        inputs_response: api_pb2.FunctionPutInputsResponse = await client._stub.FunctionPutInputs(request_put)
         processed_inputs = inputs_response.inputs
         if not processed_inputs:
             raise Exception("Could not create function call - the input queue seems to be full")
@@ -438,10 +438,10 @@ class _InputPlaneInvocation:
         input_plane_region: str,
         function_call_invocation_type: "api_pb2.FunctionCallInvocationType.ValueType",
     ) -> "_InputPlaneInvocation":
-        stub = await client.get_stub(input_plane_url)
+        stub = await client._get_stub(input_plane_url)
 
         function_id = function.object_id
-        control_plane_stub = client.stub
+        control_plane_stub = client._stub
         # Note: Blob upload is done on the control plane stub, not the input plane stub!
         input_item = await _create_input(
             args,
@@ -491,7 +491,7 @@ class _InputPlaneInvocation:
             # If we have a final output, return.
             if await_response.output.result.status in TERMINAL_STATUSES:
                 return await _process_result(
-                    await_response.output.result, await_response.output.data_format, self.client.stub, self.client
+                    await_response.output.result, await_response.output.data_format, self.client._stub, self.client
                 )
 
             # We have a failure (internal or application), so see if there are any retries left, and if so, retry.
@@ -510,7 +510,7 @@ class _InputPlaneInvocation:
 
             # No more retries left.
             return await _process_result(
-                await_response.output.result, await_response.output.data_format, self.client.stub, self.client
+                await_response.output.result, await_response.output.data_format, self.client._stub, self.client
             )
 
     async def _retry_input(self, metadata: list[tuple[str, str]]) -> str:
@@ -731,6 +731,25 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         # Needed to avoid circular imports
         from ._partial_function import _find_partial_methods_for_user_cls, _PartialFunctionFlags
 
+        experimental_options = dict(experimental_options or {})
+        if "fabric_size" in experimental_options:
+            if fabric_size is not None:
+                raise InvalidError(
+                    "Specify fabric_size only once, in experimental_options or the experimental decorator"
+                )
+            try:
+                fabric_size = int(experimental_options.pop("fabric_size"))
+            except ValueError:
+                raise InvalidError("fabric_size must be a positive integer") from None
+            if fabric_size <= 0:
+                raise InvalidError("fabric_size must be a positive integer")
+            if not cluster_size:
+                raise InvalidError("fabric_size requires @modal.clustered")
+            if cluster_size % fabric_size != 0:
+                raise InvalidError(
+                    f"fabric_size must evenly divide the cluster size ({cluster_size} % {fabric_size} != 0)"
+                )
+
         tag = info.get_tag()
 
         if info.raw_f:
@@ -818,6 +837,9 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 validate_target_concurrency(target_concurrent_inputs, "target_inputs", allow_fractional=False)
                 target_concurrent_inputs_int = int(target_concurrent_inputs)
 
+        if cluster_size and batch_max_size:
+            raise InvalidError("Clustered Functions do not support dynamic batching.")
+
         # 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"]:
@@ -941,7 +963,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             elif webhook_config:
                 req.webhook_config.CopyFrom(webhook_config)
 
-            response = await load_context.client.stub.FunctionPrecreate(req)
+            response = await load_context.client._stub.FunctionPrecreate(req)
             self._hydrate(response.function_id, load_context.client, response.handle_metadata)
 
         async def _load(self: _Function, resolver: Resolver, load_context: LoadContext, existing_object_id: str | None):
@@ -1155,7 +1177,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     existing_function_id=existing_object_id or "",
                 )
                 try:
-                    response: api_pb2.FunctionCreateResponse = await load_context.client.stub.FunctionCreate(request)
+                    response: api_pb2.FunctionCreateResponse = await load_context.client._stub.FunctionCreate(request)
                 except Exception as exc:
                     if "Received :status = '413'" in str(exc):
                         raise InvalidError(f"Function {info.function_name} is too large to deploy.")
@@ -1230,7 +1252,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             },
             # We don't have any secret IDs yet as we are dehydrated, so we return the reprs instead
             secrets=[repr(s) for s in secrets],
-            http_info=HttpInfo._from_proto(http_config) if http_config else None,
+            _http_info=HttpInfo._from_proto(http_config) if http_config else None,
+            web_info=FunctionInfo.WebInfo._from_proto(webhook_config) if webhook_config else None,
         )
 
         return obj
@@ -1256,7 +1279,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             scaledown_window=scaledown_window,
         )
         request = api_pb2.FunctionUpdateSchedulingParamsRequest(function_id=self.object_id, settings=settings)
-        response = await self.client.stub.FunctionUpdateSchedulingParams(request)
+        response = await self.client._stub.FunctionUpdateSchedulingParams(request)
 
         return FunctionAutoscalerSettings._from_proto(response.current_settings)
 
@@ -1281,7 +1304,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             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)
-        response = await self.client.stub.FunctionUpdateSchedulingParams(request)
+        response = await self.client._stub.FunctionUpdateSchedulingParams(request)
 
         return ServerAutoscalerSettings._from_proto(response.current_settings)
 
@@ -1359,7 +1382,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 app_version=version or 0,
             )
             try:
-                response = await load_context.client.stub.FunctionGet(request)
+                response = await load_context.client._stub.FunctionGet(request)
             except NotFoundError as exc:
                 # refine the error message
                 env_context = (
@@ -1403,7 +1426,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         ):
             request = api_pb2.FunctionGetByIdRequest(function_id=function_id)
             try:
-                response = await load_context.client.stub.FunctionGetById(request)
+                response = await load_context.client._stub.FunctionGetById(request)
             except NotFoundError as exc:
                 # refine the error message
                 msg = f"Lookup failed for {called_from} '{function_id}': {exc}."
@@ -1563,7 +1586,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         if refresh or self._function_info is None:
             # Accessing `.client` or `.object_id` here can't throw since we only get to this branch on a
             # hydrated handle
-            response = await self.client.stub.FunctionGetById(
+            response = await self.client._stub.FunctionGetById(
                 api_pb2.FunctionGetByIdRequest(
                     function_id=self.object_id,
                 )
@@ -2224,7 +2247,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         Returns:
             A `FunctionCurrentStats` object containing live input and container counts.
         """
-        resp = await self.client.stub.FunctionGetCurrentStats(
+        resp = await self.client._stub.FunctionGetCurrentStats(
             api_pb2.FunctionGetCurrentStatsRequest(function_id=self.object_id),
             retry=Retry(total_timeout=10.0),
         )
@@ -2270,7 +2293,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         historical_request.until.FromDatetime(until)
         if container:
             historical_request.container_id = container
-        stats = await self.client.stub.FunctionGetTimeRangeStats(historical_request)
+        stats = await self.client._stub.FunctionGetTimeRangeStats(historical_request)
         return FunctionStats._from_proto(stats)
 
     @live_method
@@ -2307,12 +2330,12 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
     _function_id: str | None = None
 
     def _invocation(self):
-        return _Invocation(self.client.stub, self.object_id, self.client)
+        return _Invocation(self.client._stub, self.object_id, self.client)
 
     async def _hydrate_from_id_metadata(self) -> None:
         """Hydrate metadata only when needed for FunctionCall fields."""
         request = api_pb2.FunctionCallFromIdRequest(function_call_id=self.object_id)
-        resp = await self.client.stub.FunctionCallFromId(request)
+        resp = await self.client._stub.FunctionCallFromId(request)
         self._hydrate_metadata(resp)
 
     async def _get_log_query_data(self) -> _LogQueryData:
@@ -2428,9 +2451,9 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         Returns:
             A list of `InputInfo` nodes describing the call graph.
         """
-        assert self._client and self._client.stub
+        assert self._client and self._client._stub
         request = api_pb2.FunctionGetCallGraphRequest(function_call_id=self.object_id)
-        response = await self._client.stub.FunctionGetCallGraph(request)
+        response = await self._client._stub.FunctionGetCallGraph(request)
         if response.truncated:
             logger.warning(
                 f"Call graph for {self.object_id} was truncated; "
@@ -2450,8 +2473,8 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         request = api_pb2.FunctionCallCancelRequest(
             function_call_id=self.object_id, terminate_containers=terminate_containers
         )
-        assert self._client and self._client.stub
-        await self._client.stub.FunctionCallCancel(request)
+        assert self._client and self._client._stub
+        await self._client._stub.FunctionCallCancel(request)
 
     @deprecate_aio_usage((2025, 11, 14), "FunctionCall.from_id")
     @classmethod

{modal-1.5.6.dev25 → modal-1.5.6.dev26}/modal/_image.py

@@ -438,7 +438,7 @@ async def _image_await_build_result(image_id: str, client: _Client) -> api_pb2.I
         nonlocal last_entry_id, result_response
 
         request = api_pb2.ImageJoinStreamingRequest(image_id=image_id, timeout=55, last_entry_id=last_entry_id)
-        async for response in client.stub.ImageJoinStreaming.unary_stream(request):
+        async for response in client._stub.ImageJoinStreaming.unary_stream(request):
             if response.entry_id:
                 last_entry_id = response.entry_id
             if response.result.status:
@@ -746,7 +746,7 @@ class _Image(_Object, type_prefix="im"):
                 allow_global_deployment=os.environ.get("MODAL_IMAGE_ALLOW_GLOBAL_DEPLOYMENT") == "1",
                 ignore_cache=config.get("ignore_cache"),
             )
-            resp = await load_context.client.stub.ImageGetOrCreate(req)
+            resp = await load_context.client._stub.ImageGetOrCreate(req)
             image_id = resp.image_id
             result: api_pb2.GenericResult
             metadata: api_pb2.ImageMetadata | None = None
@@ -1013,7 +1013,7 @@ class _Image(_Object, type_prefix="im"):
         _client = typing.cast(_Client, synchronizer._translate_in(client))
 
         async def _load(self: _Image, resolver: Resolver, load_context: LoadContext, existing_object_id: str | None):
-            resp = await load_context.client.stub.ImageFromId(api_pb2.ImageFromIdRequest(image_id=image_id))
+            resp = await load_context.client._stub.ImageFromId(api_pb2.ImageFromIdRequest(image_id=image_id))
             self._hydrate(resp.image_id, load_context.client, resp.metadata)
 
         rep = f"Image.from_id({image_id!r})"
@@ -2959,7 +2959,7 @@ class _Image(_Object, type_prefix="im"):
         request = api_pb2.ImageJoinStreamingRequest(
             image_id=self.object_id, timeout=55, last_entry_id=last_entry_id, include_logs_for_finished=True
         )
-        async for response in self.client.stub.ImageJoinStreaming.unary_stream(request):
+        async for response in self.client._stub.ImageJoinStreaming.unary_stream(request):
             if response.result.status:
                 return
             if response.entry_id:
@@ -2995,7 +2995,7 @@ class _Image(_Object, type_prefix="im"):
             req = api_pb2.ImageGetByTagRequest(
                 tag=_upgrade_image_name(name, fallback_environment_name=load_context.environment_name),
             )
-            response = await load_context.client.stub.ImageGetByTag(req)
+            response = await load_context.client._stub.ImageGetByTag(req)
             self._hydrate(response.image_id, load_context.client, None)
 
         rep = _Image._repr(name, environment_name)
@@ -3039,7 +3039,7 @@ class _Image(_Object, type_prefix="im"):
             fallback_environment_name=config.get("environment"),
         )
 
-        await _client.stub.ImagePublish(
+        await _client._stub.ImagePublish(
             api_pb2.ImagePublishRequest(
                 image_id=self._object_id,
                 allow_public=bool((experimental_options or {}).get("is_public", False)),
@@ -3074,7 +3074,7 @@ class _Image(_Object, type_prefix="im"):
 
         if self._build_steps is None:
             request = api_pb2.ImageBuildChainGetRequest(image_id=image_id)
-            response = await client.stub.ImageBuildChainGet(request)
+            response = await client._stub.ImageBuildChainGet(request)
             self._build_steps = list(response.build_steps)
         return _ImageLogQueryData(client, self._build_steps or [], image_id)
 

{modal-1.5.6.dev25 → modal-1.5.6.dev26}/modal/_logs.py

@@ -256,7 +256,7 @@ async def _refine_dense_ranges(
                     sandbox_id=filters.sandbox_id,
                     search_text=filters.search_text,
                 )
-                sub_resp = await client.stub.AppCountLogs(sub_req)
+                sub_resp = await client._stub.AppCountLogs(sub_req)
                 sub_ranges = _buckets_to_ranges(list(sub_resp.buckets), smaller_secs)
                 # Clamp the edge sub-ranges to the parent boundaries. Bucket
                 # alignment can make the first bucket begin before the parent
@@ -311,7 +311,7 @@ async def _fetch_interval(
         sandbox_id=filters.sandbox_id,
         search_text=filters.search_text,
     )
-    resp: api_pb2.AppFetchLogsResponse = await client.stub.AppFetchLogs(req)
+    resp: api_pb2.AppFetchLogsResponse = await client._stub.AppFetchLogs(req)
     return list(resp.batches)
 
 
@@ -365,7 +365,7 @@ async def tail_logs(
             sandbox_id=filters.sandbox_id,
             search_text=filters.search_text,
         )
-        resp = await client.stub.AppFetchLogs(req)
+        resp = await client._stub.AppFetchLogs(req)
         for batch in resp.batches:
             yield batch
         return
@@ -387,7 +387,7 @@ async def tail_logs(
             sandbox_id=filters.sandbox_id,
             search_text=filters.search_text,
         )
-        resp = await client.stub.AppFetchLogs(req)
+        resp = await client._stub.AppFetchLogs(req)
 
         total_items = sum(len(b.items) for b in resp.batches)
         if total_items >= n or lookback == _TAIL_LOOKBACKS[-1]:
@@ -433,7 +433,7 @@ async def fetch_logs(
         sandbox_id=filters.sandbox_id,
         search_text=filters.search_text,
     )
-    count_resp: api_pb2.AppCountLogsResponse = await client.stub.AppCountLogs(count_req)
+    count_resp: api_pb2.AppCountLogsResponse = await client._stub.AppCountLogs(count_req)
 
     ranges = _buckets_to_ranges(list(count_resp.buckets), bucket_secs)
     total_logs = sum(count for _, _, count in ranges)

{modal-1.5.6.dev25 → modal-1.5.6.dev26}/modal/_logs_manager.py

@@ -190,7 +190,7 @@ class _LogsManager:
             task_id=params.filters.task_id,
             sandbox_id=params.filters.sandbox_id,
         )
-        return params.client.stub.AppGetLogs.unary_stream(request)
+        return params.client._stub.AppGetLogs.unary_stream(request)
 
     def _stream_entries(self, batch: api_pb2.TaskLogsBatch, source_object_id: str):
         for item in batch.items:
@@ -544,7 +544,7 @@ class _FunctionCallLogsManager:
                     function_id=self._function_id,
                     function_call_id=params.filters.function_call_id,
                 )
-                response = await params.client.stub.FunctionCallGetInfo(request)
+                response = await params.client._stub.FunctionCallGetInfo(request)
                 return response.info
             except NotFoundError:
                 if i < 4: