modal 1.5.2.dev13__tar.gz → 1.5.2.dev15__tar.gz

{modal-1.5.2.dev13 → modal-1.5.2.dev15}/PKG-INFO

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

{modal-1.5.2.dev13 → modal-1.5.2.dev15}/modal/__init__.py

@@ -9,7 +9,7 @@ if sys.version_info[:2] >= (3, 15):
 from modal_version import __version__
 
 try:
-    from . import billing
+    from . import billing, 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
@@ -100,6 +100,7 @@ __all__ = [
     "interact",
     "method",
     "parameter",
+    "types",
     "web_endpoint",
     "web_server",
     "wsgi_app",

{modal-1.5.2.dev13 → modal-1.5.2.dev15}/modal/_billing.py

@@ -1,10 +1,7 @@
 # Copyright Modal Labs 2025
-from dataclasses import FrozenInstanceError, dataclass
-from datetime import datetime, timezone
+from datetime import datetime
 from decimal import Decimal
-from typing import Any, Iterable, TypedDict
-
-from modal_proto import api_pb2
+from typing import TypedDict
 
 from ._utils.deprecation import deprecation_warning
 from .client import _Client
@@ -19,54 +16,6 @@ class WorkspaceBillingReportItem(TypedDict):
     tags: dict[str, str]
 
 
-@dataclass(slots=True, frozen=True)
-class BillingReportItem:
-    object_id: str
-    description: str
-    environment_name: str
-    interval_start: datetime
-    cost: Decimal
-    cost_by_resource: dict[str, Decimal]
-    tags: dict[str, str]
-
-    def __getitem__(self, key: str) -> Any:
-        """mdmd:ignore"""
-        if key not in self.__slots__:
-            raise KeyError(key)
-
-        return getattr(self, key)
-
-    def __setitem__(self, key: str, _: Any):
-        """mdmd:ignore"""
-        raise FrozenInstanceError(f"cannot assign to field {key!r}")
-
-    def keys(self) -> Iterable[str]:
-        """mdmd:ignore"""
-        yield from self.__slots__
-
-    def values(self) -> Iterable[Any]:
-        """mdmd:ignore"""
-        for k in self.__slots__:
-            yield getattr(self, k)
-
-    def items(self) -> Iterable[tuple[str, Any]]:
-        """mdmd:ignore"""
-        for k in self.__slots__:
-            yield k, getattr(self, k)
-
-    @classmethod
-    def _from_proto(cls, pb_item: api_pb2.WorkspaceBillingReportItem) -> "BillingReportItem":
-        return cls(
-            object_id=pb_item.object_id,
-            description=pb_item.description,
-            environment_name=pb_item.environment_name,
-            interval_start=pb_item.interval.ToDatetime().replace(tzinfo=timezone.utc),
-            cost=Decimal(pb_item.cost),
-            cost_by_resource={k: Decimal(v) for k, v in pb_item.cost_by_resource.items()},
-            tags=dict(pb_item.tags),
-        )
-
-
 async def _workspace_billing_report(
     *,
     start: datetime,  # Start of the report, inclusive

{modal-1.5.2.dev13 → modal-1.5.2.dev15}/modal/_environments.py

@@ -13,7 +13,6 @@ from synchronicity import classproperty
 
 from modal_proto import api_pb2
 
-from ._billing import BillingReportItem
 from ._load_context import LoadContext
 from ._object import _Object
 from ._resolver import Resolver
@@ -21,6 +20,7 @@ from ._utils.name_utils import check_environment_name
 from .client import _Client
 from .config import config, logger
 from .exception import InvalidError, WorkspaceManagementError
+from .types import BillingReportItem
 
 
 @dataclass(frozen=True)

{modal-1.5.2.dev13 → modal-1.5.2.dev15}/modal/_functions.py

@@ -90,6 +90,7 @@ from .proxy import _Proxy
 from .retries import Retries, RetryManager
 from .schedule import Schedule
 from .secret import _Secret
+from .types import FunctionStats
 from .volume import _Volume, _volume_to_mount_proto
 
 if TYPE_CHECKING:
@@ -541,17 +542,6 @@ class _InputPlaneInvocation:
         return [("x-modal-input-plane-region", input_plane_region), ("x-modal-auth-token", token)]
 
 
-# Wrapper type for api_pb2.FunctionStats
-@dataclass(frozen=True)
-class FunctionStats:
-    """Simple data structure storing stats for a running function."""
-
-    backlog: int
-    num_total_runners: int
-    num_running_inputs: int
-    input_headroom: int
-
-
 @dataclass
 class _FunctionSpec:
     """

{modal-1.5.2.dev13 → modal-1.5.2.dev15}/modal/_image.py

@@ -2976,7 +2976,7 @@ class _Image(_Object, type_prefix="im"):
             api_pb2.ImagePublishRequest(
                 image_id=self._object_id,
                 environment_name=resolved_env,
-                is_public=False,
+                allow_public=False,
                 tag=tag,
             )
         )

{modal-1.5.2.dev13 → modal-1.5.2.dev15}/modal/_utils/grpc_utils.py

@@ -31,7 +31,7 @@ from modal_version import __version__
 
 from .._traceback import suppress_tb_frame
 from ..config import config
-from .async_utils import retry
+from .async_utils import TaskContext, retry
 from .logger import logger
 
 RequestType = TypeVar("RequestType", bound=Message)
@@ -190,14 +190,7 @@ class ConnectionManager:
 
     async def get_or_create_channel(self, server_url: str) -> grpclib.client.Channel:
         if server_url not in self._channels:
-            self._channels[server_url] = create_channel(
-                server_url,
-                self._metadata,
-            )
-            try:
-                await connect_channel(self._channels[server_url])
-            except (OSError, asyncio.TimeoutError) as exc:
-                raise ConnectionError("Could not connect to the Modal server.") from exc
+            self._channels[server_url] = await create_channel_with_fallbacks(server_url, self._metadata)
         return self._channels[server_url]
 
     def close(self):
@@ -296,6 +289,12 @@ def create_channel(
         for k, v in metadata.items():
             event.metadata[k] = v
 
+        if o.hostname is not None:
+            # GRPC actually injects a :authority pseudo-header containing the hostname.
+            # But this gets stripped out by the C/C++ extension server-side and is hard to fix.
+            # So let's just add a separate header we can parse easily.
+            event.metadata["x-modal-host"] = o.hostname
+
         idempotency_key = typing.cast(Optional[str], event.metadata.get("x-idempotency-key"))
         if idempotency_key is None:
             logger.debug(f"Sending request to {event.method_name}")
@@ -314,6 +313,47 @@ async def connect_channel(channel: grpclib.client.Channel):
     await channel.__connect__()
 
 
+async def create_channel_with_fallbacks(
+    server_url: str,
+    metadata: dict[str, str] = {},
+    stagger_delay: float = 1.0,
+) -> grpclib.client.Channel:
+    """Create a connected channel, supporting comma-separated fallback URLs.
+
+    `server_url` may be a single URL or a comma-separated list of URLs. The connection attempts
+    are raced against each other and the first one to connect wins, which lets the client fail
+    over to a secondary endpoint when the primary is unreachable (e.g. a DNS outage on the
+    primary's domain). Attempts are staggered: the candidate at index `i` waits `i * stagger_delay`
+    seconds before starting, so earlier URLs (e.g. the primary) get a head start and are preferred
+    when reachable. Losing attempts are cancelled and their channels closed.
+    """
+    urls = [url.strip() for url in server_url.split(",")]
+
+    async def connect(index: int, url: str) -> grpclib.client.Channel:
+        # Stagger the start so earlier URLs are preferred; once started, all attempts race.
+        await asyncio.sleep(index * stagger_delay)
+        channel = create_channel(url, metadata)
+        try:
+            await connect_channel(channel)
+        except BaseException:
+            # Close the channel of a losing/cancelled attempt so its socket doesn't leak.
+            channel.close()
+            raise
+        return channel
+
+    first_exc: BaseException | None = None
+    async with TaskContext() as tc:
+        tasks = [tc.create_task(connect(i, url)) for i, url in enumerate(urls)]
+        for attempt in asyncio.as_completed(tasks):
+            try:
+                return await attempt
+            except Exception as exc:
+                if first_exc is None:
+                    first_exc = exc
+
+    raise ConnectionError("Could not connect to the Modal server.") from first_exc
+
+
 if typing.TYPE_CHECKING:
     import modal.client
 

{modal-1.5.2.dev13 → modal-1.5.2.dev15}/modal/_utils/task_command_router_client.py

@@ -811,13 +811,25 @@ class TaskCommandRouterClient:
                 lambda: self._call_with_auth_retry(self._stub.TaskSetNetworkAccess, request)
             )
 
-    async def reload_volumes(self, task_id: str) -> sr_pb2.TaskReloadVolumesResponse:
-        """Reload all Volumes mounted in the task to reflect their latest committed state."""
+    async def reload_volumes(self, task_id: str, timeout: float) -> sr_pb2.TaskReloadVolumesResponse:
+        """Reload all Volumes mounted in the task to reflect their latest committed state.
+
+        Args:
+            task_id: The task whose mounted Volumes should be reloaded.
+            timeout: Client-side deadline in seconds. If the reload does not complete within this
+                window, the call is cancelled and a `modal.exception.TimeoutError` is raised.
+        """
         request = sr_pb2.TaskReloadVolumesRequest(task_id=task_id)
         with grpc_error_converter():
-            return await call_with_retries_on_transient_errors(
-                lambda: self._call_with_auth_retry(self._stub.TaskReloadVolumes, request)
-            )
+            try:
+                return await asyncio.wait_for(
+                    call_with_retries_on_transient_errors(
+                        lambda: self._call_with_auth_retry(self._stub.TaskReloadVolumes, request, timeout=timeout),
+                    ),
+                    timeout=timeout,
+                )
+            except asyncio.TimeoutError:
+                raise ModalTimeoutError("Timeout expired")
 
     async def _snapshot_with_deadline(self, rpc, request, *, timeout: float, **kwargs):
         # helper method for snapshot_directory and snapshot_filesystem to handle grpc

{modal-1.5.2.dev13 → modal-1.5.2.dev15}/modal/_workspace.py

@@ -1,22 +1,19 @@
 # Copyright Modal Labs 2025
 import builtins
-from dataclasses import dataclass
 from datetime import datetime, timezone
-from typing import Literal, Optional
+from typing import Optional
 
 from google.protobuf.empty_pb2 import Empty
 
 from modal.exception import InvalidError
 from modal_proto import api_pb2
 
-from ._billing import BillingReportItem
 from ._load_context import LoadContext
 from ._object import _Object
 from ._resolver import Resolver
 from ._utils.time_utils import timestamp_to_localized_dt
 from .client import _Client
-
-MemberRole = Literal["user", "manager", "owner"]
+from .types import BillingReportItem, MemberRole, ProxyTokenInfo, TokenData, WorkspaceMemberInfo, WorkspaceSettings
 
 
 def _member_role_from_proto(proto_value: int) -> MemberRole:
@@ -31,18 +28,6 @@ def _member_role_from_proto(proto_value: int) -> MemberRole:
             raise ValueError(f"Unknown workspace member role: {proto_value}")
 
 
-@dataclass(frozen=True)
-class WorkspaceMemberInfo:
-    """Metadata about a Workspace member."""
-
-    name: str
-    email: str
-    user_id: str
-    role: MemberRole
-    joined_at: datetime
-    last_active_at: Optional[datetime]  # None if the member has never been active
-
-
 class _WorkspaceMembersManager:
     """mdmd:namespace
     Namespace with methods for managing the membership of a Workspace.
@@ -125,22 +110,9 @@ class _Workspace(_Object, type_prefix="ac"):
     def proxy_tokens(self) -> "_WorkspaceProxyTokenManager":
         return _WorkspaceProxyTokenManager(self)
 
-
-@dataclass(frozen=True)
-class TokenData:
-    """A token ID / secret pair."""
-
-    token_id: str
-    token_secret: str
-
-
-@dataclass(frozen=True)
-class ProxyTokenInfo:
-    """Metadata about a proxy token, not including the token secret."""
-
-    token_id: str
-    created_at: datetime
-    scoped: bool
+    @property
+    def settings(self) -> "_WorkspaceSettingsManager":
+        return _WorkspaceSettingsManager(self)
 
 
 class _WorkspaceProxyTokenManager:
@@ -340,3 +312,71 @@ class _WorkspaceBillingManager:
             BillingReportItem._from_proto(pb_item)
             async for pb_item in self._workspace.client.stub.WorkspaceBillingReport.unary_stream(request)
         ]
+
+
+class _WorkspaceSettingsManager:
+    """mdmd:namespace
+    Namespace for Workspace settings APIs.
+    """
+
+    @classmethod
+    def valid_settings(cls):
+        return ("default-environment", "image-builder-version")
+
+    def __init__(self, workspace: _Workspace):
+        """mdmd:hidden"""
+        self._workspace = workspace
+
+    async def list(self):
+        """Return a the current workspace settings.
+
+        Returns:
+            A `WorkspaceSettings` dataclass.
+        """
+        if not self._workspace.is_hydrated:
+            await self._workspace.hydrate()
+        resp = await self._workspace.client.stub.WorkspaceSettings(Empty())
+        return WorkspaceSettings(
+            default_environment=resp.default_environment_name, image_builder_version=resp.image_builder_version
+        )
+
+    async def _set_image_builder_version(self, version: str) -> None:
+        """mdmd:hidden
+        Set the image builder version for the Workspace.
+        """
+        if not self._workspace.is_hydrated:
+            await self._workspace.hydrate()
+        req = api_pb2.WorkspaceSetImageBuilderVersionRequest(new_image_builder_version=version)
+        await self._workspace.client.stub.WorkspaceSetImageBuilderVersion(req)
+
+    async def _set_default_environment(self, name: str) -> None:
+        """Set the default environment for the Workspace."""
+        if not self._workspace.is_hydrated:
+            await self._workspace.hydrate()
+        req = api_pb2.WorkspaceSetDefaultEnvironmentRequest(environment_name=name)
+        await self._workspace.client.stub.WorkspaceSetDefaultEnvironment(req)
+
+    async def set(self, name: str, value: str) -> None:
+        """Set a workspace setting to a new value. Must be workspace manager or owner.
+
+        The following settings can be updated:
+
+        - image-builder-version: The image builder version determines the software included in our base images.
+        - default-environment: The default environment when the environment is omitted from SDK or CLI methods.
+
+        Args:
+            name: The name of the setting.
+            value: The new value of the setting.
+
+        Examples:
+            ```python notest
+            modal.Workspace.from_context().settings.set("default-environment", "dev")
+            ```
+        """
+        match name:
+            case "image-builder-version":
+                await self._set_image_builder_version(value)
+            case "default-environment":
+                await self._set_default_environment(value)
+            case _:
+                raise ValueError(f"Unknown setting {name!r}. Valid settings: {', '.join(self.valid_settings())}")

{modal-1.5.2.dev13 → modal-1.5.2.dev15}/modal/billing.py

@@ -1,6 +1,7 @@
 # Copyright Modal Labs 2025
-from ._billing import BillingReportItem, WorkspaceBillingReportItem, _workspace_billing_report
+from ._billing import WorkspaceBillingReportItem, _workspace_billing_report
 from ._utils.async_utils import synchronize_api
+from .types import BillingReportItem
 
 workspace_billing_report = synchronize_api(_workspace_billing_report, target_module=__name__)
 

{modal-1.5.2.dev13 → modal-1.5.2.dev15}/modal/billing.pyi

@@ -2,12 +2,32 @@ import datetime
 import decimal
 import modal._billing
 import modal.client
+import modal.types
 import modal_proto.api_pb2
 import typing
 import typing_extensions
 
+class WorkspaceBillingReportItem(typing.TypedDict):
+    """dict() -> new empty dictionary
+    dict(mapping) -> new dictionary initialized from a mapping object's
+        (key, value) pairs
+    dict(iterable) -> new dictionary initialized as if via:
+        d = {}
+        for k, v in iterable:
+            d[k] = v
+    dict(**kwargs) -> new dictionary initialized with the name=value pairs
+        in the keyword argument list.  For example:  dict(one=1, two=2)
+    """
+
+    object_id: str
+    description: str
+    environment_name: str
+    interval_start: datetime.datetime
+    cost: decimal.Decimal
+    tags: dict[str, str]
+
 class BillingReportItem:
-    """BillingReportItem(object_id: str, description: str, environment_name: str, interval_start: datetime.datetime, cost: decimal.Decimal, cost_by_resource: dict[str, decimal.Decimal], tags: dict[str, str])"""
+    """Costs generated by a specific object during a specific time interval."""
 
     object_id: str
     description: str
@@ -18,29 +38,27 @@ class BillingReportItem:
     tags: dict[str, str]
 
     def __getitem__(self, key: str) -> typing.Any:
-        """mdmd:ignore"""
+        """mdmd:hidden"""
         ...
 
     def __setitem__(self, key: str, _: typing.Any):
-        """mdmd:ignore"""
+        """mdmd:hidden"""
         ...
 
     def keys(self) -> typing.Iterable[str]:
-        """mdmd:ignore"""
+        """mdmd:hidden"""
         ...
 
     def values(self) -> typing.Iterable[typing.Any]:
-        """mdmd:ignore"""
+        """mdmd:hidden"""
         ...
 
     def items(self) -> typing.Iterable[tuple[str, typing.Any]]:
-        """mdmd:ignore"""
+        """mdmd:hidden"""
         ...
 
     @classmethod
-    def _from_proto(
-        cls, pb_item: modal_proto.api_pb2.WorkspaceBillingReportItem
-    ) -> modal._billing.BillingReportItem: ...
+    def _from_proto(cls, pb_item: modal_proto.api_pb2.WorkspaceBillingReportItem) -> modal.types.BillingReportItem: ...
     def __init__(
         self,
         object_id: str,
@@ -77,25 +95,6 @@ class BillingReportItem:
     def __getstate__(self): ...
     def __setstate__(self, state): ...
 
-class WorkspaceBillingReportItem(typing.TypedDict):
-    """dict() -> new empty dictionary
-    dict(mapping) -> new dictionary initialized from a mapping object's
-        (key, value) pairs
-    dict(iterable) -> new dictionary initialized as if via:
-        d = {}
-        for k, v in iterable:
-            d[k] = v
-    dict(**kwargs) -> new dictionary initialized with the name=value pairs
-        in the keyword argument list.  For example:  dict(one=1, two=2)
-    """
-
-    object_id: str
-    description: str
-    environment_name: str
-    interval_start: datetime.datetime
-    cost: decimal.Decimal
-    tags: dict[str, str]
-
 class __workspace_billing_report_spec(typing_extensions.Protocol):
     def __call__(
         self,

{modal-1.5.2.dev13 → modal-1.5.2.dev15}/modal/call_graph.py

@@ -1,36 +1,7 @@
 # Copyright Modal Labs 2022
-from dataclasses import dataclass
-from enum import IntEnum
-
 from modal_proto import api_pb2
 
-
-class InputStatus(IntEnum):
-    """Enum representing status of a function input."""
-
-    PENDING = 0
-    SUCCESS = api_pb2.GenericResult.GENERIC_STATUS_SUCCESS
-    FAILURE = api_pb2.GenericResult.GENERIC_STATUS_FAILURE
-    INIT_FAILURE = api_pb2.GenericResult.GENERIC_STATUS_INIT_FAILURE
-    TERMINATED = api_pb2.GenericResult.GENERIC_STATUS_TERMINATED
-    TIMEOUT = api_pb2.GenericResult.GENERIC_STATUS_TIMEOUT
-
-    @classmethod
-    def _missing_(cls, value):
-        return cls.PENDING
-
-
-@dataclass
-class InputInfo:
-    """Simple data structure storing information about a function input."""
-
-    input_id: str
-    function_call_id: str
-    task_id: str
-    status: InputStatus
-    function_name: str
-    module_name: str
-    children: list["InputInfo"]
+from .types import InputInfo, InputStatus
 
 
 def _reconstruct_call_graph(ser_graph: api_pb2.FunctionGetCallGraphResponse) -> list[InputInfo]:

{modal-1.5.2.dev13 → modal-1.5.2.dev15}/modal/cli/_download.py

@@ -13,7 +13,8 @@ from click import UsageError
 from modal._utils.async_utils import TaskContext
 from modal.config import logger
 from modal.network_file_system import _NetworkFileSystem
-from modal.volume import FileEntry, FileEntryType, _Volume
+from modal.types import FileEntry, FileEntryType
+from modal.volume import _Volume
 
 PIPE_PATH = Path("-")
 

{modal-1.5.2.dev13 → modal-1.5.2.dev15}/modal/cli/cluster.py

@@ -59,7 +59,7 @@ async def list_(env: str | None = None, json: bool = False):
     display_table(column_names, rows, json=json, title=f"Active Multi-node Clusters in environment: {environment_name}")
 
 
-@cluster_cli.command("shell")
+@cluster_cli.command("shell", no_args_is_help=True)
 @click.argument("cluster_id")
 @click.option("--rank", default=0, help="Rank of the node to shell into")
 @synchronizer.create_blocking

{modal-1.5.2.dev13 → modal-1.5.2.dev15}/modal/cli/config.py

@@ -40,7 +40,7 @@ when running a command that requires an environment.
 """
 
 
-@config_cli.command("set-environment", help=SET_DEFAULT_ENV_HELP)
+@config_cli.command("set-environment", help=SET_DEFAULT_ENV_HELP, no_args_is_help=True)
 @click.argument("environment_name")
 def set_environment(environment_name: str):
     # Confirm that the environment exists by looking it up
@@ -49,7 +49,7 @@ def set_environment(environment_name: str):
     click.echo(f"New default environment for profile {_profile}: {environment_name}")
 
 
-@config_cli.command("set", hidden=True)
+@config_cli.command("set", hidden=True, no_args_is_help=True)
 @click.argument("key")
 @click.argument("value")
 def set(key: str, value: str):

{modal-1.5.2.dev13 → modal-1.5.2.dev15}/modal/cli/container.py

@@ -317,7 +317,7 @@ async def _exec_impl(
         ).wait()
 
 
-@container_cli.command("exec")
+@container_cli.command("exec", no_args_is_help=True)
 @click.option("--pty/--no-pty", default=None, help="Run the command using a PTY.")
 @click.argument("container_id")
 @click.argument("command", nargs=-1, required=True)
@@ -330,16 +330,27 @@ def exec(
     _exec_impl(pty=pty, container_id=container_id, command=command)
 
 
-@container_cli.command("stop")
+@container_cli.command("stop", no_args_is_help=True)
 @click.argument("container_id")
+@click.option(
+    "--graceful",
+    is_flag=True,
+    default=False,
+    help="Let the container finish its current inputs before exiting, instead of cancelling them.",
+)
 @yes_option
 @synchronizer.create_blocking
-async def stop(container_id: str = "", *, yes: bool = False):
+async def stop(container_id: str = "", *, graceful: bool = False, yes: bool = False):
     """Terminate a running container.
 
-    This will send the container a SIGINT signal that Modal will handle.
-    Any inputs that are currently running on the container will be cancelled and rescheduled
-    on other containers.
+    By default, this will send the container a SIGINT signal that Modal will handle.
+    For Functions, any inputs that are currently running on the container will be cancelled
+    and rescheduled on other containers.
+
+    With `--graceful`, the container will be allowed to finish the inputs it is currently
+    running, exiting once they complete. Graceful stops are only supported for containers
+    running a Modal Function.
+
     """
     client = await _Client.from_env()
     resp = await client.stub.TaskGetInfo(api_pb2.TaskGetInfoRequest(task_id=container_id))
@@ -347,5 +358,5 @@ async def stop(container_id: str = "", *, yes: bool = False):
         raise SystemExit(f"Container '{container_id}' is already stopped.")
     if not yes:
         confirm_or_suggest_yes(f"Are you sure you want to stop container '{container_id}'?")
-    request = api_pb2.ContainerStopRequest(task_id=container_id)
+    request = api_pb2.ContainerStopRequest(task_id=container_id, graceful=graceful)
     await client.stub.ContainerStop(request)

{modal-1.5.2.dev13 → modal-1.5.2.dev15}/modal/cli/curl.py

@@ -96,7 +96,12 @@ def _run_curl(curl_args: tuple[str, ...], token: str | None = None) -> None:
     sys.exit(subprocess.call(cmd))
 
 
-@click.command("curl", cls=ModalCommand, context_settings={"ignore_unknown_options": True, "allow_extra_args": True})
+@click.command(
+    "curl",
+    cls=ModalCommand,
+    no_args_is_help=True,
+    context_settings={"ignore_unknown_options": True, "allow_extra_args": True},
+)
 @click.argument("curl_args", nargs=-1, required=True, type=click.UNPROCESSED)
 @synchronizer.create_blocking
 async def curl(curl_args: tuple[str, ...]):