modal 1.5.5.dev4__tar.gz → 1.5.5.dev6__tar.gz

{modal-1.5.5.dev4 → modal-1.5.5.dev6}/PKG-INFO

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

{modal-1.5.5.dev4 → modal-1.5.5.dev6}/modal/_environments.py

@@ -39,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
+        default_role: str | None = None,  # Default member Role for the Restricted Environment
         experimental_options: dict[str, Any] | None = None,  # Experimental options for Environment creation
         client: _Client | None = None,  # Optional client with Modal credentials
     ) -> None:
@@ -51,8 +52,11 @@ class _EnvironmentManager:
         ```
         """
         check_environment_name(name)
+
         client = await _Client.from_env() if client is None else client
         request = api_pb2.EnvironmentCreateRequest(name=name, is_managed=restricted)
+        if default_role:
+            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)

{modal-1.5.5.dev4 → modal-1.5.5.dev6}/modal/app.py

@@ -1579,33 +1579,6 @@ class _App:
         resp = await client.stub.AppGetTags(req)
         return dict(resp.tags)
 
-    async def _logs(self, client: _Client | None = None) -> AsyncGenerator[str, None]:
-        """Stream logs from the app.
-
-        This method is considered private and its interface may change - use at your own risk!
-        """
-        if not self._app_id:
-            raise InvalidError("`app._logs` requires a running/stopped app.")
-
-        client = client or self._client or await _Client.from_env()
-
-        last_log_batch_entry_id: str | None = None
-        while True:
-            request = api_pb2.AppGetLogsRequest(
-                app_id=self._app_id,
-                timeout=55,
-                last_entry_id=last_log_batch_entry_id,
-            )
-            async for log_batch in client.stub.AppGetLogs.unary_stream(request):
-                if log_batch.entry_id:
-                    # log_batch entry_id is empty for fd="server" messages from AppGetLogs
-                    last_log_batch_entry_id = log_batch.entry_id
-                if log_batch.app_done:
-                    return
-                for log in log_batch.items:
-                    if log.data:
-                        yield log.data
-
     @classmethod
     def _get_container_app(cls) -> "_App | None":
         """Returns the `App` running inside a container.
@@ -1621,7 +1594,7 @@ class _App:
     async def _get_log_query_data(self) -> _LogQueryData:
         """Get the data needed to query logs for this app."""
         if not self._app_id:
-            raise InvalidError("`app._logs` requires a running/stopped app.")
+            raise InvalidError("`app.logs` requires a running/stopped app.")
         client = self._client or await _Client.from_env()
         filters = LogsFilters()
         return _LogQueryData(client=client, app_id=self._app_id, filters=filters, source_object_id=self._app_id)

{modal-1.5.5.dev4 → modal-1.5.5.dev6}/modal/app.pyi

@@ -898,13 +898,6 @@ class _App:
         """
         ...
 
-    def _logs(self, client: typing.Optional[modal.client._Client] = None) -> collections.abc.AsyncGenerator[str, None]:
-        """Stream logs from the app.
-
-        This method is considered private and its interface may change - use at your own risk!
-        """
-        ...
-
     @classmethod
     def _get_container_app(cls) -> typing.Optional[_App]:
         """Returns the `App` running inside a container.
@@ -1960,25 +1953,6 @@ class App:
 
     get_tags: __get_tags_spec
 
-    class ___logs_spec(typing_extensions.Protocol):
-        def __call__(self, /, client: typing.Optional[modal.client.Client] = None) -> typing.Generator[str, None, None]:
-            """Stream logs from the app.
-
-            This method is considered private and its interface may change - use at your own risk!
-            """
-            ...
-
-        def aio(
-            self, /, client: typing.Optional[modal.client.Client] = None
-        ) -> collections.abc.AsyncGenerator[str, None]:
-            """Stream logs from the app.
-
-            This method is considered private and its interface may change - use at your own risk!
-            """
-            ...
-
-    _logs: ___logs_spec
-
     @classmethod
     def _get_container_app(cls) -> typing.Optional[App]:
         """Returns the `App` running inside a container.

{modal-1.5.5.dev4 → modal-1.5.5.dev6}/modal/cli/_help.py

@@ -7,6 +7,7 @@ import inspect
 import os
 import shutil
 import sys
+from collections.abc import Sequence
 from typing import Any
 
 import click
@@ -28,6 +29,83 @@ _MAX_HELP_WIDTH = 80
 _HELP_PADDING = 1
 
 
+class ModalGlobalOption(click.Option):
+    """An option supported at every level of the Modal CLI."""
+
+    def __init__(self, *args: Any, environment_variable: str, **kwargs: Any) -> None:
+        kwargs.setdefault("expose_value", False)
+        super().__init__(*args, **kwargs)
+        self.environment_variable = environment_variable
+
+    def set_environment_value(self, value: object) -> None:
+        os.environ[self.environment_variable] = str(value)
+
+
+class ModalProfileOption(ModalGlobalOption):
+    """Global option that updates Modal's active-profile cache."""
+
+    def set_environment_value(self, value: object) -> None:
+        from modal.config import _set_profile
+
+        # The profile is a global variable and currently set when modal is imported
+        # We could probably clean this up and simplify to just setting MODAL_PROFILE
+        _set_profile(str(value))
+
+
+def _root_global_options(ctx: click.Context) -> list[tuple[ModalGlobalOption, click.Context]]:
+    root_ctx = ctx.find_root()
+    return [
+        (param, root_ctx) for param in root_ctx.command.get_params(root_ctx) if isinstance(param, ModalGlobalOption)
+    ]
+
+
+def _global_option_token_length(ctx: click.Context, args: list[str], index: int) -> int:
+    option_name = args[index].split("=", 1)[0]
+    for option, _ in _root_global_options(ctx):
+        if option_name in (*option.opts, *option.secondary_opts):
+            return 1 if "=" in args[index] or option.is_flag else option.nargs + 1
+    return 0
+
+
+def _consume_global_options(ctx: click.Context, args: list[str]) -> list[str]:
+    remaining_args: list[str] = []
+    value: str | bool
+    index = 0
+    while index < len(args):
+        arg = args[index]
+        option_name, separator, option_value = arg.partition("=")
+        global_option = next(
+            (
+                option
+                for option, _ in _root_global_options(ctx)
+                if option_name in (*option.opts, *option.secondary_opts)
+            ),
+            None,
+        )
+        if global_option is None:
+            remaining_args.append(arg)
+            index += 1
+            continue
+
+        if separator:
+            value = option_value
+            index += 1
+        elif global_option.is_flag:
+            value = global_option.flag_value
+            if option_name in global_option.secondary_opts and isinstance(value, bool):
+                value = not value
+            index += 1
+        else:
+            if index + global_option.nargs >= len(args):
+                raise click.UsageError(f"Option '{option_name}' requires an argument.", ctx)
+            value = args[index + 1]
+            index += global_option.nargs + 1
+
+        global_option.set_environment_value(value)
+
+    return remaining_args
+
+
 def use_rich_style() -> bool:
     """Whether help output should be rendered in the rich style."""
     env = os.environ.get("MODAL_RICH_CLI")  # TODO move to config
@@ -82,11 +160,11 @@ def _option_label(param: click.Parameter, ctx: click.Context) -> Text:
 
 def _build_options(cmd: click.Command, ctx: click.Context) -> RenderableType | None:
     rows: list[tuple[Text, str]] = []
-    for param in cmd.get_params(ctx):
-        rec = param.get_help_record(ctx)
+    for param, param_ctx in _options_with_global_options(cmd, ctx):
+        rec = param.get_help_record(param_ctx)
         if rec is None:  # skips arguments and hidden options
             continue
-        rows.append((_option_label(param, ctx), rec[1] or ""))
+        rows.append((_option_label(param, param_ctx), rec[1] or ""))
     if not rows:
         return None
 
@@ -98,6 +176,36 @@ def _build_options(cmd: click.Command, ctx: click.Context) -> RenderableType | N
     return Group(Text("Options", style=_HEADING_STYLE), table)
 
 
+def _global_options(ctx: click.Context) -> Sequence[tuple[click.Option, click.Context]]:
+    root_ctx = ctx.find_root()
+    if root_ctx is ctx:
+        return []
+    return _root_global_options(ctx)
+
+
+def _options_with_global_options(cmd: click.Command, ctx: click.Context) -> list[tuple[click.Parameter, click.Context]]:
+    params = [(param, ctx) for param in cmd.get_params(ctx)]
+    if global_options := _global_options(ctx):
+        for index, (param, _) in enumerate(params):
+            if "--help" in param.opts or "--help" in param.secondary_opts:
+                params[index:index] = global_options
+                break
+        else:
+            params.extend(global_options)
+    return params
+
+
+def _format_options(cmd: click.Command, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+    records = [
+        rec
+        for param, param_ctx in _options_with_global_options(cmd, ctx)
+        if (rec := param.get_help_record(param_ctx)) is not None
+    ]
+    if records:
+        with formatter.section("Options"):
+            formatter.write_dl(records)
+
+
 def _build_epilog(cmd: click.Command) -> RenderableType | None:
     if not cmd.epilog:
         return None
@@ -114,6 +222,10 @@ def group_commands_by_panel(group: click.Group) -> dict[str, list[tuple[str, cli
     return panels
 
 
+def _has_visible_commands(group: click.Group) -> bool:
+    return bool(group_commands_by_panel(group))
+
+
 def _build_commands(group: click.Group, available_width: int) -> RenderableType | None:
     panels = group_commands_by_panel(group)
     if not panels:
@@ -189,6 +301,9 @@ class ModalCommand(click.Command):
         super().__init__(*args, **kwargs)
         self.panel = panel
 
+    def format_options(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        _format_options(self, ctx, formatter)
+
     def format_help(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
         if not use_rich_style():
             return super().format_help(ctx, formatter)
@@ -210,6 +325,7 @@ class ModalGroup(click.Group):
 
     command_class = ModalCommand
     group_class = type  # nested @group.group() reuses the enclosing class
+    defer_global_option_parsing = False
 
     def __init__(self, *args: Any, panel: str | None = None, **kwargs: Any) -> None:
         # Default to showing help when a group is invoked with no subcommand.
@@ -232,6 +348,29 @@ class ModalGroup(click.Group):
         if hidden is not None:
             cmd.hidden = hidden
 
+    def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]:
+        index = 0
+        while index < len(args):
+            arg = args[index]
+            if global_option_length := _global_option_token_length(ctx, args, index):
+                index += global_option_length
+                continue
+            command = self.commands.get(arg)
+            if command and getattr(command, "defer_global_option_parsing", False):
+                args[:] = _consume_global_options(ctx, args[:index]) + args[index:]
+                break
+            index += 1
+        else:
+            args[:] = _consume_global_options(ctx, args)
+
+        return super().parse_args(ctx, args)
+
+    def format_options(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        if _has_visible_commands(self):
+            self.format_commands(ctx, formatter)
+        else:
+            _format_options(self, ctx, formatter)
+
     def format_commands(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
         # Replaces click's single flat "Commands:" section with one section per
         # panel so the simple-style help output still preserves grouping.
@@ -249,7 +388,7 @@ class ModalGroup(click.Group):
             [
                 _build_usage(self, ctx),
                 _build_help_text(self),
-                _build_options(self, ctx),
+                None if _has_visible_commands(self) else _build_options(self, ctx),
                 _build_commands(self, _available_width(console)),
                 _build_epilog(self),
             ],

{modal-1.5.5.dev4 → modal-1.5.5.dev6}/modal/cli/app.py

@@ -351,6 +351,57 @@ async def logs(
             )
 
 
+@app_cli.command("promote", no_args_is_help=True, hidden=True)
+@click.argument("app_identifier")
+@click.argument("version")
+@env_option
+@synchronizer.create_blocking
+async def promote(
+    app_identifier: str,
+    version: str,
+    *,
+    env: str | None = None,
+):
+    """Deploy a staged version from an App's deployment history.
+
+    When a staged version gets promoted, the app is deployed with a new version that
+    refers back to the staged version.
+
+    Examples:
+
+    Promote an App to a specific version:
+
+    ```
+    modal app promote my-app v5
+    ```
+
+    Promote an App using its App ID instead of its name:
+
+    ```
+    modal app promote ap-abcdefghABCDEFGH123456 v5
+    ```
+
+    """
+    if m := re.fullmatch(r"v?([1-9]\d*)", version):
+        version_number = int(m.group(1))
+    else:
+        raise UsageError(f"Invalid version specifier: {version}. Expected a positive version number, e.g. 'v5' or '5'.")
+
+    env = ensure_env(env)
+    client = await _Client.from_env()
+    app_id, environment_name, lifecycle = await resolve_app_identifier(app_identifier, env, client)
+    if lifecycle.app_state != api_pb2.APP_STATE_DEPLOYED:
+        env_suffix = f" in the '{environment_name}' environment" if environment_name else ""
+        raise InvalidError(f"App '{app_identifier}' is not deployed{env_suffix}.")
+
+    resp = await client.stub.AppPromote(api_pb2.AppPromoteRequest(app_id=app_id, version=version_number))
+    print_server_warnings(resp.server_warnings)
+
+    output_mgr = OutputManager.get()
+    output_mgr.print(f"[green]✓[/green] Promoted App to v{version_number}!")
+    output_mgr.print(f"\nView Deployment: [magenta]{resp.url}[/magenta]")
+
+
 @app_cli.command("rollback", no_args_is_help=True, context_settings={"ignore_unknown_options": True})
 @click.argument("app_identifier")
 @click.argument("version", default="")

{modal-1.5.5.dev4 → modal-1.5.5.dev6}/modal/cli/config.py

@@ -3,7 +3,8 @@ import json
 
 import click
 
-from modal.config import _profile, _store_user_config, config
+from modal import config as config_module
+from modal.config import _store_user_config, config
 from modal.environments import Environment
 from modal.output import OutputManager
 
@@ -46,7 +47,7 @@ def set_environment(environment_name: str):
     # Confirm that the environment exists by looking it up
     Environment.from_name(environment_name).hydrate()
     _store_user_config({"environment": environment_name})
-    click.echo(f"New default environment for profile {_profile}: {environment_name}")
+    click.echo(f"New default environment for profile {config_module._profile}: {environment_name}")
 
 
 @config_cli.command("set", hidden=True, no_args_is_help=True)

{modal-1.5.5.dev4 → modal-1.5.5.dev6}/modal/cli/entry_point.py

@@ -8,7 +8,7 @@ from modal._utils.async_utils import synchronizer
 from modal.output import OutputManager
 
 from . import run, shell as shell_module
-from ._help import ModalCommand, ModalGroup
+from ._help import ModalCommand, ModalGroup, ModalProfileOption
 from .app import app_cli
 from .billing import billing_cli
 from .bootstrap import bootstrap
@@ -52,6 +52,12 @@ from .workspace import workspace_cli
     expose_value=False,
     callback=lambda ctx, param, value: _version_callback(ctx, value),
 )
+@click.option(
+    "--profile",
+    cls=ModalProfileOption,
+    environment_variable="MODAL_PROFILE",
+    help="Use this Modal profile for the command.",
+)
 def entrypoint_cli():
     pass
 
@@ -88,14 +94,13 @@ def check_path():
 
 
 @click.command("setup", cls=ModalCommand, help="Bootstrap Modal's configuration.")
-@click.option("--profile", default=None)
 @synchronizer.create_blocking
-async def setup(profile: str | None = None):
+async def setup():
     check_path()
     print_logo()
 
     # Fetch a new token (same as `modal token new` but redirect to /home once finishes)
-    await _new_token(profile=profile, next_url="/home")
+    await _new_token(next_url="/home")
 
     output = OutputManager.get()
     output.print("[green]→[/green] Run [bold]modal skills install[/bold] to install agent skills")

{modal-1.5.5.dev4 → modal-1.5.5.dev6}/modal/cli/environment.py

@@ -72,10 +72,26 @@ def list_(json: bool = False):
 @environment_cli.command("create", help="Create a new environment in the current workspace.", no_args_is_help=True)
 @click.argument("name")
 @click.option("--restricted", is_flag=True, default=False, help="Enable RBAC restrictions on the new environment")
+@click.option(
+    "--default-role",
+    type=str,
+    default=None,
+    help="Default member Role for the Restricted Environment",
+)
 @click.option("--public", is_flag=True, default=False, hidden=True)
-def create(name: str, restricted: bool = False, public: bool = False):
+def create(
+    name: str,
+    restricted: bool = False,
+    default_role: str | None = None,
+    public: bool = False,
+):
     check_environment_name(name)
-    Environment.objects.create(name, restricted=restricted, experimental_options={"is_public": public})
+    Environment.objects.create(
+        name,
+        restricted=restricted,
+        default_role=default_role,
+        experimental_options={"is_public": public},
+    )
     prefix = "Public " if public else "Restricted " if restricted else ""
     rich.print(f"[green]✓[/green] {prefix}Environment created: {name}")
 

{modal-1.5.5.dev4 → modal-1.5.5.dev6}/modal/cli/profile.py

@@ -8,11 +8,11 @@ import click
 from rich.json import JSON
 from rich.table import Table
 
+from modal import config as config_module
 from modal._utils.async_utils import synchronizer
 from modal.config import (
     Config,
     _lookup_workspace,
-    _profile,
     config_profiles,
     config_set_active_profile,
 )
@@ -41,7 +41,7 @@ def activate(profile: str):
 
 @profile_cli.command("current", help="Print the currently active Modal profile.")
 def current():
-    click.echo(_profile)
+    click.echo(config_module._profile)
 
 
 @profile_cli.command("list", help="Show all Modal profiles and highlight the active one.")
@@ -62,7 +62,7 @@ async def list_(json: bool | None = False):
 
     rows = []
     for profile, resp in zip(profiles, responses):
-        active = profile == _profile
+        active = profile == config_module._profile
         if isinstance(resp, AuthError):
             workspace = "Unknown (authentication failure)"
         elif isinstance(resp, TimeoutError):
@@ -80,7 +80,7 @@ async def list_(json: bool | None = False):
     if "MODAL_TOKEN_ID" in os.environ:
         try:
             env_based_resp = await _lookup_workspace(
-                config.get("server_url", profile=_profile),
+                config.get("server_url", profile=config_module._profile),
                 os.environ["MODAL_TOKEN_ID"],
                 os.environ.get("MODAL_TOKEN_SECRET", ""),
             )

{modal-1.5.5.dev4 → modal-1.5.5.dev6}/modal/cli/run.py

@@ -23,7 +23,7 @@ from ..functions import Function
 from ..output import OutputManager
 from ..runner import DEPLOYMENT_STRATEGY_TYPE, deploy_app, run_app
 from ..serving import serve_app
-from ._help import ModalCommand, ModalGroup
+from ._help import ModalCommand, ModalGroup, _consume_global_options, _global_option_token_length
 from .import_refs import (
     CLICommand,
     MethodReference,
@@ -411,6 +411,33 @@ def _get_runnable_list(all_usable_commands: list[CLICommand]) -> str:
 class RunGroup(ModalGroup):
     """Click group that resolves subcommands dynamically from a file/module ref."""
 
+    defer_global_option_parsing = True
+
+    def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]:
+        option_params: dict[str, click.Option] = {}
+        for param in self.get_params(ctx):
+            if isinstance(param, click.Option):
+                for option in (*param.opts, *param.secondary_opts):
+                    option_params[option] = param
+
+        func_ref_index = 0
+        while func_ref_index < len(args):
+            arg = args[func_ref_index]
+            if global_option_length := _global_option_token_length(ctx, args, func_ref_index):
+                func_ref_index += global_option_length
+            elif arg == "--":
+                func_ref_index += 1
+                break
+            elif param := option_params.get(arg.split("=", 1)[0]):
+                func_ref_index += 1 if "=" in arg or param.is_flag else param.nargs + 1
+            elif arg.startswith("-"):
+                func_ref_index += 1
+            else:
+                break
+
+        args[:] = _consume_global_options(ctx, args[:func_ref_index]) + args[func_ref_index:]
+        return click.Group.parse_args(self, ctx, args)
+
     def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command | None:
         # note: get_command here is run before the "group logic" in the `run` logic below
         # so to ensure that `env` has been globally populated before user code is loaded, it

{modal-1.5.5.dev4 → modal-1.5.5.dev6}/modal/cli/token.py

@@ -15,11 +15,6 @@ from ._help import ModalGroup
 
 token_cli = ModalGroup(name="token", help="Manage tokens.")
 
-_PROFILE_HELP = (
-    "Modal profile to set credentials for. If unspecified "
-    "(and MODAL_PROFILE environment variable is not set), "
-    "uses the workspace name associated with the credentials."
-)
 _ACTIVATE_HELP = "Activate the profile containing this token after creation."
 _VERIFY_HELP = "Make a test request to verify the new credentials."
 
@@ -27,14 +22,12 @@ _VERIFY_HELP = "Make a test request to verify the new credentials."
 @token_cli.command("set")
 @click.option("--token-id", default=None, help="Account token ID.")
 @click.option("--token-secret", default=None, help="Account token secret.")
-@click.option("--profile", default=None, help=_PROFILE_HELP)
 @click.option("--activate/--no-activate", default=True, help=_ACTIVATE_HELP)
 @click.option("--verify/--no-verify", default=True, help=_VERIFY_HELP)
 @synchronizer.create_blocking
 async def set(
     token_id: str | None,
     token_secret: str | None,
-    profile: str | None,
     activate: bool,
     verify: bool,
 ):
@@ -46,18 +39,17 @@ async def set(
         token_id = getpass.getpass("Token ID:")
     if token_secret is None:
         token_secret = getpass.getpass("Token secret:")
-    await _set_token(token_id, token_secret, profile=profile, activate=activate, verify=verify)
+    await _set_token(token_id, token_secret, activate=activate, verify=verify)
 
 
 @token_cli.command("new")
-@click.option("--profile", default=None, help=_PROFILE_HELP)
 @click.option("--activate/--no-activate", default=True, help=_ACTIVATE_HELP)
 @click.option("--verify/--no-verify", default=True, help=_VERIFY_HELP)
 @click.option("--source", default=None, hidden=True)
 @synchronizer.create_blocking
-async def new(profile: str | None, activate: bool, verify: bool, source: str | None):
+async def new(activate: bool, verify: bool, source: str | None):
     """Create a new token by using an authenticated web session."""
-    await _new_token(profile=profile, activate=activate, verify=verify, source=source)
+    await _new_token(activate=activate, verify=verify, source=source)
 
 
 @token_cli.command("info")

{modal-1.5.5.dev4 → modal-1.5.5.dev6}/modal/client.py

@@ -17,6 +17,7 @@ from modal._utils.async_utils import synchronizer
 from modal_proto import api_pb2, modal_api_grpc
 from modal_version import __version__
 
+from . import config as config_module
 from ._traceback import print_server_warnings
 from ._utils import async_utils
 from ._utils.async_utils import TaskContext, synchronize_api
@@ -240,6 +241,13 @@ class _Client:
                 client_type = api_pb2.CLIENT_TYPE_CLIENT
                 credentials = (token_id, token_secret)
             else:
+                profile = config_module._profile
+                if os.environ.get("MODAL_PROFILE") and profile not in config_module._user_config:
+                    raise AuthError(
+                        f"Modal profile '{profile}' was not found in {config_module.user_config_path}. "
+                        "Run `modal profile list` to see available profiles, or "
+                        f"`modal token new --profile {profile}` to configure it."
+                    )
                 raise AuthError(
                     "Token missing. Could not authenticate client."
                     " If you have token credentials, see modal.com/docs/sdk/py/latest/config for setup help."

{modal-1.5.5.dev4 → modal-1.5.5.dev6}/modal/client.pyi

@@ -38,7 +38,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.5.dev4",
+        version: str = "1.5.5.dev6",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -209,7 +209,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.5.dev4",
+        version: str = "1.5.5.dev6",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.5.5.dev4 → modal-1.5.5.dev6}/modal/config.py

@@ -242,6 +242,13 @@ def _check_config() -> None:
 
 _profile = os.environ.get("MODAL_PROFILE") or _config_active_profile()
 
+
+def _set_profile(profile: str) -> None:
+    os.environ["MODAL_PROFILE"] = profile
+    global _profile
+    _profile = profile
+
+
 # Define settings
 
 

{modal-1.5.5.dev4 → modal-1.5.5.dev6}/modal/environments.pyi

@@ -23,6 +23,7 @@ class EnvironmentManager:
             name: str,
             *,
             restricted: bool = False,
+            default_role: typing.Optional[str] = None,
             experimental_options: typing.Optional[dict[str, typing.Any]] = None,
             client: typing.Optional[modal.client.Client] = None,
         ) -> None:
@@ -42,6 +43,7 @@ class EnvironmentManager:
             name: str,
             *,
             restricted: bool = False,
+            default_role: typing.Optional[str] = None,
             experimental_options: typing.Optional[dict[str, typing.Any]] = None,
             client: typing.Optional[modal.client.Client] = None,
         ) -> None: