modal 1.5.6.dev24__tar.gz → 1.5.6.dev25__tar.gz

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

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

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

@@ -9,7 +9,7 @@ if sys.version_info[:2] >= (3, 15):
 from modal_version import __version__
 
 try:
-    from . import billing, types
+    from . import billing, experimental, types
     from ._runtime.execution_context import current_function_call_id, current_input_id, interact, is_local
     from ._tunnel import Tunnel, forward
     from .app import App
@@ -96,6 +96,7 @@ __all__ = [
     "enable_output",
     "enter",
     "exit",
+    "experimental",
     "fastapi_endpoint",
     "forward",
     "is_local",

{modal-1.5.6.dev24 → modal-1.5.6.dev25}/modal/_traceback.py

@@ -123,13 +123,25 @@ def print_exception(exc: type[BaseException] | None, value: BaseException | None
         print(*notes, sep="\n", file=sys.stderr)  # noqa: T201
 
 
-def print_server_warnings(server_warnings: Iterable[api_pb2.Warning]):
+_server_warning_registry: dict[Any, Any] = {}
+SERVER_WARNING_REGISTRY_LIMIT = 2048
+
+
+def print_server_warning(message: str):
     """Issue a warning originating from the server with empty metadata about local origin.
 
     When using the Modal CLI, these warnings should get caught and coerced into Rich panels.
     """
+    if len(_server_warning_registry) > SERVER_WARNING_REGISTRY_LIMIT:
+        # Start over instead of going quiet: overflow costs a repeat, never a hidden warning.
+        _server_warning_registry.clear()
+    warnings.warn_explicit(message, ServerWarning, "<modal-server>", 0, registry=_server_warning_registry)
+
+
+def print_server_warnings(server_warnings: Iterable[api_pb2.Warning]):
+    """Issue warnings that the server attached to a response message."""
     for warning in server_warnings:
-        warnings.warn_explicit(warning.message, ServerWarning, "<modal-server>", 0)
+        print_server_warning(warning.message)
 
 
 # for some reason, the traceback cleanup here can't be moved into a context manager :(

{modal-1.5.6.dev24 → modal-1.5.6.dev25}/modal/_utils/grpc_utils.py

@@ -24,12 +24,13 @@ from grpclib.config import Configuration
 from grpclib.encoding.base import CodecBase, StatusDetailsCodecBase
 from grpclib.exceptions import StreamTerminatedError
 from grpclib.protocol import H2Protocol
+from h2.exceptions import ProtocolError as H2ProtocolError
 
 from modal.exception import ClientClosed, ConnectionError, NotFoundError
 from modal_proto import api_pb2
 from modal_version import __version__
 
-from .._traceback import suppress_tb_frame
+from .._traceback import print_server_warning, suppress_tb_frame
 from ..config import config
 from .async_utils import TaskContext, retry
 from .logger import logger
@@ -130,6 +131,24 @@ class ModalChannel(grpclib.client.Channel):
         return await super().__connect__()
 
     async def _create_connection(self) -> H2Protocol:
+        target = self._path if self.__use_unix_socket else f"{self.__target_host}:{self.__target_port}"
+        tls = self.__ssl_context is not None
+        started_at = time.monotonic()
+        # Logged before awaiting: a reconnect is invisible until it resolves, which
+        # can be long after the RPC waiting on it appears to hang.
+        logger.debug(f"Starting connection attempt to {target} (TLS={tls})")
+        try:
+            protocol = await self._open_connection()
+        except (asyncio.CancelledError, Exception) as exc:
+            outcome = "cancelled" if isinstance(exc, asyncio.CancelledError) else "failed"
+            elapsed = time.monotonic() - started_at
+            logger.debug(f"Connection attempt to {target} {outcome} after {elapsed:.3f}s: {exc!r}")
+            raise
+        elapsed = time.monotonic() - started_at
+        logger.debug(f"Connection to {target} established after {elapsed:.3f}s")
+        return protocol
+
+    async def _open_connection(self) -> H2Protocol:
         if self.__use_unix_socket:
             return await super()._create_connection()
 
@@ -308,6 +327,20 @@ def create_channel_config(*, sustained_keepalive: bool = False) -> grpclib.confi
     )
 
 
+# Header the server uses to attach a non-fatal message to any response, one entry per
+# percent-encoded warning. It rides in the trailing metadata, which grpclib also
+# surfaces for trailers-only responses, i.e. failed requests.
+SERVER_WARNING_HEADER = "x-modal-warning"
+
+
+def _issue_server_warnings(metadata: Any) -> None:
+    """Issue the warnings in a response's metadata, which `print_server_warning` deduplicates."""
+    for key, encoded_message in metadata.items():
+        if key != SERVER_WARNING_HEADER:
+            continue
+        print_server_warning(urllib.parse.unquote(encoded_message))
+
+
 def create_channel(
     server_url: str,
     metadata: dict[str, str] = {},
@@ -356,6 +389,12 @@ def create_channel(
 
     grpclib.events.listen(channel, grpclib.events.SendRequest, send_request)
 
+    # Surface warnings the server attached to any response on this channel.
+    async def recv_trailing_metadata(event: grpclib.events.RecvTrailingMetadata) -> None:
+        _issue_server_warnings(event.metadata)
+
+    grpclib.events.listen(channel, grpclib.events.RecvTrailingMetadata, recv_trailing_metadata)
+
     return channel
 
 
@@ -496,6 +535,8 @@ def process_exception_before_retry(
                 raise ConnectionError(str(exc))
             elif isinstance(exc, asyncio.TimeoutError):
                 raise ConnectionError(str(exc))
+            elif isinstance(exc, H2ProtocolError):
+                raise ConnectionError(str(exc))
             else:
                 raise exc
 
@@ -583,6 +624,7 @@ async def _retry_transient_errors(
             OSError,
             asyncio.TimeoutError,
             AttributeError,
+            H2ProtocolError,
         ) as exc:
             # Note that we only catch AttributeError to handle a specific case that works around a bug
             # in grpclib<=0.4.7. See above (search for `write_appdata`).

{modal-1.5.6.dev24 → modal-1.5.6.dev25}/modal/_utils/task_command_router_client.py

@@ -89,6 +89,11 @@ def _parse_jwt_expiration(jwt_token: str) -> float | None:
     return None
 
 
+# Enough consecutive failures to distinguish a connection that keeps breaking from
+# an isolated blip, without leaving a stuck call silent for long.
+RETRY_WARNING_THRESHOLD = 3
+
+
 async def call_with_retries_on_transient_errors(
     func,
     *,
@@ -97,6 +102,9 @@ async def call_with_retries_on_transient_errors(
     max_retries: int | None = 10,
     exclude_status_codes: list[Status] | None = None,
     timeout_deadline: float | None = None,
+    rpc_name: str = "RPC",
+    exec_id: str | None = None,
+    warning_message: str | None = None,
 ):
     """Call func() with transient error retries and exponential backoff.
 
@@ -113,10 +121,18 @@ async def call_with_retries_on_transient_errors(
             exception (e.g., into a TimeoutError) based on the deadline check.
             The caller is also responsible for propagating the remaining budget
             into `func()` (typically as the per-call gRPC timeout).
+        rpc_name: RPC name to include in retry diagnostics.
+        exec_id: Execution ID to include in retry diagnostics, for correlating
+            the retries of concurrent executions.
+        warning_message: Optional warning to emit once after
+            RETRY_WARNING_THRESHOLD consecutive non-timeout failures.
     """
     delay_secs = base_delay_secs
     num_retries = 0
+    consecutive_failures = 0
+    warned = False
     exclude_status_codes = exclude_status_codes or []
+    called_for = f" for exec {exec_id}" if exec_id is not None else ""
 
     def is_retryable_status(status: Status) -> bool:
         return status in RETRYABLE_GRPC_STATUS_CODES and status not in exclude_status_codes
@@ -128,25 +144,41 @@ async def call_with_retries_on_transient_errors(
             return False
         return True
 
-    async def sleep_and_advance(e: Exception):
-        nonlocal delay_secs, num_retries
+    async def sleep_and_advance(e: Exception, *, count_failure: bool = True):
+        nonlocal delay_secs, num_retries, consecutive_failures, warned
         # Clamp the backoff sleep to the remaining deadline so we don't sleep
         # past it just to fail on the next iteration's deadline check.
         sleep_for = delay_secs
         if timeout_deadline is not None:
             sleep_for = min(sleep_for, max(0.0, timeout_deadline - time.monotonic()))
-        logger.debug(f"Retrying RPC with delay {sleep_for}s due to error: {e}")
+        elapsed = time.monotonic() - attempt_started_at
+        logger.debug(
+            f"{rpc_name}{called_for} attempt {num_retries + 1} failed after {elapsed:.3f}s, "
+            f"retrying in {sleep_for}s: {e!r}"
+        )
+        if count_failure:
+            consecutive_failures += 1
+            if warning_message is not None and consecutive_failures >= RETRY_WARNING_THRESHOLD and not warned:
+                logger.warning(
+                    f"{warning_message} Retrying after {consecutive_failures} consecutive failures. "
+                    "Set MODAL_LOGLEVEL=DEBUG for details."
+                )
+                warned = True
+        else:
+            consecutive_failures = 0
         await asyncio.sleep(sleep_for)
         delay_secs *= delay_factor
         num_retries += 1
 
     while True:
+        attempt_started_at = time.monotonic()
         try:
             return await func()
         except GRPCError as e:
             if not is_retryable_status(e.status) or not can_retry():
                 raise
-            await sleep_and_advance(e)
+            # Long-poll deadlines can expire while the process is still running on a healthy connection.
+            await sleep_and_advance(e, count_failure=e.status != Status.DEADLINE_EXCEEDED)
         except AttributeError as e:
             # StreamTerminatedError are not properly raised in grpclib<=0.4.7
             # fixed in https://github.com/vmagamedov/grpclib/issues/185
@@ -165,7 +197,9 @@ async def call_with_retries_on_transient_errors(
                 # `timeout_deadline` can further translate this based on
                 # whether the deadline has elapsed.
                 raise ConnectionError(str(e))
-            await sleep_and_advance(e)
+            # A client-side timeout says nothing about the connection's health, so it
+            # doesn't count toward the warning.
+            await sleep_and_advance(e, count_failure=not isinstance(e, asyncio.TimeoutError))
 
 
 _StdioReq = TypeVar("_StdioReq")
@@ -828,6 +862,12 @@ class TaskCommandRouterClient:
                         #   infinitely retry. For callers without an exec deadline, this
                         #   could hang indefinitely.
                         lambda: self._call_with_auth_retry(self._stub.TaskExecWait, request, timeout=60),
+                        rpc_name="TaskExecWait",
+                        exec_id=exec_id,
+                        warning_message=(
+                            f"Cannot retrieve the exit status for exec {exec_id} due to connection or service errors. "
+                            "The command may have already exited."
+                        ),
                         base_delay_secs=1,  # Retry after 1s since total time is expected to be long.
                         delay_factor=1,  # Fixed delay.
                         max_retries=None,  # Retry forever.

{modal-1.5.6.dev24 → modal-1.5.6.dev25}/modal/cli/token.py

@@ -6,6 +6,7 @@ from datetime import datetime
 import click
 
 from modal._utils.async_utils import synchronizer
+from modal._utils.time_utils import parse_duration
 from modal.client import _Client
 from modal.output import OutputManager
 from modal.token_flow import _new_token, _set_token
@@ -45,11 +46,28 @@ async def set(
 @token_cli.command("new")
 @click.option("--activate/--no-activate", default=True, help=_ACTIVATE_HELP)
 @click.option("--verify/--no-verify", default=True, help=_VERIFY_HELP)
+@click.option(
+    "--expires-in",
+    default=None,
+    help="Lifetime of the new token, e.g. 12h, 7d, or 90d. Defaults to the workspace's maximum allowed lifetime.",
+)
 @click.option("--source", default=None, hidden=True)
 @synchronizer.create_blocking
-async def new(activate: bool, verify: bool, source: str | None):
+async def new(activate: bool, verify: bool, expires_in: str | None, source: str | None):
     """Create a new token by using an authenticated web session."""
-    await _new_token(activate=activate, verify=verify, source=source)
+    expires_in_seconds: int | None = None
+    if expires_in is not None:
+        try:
+            expires_in_seconds = int(parse_duration(expires_in).total_seconds())
+        except (OverflowError, ValueError):
+            raise click.BadParameter(
+                "Expected a duration such as 30m, 12h, or 7d.", param_hint="--expires-in"
+            ) from None
+        if expires_in_seconds <= 0:
+            raise click.BadParameter("Duration must be positive.", param_hint="--expires-in")
+        if expires_in_seconds > 2**32 - 1:
+            raise click.BadParameter("Duration is too large.", param_hint="--expires-in")
+    await _new_token(activate=activate, verify=verify, source=source, expires_in_seconds=expires_in_seconds)
 
 
 @token_cli.command("info")

{modal-1.5.6.dev24 → modal-1.5.6.dev25}/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.dev24",
+        version: str = "1.5.6.dev25",
         *,
         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.dev24",
+        version: str = "1.5.6.dev25",
         *,
         oauth_credentials: typing.Optional[_OAuthCredentials] = None,
     ):

{modal-1.5.6.dev24 → modal-1.5.6.dev25}/modal/secret.py

@@ -242,6 +242,7 @@ class _Secret(_Object, type_prefix="st"):
     """
 
     _metadata: api_pb2.SecretMetadata | None = None
+    _keys: set[str] | None = None
     _load_env_dict: Callable[[], dict[str, str]] | None = None
 
     @classproperty
@@ -253,16 +254,35 @@ class _Secret(_Object, type_prefix="st"):
     def name(self) -> str | None:
         return self._name
 
+    async def _refresh_metadata(self):
+        # Not using @live_method because if we are dehydrated, the act of hydration will refresh
+        # metadata anyway, so we don't need to do the SecretGetInfo rpc
+        if not self._is_hydrated:
+            await self.hydrate()
+            return
+
+        req = api_pb2.SecretGetInfoRequest(secret_id=self.object_id)
+        response = await self.client.stub.SecretGetInfo(req)
+        self._hydrate(self.object_id, self.client, response.metadata)
+
     def _hydrate_metadata(self, metadata: Message | None):
         if metadata:
             assert isinstance(metadata, api_pb2.SecretMetadata)
             self._metadata = metadata
             self._name = metadata.name
+            self._keys = set(metadata.keys)
 
     def _get_metadata(self) -> api_pb2.SecretMetadata:
         assert self._metadata
         return self._metadata
 
+    async def _get_keys(self, *, refresh: bool = False) -> set[str]:
+        if refresh or self._keys is None:
+            await self._refresh_metadata()
+
+        assert self._keys is not None
+        return set(self._keys)
+
     @property
     def _is_ephemeral(self) -> bool:
         """Whether this Secret is backed by a locally-resolvable env dict rather than a named deployment.
@@ -307,9 +327,12 @@ class _Secret(_Object, type_prefix="st"):
 
         rep = f"Secret.from_dict([{', '.join(env_dict.keys())}])"
         # TODO: scoping - these should probably not be lazily hydrated without having an app and/or sandbox association
-        return _Secret._from_load_env_dict(
+        obj = _Secret._from_load_env_dict(
             _load_env_dict, rep, hydrate_lazily=True, load_context_overrides=LoadContext.empty()
         )
+        obj._keys = set(env_dict_filtered.keys())
+
+        return obj
 
     @staticmethod
     def from_local_environ(
@@ -458,6 +481,45 @@ class _Secret(_Object, type_prefix="st"):
             skip_reload=True,
         )
 
+    @staticmethod
+    def _from_id(secret_id: str, *, client: _Client | None = None):
+        """mdmd:hidden
+
+        Reference a Secret by ID.
+
+        Hydration is lazy until the Secret is used.
+
+        Args:
+            secret_id: ID of the Secret.
+            client: Modal client to use for loading; defaults to `Client.from_env()` when omitted.
+
+        Returns:
+            A `Secret` handle (possibly not yet hydrated).
+
+        Examples:
+            ```python
+            secret = modal.Secret._from_id("st-1234")
+
+            @app.function(secrets=[secret])
+            def run():
+                ...
+            ```
+        """
+
+        async def _load(self: _Secret, resolver: Resolver, load_context: LoadContext, existing_object_id: str | None):
+            req = api_pb2.SecretGetInfoRequest(secret_id=secret_id)
+            response = await load_context.client.stub.SecretGetInfo(req)
+            self._hydrate(secret_id, load_context.client, response.metadata)
+
+        rep = f"modal.Secret.from_id({secret_id!r})"
+        return _Secret._from_loader(
+            _load,
+            rep,
+            hydrate_lazily=True,
+            load_context_overrides=LoadContext(client=client),
+            skip_reload=True,
+        )
+
     @staticmethod
     async def _create_deployed(
         deployment_name: str,
@@ -493,6 +555,7 @@ class _Secret(_Object, type_prefix="st"):
             name=metadata.name or None,
             created_at=timestamp_to_localized_dt(creation_info.created_at),
             created_by=creation_info.created_by or None,
+            environment_name=metadata.environment_name,
         )
 
     @live_method
@@ -511,8 +574,13 @@ class _Secret(_Object, type_prefix="st"):
             raise InvalidError(err)
         updates = [api_pb2.SecretUpdateRequest.Update(key=k, value=v) for k, v in env_dict.items()]
         req = api_pb2.SecretUpdateRequest(secret_id=self.object_id, updates=updates)
+
         await self.client.stub.SecretUpdate(req)
 
+        # Since we are hydrated at this point, this will never be None
+        assert self._keys is not None
+        self._keys = self._keys | set(env_dict.keys())
+
 
 def _split_env_dict_and_resolvable_secrets(secrets: list[_Secret]) -> tuple[dict[str, str], list[_Secret]]:
     """Split secrets into secrets that can be resolved locally and secrets that are remote.

{modal-1.5.6.dev24 → modal-1.5.6.dev25}/modal/secret.pyi

@@ -423,6 +423,7 @@ class _Secret(modal._object._Object):
     """
 
     _metadata: typing.Optional[modal_proto.api_pb2.SecretMetadata]
+    _keys: typing.Optional[set[str]]
     _load_env_dict: typing.Optional[collections.abc.Callable[[], dict[str, str]]]
 
     @synchronicity.classproperty
@@ -430,8 +431,10 @@ class _Secret(modal._object._Object):
     def objects(cls) -> _SecretManager: ...
     @property
     def name(self) -> typing.Optional[str]: ...
+    async def _refresh_metadata(self): ...
     def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
     def _get_metadata(self) -> modal_proto.api_pb2.SecretMetadata: ...
+    async def _get_keys(self, *, refresh: bool = False) -> set[str]: ...
     @property
     def _is_ephemeral(self) -> bool:
         """Whether this Secret is backed by a locally-resolvable env dict rather than a named deployment.
@@ -542,6 +545,32 @@ class _Secret(modal._object._Object):
         """
         ...
 
+    @staticmethod
+    def _from_id(secret_id: str, *, client: typing.Optional[modal.client._Client] = None):
+        """mdmd:hidden
+
+        Reference a Secret by ID.
+
+        Hydration is lazy until the Secret is used.
+
+        Args:
+            secret_id: ID of the Secret.
+            client: Modal client to use for loading; defaults to `Client.from_env()` when omitted.
+
+        Returns:
+            A `Secret` handle (possibly not yet hydrated).
+
+        Examples:
+            ```python
+            secret = modal.Secret._from_id("st-1234")
+
+            @app.function(secrets=[secret])
+            def run():
+                ...
+            ```
+        """
+        ...
+
     @staticmethod
     async def _create_deployed(
         deployment_name: str,
@@ -584,6 +613,7 @@ class Secret(modal.object.Object):
     """
 
     _metadata: typing.Optional[modal_proto.api_pb2.SecretMetadata]
+    _keys: typing.Optional[set[str]]
     _load_env_dict: typing.Optional[collections.abc.Callable[[], dict[str, str]]]
 
     def __init__(self, *args, **kwargs):
@@ -595,8 +625,22 @@ class Secret(modal.object.Object):
     def objects(cls) -> SecretManager: ...
     @property
     def name(self) -> typing.Optional[str]: ...
+
+    class ___refresh_metadata_spec(typing_extensions.Protocol):
+        def __call__(self, /): ...
+        async def aio(self, /): ...
+
+    _refresh_metadata: ___refresh_metadata_spec
+
     def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
     def _get_metadata(self) -> modal_proto.api_pb2.SecretMetadata: ...
+
+    class ___get_keys_spec(typing_extensions.Protocol):
+        def __call__(self, /, *, refresh: bool = False) -> set[str]: ...
+        async def aio(self, /, *, refresh: bool = False) -> set[str]: ...
+
+    _get_keys: ___get_keys_spec
+
     @property
     def _is_ephemeral(self) -> bool:
         """Whether this Secret is backed by a locally-resolvable env dict rather than a named deployment.
@@ -707,6 +751,32 @@ class Secret(modal.object.Object):
         """
         ...
 
+    @staticmethod
+    def _from_id(secret_id: str, *, client: typing.Optional[modal.client.Client] = None):
+        """mdmd:hidden
+
+        Reference a Secret by ID.
+
+        Hydration is lazy until the Secret is used.
+
+        Args:
+            secret_id: ID of the Secret.
+            client: Modal client to use for loading; defaults to `Client.from_env()` when omitted.
+
+        Returns:
+            A `Secret` handle (possibly not yet hydrated).
+
+        Examples:
+            ```python
+            secret = modal.Secret._from_id("st-1234")
+
+            @app.function(secrets=[secret])
+            def run():
+                ...
+            ```
+        """
+        ...
+
     class ___create_deployed_spec(typing_extensions.Protocol):
         def __call__(
             self,

{modal-1.5.6.dev24 → modal-1.5.6.dev25}/modal/token_flow.py

@@ -23,7 +23,7 @@ class _TokenFlow:
 
     @asynccontextmanager
     async def start(
-        self, utm_source: str | None = None, next_url: str | None = None
+        self, utm_source: str | None = None, next_url: str | None = None, expires_in_seconds: int | None = None
     ) -> AsyncGenerator[tuple[str, str, str], None]:
         """mdmd:hidden"""
         # Run a temporary http server returning the token id on /
@@ -41,6 +41,7 @@ class _TokenFlow:
                 utm_source=utm_source or "",
                 next_url=next_url or "",
                 localhost_port=int(url.split(":")[-1]),
+                expires_in_seconds=expires_in_seconds or 0,
             )
             resp = await self.stub.TokenFlowCreate(req)
             self.token_flow_id = resp.token_flow_id
@@ -72,6 +73,7 @@ async def _new_token(
     verify: bool = True,
     source: str | None = None,
     next_url: str | None = None,
+    expires_in_seconds: int | None = None,
 ):
     server_url = config.get("server_url", profile=profile)
 
@@ -80,7 +82,7 @@ async def _new_token(
     async with _Client.anonymous(server_url) as client:
         token_flow = _TokenFlow(client)
 
-        async with token_flow.start(source, next_url) as (_, web_url, code):
+        async with token_flow.start(source, next_url, expires_in_seconds) as (_, web_url, code):
             with output.status("Waiting for authentication in the web browser"):
                 # Open the web url in the browser
                 if open_url(web_url):

{modal-1.5.6.dev24 → modal-1.5.6.dev25}/modal/token_flow.pyi

@@ -10,7 +10,10 @@ class _TokenFlow:
         ...
 
     def start(
-        self, utm_source: typing.Optional[str] = None, next_url: typing.Optional[str] = None
+        self,
+        utm_source: typing.Optional[str] = None,
+        next_url: typing.Optional[str] = None,
+        expires_in_seconds: typing.Optional[int] = None,
     ) -> typing.AsyncContextManager[tuple[str, str, str]]:
         """mdmd:hidden"""
         ...
@@ -26,13 +29,21 @@ class TokenFlow:
 
     class __start_spec(typing_extensions.Protocol):
         def __call__(
-            self, /, utm_source: typing.Optional[str] = None, next_url: typing.Optional[str] = None
+            self,
+            /,
+            utm_source: typing.Optional[str] = None,
+            next_url: typing.Optional[str] = None,
+            expires_in_seconds: typing.Optional[int] = None,
         ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[tuple[str, str, str]]:
             """mdmd:hidden"""
             ...
 
         def aio(
-            self, /, utm_source: typing.Optional[str] = None, next_url: typing.Optional[str] = None
+            self,
+            /,
+            utm_source: typing.Optional[str] = None,
+            next_url: typing.Optional[str] = None,
+            expires_in_seconds: typing.Optional[int] = None,
         ) -> typing.AsyncContextManager[tuple[str, str, str]]:
             """mdmd:hidden"""
             ...
@@ -61,6 +72,7 @@ async def _new_token(
     verify: bool = True,
     source: typing.Optional[str] = None,
     next_url: typing.Optional[str] = None,
+    expires_in_seconds: typing.Optional[int] = None,
 ): ...
 async def _set_token(
     token_id: str,

{modal-1.5.6.dev24 → modal-1.5.6.dev25}/modal/types.py

@@ -108,6 +108,7 @@ class SecretInfo:
     # since it is transmitted from the server when the object is hydrated and could be stale when accessed.
 
     name: str | None
+    environment_name: str
     created_at: datetime
     created_by: str | None
 

{modal-1.5.6.dev24 → modal-1.5.6.dev25}/modal.egg-info/PKG-INFO

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