indent 0.0.8__py3-none-any.whl

exponent/commands/theme.py

@@ -0,0 +1,246 @@
+import logging
+import os
+import select
+import sys
+
+from colour import Color
+
+from exponent.utils.colors import (
+    adjust_color_for_contrast,
+    blend_colors_srgb,
+    color_distance,
+)
+
+logger = logging.getLogger(__name__)
+
+
+DEFAULT_TERM_PALETTE = [
+    # Windows 10 Console default palette.
+    # The least bad default of them all ;)
+    # Used as a fallback when terminal doesn't report its palette,
+    # which only happens on older or feature-poor terminals, i.e. very rarely.
+    Color("#0c0c0c"),
+    Color("#c50f1f"),
+    Color("#13a10e"),
+    Color("#c19c00"),
+    Color("#0037da"),
+    Color("#881798"),
+    Color("#3a96dd"),
+    Color("#cccccc"),
+]
+
+
+# As the only popular "modern" terminal emulator, Terminal.app doesn't support true color
+# so disable true color output if we're running in it.
+TRUE_COLOR = os.getenv("TERM_PROGRAM") != "Apple_Terminal"
+
+
+class Theme:
+    term_fg: Color
+    term_bg: Color
+    red: Color
+    green: Color
+    blue: Color
+    exponent_green: Color
+    hl_theme_name: str
+    dimmed_text_fg: Color
+    block_header_bg: Color
+    block_body_bg: Color
+    block_footer_fg: Color
+    block_footer_bg: Color
+    statusbar_default_fg: Color
+    statusbar_autorun_all: Color
+    statusbar_autorun_ro: Color
+    statusbar_thinking_on: Color
+    thinking_spinner_fg: Color
+
+    def __init__(
+        self, term_fg: Color, term_bg: Color, term_palette: list[Color | None]
+    ):
+        self.term_fg = term_bg
+        self.term_bg = term_bg
+        self.red = adjust_color_for_contrast(
+            term_bg, term_palette[1] or DEFAULT_TERM_PALETTE[1]
+        )
+        self.green = adjust_color_for_contrast(
+            term_bg, term_palette[2] or DEFAULT_TERM_PALETTE[2]
+        )
+        self.blue = adjust_color_for_contrast(
+            term_bg, term_palette[4] or DEFAULT_TERM_PALETTE[4]
+        )
+        self.exponent_green = adjust_color_for_contrast(
+            term_bg,
+            Color("#03bd89"),  # green used in Exponent logo
+        )
+        dark_mode = term_bg.luminance < 0.5
+        self.hl_theme_name = "ansi_dark" if dark_mode else "ansi_light"
+        direction = 1 if dark_mode else -1
+        (h, s, l) = term_bg.hsl  # noqa: E741
+        block_target = Color(hsl=(h, s, min(1.0, l + 0.005 * direction)))
+        self.block_header_bg = adjust_color_for_contrast(term_bg, block_target, 1.2)
+        self.block_body_bg = adjust_color_for_contrast(term_bg, block_target, 1.1)
+        self.block_footer_bg = adjust_color_for_contrast(term_bg, block_target, 1.05)
+        self.block_footer_fg = blend_colors_srgb(term_fg, self.block_footer_bg, 0.4)
+        self.dimmed_text_fg = adjust_color_for_contrast(
+            term_bg, blend_colors_srgb(term_fg, term_bg, 0.5)
+        )
+        self.statusbar_default_fg = self.dimmed_text_fg
+        self.statusbar_autorun_all = self.red
+        self.statusbar_autorun_ro = self.green
+        self.statusbar_thinking_on = self.blue
+        self.thinking_spinner_fg = adjust_color_for_contrast(
+            term_bg, Color("#968ce6")
+        )  # nice purple
+
+
+def get_term_colors(
+    use_default_colors: bool,
+) -> tuple[Color, Color, list[Color | None]]:
+    from exponent.commands.shell_commands import POSIX_TERMINAL, RawMode
+
+    fg = DEFAULT_TERM_PALETTE[7]
+    bg = DEFAULT_TERM_PALETTE[0]
+    palette: list[Color | None] = [None, None, None, None, None, None, None, None]
+
+    # Not supported on Windows or when stdin is not a TTY
+    if use_default_colors or not POSIX_TERMINAL or not sys.stdin.isatty():
+        return (fg, bg, palette)
+
+    try:
+        with RawMode(sys.stdin.fileno()):
+            stdin_fd = sys.stdin.fileno()
+            stdout_fd = sys.stdout.fileno()
+
+            # Try to write the ANSI escape sequences
+            if stdout_fd in select.select([], [stdout_fd], [], 1)[1]:
+                os.write(
+                    stdout_fd,
+                    b"\x1b]10;?\x07\x1b]11;?\x07\x1b]4;0;?\x07\x1b]4;1;?\x07\x1b]4;2;?\x07\x1b]4;3;?\x07\x1b]4;4;?\x07\x1b]4;5;?\x07\x1b]4;6;?\x07\x1b]4;7;?\x07\x1b[c",
+                )
+            else:
+                return (fg, bg, palette)  # Can't write to stdout
+
+            got_da_response = False
+            timeout = 0.5  # Short timeout to avoid hanging
+
+            # Read terminal responses until we get DA response or timeout
+            while not got_da_response:
+                if stdin_fd in select.select([stdin_fd], [], [], timeout)[0]:
+                    reply = os.read(stdin_fd, 1024)
+                    seqs = reply.split(b"\x1b")
+
+                    for seq in seqs:
+                        if seq.startswith(b"]10;rgb:"):
+                            [r, g, b] = seq[8:].decode().split("/")
+                            fg = Color(f"#{r[0:2]}{g[0:2]}{b[0:2]}")
+                        elif seq.startswith(b"]11;rgb:"):
+                            [r, g, b] = seq[8:].decode().split("/")
+                            bg = Color(f"#{r[0:2]}{g[0:2]}{b[0:2]}")
+                        elif seq.startswith(b"]4;"):
+                            text = seq.decode()
+                            idx = int(text[3])
+                            [r, g, b] = text[9:].split("/")
+                            palette[idx] = Color(f"#{r[0:2]}{g[0:2]}{b[0:2]}")
+                        elif seq.endswith(b"c"):
+                            got_da_response = True
+                else:
+                    # Timeout, terminal didn't respond
+                    break
+    except Exception:
+        logger.debug("Error getting term colors", exc_info=True)
+        # Any exception at all, just use default colors
+        pass
+
+    return (fg, bg, palette)
+
+
+def color_component_to_8bit_cube(value: int) -> tuple[int, int]:
+    # Based on https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit
+
+    if value < 48:
+        value = 0
+        idx = 0
+    elif value < 115:
+        value = 0x5F
+        idx = 1
+    elif value < 155:
+        value = 0x87
+        idx = 2
+    elif value < 195:
+        value = 0xAF
+        idx = 3
+    elif value < 235:
+        value = 0xD7
+        idx = 4
+    else:
+        value = 0xFF
+        idx = 5
+
+    return (value, idx)
+
+
+def closest_8bit_color_index(c: Color) -> int:
+    (quantized_red, red_idx) = color_component_to_8bit_cube(round(c.red * 255))
+    (quantized_green, green_idx) = color_component_to_8bit_cube(round(c.green * 255))
+    (quantized_blue, blue_idx) = color_component_to_8bit_cube(round(c.blue * 255))
+    quantized = Color(
+        rgb=(quantized_red / 255, quantized_green / 255, quantized_blue / 255)
+    )
+    quantized_error = color_distance(c, quantized)
+
+    gray = Color(hsl=(c.hue, 0, c.luminance))
+    gray_idx = round(max(gray.red * 255 - 8, 0) / 10)
+    quantized_gray_value = 8 + 10 * gray_idx
+    quantized_gray = Color(
+        rgb=(
+            quantized_gray_value / 255,
+            quantized_gray_value / 255,
+            quantized_gray_value / 255,
+        )
+    )
+    quantized_gray_error = color_distance(c, quantized_gray)
+
+    if quantized_error < quantized_gray_error:
+        # 16 + 36 × r + 6 × g + b (0 ≤ r, g, b ≤ 5)
+        idx = 16 + 36 * red_idx + 6 * green_idx + blue_idx
+    else:
+        idx = 232 + gray_idx
+
+    return idx
+
+
+def fg_color_seq(c: int | Color) -> str:
+    if isinstance(c, int):
+        return f"\x1b[{30 + c}m"
+    elif TRUE_COLOR:
+        (r, g, b) = c.rgb
+        r = round(r * 255)
+        g = round(g * 255)
+        b = round(b * 255)
+        return f"\x1b[38;2;{r};{g};{b}m"
+    else:
+        idx = closest_8bit_color_index(c)
+        return f"\x1b[38;5;{idx}m"
+
+
+def default_fg_color_seq() -> str:
+    return "\x1b[39m"
+
+
+def bg_color_seq(c: int | Color) -> str:
+    if isinstance(c, int):
+        return f"\x1b[{40 + c}m"
+    elif TRUE_COLOR:
+        (r, g, b) = c.rgb
+        r = round(r * 255)
+        g = round(g * 255)
+        b = round(b * 255)
+        return f"\x1b[48;2;{r};{g};{b}m"
+    else:
+        idx = closest_8bit_color_index(c)
+        return f"\x1b[48;5;{idx}m"
+
+
+def get_theme(use_default_colors: bool) -> Theme:
+    (fg, bg, palette) = get_term_colors(use_default_colors)
+    return Theme(fg, bg, palette)

exponent/commands/types.py

@@ -0,0 +1,111 @@
+from collections.abc import Callable, Sequence
+from gettext import gettext
+from typing import Any
+
+import click
+import questionary
+
+from exponent.core.types.generated.strategy_info import StrategyInfo
+
+
+class AutoCompleteOption(click.Option):
+    prompt: str
+
+    def __init__(
+        self,
+        param_decls: Sequence[str] | None = None,
+        prompt: bool | str = True,
+        choices: list[str] | None = None,
+        **kwargs: Any,
+    ):
+        super().__init__(param_decls, prompt=prompt, **kwargs)
+        if isinstance(self.type, click.Choice):
+            self.choices = self.type.choices
+        else:
+            self.choices = choices or []
+
+    def prompt_for_value(self, ctx: click.core.Context) -> Any:
+        return questionary.autocomplete(
+            self.prompt,
+            list(self.choices),
+            style=questionary.Style(
+                [
+                    ("question", "bold"),  # question text
+                    (
+                        "answer",
+                        "fg:#33ccff bold",
+                    ),  # submitted answer text behind the question
+                    (
+                        "answer",
+                        "bg:#000066",
+                    ),  # submitted answer text behind the question
+                ]
+            ),
+        ).unsafe_ask()
+
+
+class StrategyChoice(click.Choice[str]):
+    def __init__(self, choices: Sequence[StrategyInfo]) -> None:
+        self.strategy_choices = choices
+        self.choices = [strategy.strategy_name.value for strategy in choices]
+        self.case_sensitive = True
+
+
+class StrategyOption(AutoCompleteOption):
+    def __init__(self, *args: Any, type: StrategyChoice, **kwargs: Any):
+        super().__init__(*args, type=type, **kwargs)
+        self.default = self.default_choice(type.strategy_choices)
+        self.strategy_choices = type.strategy_choices
+
+    def _format_strategy_info(
+        self, strategy_info: StrategyInfo, formatter: click.HelpFormatter
+    ) -> None:
+        row = (strategy_info.strategy_name.value, strategy_info.display_name)
+        formatter.write_dl([row])
+        with formatter.indentation():
+            formatter.write_text(strategy_info.description)
+
+    def help_extra_hook(self, formatter: click.HelpFormatter) -> None:
+        with formatter.section("Strategies"):
+            for strategy_info in self.strategy_choices:
+                formatter.write_paragraph()
+                self._format_strategy_info(strategy_info, formatter)
+
+    @staticmethod
+    def default_choice(choices: Sequence[StrategyInfo]) -> str:
+        return min(choices, key=lambda x: x.display_order).strategy_name.value
+
+
+class ExponentCommand(click.Command):
+    def format_options(
+        self, ctx: click.Context, formatter: click.HelpFormatter
+    ) -> None:
+        """Writes all the options into the formatter if they exist."""
+        opts = []
+        for param in self.get_params(ctx):
+            rv = param.get_help_record(ctx)
+            hook = getattr(param, "help_extra_hook", None)
+            if rv is not None:
+                opts.append((rv, hook))
+
+        if not opts:
+            return
+
+        with formatter.section(gettext("Options")):
+            for opt, hook in opts:
+                formatter.write_dl([opt])
+                if hook is not None:
+                    hook(formatter)
+                    formatter.write_paragraph()
+
+
+class ExponentGroup(click.Group):
+    command_class = ExponentCommand
+    group_class = type
+
+
+def exponent_cli_group(
+    name: str | None = None,
+    **attrs: Any,
+) -> Callable[[Callable[..., Any]], ExponentGroup]:
+    return click.command(name, ExponentGroup, **attrs)

exponent/commands/upgrade.py

@@ -0,0 +1,29 @@
+import click
+
+from exponent.commands.types import exponent_cli_group
+from exponent.utils.version import check_exponent_version, upgrade_exponent
+
+
+@exponent_cli_group()
+def upgrade_cli() -> None:
+    """Manage Exponent version upgrades."""
+    pass
+
+
+@upgrade_cli.command()
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Upgrade without prompting for confirmation, if a new version is available.",
+)
+def upgrade(force: bool = False) -> None:
+    """Upgrade Exponent to the latest version."""
+    if result := check_exponent_version():
+        installed_version, latest_version = result
+        upgrade_exponent(
+            current_version=installed_version,
+            new_version=latest_version,
+            force=force,
+        )
+    else:
+        click.echo("Exponent is already up to date.")

exponent/commands/utils.py

@@ -0,0 +1,236 @@
+import asyncio
+import os
+import sys
+import threading
+import time
+import webbrowser
+
+import click
+
+from exponent.core.config import Environment, Settings
+from exponent.utils.version import get_installed_version
+
+
+def print_editable_install_forced_prod_warning(settings: Settings) -> None:
+    click.secho(
+        "Detected local editable install, but this command only works against prod.",
+        fg="red",
+        bold=True,
+    )
+    click.secho("Using prod settings:", fg="red", bold=True)
+    click.secho("- base_url=", fg="yellow", bold=True, nl=False)
+    click.secho(f"{settings.base_url}", fg=(100, 200, 255), bold=False)
+    click.secho("- base_api_url=", fg="yellow", bold=True, nl=False)
+    click.secho(f"{settings.get_base_api_url()}", fg=(100, 200, 255), bold=False)
+    click.secho()
+
+
+def print_editable_install_warning(settings: Settings) -> None:
+    click.secho(
+        "Detected local editable install, using local URLs", fg="yellow", bold=True
+    )
+    click.secho("- base_url=", fg="yellow", bold=True, nl=False)
+    click.secho(f"{settings.base_url}", fg=(100, 200, 255), bold=False)
+    click.secho("- base_api_url=", fg="yellow", bold=True, nl=False)
+    click.secho(f"{settings.get_base_api_url()}", fg=(100, 200, 255), bold=False)
+    click.secho()
+
+
+def print_exponent_message(base_url: str, chat_uuid: str) -> None:
+    version = get_installed_version()
+    shell = os.environ.get("SHELL")
+
+    click.echo()
+    click.secho(f"△ Indent v{version}", fg=(180, 150, 255), bold=True)
+    click.echo()
+    click.echo(
+        " - Link: " + click.style(f"{base_url}/chats/{chat_uuid}", fg=(100, 200, 255))
+    )
+
+    if shell is not None:
+        click.echo(f" - Shell: {shell}")
+
+
+def is_indent_app_installed() -> bool:
+    if sys.platform == "darwin":  # macOS
+        return os.path.exists("/Applications/Indent.app")
+
+    # TODO: Add support for Windows and Linux
+    return False
+
+
+def launch_exponent_browser(
+    environment: Environment, base_url: str, chat_uuid: str
+) -> None:
+    if is_indent_app_installed() and environment == Environment.production:
+        url = f"exponent://chats/{chat_uuid}"
+    else:
+        url = f"{base_url}/chats/{chat_uuid}"
+    webbrowser.open(url)
+
+
+def start_background_event_loop() -> asyncio.AbstractEventLoop:
+    def run_event_loop(loop: asyncio.AbstractEventLoop) -> None:
+        asyncio.set_event_loop(loop)
+        loop.run_forever()
+
+    loop = asyncio.new_event_loop()
+    thread = threading.Thread(target=run_event_loop, args=(loop,), daemon=True)
+    thread.start()
+    return loop
+
+
+def read_input(prompt: str) -> str:
+    sys.stdout.write(prompt)
+    sys.stdout.flush()
+    return sys.stdin.readline()
+
+
+def ask_for_quit_confirmation(program_name: str = "Exponent") -> bool:
+    while True:
+        try:
+            answer = (
+                input(f"Do you want to quit {program_name}? [y/\x1b[1mN\x1b[0m]")
+                .strip()
+                .lower()
+            )
+            if answer in {"y", "yes"}:
+                return True
+            elif answer in {"n", "no", ""}:
+                return False
+        except KeyboardInterrupt:
+            print()
+            return True
+        except EOFError:
+            print()
+            return True
+
+
+class Spinner:
+    def __init__(self, text: str) -> None:
+        self.text = text
+        self.task: asyncio.Task[None] | None = None
+        self.base_time = time.time()
+        self.fg_color: tuple[int, int, int] | None = None
+        self.bold = False
+        self.animation_chars = "⣷⣯⣟⡿⢿⣻⣽⣾"
+        self.animation_speed = 10
+
+    def show(self) -> None:
+        if self.task is not None:
+            return
+
+        async def spinner(base_time: float) -> None:
+            color_start = ""
+            if self.fg_color:
+                if isinstance(self.fg_color, tuple) and len(self.fg_color) == 3:
+                    r, g, b = self.fg_color
+                    color_start = f"\x1b[38;2;{r};{g};{b}m"
+                elif isinstance(self.fg_color, int):
+                    color_start = f"\x1b[{30 + self.fg_color}m"
+
+            bold_start = "\x1b[1m" if self.bold else ""
+            style_start = f"{color_start}{bold_start}"
+            style_end = "\x1b[0m"
+
+            while True:
+                t = time.time() - base_time
+                i = round(t * self.animation_speed) % len(self.animation_chars)
+                print(
+                    f"\r{style_start}{self.animation_chars[i]} {self.text}{style_end}",
+                    end="",
+                )
+                await asyncio.sleep(0.1)
+
+        self.task = asyncio.get_event_loop().create_task(spinner(self.base_time))
+
+    def hide(self) -> None:
+        if self.task is None:
+            return
+
+        self.task.cancel()
+        self.task = None
+        print("\r\x1b[0m\x1b[2K", end="")
+        sys.stdout.flush()
+
+
+class ThinkingSpinner(Spinner):
+    def __init__(
+        self,
+        fg_color: tuple[int, int, int] | None = None,
+        text: str = "Exponent is thinking",
+    ) -> None:
+        super().__init__(text)
+        self.fg_color = fg_color
+        self.bold = True
+        self.animation_chars = "⣾⣽⣻⢿⡿⣟⣯⣷"  # More subtle animation
+        self.animation_speed = 8  # Medium speed animation
+        self.start_time = time.time()  # Track when thinking started
+
+    def show(self) -> None:
+        if self.task is not None:
+            return
+
+        async def spinner(base_time: float) -> None:
+            color_start = ""
+            if self.fg_color:
+                if isinstance(self.fg_color, tuple) and len(self.fg_color) == 3:
+                    r, g, b = self.fg_color
+                    color_start = f"\x1b[38;2;{r};{g};{b}m"
+                elif isinstance(self.fg_color, int):
+                    color_start = f"\x1b[{30 + self.fg_color}m"
+
+            bold_start = "\x1b[1m" if self.bold else ""
+            style_start = f"{color_start}{bold_start}"
+            style_end = "\x1b[0m"
+
+            while True:
+                t = time.time() - base_time
+                i = round(t * self.animation_speed) % len(self.animation_chars)
+
+                # Calculate elapsed seconds
+                elapsed = time.time() - self.start_time
+                if elapsed < 60:
+                    timer = f"{int(elapsed)}s"
+                else:
+                    mins = int(elapsed // 60)
+                    secs = int(elapsed % 60)
+                    timer = f"{mins}m {secs}s"
+
+                print(
+                    f"\r{style_start}{self.animation_chars[i]} {self.text} ({timer}){style_end}",
+                    end="",
+                )
+                await asyncio.sleep(0.1)
+
+        self.task = asyncio.get_event_loop().create_task(spinner(self.base_time))
+
+
+class ConnectionTracker:
+    def __init__(self) -> None:
+        self.connected = True
+        self.queue: asyncio.Queue[bool] = asyncio.Queue()
+
+    def is_connected(self) -> bool:
+        while True:
+            try:
+                self.connected = self.queue.get_nowait()
+            except asyncio.QueueEmpty:
+                break
+
+        return self.connected
+
+    async def wait_for_reconnection(self) -> None:
+        if not self.is_connected():
+            assert await self.queue.get()
+            self.connected = True
+
+    async def set_connected(self, connected: bool) -> None:
+        await self.queue.put(connected)
+
+    async def next_change(self) -> bool:
+        return await self.queue.get()
+
+
+def get_short_git_commit_hash(commit_hash: str) -> str:
+    return commit_hash[:8]