indent 0.1.26__py3-none-any.whl

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 Indent 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 Indent 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("Indent is already up to date.")

exponent/commands/utils.py

@@ -0,0 +1,146 @@
+import asyncio
+import os
+import sys
+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)
+
+
+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)
+                click.echo(
+                    f"\r{style_start}{self.animation_chars[i]} {self.text}{style_end}",
+                    nl=False,
+                )
+                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
+        click.echo("\r\x1b[0m\x1b[2K", nl=False)
+        sys.stdout.flush()
+
+
+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]

exponent/core/config.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import enum
+import json
+import logging
+import os
+from functools import lru_cache
+from importlib.metadata import Distribution, PackageNotFoundError
+from typing import Any, Dict  # noqa: UP035
+
+from pydantic import BaseModel
+from pydantic_settings import (
+    BaseSettings,
+    JsonConfigSettingsSource,
+    PydanticBaseSettingsSource,
+    SettingsConfigDict,
+)
+
+logger = logging.getLogger(__name__)
+
+# If the package is editable, we want to use:
+# base_url = localhost:3000
+# base_api_url = localhost:8000
+
+
+def is_editable_install() -> bool:
+    if os.getenv("ENVIRONMENT") == "test" or os.getenv("EXPONENT_TEST_AUTO_UPGRADE"):
+        # We should explicitly set these variables
+        # in test when needed
+        return False
+
+    try:
+        dist = Distribution.from_name("indent")
+    except PackageNotFoundError:
+        logger.info("No distribution info found for indent")
+        return False
+
+    direct_url = dist.read_text("direct_url.json")
+    if not direct_url:
+        return False
+
+    try:
+        direct_url_json = json.loads(direct_url)
+    except json.JSONDecodeError:
+        logger.warning("Failed to decode distribution info for exponent-run")
+        return False
+
+    pkg_is_editable = direct_url_json.get("dir_info", {}).get("editable", False)
+    return bool(pkg_is_editable)
+
+
+class Environment(str, enum.Enum):
+    test = "test"
+    development = "development"
+    staging = "staging"
+    production = "production"
+
+    @property
+    def is_local(self) -> bool:
+        return self in [Environment.development, Environment.test]
+
+
+class APIKeys(BaseModel):
+    development: str | None = None
+    staging: str | None = None
+    production: str | None = None
+
+
+SETTINGS_FOLDER = os.path.expanduser("~/.config/indent")
+SETTINGS_FILE_PATH = os.path.join(SETTINGS_FOLDER, "config.json")
+
+
+class GlobalExponentOptions(BaseModel):
+    git_warning_disabled: bool = False
+    auto_upgrade: bool = True
+    base_api_url_override: str | None = None
+    base_ws_url_override: str | None = None
+    use_default_colors: bool = False
+
+
+class Settings(BaseSettings):
+    environment: Environment
+    base_url: str
+    base_api_url: str
+    base_ws_url: str
+
+    exponent_api_key: str | None = None
+    extra_exponent_api_keys: Dict[str, str] = {}  # noqa: UP006
+
+    options: GlobalExponentOptions = GlobalExponentOptions()
+
+    log_level: str = "WARNING"
+
+    model_config = SettingsConfigDict(
+        json_file=SETTINGS_FILE_PATH,
+        json_file_encoding="utf-8",
+        env_prefix="EXPONENT_",
+    )
+
+    def get_base_api_url(self) -> str:
+        return self.options.base_api_url_override or self.base_api_url
+
+    def get_base_ws_url(self) -> str:
+        return self.options.base_ws_url_override or self.base_ws_url
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,
+    ) -> tuple[PydanticBaseSettingsSource, ...]:
+        return env_settings, JsonConfigSettingsSource(settings_cls), init_settings
+
+    def write_settings_to_config_file(self) -> None:
+        os.makedirs(SETTINGS_FOLDER, exist_ok=True)
+        with open(SETTINGS_FILE_PATH, "w") as f:
+            f.write(
+                self.model_dump_json(
+                    include=self.config_file_keys, exclude_defaults=True
+                )
+            )
+
+    def get_config_file_settings(self) -> dict[str, Any]:
+        return self.model_dump(include=self.config_file_keys, exclude_defaults=True)
+
+    @property
+    def config_file_path(self) -> str:
+        return SETTINGS_FILE_PATH
+
+    @property
+    def config_file_keys(self) -> set[str]:
+        return {"exponent_api_key", "extra_exponent_api_keys", "options"}
+
+    @property
+    def api_key(self) -> str | None:
+        if self.environment.is_local:
+            return self.extra_exponent_api_keys.get(Environment.development)
+        elif self.environment == Environment.staging:
+            return self.extra_exponent_api_keys.get(Environment.staging)
+        elif self.environment == Environment.production:
+            return self.exponent_api_key
+        else:
+            raise ValueError(f"Unknown environment: {self.environment}")
+
+    def update_api_key(self, api_key: str) -> None:
+        if self.environment == Environment.development:
+            self.extra_exponent_api_keys[Environment.development] = api_key
+        elif self.environment == Environment.staging:
+            self.extra_exponent_api_keys[Environment.staging] = api_key
+        elif self.environment == Environment.production:
+            self.exponent_api_key = api_key
+
+
+@lru_cache(maxsize=1)
+def get_settings(use_prod: bool = False, use_staging: bool = False) -> Settings:
+    if is_editable_install() and not (use_prod or use_staging):
+        base_url = "http://localhost:3000"
+        base_api_url = "http://localhost:8000"
+        base_ws_url = "ws://localhost:8000"
+        environment = Environment.development
+    elif use_staging:
+        base_url = "https://staging.indent.com"
+        base_api_url = "https://staging-api.indent.com"
+        base_ws_url = "wss://ws-staging-api.indent.com"
+        environment = Environment.staging
+    else:
+        base_url = "https://app.indent.com"
+        base_api_url = "https://api.indent.com"
+        base_ws_url = "wss://ws-api.indent.com"
+        environment = Environment.production
+
+    return Settings(
+        base_url=base_url,
+        base_api_url=base_api_url,
+        base_ws_url=base_ws_url,
+        environment=environment,
+    )

exponent/core/graphql/client.py

@@ -0,0 +1,61 @@
+from collections.abc import AsyncGenerator
+from typing import Any
+
+from gql import Client, GraphQLRequest, gql
+from gql.transport.httpx import HTTPXAsyncTransport
+from gql.transport.websockets import WebsocketsTransport
+
+
+class GraphQLClient:
+    def __init__(self, api_key: str, base_api_url: str, base_ws_url: str):
+        self.graphql_url = f"{base_api_url}/graphql"
+        self.websocket_url = f"{base_ws_url}/graphql_ws".replace(
+            "https", "wss"
+        ).replace("http", "ws")
+
+        self.api_key = api_key
+
+    def get_transport(self, timeout: float | None = None) -> HTTPXAsyncTransport:
+        return HTTPXAsyncTransport(
+            url=self.graphql_url,
+            headers={"API-KEY": self.api_key},
+            timeout=timeout,
+        )
+
+    def get_ws_transport(self) -> WebsocketsTransport:
+        return WebsocketsTransport(
+            url=self.websocket_url,
+            init_payload={"apiKey": self.api_key},
+        )
+
+    async def execute(
+        self,
+        query_str: str,
+        vars: dict[str, Any] | None = None,
+        op_name: str | None = None,
+        timeout: float | None = None,
+    ) -> Any:
+        async with Client(
+            transport=self.get_transport(timeout),
+            fetch_schema_from_transport=False,
+            execute_timeout=timeout,
+        ) as session:
+            # Execute single query
+            query = GraphQLRequest(
+                query_str, variable_values=vars, operation_name=op_name
+            )
+            result = await session.execute(query)
+            return result
+
+    async def subscribe(
+        self,
+        subscription_str: str,
+        vars: dict[str, Any] | None = None,
+    ) -> AsyncGenerator[dict[str, Any], None]:
+        async with Client(
+            transport=self.get_ws_transport(),
+        ) as session:
+            # Execute subscription
+            subscription = gql(subscription_str)
+            async for result in session.subscribe(subscription, vars):
+                yield result

exponent/core/graphql/get_chats_query.py

@@ -0,0 +1,47 @@
+GET_CHATS_QUERY: str = """
+    query Chats {
+        chats {
+            ... on UnauthenticatedError {
+                message
+            }
+            ... on Chats {
+                chats {
+                    id
+                    chatUuid
+                    name
+                    subtitle
+                    isShared
+                    isStarted
+                    updatedAt # ISO datetime string
+                }
+            }
+        }
+    }
+"""
+CREATE_CLOUD_CONFIG_MUTATION: str = """
+    mutation CreateCloudConfig(
+        $githubOrgName: String!,
+        $githubRepoName: String!,
+        $setupCommands: [String!],
+    ) {
+        createCloudConfig(
+            input: {
+                githubOrgName: $githubOrgName,
+                githubRepoName: $githubRepoName,
+                setupCommands: $setupCommands,
+            }
+        ) {
+            __typename
+            ... on UnauthenticatedError {
+                message
+            }
+            ... on CloudConfig {
+                cloudConfigUuid
+                githubOrgName
+                githubRepoName
+                setupCommands
+                repoUrl
+            }
+        }
+    }
+"""