modal 1.5.6.dev5__tar.gz → 1.5.6.dev7__tar.gz

{modal-1.5.6.dev5 → modal-1.5.6.dev7}/PKG-INFO

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

{modal-1.5.6.dev5 → modal-1.5.6.dev7}/modal/_function_variants.py

@@ -4,6 +4,7 @@ from collections.abc import Collection, Sequence, Sized
 from pathlib import PurePosixPath
 from typing import TYPE_CHECKING, Any
 
+from modal.types import CloudBucketMountInfo, FunctionInfo, VolumeMountInfo
 from modal_proto import api_pb2
 
 from ._resources import convert_fn_config_to_resources_config
@@ -248,6 +249,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
 
         if parameter_schema is None:
@@ -278,6 +280,12 @@ def _make_function_variant(
         response = await _function_bind_params_cached(base_function, req)
         function_variant._hydrate(response.bound_function_id, base_function._client, response.handle_metadata)
 
+        if base_function._function_info is not None:
+            if options is not None:
+                function_variant._function_info = _get_function_info_with_options(base_function._function_info, options)
+            else:
+                function_variant._function_info = base_function._function_info._get_copy()
+
     def _deps():
         if options:
             return options._unhydrated_object_deps()
@@ -292,4 +300,73 @@ def _make_function_variant(
     )
     fun._source_info = base_function._source_info
     fun._spec = base_function._spec  # TODO (elias): fix - this is incorrect when using with_options
+
+    # If we already have a ._function_info for the base function, we can pass it down - otherwise this
+    # will be filled in during hydration
+    if base_function._function_info is not None:
+        if options is not None:
+            fun._function_info = _get_function_info_with_options(base_function._function_info, options)
+        else:
+            fun._function_info = base_function._function_info._get_copy()
+
     return fun
+
+
+def _get_function_info_with_options(info: FunctionInfo, options: _FunctionOptions):
+    new_info = info._get_copy()
+
+    if options.resources is not None:
+        res = options.resources
+        if res.milli_cpu_max > 0:
+            new_info.cpu = (res.milli_cpu / 1000, res.milli_cpu_max / 1000)
+        elif res.milli_cpu > 0:
+            new_info.cpu = res.milli_cpu / 1000
+
+        if res.memory_mb_max > 0:
+            new_info.memory_mib = (res.memory_mb, res.memory_mb_max)
+        elif res.memory_mb > 0:
+            new_info.memory_mib = res.memory_mb
+
+        if res.HasField("gpu_config") and res.gpu_config.count > 0:
+            new_info.gpus = [(res.gpu_config.count, res.gpu_config.gpu_type)]
+
+        if res.ephemeral_disk_mb > 0:
+            new_info.ephemeral_disk_mib = res.ephemeral_disk_mb
+
+    if options.scheduler_placement is not None:
+        sp = options.scheduler_placement
+        # Note: not putting `nonpreemptible` here as that is not currently possible to set via
+        # `.with_options(...)`
+        if len(sp.regions) > 0:
+            new_info.regions = list(sp.regions)
+
+    if options.cloud is not None:
+        new_info.cloud = options.cloud
+
+    if len(options.validated_volumes) > 0:
+        new_info.volumes = {
+            mount_path: VolumeMountInfo(vol._name, vol._object_id, False, None)
+            if vol._mount_options is None
+            else VolumeMountInfo(
+                vol._name,
+                vol._object_id,
+                vol._mount_options.read_only,
+                vol._mount_options.sub_path,
+            )
+            for mount_path, vol in options.validated_volumes
+        }
+
+    if len(options.cloud_bucket_mounts) > 0:
+        new_info.cloud_bucket_mounts = {}
+        protos, _ = cloud_bucket_mounts_to_proto(options.cloud_bucket_mounts, include_secrets=False)
+
+        for proto in protos:
+            new_info.cloud_bucket_mounts[proto.mount_path] = CloudBucketMountInfo._from_proto(proto)
+
+    if len(options.secrets) > 0:
+        new_info.secrets = [repr(s) for s in options.secrets]
+
+    if options.routing_region:
+        new_info.routing_region = options.routing_region
+
+    return new_info

{modal-1.5.6.dev5 → modal-1.5.6.dev7}/modal/_functions.py

@@ -16,6 +16,7 @@ from google.protobuf.message import Message
 from grpclib import Status
 from synchronicity.combined_types import MethodWithAio
 
+from modal.types import CloudBucketMountInfo, FunctionInfo, HttpInfo, VolumeMountInfo
 from modal_proto import api_pb2
 from modal_proto.modal_api_grpc import ModalClientModal
 
@@ -56,6 +57,7 @@ from ._utils.function_utils import (
     _process_result,
     _stream_function_call_data,
     get_function_type,
+    get_schedule_str,
     is_async,
     normalize_fractional_target_concurrency,
     parse_gpu_config,
@@ -636,6 +638,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     _options: _FunctionOptions
     _base_function: "_Function | None" = None
     _app_id: str | None = None
+    _function_info: FunctionInfo | None = None
 
     async def _get_log_query_data(self) -> _LogQueryData:
         await self.hydrate()
@@ -1158,6 +1161,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             serve_mounts = {m for m in all_mounts if m.is_local()}
             serve_mounts |= image._serve_mounts
             obj._serve_mounts = frozenset(serve_mounts)
+            obj._function_info = FunctionInfo._from_function_proto(response.function_data)
+
             self._hydrate(response.function_id, load_context.client, response.handle_metadata)
 
         rep = f"Function({tag})"
@@ -1193,6 +1198,36 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             obj._build_args["cloud"] = repr(cloud)
             obj._build_args["scheduler_placement"] = repr(scheduler_placement)
 
+        obj._function_info = FunctionInfo(
+            cpu=cpu,
+            memory_mib=memory,
+            gpus=[(parsed.count, parsed.gpu_type) for parsed in (parse_gpu_config(g) for g in gpus)],
+            ephemeral_disk_mib=ephemeral_disk,
+            nonpreemptible=nonpreemptible,
+            regions=None if region is None else [region] if isinstance(region, str) else list(region),
+            routing_region=routing_region,
+            cloud=cloud,
+            schedule=None if schedule is None else get_schedule_str(schedule.proto_message),
+            volumes={
+                mount_path: VolumeMountInfo(vol._name, vol._object_id, False, None)
+                if vol._mount_options is None
+                else VolumeMountInfo(
+                    vol._name,
+                    vol._object_id,
+                    vol._mount_options.read_only,
+                    vol._mount_options.sub_path,
+                )
+                for mount_path, vol in validated_volumes_no_cloud_buckets
+            },
+            cloud_bucket_mounts={
+                cbm.mount_path: CloudBucketMountInfo._from_proto(cbm)
+                for cbm in cloud_bucket_mounts_to_proto(cloud_bucket_mounts, include_secrets=False)[0]
+            },
+            # 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,
+        )
+
         return obj
 
     from_local = with_deprecation_warning(
@@ -1332,6 +1367,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             print_server_warnings(response.server_warnings)
 
             self._hydrate(response.function_id, load_context.client, response.handle_metadata)
+            self._function_info = FunctionInfo._from_function_proto(response.function)
 
         environment_rep = (
             f", environment_name={load_context_overrides.environment_name!r}"
@@ -1424,14 +1460,44 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         # Deprecated soon, only for backwards compatibility
         return self.app
 
-    @property
-    @with_deprecation_warning(
-        (2026, 8, 26),
-        "`Function.info` is deprecated and will be removed in `modal` version 1.6.0",
-    )
-    def info(self) -> FunctionSourceInfo:
-        """mdmd:hidden"""
-        return self._source_info_
+    async def info(self, *, refresh: bool = False) -> FunctionInfo:
+        """Get an overview of a Function's resource requests, associated mounts, etc.
+
+        This method performs a network request to populate this information if the Function handle is
+        a remote lookup whose information has not yet been fetched (e.g. from `Function.from_name(...)`),
+        or if `refresh=True`.
+
+        Args:
+            refresh: Always perform a network request. Pass `refresh=True` to ensure that this method
+                returns the most up to date information.
+
+        Returns:
+            This returns a [`modal.types.FunctionInfo`](https://modal.com/docs/sdk/py/latest/types#FunctionInfo)
+            dataclass.
+        """
+
+        if self._function_info is not None and not refresh:
+            return self._function_info
+
+        # For some constructors, e.g. Function.from_name(), hydration will set self._function_info
+        if not self._is_hydrated:
+            await self.hydrate()
+
+        # Other constructors, such as `Function._new_hydrated()`, don't set self._function_info on
+        # hydration, so we have to do an RPC to get that information
+        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(
+                api_pb2.FunctionGetByIdRequest(
+                    function_id=self.object_id,
+                )
+            )
+
+            self._function_info = FunctionInfo._from_function_proto(response.function)
+
+        assert self._function_info is not None
+        return self._function_info._get_copy()
 
     @property
     def _source_info_(self) -> FunctionSourceInfo:

{modal-1.5.6.dev5 → modal-1.5.6.dev7}/modal/_object.py

@@ -358,6 +358,7 @@ class _Object:
 
         *Added in v0.72.39*: This method replaces the deprecated `.resolve()` method.
         """
+
         # TODO: add deprecation for the client argument here - should be added in constructors instead
         if self._is_hydrated:
             if self.client._snapshotted and not self._is_rehydrated:
@@ -388,4 +389,5 @@ class _Object:
                 root_load_context = LoadContext(client=client, task_context=tc)
                 with suppress_tb_frame():  # skip this frame by default
                     await resolver.load(self, root_load_context)
+
         return self

{modal-1.5.6.dev5 → modal-1.5.6.dev7}/modal/_utils/function_utils.py

@@ -668,3 +668,32 @@ def parse_gpu_config(value: str | None) -> api_pb2.GPUConfig:
         return api_pb2.GPUConfig(gpu_type=gpu_type, count=count)
     else:
         raise InvalidError(f"Invalid GPU config: {value!r}. Value must be a string or `None`")
+
+
+def get_schedule_str(schedule: api_pb2.Schedule) -> str | None:
+    if schedule.WhichOneof("schedule_oneof") is None:
+        return None
+
+    if schedule.WhichOneof("schedule_oneof") == "cron":
+        cron = schedule.cron
+        return f"Cron({cron.cron_string!r}, {cron.timezone})"
+
+    period = schedule.period
+
+    period_args = []
+    if period.years > 0:
+        period_args.append(f"years={period.years}")
+    if period.months > 0:
+        period_args.append(f"months={period.months}")
+    if period.weeks > 0:
+        period_args.append(f"weeks={period.weeks}")
+    if period.days > 0:
+        period_args.append(f"days={period.days}")
+    if period.hours > 0:
+        period_args.append(f"hours={period.hours}")
+    if period.minutes > 0:
+        period_args.append(f"minutes={period.minutes}")
+    if period.seconds > 0:
+        period_args.append(f"seconds={period.seconds}")
+
+    return f"Period({', '.join(period_args)})"

{modal-1.5.6.dev5 → modal-1.5.6.dev7}/modal/_utils/grpc_utils.py

@@ -272,18 +272,34 @@ class CustomProtoStatusDetailsCodec(StatusDetailsCodecBase):
 custom_detail_codec = CustomProtoStatusDetailsCodec()
 
 
-def create_channel_config() -> grpclib.config.Configuration:
+def create_channel_config(*, sustained_keepalive: bool = False) -> grpclib.config.Configuration:
     """Shared grpclib channel settings for Modal client connections.
 
     HTTP/2 keepalive probes keep idle transports warm through stateful
     middleboxes and surface dead connections before retries reuse them.
+
+    `sustained_keepalive` clears the two grpclib defaults such that a probe
+    actually goes out every `_keepalive_time`, for as long as the connection is
+    open.
     """
+    ping_throttle_overrides: dict[str, Any] = {}
+    if sustained_keepalive:
+        ping_throttle_overrides = {
+            # Default 2: probing stops after two probes with no request sent in
+            # between. Requests reset the count, acks don't. 0 = no cap.
+            "_http2_max_pings_without_data": 0,
+            # Default 300s floor between probes, applied regardless of data
+            # despite the name, so it has to stay under `_keepalive_time`.
+            "_http2_min_sent_ping_interval_without_data": GRPC_KEEPALIVE_TIME_SECS / 2,
+        }
+
     return grpclib.config.Configuration(
         _keepalive_time=GRPC_KEEPALIVE_TIME_SECS,
         _keepalive_timeout=GRPC_KEEPALIVE_TIMEOUT_SECS,
         _keepalive_permit_without_calls=True,
         http2_connection_window_size=GRPC_WINDOW_SIZE,
         http2_stream_window_size=GRPC_WINDOW_SIZE,
+        **ping_throttle_overrides,
     )
 
 

{modal-1.5.6.dev5 → modal-1.5.6.dev7}/modal/_utils/task_command_router_client.py

@@ -251,7 +251,7 @@ class TaskCommandRouterClient:
             host,
             port,
             ssl=ssl_context,
-            config=create_channel_config(),
+            config=create_channel_config(sustained_keepalive=True),
             closed_error_message="Unable to perform operation on a detached sandbox",
         )
 

{modal-1.5.6.dev5 → modal-1.5.6.dev7}/modal/app.py

@@ -56,6 +56,7 @@ from .retries import Retries
 from .running_app import RunningApp
 from .schedule import Schedule
 from .secret import _Secret
+from .types import AppInfo
 from .volume import _Volume
 
 _default_image: _Image = _Image.debian_slim()
@@ -182,6 +183,7 @@ class _App:
     # Metadata for loading objects within this app
     # passed by reference to functions and classes so it can be updated by run()/deploy()
     _root_load_context: LoadContext
+    _info: AppInfo | None
 
     @property
     def _local_state(self) -> _LocalAppState:
@@ -366,6 +368,7 @@ class _App:
         app._client = client
         app._root_load_context = LoadContext(client=client, environment_name=environment_name, app_id=response.app_id)
         app._running_app = RunningApp(response.app_id, interactive=False)
+        app._info = AppInfo._from_proto(response.handle_metadata, response.app_id)
         return app
 
     async def get_dashboard_url(self) -> str:
@@ -1655,5 +1658,37 @@ class _App:
 
         return _AppLogsManager(self)
 
+    async def info(self, refresh: bool = False) -> AppInfo:
+        """Return information for a modal `App`.
+
+        The information returned includes the App's ID, member functions and servers,
+        as well as basic lifecycle information, e.g. who created the app and when.
+
+        Args:
+            refresh: Whether to fetch the latest info. By default, false, so
+                the info corresponds the App state at the time of the previous lookup.
+
+        See also:
+            - [`AppInfo`](https://modal.com/docs/sdk/py/latest/types#appinfo)
+
+        Returns:
+            `AppInfo` object.
+        """
+        if hasattr(self, "_info") and self._info and not refresh:
+            return AppInfo(
+                app_id=self._info.app_id,
+                description=self._info.description,
+                functions=self._info.functions,
+                servers=self._info.servers,
+                lifecycle=self._info.lifecycle,
+            )
+        if not self._app_id:
+            raise InvalidError("`app.info` requires a running or stopped app.")
+        request = api_pb2.AppGetInfoRequest(app_id=self._app_id)
+        client = self._client or await _Client.from_env()
+        resp = await client.stub.AppGetInfo(request)
+        self._info = AppInfo._from_proto(resp.info, self._app_id)
+        return self._info
+
 
 App = synchronize_api(_App)

{modal-1.5.6.dev5 → modal-1.5.6.dev7}/modal/app.pyi

@@ -20,6 +20,7 @@ import modal.running_app
 import modal.schedule
 import modal.secret
 import modal.server
+import modal.types
 import modal.volume
 import pathlib
 import synchronicity.combined_types
@@ -155,6 +156,7 @@ class _App:
     _running_app: typing.Optional[modal.running_app.RunningApp]
     _client: typing.Optional[modal.client._Client]
     _root_load_context: modal._load_context.LoadContext
+    _info: typing.Optional[modal.types.AppInfo]
 
     @property
     def _local_state(self) -> _LocalAppState:
@@ -940,6 +942,24 @@ class _App:
         """
         ...
 
+    async def info(self, refresh: bool = False) -> modal.types.AppInfo:
+        """Return information for a modal `App`.
+
+        The information returned includes the App's ID, member functions and servers,
+        as well as basic lifecycle information, e.g. who created the app and when.
+
+        Args:
+            refresh: Whether to fetch the latest info. By default, false, so
+                the info corresponds the App state at the time of the previous lookup.
+
+        See also:
+            - [`AppInfo`](https://modal.com/docs/sdk/py/latest/types#appinfo)
+
+        Returns:
+            `AppInfo` object.
+        """
+        ...
+
 SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
 
 class App:
@@ -983,6 +1003,7 @@ class App:
     _running_app: typing.Optional[modal.running_app.RunningApp]
     _client: typing.Optional[modal.client.Client]
     _root_load_context: modal._load_context.LoadContext
+    _info: typing.Optional[modal.types.AppInfo]
 
     def __init__(
         self,
@@ -2012,4 +2033,43 @@ class App:
         """
         ...
 
+    class __info_spec(typing_extensions.Protocol):
+        def __call__(self, /, refresh: bool = False) -> modal.types.AppInfo:
+            """Return information for a modal `App`.
+
+            The information returned includes the App's ID, member functions and servers,
+            as well as basic lifecycle information, e.g. who created the app and when.
+
+            Args:
+                refresh: Whether to fetch the latest info. By default, false, so
+                    the info corresponds the App state at the time of the previous lookup.
+
+            See also:
+                - [`AppInfo`](https://modal.com/docs/sdk/py/latest/types#appinfo)
+
+            Returns:
+                `AppInfo` object.
+            """
+            ...
+
+        async def aio(self, /, refresh: bool = False) -> modal.types.AppInfo:
+            """Return information for a modal `App`.
+
+            The information returned includes the App's ID, member functions and servers,
+            as well as basic lifecycle information, e.g. who created the app and when.
+
+            Args:
+                refresh: Whether to fetch the latest info. By default, false, so
+                    the info corresponds the App state at the time of the previous lookup.
+
+            See also:
+                - [`AppInfo`](https://modal.com/docs/sdk/py/latest/types#appinfo)
+
+            Returns:
+                `AppInfo` object.
+            """
+            ...
+
+    info: __info_spec
+
 _default_image: modal._image._Image

{modal-1.5.6.dev5 → modal-1.5.6.dev7}/modal/cli/app.py

@@ -4,6 +4,7 @@ import sys
 import time
 import warnings
 from datetime import datetime, timedelta, timezone
+from json import dumps
 from typing import Literal, get_args
 
 import click
@@ -709,3 +710,79 @@ async def dashboard(
     app_id, _, _ = await resolve_app_identifier(app_identifier, env, client)
     url = f"https://modal.com/id/{app_id}"
     open_url_and_display(url, "App dashboard")
+
+
+@app_cli.command("info", no_args_is_help=True)
+@click.argument("app_identifier")
+@env_option
+@click.option("--json", is_flag=True, default=False)
+@synchronizer.create_blocking
+async def info(app_identifier: str, *, env: str | None = None, json: bool = False):
+    """Show an App's lifecycle, Functions, and Servers.
+
+    Examples:
+
+    Get info based on an App ID:
+
+    ```
+    modal app info ap-123456
+    ```
+
+    Get info for a currently deployed App based on its name:
+
+    ```
+    modal app info my-app
+    ```
+
+    """
+    env = ensure_env(env)
+    client = await _Client.from_env()
+    app_id, _, _ = await resolve_app_identifier(app_identifier, env, client)
+    request = api_pb2.AppGetInfoRequest(app_id=app_id)
+    resp: api_pb2.AppGetInfoResponse = await client.stub.AppGetInfo(request)
+    app_info = resp.info
+    lifecycle = app_info.lifecycle
+    output = OutputManager.get()
+    state = APP_STATE_TO_MESSAGE.get(lifecycle.app_state, Text("unknown", style="gray"))
+
+    if json:
+        output.print_json(
+            dumps(
+                {
+                    "description": app_info.description,
+                    "app_id": app_info.app_id,
+                    "lifecycle": {
+                        "state": state.plain,
+                        "created_at": timestamp_to_localized_str(lifecycle.created_at, json),
+                        "created_by": lifecycle.created_by or None,
+                        "deployed_at": timestamp_to_localized_str(lifecycle.deployed_at, json),
+                        "deployed_by": lifecycle.deployed_by or None,
+                        "version": lifecycle.version or None,
+                        "stopped_at": timestamp_to_localized_str(lifecycle.stopped_at, json),
+                        "stopped_by": lifecycle.stopped_by or None,
+                    },
+                    "functions": dict(sorted(app_info.functions.items())),
+                    "servers": dict(sorted(app_info.servers.items())),
+                }
+            )
+        )
+        return
+
+    output.print(
+        Text.assemble("App: ", (app_info.app_id, "bold"), " - ", (app_info.description, "bold"), " (", state, ")")
+    )
+
+    if app_info.functions:
+        display_table(["Name", "Function ID"], sorted(app_info.functions.items()), title="Functions")
+    if app_info.servers:
+        display_table(["Name", "Function ID"], sorted(app_info.servers.items()), title="Servers")
+
+    events: list[list[Text | str | None]] = [
+        ["Created", timestamp_to_localized_str(lifecycle.created_at, json), lifecycle.created_by]
+    ]
+    if lifecycle.deployed_at:
+        label = f"Deployed (v{lifecycle.version})" if lifecycle.version else "Deployed"
+        events.append([label, timestamp_to_localized_str(lifecycle.deployed_at, json), lifecycle.deployed_by])
+    if lifecycle.stopped_at:
+        events.append(["Stopped", timestamp_to_localized_str(lifecycle.stopped_at, json), lifecycle.stopped_by])
+    display_table(["Event", "Time", "By"], events, title="Lifecycle")

{modal-1.5.6.dev5 → modal-1.5.6.dev7}/modal/client.pyi

@@ -77,7 +77,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.6.dev5",
+        version: str = "1.5.6.dev7",
         *,
         oauth_credentials: typing.Optional[_OAuthCredentials] = None,
     ):
@@ -277,7 +277,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.6.dev5",
+        version: str = "1.5.6.dev7",
         *,
         oauth_credentials: typing.Optional[_OAuthCredentials] = None,
     ):

{modal-1.5.6.dev5 → modal-1.5.6.dev7}/modal/cloud_bucket_mount.py

@@ -122,7 +122,9 @@ class _CloudBucketMount:
 
 
 def cloud_bucket_mounts_to_proto(
-    mounts: Sequence[tuple[str, _CloudBucketMount]], split_ephemeral_credentials: bool = False
+    mounts: Sequence[tuple[str, _CloudBucketMount]],
+    split_ephemeral_credentials: bool = False,
+    include_secrets: bool = True,
 ) -> tuple[list[api_pb2.CloudBucketMount], dict[str, api_pb2.StringMap]]:
     """mdmd:hidden
     Helper function to convert `CloudBucketMount` to a list of protobufs that can be passed to the server.
@@ -158,11 +160,11 @@ def cloud_bucket_mounts_to_proto(
             key_prefix = mount.key_prefix
 
         credentials_secret_id = ""
-        if secret := mount.secret:
+        if include_secrets and (secret := mount.secret):
             if split_ephemeral_credentials and secret._load_env_dict:
                 env_dict = secret._load_env_dict()
-                credientials = api_pb2.StringMap(contents=env_dict)
-                cloud_bucket_credentials[path] = credientials
+                credentials = api_pb2.StringMap(contents=env_dict)
+                cloud_bucket_credentials[path] = credentials
             else:
                 credentials_secret_id = secret.object_id
 

{modal-1.5.6.dev5 → modal-1.5.6.dev7}/modal/cloud_bucket_mount.pyi

@@ -126,7 +126,9 @@ class _CloudBucketMount:
         ...
 
 def cloud_bucket_mounts_to_proto(
-    mounts: collections.abc.Sequence[tuple[str, _CloudBucketMount]], split_ephemeral_credentials: bool = False
+    mounts: collections.abc.Sequence[tuple[str, _CloudBucketMount]],
+    split_ephemeral_credentials: bool = False,
+    include_secrets: bool = True,
 ) -> tuple[list[modal_proto.api_pb2.CloudBucketMount], dict[str, modal_proto.api_pb2.StringMap]]:
     """mdmd:hidden
     Helper function to convert `CloudBucketMount` to a list of protobufs that can be passed to the server.