modal 0.67.33__py3-none-any.whl → 0.67.43__py3-none-any.whl

modal/_runtime/container_io_manager.py

@@ -908,7 +908,7 @@ class _ContainerIOManager:
         if self.checkpoint_id:
             logger.debug(f"Checkpoint ID: {self.checkpoint_id} (Memory Snapshot ID)")
         else:
-            logger.debug("No checkpoint ID provided (Memory Snapshot ID)")
+            raise ValueError("No checkpoint ID provided for memory snapshot")
 
         # Pause heartbeats since they keep the client connection open which causes the snapshotter to crash
         async with self.heartbeat_condition:
@@ -918,7 +918,7 @@ class _ContainerIOManager:
             self.heartbeat_condition.notify_all()
 
             await self._client.stub.ContainerCheckpoint(
-                api_pb2.ContainerCheckpointRequest(checkpoint_id=self.checkpoint_id or "")
+                api_pb2.ContainerCheckpointRequest(checkpoint_id=self.checkpoint_id)
             )
 
             await self._client._close(prep_for_restore=True)

modal/cli/_traceback.py

@@ -1,6 +1,7 @@
 # Copyright Modal Labs 2024
 """Helper functions related to displaying tracebacks in the CLI."""
 import functools
+import re
 import warnings
 from typing import Optional
 
@@ -166,8 +167,12 @@ def highlight_modal_deprecation_warnings() -> None:
     def showwarning(warning, category, filename, lineno, file=None, line=None):
         if issubclass(category, (DeprecationError, PendingDeprecationError)):
             content = str(warning)
-            date = content[:10]
-            message = content[11:].strip()
+            if re.match(r"^\d{4}-\d{2}-\d{2}", content):
+                date = content[:10]
+                message = content[11:].strip()
+            else:
+                date = ""
+                message = content
             try:
                 with open(filename, encoding="utf-8", errors="replace") as code_file:
                     source = code_file.readlines()[lineno - 1].strip()
@@ -178,7 +183,7 @@ def highlight_modal_deprecation_warnings() -> None:
             panel = Panel(
                 message,
                 style="yellow",
-                title=f"Modal Deprecation Warning ({date})",
+                title=f"Modal Deprecation Warning ({date})" if date else "Modal Deprecation Warning",
                 title_align="left",
             )
             Console().print(panel)

modal/cli/app.py

@@ -115,7 +115,7 @@ def logs(
     ```
 
     """
-    app_identifier = warn_on_name_option("stop", app_identifier, name)
+    app_identifier = warn_on_name_option("logs", app_identifier, name)
     app_id = get_app_id(app_identifier, env)
     stream_app_logs(app_id)
 

modal/cli/container.py

@@ -1,5 +1,4 @@
 # Copyright Modal Labs 2022
-
 from typing import Optional, Union
 
 import typer
@@ -8,12 +7,13 @@ from rich.text import Text
 from modal._pty import get_pty_info
 from modal._utils.async_utils import synchronizer
 from modal._utils.grpc_utils import retry_transient_errors
-from modal.cli.utils import ENV_OPTION, display_table, stream_app_logs, timestamp_to_local
+from modal.cli.utils import ENV_OPTION, display_table, is_tty, stream_app_logs, timestamp_to_local
 from modal.client import _Client
 from modal.config import config
 from modal.container_process import _ContainerProcess
 from modal.environments import ensure_env
 from modal.object import _get_environment_name
+from modal.stream_type import StreamType
 from modal_proto import api_pb2
 
 container_cli = typer.Typer(name="container", help="Manage and connect to running containers.", no_args_is_help=True)
@@ -55,12 +55,19 @@ def logs(container_id: str = typer.Argument(help="Container ID")):
 @container_cli.command("exec")
 @synchronizer.create_blocking
 async def exec(
+    pty: Optional[bool] = typer.Option(default=None, help="Run the command using a PTY."),
     container_id: str = typer.Argument(help="Container ID"),
-    command: list[str] = typer.Argument(help="A command to run inside the container."),
-    pty: bool = typer.Option(default=True, help="Run the command using a PTY."),
+    command: list[str] = typer.Argument(
+        help="A command to run inside the container.\n\n"
+        "To pass command-line flags or options, add `--` before the start of your commands. "
+        "For example: `modal container exec <id> -- /bin/bash -c 'echo hi'`"
+    ),
 ):
     """Execute a command in a container."""
 
+    if pty is None:
+        pty = is_tty()
+
     client = await _Client.from_env()
 
     req = api_pb2.ContainerExecRequest(
@@ -71,7 +78,11 @@ async def exec(
     )
     res: api_pb2.ContainerExecResponse = await client.stub.ContainerExec(req)
 
-    await _ContainerProcess(res.exec_id, client).attach(pty=pty)
+    if pty:
+        await _ContainerProcess(res.exec_id, client).attach()
+    else:
+        # TODO: redirect stderr to its own stream?
+        await _ContainerProcess(res.exec_id, client, stdout=StreamType.STDOUT, stderr=StreamType.STDOUT).wait()
 
 
 @container_cli.command("stop")

modal/cli/network_file_system.py

@@ -10,7 +10,7 @@ from grpclib import GRPCError, Status
 from rich.console import Console
 from rich.syntax import Syntax
 from rich.table import Table
-from typer import Typer
+from typer import Argument, Typer
 
 import modal
 from modal._location import display_location
@@ -18,7 +18,7 @@ from modal._output import OutputManager, ProgressHandler
 from modal._utils.async_utils import synchronizer
 from modal._utils.grpc_utils import retry_transient_errors
 from modal.cli._download import _volume_download
-from modal.cli.utils import ENV_OPTION, display_table, timestamp_to_local
+from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table, timestamp_to_local
 from modal.client import _Client
 from modal.environments import ensure_env
 from modal.network_file_system import _NetworkFileSystem
@@ -217,3 +217,24 @@ async def rm(
         if exc.status in (Status.NOT_FOUND, Status.INVALID_ARGUMENT):
             raise UsageError(exc.message)
         raise
+
+
+@nfs_cli.command(
+    name="delete",
+    help="Delete a named, persistent modal.NetworkFileSystem.",
+    rich_help_panel="Management",
+)
+@synchronizer.create_blocking
+async def delete(
+    nfs_name: str = Argument(help="Name of the modal.NetworkFileSystem to be deleted. Case sensitive"),
+    yes: bool = YES_OPTION,
+    env: Optional[str] = ENV_OPTION,
+):
+    if not yes:
+        typer.confirm(
+            f"Are you sure you want to irrevocably delete the modal.NetworkFileSystem '{nfs_name}'?",
+            default=False,
+            abort=True,
+        )
+
+    await _NetworkFileSystem.delete(label=nfs_name, environment_name=env)

modal/cli/run.py

@@ -29,7 +29,7 @@ from ..runner import deploy_app, interactive_shell, run_app
 from ..serving import serve_app
 from ..volume import Volume
 from .import_refs import import_app, import_function
-from .utils import ENV_OPTION, ENV_OPTION_HELP, stream_app_logs
+from .utils import ENV_OPTION, ENV_OPTION_HELP, is_tty, stream_app_logs
 
 
 class ParameterMetadata(TypedDict):
@@ -392,40 +392,47 @@ def shell(
             "Can be a single region or a comma-separated list to choose from (if not using REF)."
         ),
     ),
+    pty: Optional[bool] = typer.Option(default=None, help="Run the command using a PTY."),
 ):
-    """Run an interactive shell inside a Modal container.
+    """Run a command or interactive shell inside a Modal container.
 
-    **Examples:**
+    \b**Examples:**
 
-    Start a shell inside the default Debian-based image:
+    \bStart an interactive shell inside the default Debian-based image:
 
-    ```
+    \b```
     modal shell
     ```
 
-    Start a bash shell using the spec for `my_function` in your App:
+    \bStart an interactive shell with the spec for `my_function` in your App
+    (uses the same image, volumes, mounts, etc.):
 
-    ```
+    \b```
     modal shell hello_world.py::my_function
     ```
 
-    Or, if you're using a [modal.Cls](/docs/reference/modal.Cls), you can refer to a `@modal.method` directly:
+    \bOr, if you're using a [modal.Cls](/docs/reference/modal.Cls), you can refer to a `@modal.method` directly:
 
-    ```
+    \b```
     modal shell hello_world.py::MyClass.my_method
     ```
 
     Start a `python` shell:
 
-    ```
+    \b```
     modal shell hello_world.py --cmd=python
     ```
+
+    \bRun a command with your function's spec and pipe the output to a file:
+
+    \b```
+    modal shell hello_world.py -c 'uv pip list' > env.txt
+    ```
     """
     env = ensure_env(env)
 
-    console = Console()
-    if not console.is_terminal:
-        raise click.UsageError("`modal shell` can only be run from a terminal.")
+    if pty is None:
+        pty = is_tty()
 
     if platform.system() == "Windows":
         raise InvalidError("`modal shell` is currently not supported on Windows")
@@ -441,7 +448,7 @@ def shell(
         ):
             from .container import exec
 
-            exec(container_id=container_or_function, command=shlex.split(cmd), pty=True)
+            exec(container_id=container_or_function, command=shlex.split(cmd))
             return
 
         function = import_function(
@@ -461,6 +468,7 @@ def shell(
             memory=function_spec.memory,
             volumes=function_spec.volumes,
             region=function_spec.scheduler_placement.proto.regions if function_spec.scheduler_placement else None,
+            pty=pty,
         )
     else:
         modal_image = Image.from_registry(image, add_python=add_python) if image else None
@@ -474,6 +482,7 @@ def shell(
             cloud=cloud,
             volumes=volumes,
             region=region.split(",") if region else [],
+            pty=pty,
         )
 
     # NB: invoking under bash makes --cmd a lot more flexible.

modal/cli/utils.py

@@ -77,6 +77,10 @@ def _plain(text: Union[Text, str]) -> str:
     return text.plain if isinstance(text, Text) else text
 
 
+def is_tty() -> bool:
+    return Console().is_terminal
+
+
 def display_table(
     columns: Sequence[Union[Column, str]],
     rows: Sequence[Sequence[Union[Text, str]]],

modal/client.py

@@ -147,7 +147,7 @@ class _Client:
             )
             if resp.warning:
                 ALARM_EMOJI = chr(0x1F6A8)
-                warnings.warn(f"{ALARM_EMOJI} {resp.warning} {ALARM_EMOJI}", DeprecationError)
+                warnings.warn_explicit(f"{ALARM_EMOJI} {resp.warning} {ALARM_EMOJI}", DeprecationError, "<unknown>", 0)
         except GRPCError as exc:
             if exc.status == Status.FAILED_PRECONDITION:
                 raise VersionError(

modal/client.pyi

@@ -26,7 +26,7 @@ class _Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.67.33"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.67.43"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -81,7 +81,7 @@ class Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.67.33"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.67.43"
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/container_process.py

@@ -9,7 +9,7 @@ from ._utils.async_utils import TaskContext, synchronize_api
 from ._utils.grpc_utils import retry_transient_errors
 from ._utils.shell_utils import stream_from_stdin, write_to_fd
 from .client import _Client
-from .exception import InteractiveTimeoutError, InvalidError
+from .exception import InteractiveTimeoutError, InvalidError, deprecation_error
 from .io_streams import _StreamReader, _StreamWriter
 from .stream_type import StreamType
 
@@ -114,11 +114,18 @@ class _ContainerProcess(Generic[T]):
                 self._returncode = resp.exit_code
                 return self._returncode
 
-    async def attach(self, *, pty: bool):
+    async def attach(self, *, pty: Optional[bool] = None):
         if platform.system() == "Windows":
             print("interactive exec is not currently supported on Windows.")
             return
 
+        if pty is not None:
+            deprecation_error(
+                (2024, 12, 9),
+                "The `pty` argument to `modal.container_process.attach(pty=...)` is deprecated, "
+                "as only PTY mode is supported. Please remove the argument.",
+            )
+
         from rich.console import Console
 
         console = Console()
@@ -151,7 +158,7 @@ class _ContainerProcess(Generic[T]):
                 # time out if we can't connect to the server fast enough
                 await asyncio.wait_for(on_connect.wait(), timeout=60)
 
-                async with stream_from_stdin(_handle_input, use_raw_terminal=pty):
+                async with stream_from_stdin(_handle_input, use_raw_terminal=True):
                     await stdout_task
                     await stderr_task
 

modal/container_process.pyi

@@ -34,7 +34,7 @@ class _ContainerProcess(typing.Generic[T]):
     def returncode(self) -> int: ...
     async def poll(self) -> typing.Optional[int]: ...
     async def wait(self) -> int: ...
-    async def attach(self, *, pty: bool): ...
+    async def attach(self, *, pty: typing.Optional[bool] = None): ...
 
 class ContainerProcess(typing.Generic[T]):
     _process_id: typing.Optional[str]
@@ -76,7 +76,7 @@ class ContainerProcess(typing.Generic[T]):
     wait: __wait_spec
 
     class __attach_spec(typing_extensions.Protocol):
-        def __call__(self, *, pty: bool): ...
-        async def aio(self, *, pty: bool): ...
+        def __call__(self, *, pty: typing.Optional[bool] = None): ...
+        async def aio(self, *, pty: typing.Optional[bool] = None): ...
 
     attach: __attach_spec

modal/functions.py

@@ -347,7 +347,7 @@ class _FunctionSpec:
     volumes: dict[Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]]
     gpus: Union[GPU_T, list[GPU_T]]  # TODO(irfansharif): Somehow assert that it's the first kind, in sandboxes
     cloud: Optional[str]
-    cpu: Optional[float]
+    cpu: Optional[Union[float, tuple[float, float]]]
     memory: Optional[Union[int, tuple[int, int]]]
     ephemeral_disk: Optional[int]
     scheduler_placement: Optional[SchedulerPlacement]
@@ -448,7 +448,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         batch_max_size: Optional[int] = None,
         batch_wait_ms: Optional[int] = None,
         container_idle_timeout: Optional[int] = None,
-        cpu: Optional[float] = None,
+        cpu: Optional[Union[float, tuple[float, float]]] = None,
         keep_warm: Optional[int] = None,  # keep_warm=True is equivalent to keep_warm=1
         cloud: Optional[str] = None,
         scheduler_placement: Optional[SchedulerPlacement] = None,

modal/functions.pyi

@@ -96,7 +96,7 @@ class _FunctionSpec:
     ]
     gpus: typing.Union[None, bool, str, modal.gpu._GPUConfig, list[typing.Union[None, bool, str, modal.gpu._GPUConfig]]]
     cloud: typing.Optional[str]
-    cpu: typing.Optional[float]
+    cpu: typing.Union[float, tuple[float, float], None]
     memory: typing.Union[int, tuple[int, int], None]
     ephemeral_disk: typing.Optional[int]
     scheduler_placement: typing.Optional[modal.scheduler_placement.SchedulerPlacement]
@@ -117,7 +117,7 @@ class _FunctionSpec:
             None, bool, str, modal.gpu._GPUConfig, list[typing.Union[None, bool, str, modal.gpu._GPUConfig]]
         ],
         cloud: typing.Optional[str],
-        cpu: typing.Optional[float],
+        cpu: typing.Union[float, tuple[float, float], None],
         memory: typing.Union[int, tuple[int, int], None],
         ephemeral_disk: typing.Optional[int],
         scheduler_placement: typing.Optional[modal.scheduler_placement.SchedulerPlacement],
@@ -180,7 +180,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.
         batch_max_size: typing.Optional[int] = None,
         batch_wait_ms: typing.Optional[int] = None,
         container_idle_timeout: typing.Optional[int] = None,
-        cpu: typing.Optional[float] = None,
+        cpu: typing.Union[float, tuple[float, float], None] = None,
         keep_warm: typing.Optional[int] = None,
         cloud: typing.Optional[str] = None,
         scheduler_placement: typing.Optional[modal.scheduler_placement.SchedulerPlacement] = None,
@@ -348,7 +348,7 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
         batch_max_size: typing.Optional[int] = None,
         batch_wait_ms: typing.Optional[int] = None,
         container_idle_timeout: typing.Optional[int] = None,
-        cpu: typing.Optional[float] = None,
+        cpu: typing.Union[float, tuple[float, float], None] = None,
         keep_warm: typing.Optional[int] = None,
         cloud: typing.Optional[str] = None,
         scheduler_placement: typing.Optional[modal.scheduler_placement.SchedulerPlacement] = None,

modal/io_streams.py

@@ -184,7 +184,7 @@ class _StreamReader(Generic[T]):
 
                 async for message in iterator:
                     if self._stream_type == StreamType.STDOUT and message:
-                        print(message, end="")
+                        print(message.decode("utf-8"), end="")
                     elif self._stream_type == StreamType.PIPE:
                         self._container_process_buffer.append(message)
                     if message is None:

modal/network_file_system.py

@@ -221,6 +221,12 @@ class _NetworkFileSystem(_Object, type_prefix="sv"):
         resp = await retry_transient_errors(client.stub.SharedVolumeGetOrCreate, request)
         return resp.shared_volume_id
 
+    @staticmethod
+    async def delete(label: str, client: Optional[_Client] = None, environment_name: Optional[str] = None):
+        obj = await _NetworkFileSystem.lookup(label, client=client, environment_name=environment_name)
+        req = api_pb2.SharedVolumeDeleteRequest(shared_volume_id=obj.object_id)
+        await retry_transient_errors(obj._client.stub.SharedVolumeDelete, req)
+
     @live_method
     async def write_file(self, remote_path: str, fp: BinaryIO, progress_cb: Optional[Callable[..., Any]] = None) -> int:
         """Write from a file object to a path on the network file system, atomically.

modal/network_file_system.pyi

@@ -41,6 +41,10 @@ class _NetworkFileSystem(modal.object._Object):
         client: typing.Optional[modal.client._Client] = None,
         environment_name: typing.Optional[str] = None,
     ) -> str: ...
+    @staticmethod
+    async def delete(
+        label: str, client: typing.Optional[modal.client._Client] = None, environment_name: typing.Optional[str] = None
+    ): ...
     async def write_file(
         self,
         remote_path: str,
@@ -118,6 +122,22 @@ class NetworkFileSystem(modal.object.Object):
 
     create_deployed: __create_deployed_spec
 
+    class __delete_spec(typing_extensions.Protocol):
+        def __call__(
+            self,
+            label: str,
+            client: typing.Optional[modal.client.Client] = None,
+            environment_name: typing.Optional[str] = None,
+        ): ...
+        async def aio(
+            self,
+            label: str,
+            client: typing.Optional[modal.client.Client] = None,
+            environment_name: typing.Optional[str] = None,
+        ): ...
+
+    delete: __delete_spec
+
     class __write_file_spec(typing_extensions.Protocol):
         def __call__(
             self,

modal/queue.py

@@ -27,38 +27,12 @@ class _Queue(_Object, type_prefix="qu"):
 
     By default, the `Queue` object acts as a single FIFO queue which supports puts and gets (blocking and non-blocking).
 
-    **Queue partitions (beta)**
-
-    Specifying partition keys gives access to other independent FIFO partitions within the same `Queue` object.
-    Across any two partitions, puts and gets are completely independent.
-    For example, a put in one partition does not affect a get in any other partition.
-
-    When no partition key is specified (by default), puts and gets will operate on a default partition.
-    This default partition is also isolated from all other partitions.
-    Please see the Usage section below for an example using partitions.
-
-    **Lifetime of a queue and its partitions**
-
-    By default, each partition is cleared 24 hours after the last `put` operation.
-    A lower TTL can be specified by the `partition_ttl` argument in the `put` or `put_many` methods.
-    Each partition's expiry is handled independently.
-
-    As such, `Queue`s are best used for communication between active functions and not relied on for persistent storage.
-
-    On app completion or after stopping an app any associated `Queue` objects are cleaned up.
-    All its partitions will be cleared.
-
-    **Limits**
-
-    A single `Queue` can contain up to 100,000 partitions, each with up to 5,000 items. Each item can be up to 256 KiB.
-
-    Partition keys must be non-empty and must not exceed 64 bytes.
-
     **Usage**
 
     ```python
     from modal import Queue
 
+    # Create an ephemeral queue which is anonymous and garbage collected
     with Queue.ephemeral() as my_queue:
         # Putting values
         my_queue.put("some value")
@@ -82,9 +56,41 @@ class _Queue(_Object, type_prefix="qu"):
         # (beta feature) Iterate through items in place (read immutably)
         my_queue.put(1)
         assert [v for v in my_queue.iterate()] == [0, 1]
+
+    # You can also create persistent queues that can be used across apps
+    queue = Queue.from_name("my-persisted-queue", create_if_missing=True)
+    queue.put(42)
+    assert queue.get() == 42
     ```
 
     For more examples, see the [guide](/docs/guide/dicts-and-queues#modal-queues).
+
+    **Queue partitions (beta)**
+
+    Specifying partition keys gives access to other independent FIFO partitions within the same `Queue` object.
+    Across any two partitions, puts and gets are completely independent.
+    For example, a put in one partition does not affect a get in any other partition.
+
+    When no partition key is specified (by default), puts and gets will operate on a default partition.
+    This default partition is also isolated from all other partitions.
+    Please see the Usage section below for an example using partitions.
+
+    **Lifetime of a queue and its partitions**
+
+    By default, each partition is cleared 24 hours after the last `put` operation.
+    A lower TTL can be specified by the `partition_ttl` argument in the `put` or `put_many` methods.
+    Each partition's expiry is handled independently.
+
+    As such, `Queue`s are best used for communication between active functions and not relied on for persistent storage.
+
+    On app completion or after stopping an app any associated `Queue` objects are cleaned up.
+    All its partitions will be cleared.
+
+    **Limits**
+
+    A single `Queue` can contain up to 100,000 partitions, each with up to 5,000 items. Each item can be up to 256 KiB.
+
+    Partition keys must be non-empty and must not exceed 64 bytes.
     """
 
     @staticmethod

modal/runner.py

@@ -38,6 +38,7 @@ from .output import _get_output_manager, enable_output
 from .running_app import RunningApp
 from .sandbox import _Sandbox
 from .secret import _Secret
+from .stream_type import StreamType
 
 if TYPE_CHECKING:
     from .app import _App
@@ -557,7 +558,9 @@ async def _deploy_app(
     )
 
 
-async def _interactive_shell(_app: _App, cmds: list[str], environment_name: str = "", **kwargs: Any) -> None:
+async def _interactive_shell(
+    _app: _App, cmds: list[str], environment_name: str = "", pty: bool = True, **kwargs: Any
+) -> None:
     """Run an interactive shell (like `bash`) within the image for this app.
 
     This is useful for online debugging and interactive exploration of the
@@ -599,9 +602,17 @@ async def _interactive_shell(_app: _App, cmds: list[str], environment_name: str
                 **kwargs,
             )
 
-        container_process = await sandbox.exec(*sandbox_cmds, pty_info=get_pty_info(shell=True))
         try:
-            await container_process.attach(pty=True)
+            if pty:
+                container_process = await sandbox.exec(
+                    *sandbox_cmds, pty_info=get_pty_info(shell=True) if pty else None
+                )
+                await container_process.attach()
+            else:
+                container_process = await sandbox.exec(
+                    *sandbox_cmds, stdout=StreamType.STDOUT, stderr=StreamType.STDOUT
+                )
+                await container_process.wait()
         except InteractiveTimeoutError:
             # Check on status of Sandbox. It may have crashed, causing connection failure.
             req = api_pb2.SandboxWaitRequest(sandbox_id=sandbox._object_id, timeout=0)

modal/runner.pyi

@@ -75,7 +75,9 @@ async def _deploy_app(
     environment_name: typing.Optional[str] = None,
     tag: str = "",
 ) -> DeployResult: ...
-async def _interactive_shell(_app: _App, cmds: list[str], environment_name: str = "", **kwargs: typing.Any) -> None: ...
+async def _interactive_shell(
+    _app: _App, cmds: list[str], environment_name: str = "", pty: bool = True, **kwargs: typing.Any
+) -> None: ...
 def _run_stub(*args: typing.Any, **kwargs: typing.Any): ...
 def _deploy_stub(*args: typing.Any, **kwargs: typing.Any): ...
 
@@ -134,8 +136,12 @@ class __deploy_app_spec(typing_extensions.Protocol):
 deploy_app: __deploy_app_spec
 
 class __interactive_shell_spec(typing_extensions.Protocol):
-    def __call__(self, _app: _App, cmds: list[str], environment_name: str = "", **kwargs: typing.Any) -> None: ...
-    async def aio(self, _app: _App, cmds: list[str], environment_name: str = "", **kwargs: typing.Any) -> None: ...
+    def __call__(
+        self, _app: _App, cmds: list[str], environment_name: str = "", pty: bool = True, **kwargs: typing.Any
+    ) -> None: ...
+    async def aio(
+        self, _app: _App, cmds: list[str], environment_name: str = "", pty: bool = True, **kwargs: typing.Any
+    ) -> None: ...
 
 interactive_shell: __interactive_shell_spec