modal 1.0.6.dev58__py3-none-any.whl → 1.2.3.dev7__py3-none-any.whl

modal/cli/programs/launch_instance_ssh.py

@@ -0,0 +1,94 @@
+# Copyright Modal Labs 2023
+# type: ignore
+import json
+import os
+import sys
+from typing import Any
+
+import rich
+import rich.panel
+import rich.rule
+
+import modal
+import modal.experimental
+
+# Passed by `modal launch` locally via CLI.
+args: dict[str, Any] = json.loads(os.environ.get("MODAL_LAUNCH_ARGS", "{}"))
+
+app = modal.App()
+
+image: modal.Image
+if args.get("image"):
+    image = modal.Image.from_registry(args.get("image"))
+else:
+    # Must be set to the same image builder version as the notebook base image.
+    os.environ["MODAL_IMAGE_BUILDER_VERSION"] = "2024.10"
+    image = modal.experimental.notebook_base_image(python_version="3.12")
+
+volume = (
+    modal.Volume.from_name(
+        args.get("volume"),
+        create_if_missing=True,
+    )
+    if args.get("volume")
+    else None
+)
+volumes = {"/workspace": volume} if volume else {}
+
+
+startup_script = """
+set -eu
+mkdir -p /run/sshd
+
+# Check if sshd is installed, install if not
+test -x /usr/sbin/sshd || (apt-get update && apt-get install -y openssh-server)
+
+# Change default working directory to /workspace
+echo "cd /workspace" >> /root/.profile
+
+mkdir -p /root/.ssh
+echo "$SSH_PUBLIC_KEY" >> /root/.ssh/authorized_keys
+/usr/sbin/sshd -D -e
+"""
+
+
+@app.local_entrypoint()
+def main():
+    if not os.environ.get("SSH_PUBLIC_KEY"):
+        raise ValueError("SSH_PUBLIC_KEY environment variable is not set")
+
+    sb = modal.Sandbox.create(
+        *("sh", "-c", startup_script),
+        app=app,
+        image=image,
+        cpu=args.get("cpu"),
+        memory=args.get("memory"),
+        gpu=args.get("gpu"),
+        timeout=args.get("timeout"),
+        volumes=volumes,
+        unencrypted_ports=[22],  # Forward SSH port
+        secrets=[modal.Secret.from_dict({"SSH_PUBLIC_KEY": os.environ.get("SSH_PUBLIC_KEY")})],
+    )
+    hostname, port = sb.tunnels()[22].tcp_socket
+    connection_cmd = f"ssh -A -p {port} root@{hostname}"
+
+    rich.print(
+        rich.rule.Rule(style="yellow"),
+        rich.panel.Panel(
+            f"""Your instance is ready! You can SSH into it using the following command:
+
+  [dim gray]>[/dim gray] [bold cyan]{connection_cmd}[/bold cyan]
+
+[italic]Details:[/italic]
+  • Name:    [magenta]{app.description}[/magenta]
+  • CPU:     [yellow]{args.get("cpu")} cores[/yellow]
+  • Memory:  [yellow]{args.get("memory")} MiB[/yellow]
+  • Timeout: [yellow]{args.get("timeout")} seconds[/yellow]
+  • GPU:     [green]{(args.get("gpu") or "N/A").upper()}[/green]""",
+            title="SSH Connection",
+            expand=False,
+        ),
+        rich.rule.Rule(style="yellow"),
+    )
+
+    sys.exit(0)  # Exit immediately to prevent "Timed out waiting for final apps log."

modal/cli/programs/run_jupyter.py

@@ -54,7 +54,7 @@ def wait_for_port(url: str, q: Queue):
     cpu=args.get("cpu"),
     memory=args.get("memory"),
     gpu=args.get("gpu"),
-    timeout=args.get("timeout"),
+    timeout=args.get("timeout", 3600),
     secrets=[Secret.from_dict({"MODAL_LAUNCH_ARGS": json.dumps(args)})],
     volumes=volumes,
     max_containers=1 if volume else None,

modal/cli/programs/run_marimo.py

@@ -0,0 +1,95 @@
+# Copyright Modal Labs 2025
+# type: ignore
+import json
+import os
+import secrets
+import socket
+import subprocess
+import threading
+import time
+import webbrowser
+from typing import Any
+
+from modal import App, Image, Queue, Secret, Volume, forward
+
+# Args injected by `modal launch` CLI.
+args: dict[str, Any] = json.loads(os.environ.get("MODAL_LAUNCH_ARGS", "{}"))
+
+app = App()
+
+image = Image.from_registry(args.get("image"), add_python=args.get("add_python")).uv_pip_install("marimo")
+
+# Optional host-filesystem mount (read-only snapshot of your project, useful for editing)
+if args.get("mount"):
+    image = image.add_local_dir(args["mount"], remote_path="/root/marimo/mount")
+
+# Optional persistent Modal volume
+volume = Volume.from_name(args["volume"], create_if_missing=True) if args.get("volume") else None
+volumes = {"/root/marimo/volume": volume} if volume else {}
+
+
+def _wait_for_port(url: str, q: Queue) -> None:
+    start = time.monotonic()
+    while True:
+        try:
+            with socket.create_connection(("localhost", 8888), timeout=30):
+                break
+        except OSError as exc:
+            if time.monotonic() - start > 30:
+                raise TimeoutError("marimo server did not start within 30 s") from exc
+            time.sleep(0.05)
+    q.put(url)
+
+
+@app.function(
+    image=image,
+    cpu=args.get("cpu"),
+    memory=args.get("memory"),
+    gpu=args.get("gpu"),
+    timeout=args.get("timeout", 3600),
+    secrets=[Secret.from_dict({"MODAL_LAUNCH_ARGS": json.dumps(args)})],
+    volumes=volumes,
+    max_containers=1 if volume else None,
+)
+def run_marimo(q: Queue):
+    os.makedirs("/root/marimo", exist_ok=True)
+
+    # marimo supports token-based auth; generate one so only you can connect
+    token = secrets.token_urlsafe(12)
+
+    with forward(8888) as tunnel:
+        url = f"{tunnel.url}/?access_token={token}"
+        threading.Thread(target=_wait_for_port, args=(url, q), daemon=True).start()
+
+        print("\nmarimo on Modal, opening in browser …")
+        print(f"   -> {url}\n")
+
+        # Launch the headless edit server
+        subprocess.run(
+            [
+                "marimo",
+                "edit",
+                "--headless",  # don't open browser in container
+                "--host",
+                "0.0.0.0",  # bind all interfaces
+                "--port",
+                "8888",
+                "--token-password",
+                token,  # enable session-based auth
+                "--skip-update-check",
+                "/root/marimo",  # workspace directory
+            ],
+            env={**os.environ, "SHELL": "/bin/bash"},
+        )
+
+    q.put("done")
+
+
+@app.local_entrypoint()
+def main():
+    with Queue.ephemeral() as q:
+        run_marimo.spawn(q)
+        url = q.get()  # first message = connect URL
+        time.sleep(1)  # give server a heartbeat
+        webbrowser.open(url)
+        assert q.get() == "done"

modal/cli/programs/vscode.py

@@ -79,7 +79,7 @@ def wait_for_port(data: tuple[str, str], q: Queue):
     cpu=args.get("cpu"),
     memory=args.get("memory"),
     gpu=args.get("gpu"),
-    timeout=args.get("timeout"),
+    timeout=args.get("timeout", 3600),
     secrets=[Secret.from_dict({"MODAL_LAUNCH_ARGS": json.dumps(args)})],
     volumes=volumes,
     max_containers=1 if volume else None,

modal/cli/queues.py

@@ -1,14 +1,15 @@
 # Copyright Modal Labs 2024
+from datetime import datetime
 from typing import Optional
 
 import typer
-from rich.console import Console
 from typer import Argument, Option, Typer
 
+from modal._load_context import LoadContext
+from modal._output import make_console
 from modal._resolver import Resolver
 from modal._utils.async_utils import synchronizer
-from modal._utils.grpc_utils import retry_transient_errors
-from modal._utils.time_utils import timestamp_to_local
+from modal._utils.time_utils import timestamp_to_localized_str
 from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table
 from modal.client import _Client
 from modal.environments import ensure_env
@@ -38,23 +39,29 @@ async def create(name: str, *, env: Optional[str] = ENV_OPTION):
     """
     q = _Queue.from_name(name, environment_name=env, create_if_missing=True)
     client = await _Client.from_env()
-    resolver = Resolver(client=client)
-    await resolver.load(q)
+    resolver = Resolver()
+    load_context = LoadContext(client=client, environment_name=env)
+    await resolver.load(q, load_context)
 
 
 @queue_cli.command(name="delete", rich_help_panel="Management")
 @synchronizer.create_blocking
-async def delete(name: str, *, yes: bool = YES_OPTION, env: Optional[str] = ENV_OPTION):
+async def delete(
+    name: str,
+    *,
+    allow_missing: bool = Option(False, "--allow-missing", help="Don't error if the Queue doesn't exist."),
+    yes: bool = YES_OPTION,
+    env: Optional[str] = ENV_OPTION,
+):
     """Delete a named Queue and all of its data."""
-    # Lookup first to validate the name, even though delete is a staticmethod
-    await _Queue.from_name(name, environment_name=env).hydrate()
+    env = ensure_env(env)
     if not yes:
         typer.confirm(
             f"Are you sure you want to irrevocably delete the modal.Queue '{name}'?",
             default=False,
             abort=True,
         )
-    await _Queue.delete(name, environment_name=env)
+    await _Queue.objects.delete(name, environment_name=env, allow_missing=allow_missing)
 
 
 @queue_cli.command(name="list", rich_help_panel="Management")
@@ -62,22 +69,46 @@ async def delete(name: str, *, yes: bool = YES_OPTION, env: Optional[str] = ENV_
 async def list_(*, json: bool = False, env: Optional[str] = ENV_OPTION):
     """List all named Queues."""
     env = ensure_env(env)
-
-    max_total_size = 100_000
     client = await _Client.from_env()
-    request = api_pb2.QueueListRequest(environment_name=env, total_size_limit=max_total_size + 1)
-    response = await retry_transient_errors(client.stub.QueueList, request)
-
-    rows = [
-        (
-            q.name,
-            timestamp_to_local(q.created_at, json),
-            str(q.num_partitions),
-            str(q.total_size) if q.total_size <= max_total_size else f">{max_total_size}",
+    max_total_size = 100_000  # Limit on the *Queue size* that we report
+
+    items: list[api_pb2.QueueListResponse.QueueInfo] = []
+
+    # Note that we need to continue using the gRPC API directly here rather than using Queue.objects.list.
+    # There is some metadata that historically appears in the CLI output (num_partitions, total_size) that
+    # doesn't make sense to transmit as hydration metadata, because the values can change over time and
+    # the metadata retrieved at hydration time could get stale. Alternatively, we could rewrite this using
+    # only public API by sequentially retrieving the queues and then querying their dynamic metadata, but
+    # that would require multiple round trips and would add lag to the CLI.
+    async def retrieve_page(created_before: float) -> bool:
+        max_page_size = 100
+        pagination = api_pb2.ListPagination(max_objects=max_page_size, created_before=created_before)
+        req = api_pb2.QueueListRequest(environment_name=env, pagination=pagination, total_size_limit=max_total_size)
+        resp = await client.stub.QueueList(req)
+        items.extend(resp.queues)
+        return len(resp.queues) < max_page_size
+
+    finished = await retrieve_page(datetime.now().timestamp())
+    while True:
+        if finished:
+            break
+        finished = await retrieve_page(items[-1].metadata.creation_info.created_at)
+
+    queues = [_Queue._new_hydrated(item.queue_id, client, item.metadata, is_another_app=True) for item in items]
+
+    rows = []
+    for obj, resp_data in zip(queues, items):
+        info = await obj.info()
+        rows.append(
+            (
+                obj.name,
+                timestamp_to_localized_str(info.created_at.timestamp(), json),
+                info.created_by,
+                str(resp_data.num_partitions),
+                str(resp_data.total_size) if resp_data.total_size <= max_total_size else f">{max_total_size}",
+            )
         )
-        for q in response.queues
-    ]
-    display_table(["Name", "Created at", "Partitions", "Total size"], rows, json)
+    display_table(["Name", "Created at", "Created by", "Partitions", "Total size"], rows, json)
 
 
 @queue_cli.command(name="clear", rich_help_panel="Management")
@@ -108,7 +139,7 @@ async def peek(
 ):
     """Print the next N items in the queue or queue partition (without removal)."""
     q = _Queue.from_name(name, environment_name=env)
-    console = Console()
+    console = make_console()
     i = 0
     async for item in q.iterate(partition=partition):
         console.print(item)
@@ -119,7 +150,7 @@ async def peek(
 
 @queue_cli.command(name="len", rich_help_panel="Inspection")
 @synchronizer.create_blocking
-async def len(
+async def len_(
     name: str,
     partition: Optional[str] = PARTITION_OPTION,
     total: bool = Option(False, "-t", "--total", help="Compute the sum of the queue lengths across all partitions"),
@@ -128,5 +159,5 @@ async def len(
 ):
     """Print the length of a queue partition or the total length of all partitions."""
     q = _Queue.from_name(name, environment_name=env)
-    console = Console()
+    console = make_console()
     console.print(await q.len(partition=partition, total=total))

modal/cli/run.py

@@ -10,6 +10,7 @@ import time
 import typing
 from dataclasses import dataclass
 from functools import partial
+from pathlib import Path, PurePosixPath
 from typing import Any, Callable, Optional
 
 import click
@@ -22,9 +23,10 @@ from ..app import App, LocalEntrypoint
 from ..cls import _get_class_constructor_signature
 from ..config import config
 from ..environments import ensure_env
-from ..exception import ExecutionError, InvalidError, _CliUserExecutionError
+from ..exception import ExecutionError, InvalidError, NotFoundError, _CliUserExecutionError
 from ..functions import Function
 from ..image import Image
+from ..mount import _Mount
 from ..output import enable_output
 from ..runner import deploy_app, interactive_shell, run_app
 from ..secret import Secret
@@ -467,11 +469,10 @@ def deploy(
     if not name:
         raise ExecutionError(
             "You need to either supply an explicit deployment name on the command line "
-            "or have a name set on the app.\n"
+            "or have a name set on the App.\n"
             "\n"
             "Examples:\n"
-            'app = modal.App("some-name")'
-            "or\n"
+            'app = modal.App("some-name")\n'
             "modal deploy ... --name=some-name"
         )
 
@@ -497,6 +498,12 @@ def serve(
     ```
     modal serve hello_world.py
     ```
+
+    Modal-generated URLs will have a `-dev` suffix appended to them when running with `modal serve`.
+    To customize this suffix (i.e., to avoid collisions with other users in your workspace who are
+    concurrently serving the App), you can set the `dev_suffix` in your `.modal.toml` file or the
+    `MODAL_DEV_SUFFIX` environment variable.
+
     """
     env = ensure_env(env)
     import_ref = parse_import_ref(app_ref, use_module_mode=use_module_mode)
@@ -517,13 +524,12 @@ def serve(
 
 
 def shell(
-    container_or_function: Optional[str] = typer.Argument(
+    ref: Optional[str] = typer.Argument(
         default=None,
         help=(
-            "ID of running container, or path to a Python file containing a Modal App."
-            " Can also include a function specifier, like `module.py::func`, if the file defines multiple functions."
+            "ID of running container or Sandbox, or path to a Python file containing an App."
+            " Can also include a Function specifier, like `module.py::func`, if the file defines multiple Functions."
         ),
-        metavar="REF",
     ),
     cmd: str = typer.Option("/bin/bash", "-c", "--cmd", help="Command to run inside the Modal image."),
     env: str = ENV_OPTION,
@@ -538,6 +544,13 @@ def shell(
             " Can be used multiple times."
         ),
     ),
+    add_local: Optional[list[str]] = typer.Option(
+        default=None,
+        help=(
+            "Local file or directory to mount inside the shell at `/mnt/{basename}` (if not using REF)."
+            " Can be used multiple times."
+        ),
+    ),
     secret: Optional[list[str]] = typer.Option(
         default=None,
         help=("Name of a `modal.Secret` to mount inside the shell (if not using REF). Can be used multiple times."),
@@ -603,6 +616,12 @@ def shell(
     ```
     modal shell hello_world.py -c 'uv pip list' > env.txt
     ```
+
+    Connect to a running Sandbox by ID:
+
+    ```
+    modal shell sb-abc123xyz
+    ```
     """
     env = ensure_env(env)
 
@@ -614,19 +633,28 @@ def shell(
 
     app = App("modal shell")
 
-    if container_or_function is not None:
+    if ref is not None:
+        # `modal shell` with a sandbox ID gets the task_id, that's then handled by the `ta-*` flow below.
+        if ref.startswith("sb-") and len(ref[3:]) > 0 and ref[3:].isalnum():
+            from ..sandbox import Sandbox
+
+            try:
+                sandbox = Sandbox.from_id(ref)
+                task_id = sandbox._get_task_id()
+                ref = task_id
+            except NotFoundError as e:
+                raise ClickException(f"Sandbox '{ref}' not found")
+            except Exception as e:
+                raise ClickException(f"Error connecting to sandbox '{ref}': {str(e)}")
+
         # `modal shell` with a container ID is a special case, alias for `modal container exec`.
-        if (
-            container_or_function.startswith("ta-")
-            and len(container_or_function[3:]) > 0
-            and container_or_function[3:].isalnum()
-        ):
+        if ref.startswith("ta-") and len(ref[3:]) > 0 and ref[3:].isalnum():
             from .container import exec
 
-            exec(container_id=container_or_function, command=shlex.split(cmd), pty=pty)
+            exec(container_id=ref, command=shlex.split(cmd), pty=pty)
             return
 
-        import_ref = parse_import_ref(container_or_function, use_module_mode=use_module_mode)
+        import_ref = parse_import_ref(ref, use_module_mode=use_module_mode)
         runnable, all_usable_commands = import_and_filter(
             import_ref, base_cmd="modal shell", accept_local_entrypoint=False, accept_webhook=True
         )
@@ -673,9 +701,23 @@ def shell(
         modal_image = Image.from_registry(image, add_python=add_python) if image else None
         volumes = {} if volume is None else {f"/mnt/{vol}": Volume.from_name(vol) for vol in volume}
         secrets = [] if secret is None else [Secret.from_name(s) for s in secret]
+
+        mounts = []
+        if add_local:
+            for local_path_str in add_local:
+                local_path = Path(local_path_str).expanduser().resolve()
+                remote_path = PurePosixPath(f"/mnt/{local_path.name}")
+
+                if local_path.is_dir():
+                    m = _Mount._from_local_dir(local_path, remote_path=remote_path)
+                else:
+                    m = _Mount._from_local_file(local_path, remote_path=remote_path)
+                mounts.append(m)
+
         start_shell = partial(
             interactive_shell,
             image=modal_image,
+            mounts=mounts,
             cpu=cpu,
             memory=memory,
             gpu=gpu,

modal/cli/secret.py

@@ -3,19 +3,19 @@ import json
 import os
 import platform
 import subprocess
+from datetime import datetime
 from pathlib import Path
 from tempfile import NamedTemporaryFile
 from typing import Optional
 
 import click
 import typer
-from rich.console import Console
 from rich.syntax import Syntax
-from typer import Argument
+from typer import Argument, Option
 
+from modal._output import make_console
 from modal._utils.async_utils import synchronizer
-from modal._utils.grpc_utils import retry_transient_errors
-from modal._utils.time_utils import timestamp_to_local
+from modal._utils.time_utils import timestamp_to_localized_str
 from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table
 from modal.client import _Client
 from modal.environments import ensure_env
@@ -30,20 +30,45 @@ secret_cli = typer.Typer(name="secret", help="Manage secrets.", no_args_is_help=
 async def list_(env: Optional[str] = ENV_OPTION, json: bool = False):
     env = ensure_env(env)
     client = await _Client.from_env()
-    response = await retry_transient_errors(client.stub.SecretList, api_pb2.SecretListRequest(environment_name=env))
-    column_names = ["Name", "Created at", "Last used at"]
-    rows = []
 
-    for item in response.items:
+    items: list[api_pb2.SecretListItem] = []
+
+    # Note that we need to continue using the gRPC API directly here rather than using Secret.objects.list.
+    # There is some metadata that historically appears in the CLI output (last_used_at) that
+    # doesn't make sense to transmit as hydration metadata, because the value can change over time and
+    # the metadata retrieved at hydration time could get stale. Alternatively, we could rewrite this using
+    # only public API by sequentially retrieving the secrets and then querying their dynamic metadata, but
+    # that would require multiple round trips and would add lag to the CLI.
+    async def retrieve_page(created_before: float) -> bool:
+        max_page_size = 100
+        pagination = api_pb2.ListPagination(max_objects=max_page_size, created_before=created_before)
+        req = api_pb2.SecretListRequest(environment_name=env, pagination=pagination)
+        resp = await client.stub.SecretList(req)
+        items.extend(resp.items)
+        return len(resp.items) < max_page_size
+
+    finished = await retrieve_page(datetime.now().timestamp())
+    while True:
+        if finished:
+            break
+        finished = await retrieve_page(items[-1].metadata.creation_info.created_at)
+
+    secrets = [_Secret._new_hydrated(item.secret_id, client, item.metadata, is_another_app=True) for item in items]
+
+    rows = []
+    for obj, resp_data in zip(secrets, items):
+        info = await obj.info()
         rows.append(
             [
-                item.label,
-                timestamp_to_local(item.created_at, json),
-                timestamp_to_local(item.last_used_at, json) if item.last_used_at else "-",
+                obj.name,
+                timestamp_to_localized_str(info.created_at.timestamp(), json),
+                info.created_by,
+                timestamp_to_localized_str(resp_data.last_used_at, json) if resp_data.last_used_at else "-",
             ]
         )
 
     env_part = f" in environment '{env}'" if env else ""
+    column_names = ["Name", "Created at", "Created by", "Last used at"]
     display_table(column_names, rows, json, title=f"Secrets{env_part}")
 
 
@@ -114,10 +139,14 @@ modal secret create my-credentials username=john password="$PASSWORD"
             raise click.UsageError(f"Non-string value for secret '{k}'")
 
     # Create secret
-    await _Secret.create_deployed(secret_name, env_dict, overwrite=force)
+    if force:
+        # TODO migrate this path once we support Secret.update()?
+        await _Secret._create_deployed(secret_name, env_dict, overwrite=force)
+    else:
+        await _Secret.objects.create(secret_name, env_dict)
 
     # Print code sample
-    console = Console()
+    console = make_console()
     env_var_code = "\n    ".join(f'os.getenv("{name}")' for name in env_dict.keys()) if env_dict else "..."
     example_code = f"""
 @app.function(secrets=[modal.Secret.from_name("{secret_name}")])
@@ -132,26 +161,23 @@ def some_function():
     console.print(Syntax(example_code, "python"))
 
 
-@secret_cli.command("delete", help="Delete a named secret.")
+@secret_cli.command("delete", help="Delete a named Secret.")
 @synchronizer.create_blocking
 async def delete(
-    secret_name: str = Argument(help="Name of the modal.Secret to be deleted. Case sensitive"),
+    name: str = Argument(help="Name of the modal.Secret to be deleted. Case sensitive"),
+    *,
+    allow_missing: bool = Option(False, "--allow-missing", help="Don't error if the Secret doesn't exist."),
     yes: bool = YES_OPTION,
     env: Optional[str] = ENV_OPTION,
 ):
-    """TODO"""
     env = ensure_env(env)
-    secret = await _Secret.from_name(secret_name, environment_name=env).hydrate()
     if not yes:
         typer.confirm(
-            f"Are you sure you want to irrevocably delete the modal.Secret '{secret_name}'?",
+            f"Are you sure you want to irrevocably delete the modal.Secret '{name}'?",
             default=False,
             abort=True,
         )
-    client = await _Client.from_env()
-
-    # TODO: replace with API on `modal.Secret` when we add it
-    await client.stub.SecretDelete(api_pb2.SecretDeleteRequest(secret_id=secret.object_id))
+    await _Secret.objects.delete(name, environment_name=env, allow_missing=allow_missing)
 
 
 def get_text_from_editor(key) -> str:

modal/cli/utils.py

@@ -7,13 +7,12 @@ from typing import Optional, Union
 import typer
 from click import UsageError
 from grpclib import GRPCError, Status
-from rich.console import Console
 from rich.table import Column, Table
 from rich.text import Text
 
 from modal_proto import api_pb2
 
-from .._output import OutputManager, get_app_logs_loop
+from .._output import OutputManager, get_app_logs_loop, make_console
 from .._utils.async_utils import synchronizer
 from ..client import _Client
 from ..environments import ensure_env
@@ -66,7 +65,7 @@ def _plain(text: Union[Text, str]) -> str:
 
 
 def is_tty() -> bool:
-    return Console().is_terminal
+    return make_console().is_terminal
 
 
 def display_table(
@@ -78,7 +77,7 @@ def display_table(
     def col_to_str(col: Union[Column, str]) -> str:
         return str(col.header) if isinstance(col, Column) else col
 
-    console = Console()
+    console = make_console()
     if json:
         json_data = [{col_to_str(col): _plain(row[i]) for i, col in enumerate(columns)} for row in rows]
         console.print_json(dumps(json_data))