kash-shell 0.3.8__py3-none-any.whl → 0.3.10__py3-none-any.whl

kash/shell/clideps/api_keys.py

@@ -1,99 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from logging import getLogger
-
-from rich.text import Text
-
-from kash.shell.clideps.dotenv_utils import env_var_is_set, load_dotenv_paths
-from kash.shell.output.shell_formatting import format_success_or_failure
-from kash.shell.output.shell_output import cprint
-from kash.utils.common.atomic_var import AtomicVar
-
-log = getLogger(__name__)
-
-
-class ApiEnvKey(str, Enum):
-    """
-    Convenience names for common API env vars. Any other env key is allowed too.
-    """
-
-    OPENAI_API_KEY = "OPENAI_API_KEY"
-    ANTHROPIC_API_KEY = "ANTHROPIC_API_KEY"
-    GEMINI_API_KEY = "GEMINI_API_KEY"
-    AZURE_API_KEY = "AZURE_API_KEY"
-    XAI_API_KEY = "XAI_API_KEY"
-    DEEPSEEK_API_KEY = "DEEPSEEK_API_KEY"
-    MISTRAL_API_KEY = "MISTRAL_API_KEY"
-    PERPLEXITYAI_API_KEY = "PERPLEXITYAI_API_KEY"
-    DEEPGRAM_API_KEY = "DEEPGRAM_API_KEY"
-    GROQ_API_KEY = "GROQ_API_KEY"
-    FIRECRAWL_API_KEY = "FIRECRAWL_API_KEY"
-    EXA_API_KEY = "EXA_API_KEY"
-
-    @classmethod
-    def for_provider(cls, provider_name: str) -> ApiEnvKey | None:
-        """
-        Get the ApiKey for a provider name, if known.
-        """
-        return getattr(cls, provider_name.upper() + "_API_KEY", None)
-
-    @property
-    def provider_name(self) -> str:
-        """
-        Get the lowercase provider name for an API ("openai", "azure", etc.).
-        This matches LiteLLM's provider names.
-        """
-        return self.value.removesuffix("_API_KEY").lower()
-
-
-_log_api_setup_done = AtomicVar(False)
-
-
-def warn_if_missing_api_keys(env_keys: list[str]) -> list[str]:
-    missing_apis = [key for key in env_keys if not env_var_is_set(key)]
-    if missing_apis:
-        log.warning(
-            "Missing recommended API keys (%s):\nCheck .env file or run `self_configure` to set them.",
-            ", ".join(missing_apis),
-        )
-
-    return missing_apis
-
-
-def available_api_keys(all_keys: list[str] | None) -> list[tuple[ApiEnvKey, bool]]:
-    if not all_keys:
-        all_keys = [key.value for key in ApiEnvKey]
-    return [(ApiEnvKey(key), env_var_is_set(key)) for key in all_keys]
-
-
-def print_api_key_setup(
-    recommended_keys: list[str], all_keys: list[str] | None = None, once: bool = False
-) -> None:
-    if not all_keys:
-        all_keys = [key.value for key in ApiEnvKey]
-    if once and _log_api_setup_done:
-        return
-
-    dotenv_paths = load_dotenv_paths()
-
-    cprint(
-        Text.assemble(
-            format_success_or_failure(
-                value=bool(dotenv_paths),
-                true_str=f"Found .env files: {', '.join(dotenv_paths)}",
-                false_str="No .env files found. Set up your API keys in a .env file.",
-            ),
-        )
-    )
-
-    texts = [
-        format_success_or_failure(is_found, key.provider_name)
-        for key, is_found in available_api_keys(all_keys)
-    ]
-
-    cprint(Text.assemble("API keys found: ", Text(" ").join(texts)))
-
-    warn_if_missing_api_keys(recommended_keys)
-
-    _log_api_setup_done.set(True)

kash/shell/clideps/dotenv_setup.py

@@ -1,114 +0,0 @@
-from pathlib import Path
-
-from flowmark import Wrap
-from prettyfmt import fmt_lines
-from strif import abbrev_str
-
-from kash.shell.clideps.dotenv_utils import (
-    env_var_is_set,
-    find_dotenv_paths,
-    read_dotenv_file,
-    update_env_file,
-)
-from kash.shell.input.input_prompts import input_confirm, input_simple_string
-from kash.shell.output.shell_formatting import format_failure, format_success
-from kash.shell.output.shell_output import (
-    cprint,
-    print_h2,
-    print_status,
-)
-
-
-def interactive_dotenv_setup(
-    api_keys: list[str],
-    update: bool = False,
-) -> None:
-    """
-    Interactively configure your .env file with the requested API key
-    environment variables.
-
-    :param all: Configure all known API keys (instead of just recommended ones).
-    :param update: Update values even if they are already set.
-    """
-
-    if not update:
-        api_keys = [key for key in api_keys if not env_var_is_set(key)]
-
-    cprint()
-    print_h2("Configuring .env file")
-    if api_keys:
-        cprint(format_failure(f"API keys needed: {', '.join(api_keys)}"))
-        interactive_update_dotenv(api_keys)
-    else:
-        cprint(format_success("All requested API keys are set!"))
-
-
-def interactive_update_dotenv(keys: list[str]) -> bool:
-    """
-    Interactively fill missing values in the active .env file.
-    Returns True if the user made changes, False otherwise.
-    """
-    dotenv_paths = find_dotenv_paths()
-    dotenv_path = dotenv_paths[0] if dotenv_paths else Path("~/.env.local").expanduser()
-
-    if dotenv_paths:
-        print_status(f"Found .env file you will update: {dotenv_path}")
-        old_dotenv = read_dotenv_file(dotenv_path)
-        if old_dotenv:
-            cprint("Current values:")
-            summary = fmt_lines(
-                [f"{k} = {repr(abbrev_str(v or '', 12))}" for k, v in old_dotenv.items()]
-            )
-            cprint(f"File has {len(old_dotenv)} keys:\n{summary}", text_wrap=Wrap.NONE)
-    else:
-        print_status("No .env file found.")
-
-    if input_confirm(
-        "Do you want make updates to your .env file?",
-        instruction="This will leave existing keys intact unless you choose to update them.",
-        default=True,
-    ):
-        dotenv_path_str = input_simple_string("Path to the .env file: ", default=str(dotenv_path))
-        if not dotenv_path_str:
-            print_status("Config changes cancelled.")
-            return False
-
-        dotenv_path = Path(dotenv_path_str)
-
-        cprint()
-        cprint(
-            "We will update the following keys from %s:\n%s",
-            dotenv_path,
-            fmt_lines(keys),
-            text_wrap=Wrap.NONE,
-        )
-        cprint()
-        cprint(
-            "Enter values for each key, or press enter to skip changes for that key. Values need not be quoted."
-        )
-
-        updates = {}
-        for key in keys:
-            value = input_simple_string(
-                f"Enter value for {key}:",
-                instruction='Leave empty to skip, use "" for a true empty string.',
-            )
-            if value and value.strip():
-                updates[key] = value
-            else:
-                cprint(f"Skipping {key}. Will not change this key.")
-
-        # Actually save the collected variables to the .env file
-        update_env_file(dotenv_path, updates, create_if_missing=True)
-        cprint()
-        cprint(format_success(f"{len(updates)} API keys saved to {dotenv_path}"))
-        cprint()
-        cprint(
-            "You can always edit the .env file directly if you need to, or "
-            "rerun `self_configure` to update your configs again."
-        )
-    else:
-        print_status("Config changes cancelled.")
-        return False
-
-    return True

kash/shell/clideps/dotenv_utils.py

@@ -1,89 +0,0 @@
-import os
-from pathlib import Path
-from shutil import copyfile
-
-from dotenv import find_dotenv, load_dotenv
-from dotenv.main import DotEnv, rewrite, with_warn_for_invalid_lines
-from dotenv.parser import parse_stream
-
-DOTENV_NAMES = [".env", ".env.local"]
-
-
-def find_dotenv_paths() -> list[str]:
-    """
-    Find .env files in the current directory and return a list of paths.
-    """
-    paths = [find_dotenv(filename=path, usecwd=True) for path in DOTENV_NAMES]
-    return [path for path in paths if path]
-
-
-def load_dotenv_paths(override: bool = True) -> list[str]:
-    """
-    Find and load .env files.
-    """
-    dotenv_paths = find_dotenv_paths()
-    for dotenv_path in dotenv_paths:
-        load_dotenv(dotenv_path, override=override)
-    return dotenv_paths
-
-
-def read_dotenv_file(dotenv_path: str | Path) -> dict[str, str | None]:
-    """
-    Read a .env file and return a dictionary of key-value pairs.
-    """
-    return DotEnv(dotenv_path=dotenv_path).dict()
-
-
-def env_var_is_set(key: str, min_length: int = 10, forbidden_str: str = "changeme") -> bool:
-    """
-    Check if an environment variable is set and plausible (not a dummy or empty value).
-    """
-    value = os.environ.get(key, None)
-    return bool(value and len(value.strip()) > min_length and forbidden_str not in value)
-
-
-def update_env_file(
-    dotenv_path: Path,
-    updates: dict[str, str],
-    create_if_missing: bool = False,
-    backup_suffix: str | None = ".bak",
-) -> tuple[list[str], list[str]]:
-    """
-    Updates values in a .env file (safely). Similar to what dotenv offers but allows multiple
-    updates at once and keeps a backup. Values may be quoted or unquoted.
-    """
-    if not create_if_missing and not dotenv_path.exists():
-        raise FileNotFoundError(f".env file does not exist: {dotenv_path}")
-
-    # Create the .env file directory if it doesn't exist
-    if create_if_missing and not dotenv_path.parent.exists():
-        dotenv_path.parent.mkdir(parents=True, exist_ok=True)
-
-    def format_line(key: str, value: str) -> str:
-        if (value.startswith("'") and value.endswith("'")) or (
-            value.startswith('"') and value.endswith('"')
-        ):
-            return f"{key}={value}"
-        else:
-            return f"{key}=" + '"' + value.replace('"', '\\"') + '"'
-
-    if backup_suffix and dotenv_path.exists():
-        copyfile(dotenv_path, dotenv_path.with_name(dotenv_path.name + backup_suffix))
-
-    changed = []
-    added = []
-    with rewrite(dotenv_path, encoding="utf-8") as (source, dest):
-        for mapping in with_warn_for_invalid_lines(parse_stream(source)):
-            if mapping.key in updates:
-                dest.write(format_line(mapping.key, updates[mapping.key]))
-                dest.write("\n")
-                changed.append(mapping.key)
-            else:
-                dest.write(mapping.original.string.rstrip("\n"))
-                dest.write("\n")
-        for key in set(updates.keys()) - set(changed):
-            dest.write(format_line(key, updates[key]))
-            dest.write("\n")
-            added.append(key)
-
-    return changed, added

kash/shell/clideps/pkg_deps.py

@@ -1,232 +0,0 @@
-import logging
-import shutil
-from collections.abc import Callable
-from dataclasses import dataclass
-from enum import Enum
-
-from cachetools import TTLCache, cached
-from rich.console import Group
-from rich.text import Text
-
-from kash.config.text_styles import EMOJI_WARN
-from kash.shell.clideps.platforms import PLATFORM, Platform
-from kash.shell.output.shell_formatting import format_name_and_value, format_success_or_failure
-from kash.shell.output.shell_output import cprint
-from kash.utils.errors import SetupError
-
-log = logging.getLogger(__name__)
-
-
-@dataclass(frozen=True)
-class PkgDep:
-    """
-    Information about a system tool dependency and how to install it.
-    """
-
-    command_names: tuple[str, ...]
-    check_function: Callable[[], bool] | None = None
-    comment: str | None = None
-    warn_if_missing: bool = False
-
-    brew_pkg: str | None = None
-    apt_pkg: str | None = None
-    pip_pkg: str | None = None
-    winget_pkg: str | None = None
-
-
-def check_libmagic():
-    try:
-        import magic
-
-        magic.Magic()
-        return True
-    except Exception as e:
-        log.info("libmagic is not installed or not accessible: %s", e)
-        return False
-
-
-class Pkg(Enum):
-    """
-    External (usually non-Python) system tools that we like to use.
-    """
-
-    # These are usually pre-installed on all platforms:
-    less = PkgDep(("less",))
-    tail = PkgDep(("tail",))
-
-    bat = PkgDep(
-        ("batcat", "bat"),  # batcat for Debian/Ubuntu), bat for macOS
-        brew_pkg="bat",
-        apt_pkg="bat",
-        winget_pkg="sharkdp.bat",
-        warn_if_missing=True,
-    )
-    ripgrep = PkgDep(
-        ("rg",),
-        brew_pkg="ripgrep",
-        apt_pkg="ripgrep",
-        winget_pkg="BurntSushi.ripgrep",
-        warn_if_missing=True,
-    )
-    eza = PkgDep(
-        ("eza",),
-        brew_pkg="eza",
-        apt_pkg="eza",
-        winget_pkg="eza-community.eza",
-        warn_if_missing=True,
-    )
-    zoxide = PkgDep(
-        ("zoxide",),
-        brew_pkg="zoxide",
-        apt_pkg="zoxide",
-        winget_pkg="ajeetdsouza.zoxide",
-        warn_if_missing=True,
-    )
-    hexyl = PkgDep(
-        ("hexyl",),
-        brew_pkg="hexyl",
-        apt_pkg="hexyl",
-        winget_pkg="sharkdp.hexyl",
-        warn_if_missing=True,
-    )
-    pygmentize = PkgDep(
-        ("pygmentize",),
-        brew_pkg="pygments",
-        apt_pkg="python3-pygments",
-        pip_pkg="Pygments",
-    )
-    libmagic = PkgDep(
-        (),
-        comment="""
-          For macOS and Linux, brew or apt gives the latest binaries. For Windows, it may be
-          easier to use pip.
-        """,
-        check_function=check_libmagic,
-        brew_pkg="libmagic",
-        apt_pkg="libmagic1",
-        pip_pkg="python-magic-bin",
-        warn_if_missing=True,
-    )
-    ffmpeg = PkgDep(
-        ("ffmpeg",),
-        brew_pkg="ffmpeg",
-        apt_pkg="ffmpeg",
-        winget_pkg="Gyan.FFmpeg",
-        warn_if_missing=True,
-    )
-    imagemagick = PkgDep(
-        ("magick",),
-        brew_pkg="imagemagick",
-        apt_pkg="imagemagick",
-        winget_pkg="ImageMagick.ImageMagick",
-        warn_if_missing=True,
-    )
-
-    @property
-    def full_name(self) -> str:
-        name = self.name
-        if self.value.command_names:
-            name += f" ({' or '.join(f'`{name}`' for name in self.value.command_names)})"
-        return name
-
-
-@dataclass(frozen=True)
-class InstalledPkgs:
-    """
-    Info about which tools are installed.
-    """
-
-    tools: dict[Pkg, str | bool]
-
-    def has(self, *tools: Pkg) -> bool:
-        return all(self.tools[tool] for tool in tools)
-
-    def require(self, *tools: Pkg) -> None:
-        for tool in tools:
-            if not self.has(tool):
-                print_missing_tool_help(tool)
-                raise SetupError(
-                    f"`{tool.value}` ({tool.value.command_names}) needed but not found"
-                )
-
-    def missing_tools(self, *tools: Pkg) -> list[Pkg]:
-        if not tools:
-            tools = tuple(Pkg)
-        return [tool for tool in tools if not self.tools[tool]]
-
-    def warn_if_missing(self, *tools: Pkg) -> None:
-        for tool in self.missing_tools(*tools):
-            if tool.value.warn_if_missing:
-                print_missing_tool_help(tool)
-
-    def formatted(self) -> Group:
-        texts: list[Text | Group] = []
-        for tool, path in self.items():
-            found_str = "Found" if isinstance(path, bool) else f"Found: `{path}`"
-            doc = format_success_or_failure(
-                bool(path),
-                true_str=format_name_and_value(tool.name, found_str),
-                false_str=format_name_and_value(tool.name, "Not found!"),
-            )
-            texts.append(doc)
-
-        return Group(*texts)
-
-    def items(self) -> list[tuple[Pkg, str | bool]]:
-        return sorted(self.tools.items(), key=lambda item: item[0].name)
-
-    def status(self) -> Text:
-        texts: list[Text] = []
-        for tool, path in self.items():
-            texts.append(format_success_or_failure(bool(path), tool.name))
-
-        return Text.assemble("Local system tools found: ", Text(" ").join(texts))
-
-
-def print_missing_tool_help(tool: Pkg):
-    warn_str = f"{EMOJI_WARN} {tool.full_name} was not found; it is recommended to install it for better functionality."
-    if tool.value.comment:
-        warn_str += f" {tool.value.comment}"
-    install_str = get_install_suggestion(tool)
-    if install_str:
-        warn_str += f" {install_str}"
-
-    cprint(warn_str)
-
-
-def get_install_suggestion(*missing_tools: Pkg) -> str | None:
-    brew_pkgs = [tool.value.brew_pkg for tool in missing_tools if tool.value.brew_pkg]
-    apt_pkgs = [tool.value.apt_pkg for tool in missing_tools if tool.value.apt_pkg]
-    winget_pkgs = [tool.value.winget_pkg for tool in missing_tools if tool.value.winget_pkg]
-    pip_pkgs = [tool.value.pip_pkg for tool in missing_tools if tool.value.pip_pkg]
-
-    if PLATFORM == Platform.Darwin and brew_pkgs:
-        return "On macOS, try using Homebrew: `brew install %s`" % " ".join(brew_pkgs)
-    elif PLATFORM == Platform.Linux and apt_pkgs:
-        return "On Linux, try using your package manager, e.g.: `sudo apt install %s`" % " ".join(
-            apt_pkgs
-        )
-    elif PLATFORM == Platform.Windows and winget_pkgs:
-        return "On Windows, try using Winget: `winget install %s`" % " ".join(winget_pkgs)
-
-    if pip_pkgs:
-        return "You may also try using pip: `pip install %s`" % " ".join(pip_pkgs)
-
-
-@cached(TTLCache(maxsize=1, ttl=5.0))
-def pkg_check() -> InstalledPkgs:
-    """
-    Check which third-party tools are installed.
-    """
-    tools: dict[Pkg, str | bool] = {}
-
-    def which_tool(tool: Pkg) -> str | None:
-        return next(filter(None, (shutil.which(name) for name in tool.value.command_names)), None)
-
-    def check_tool(tool: Pkg) -> bool:
-        return bool(tool.value.check_function and tool.value.check_function())
-
-    for tool in Pkg:
-        tools[tool] = which_tool(tool) or check_tool(tool)
-
-    return InstalledPkgs(tools)

kash/shell/clideps/platforms.py

@@ -1,11 +0,0 @@
-import platform
-from enum import StrEnum
-
-
-class Platform(StrEnum):
-    Darwin = "Darwin"
-    Linux = "Linux"
-    Windows = "Windows"
-
-
-PLATFORM = Platform(platform.system())

kash/shell/clideps/terminal_features.py

@@ -1,56 +0,0 @@
-import os
-from dataclasses import dataclass
-
-from rich import get_console
-from rich.text import Text
-
-from kash.shell.output.shell_formatting import format_success_or_failure
-from kash.shell.output.shell_output import cprint
-from kash.shell.utils.osc_utils import osc8_link_rich, terminal_supports_osc8
-from kash.shell.utils.terminal_images import terminal_supports_sixel
-
-
-@dataclass(frozen=True)
-class TerminalInfo:
-    term: str
-    term_program: str
-    terminal_width: int
-    supports_sixel: bool
-    supports_osc8: bool
-
-    def as_text(self) -> Text:
-        return Text.assemble(
-            f"{self.terminal_width} cols, ",
-            format_success_or_failure(
-                self.supports_sixel, true_str="Sixel images", false_str="No Sixel images"
-            ),
-            ", ",
-            format_success_or_failure(
-                self.supports_osc8,
-                true_str=osc8_link_rich(
-                    "https://github.com/Alhadis/OSC8-Adoption", "OSC 8 hyperlinks"
-                ),
-                false_str="No OSC 8 hyperlinks",
-            ),
-        )
-
-    def print_term_info(self):
-        cprint(
-            Text.assemble(
-                f"Terminal is {self.term} ({self.term_program}), ",
-                self.as_text(),
-            )
-        )
-
-
-def terminal_check() -> TerminalInfo:
-    """
-    Get a summary of the current terminal's name, settings, and capabilities.
-    """
-    return TerminalInfo(
-        term=os.environ.get("TERM", ""),
-        term_program=os.environ.get("TERM_PROGRAM", ""),
-        supports_sixel=terminal_supports_sixel(),
-        supports_osc8=terminal_supports_osc8(),
-        terminal_width=get_console().width,
-    )

kash/shell/utils/osc_utils.py

@@ -1,95 +0,0 @@
-import os
-from functools import cache
-
-from rich.style import Style
-from rich.text import Text
-
-
-@cache
-def terminal_supports_osc8() -> bool:
-    """
-    Attempt to detect if the terminal supports OSC 8 hyperlinks.
-    """
-    term_program = os.environ.get("TERM_PROGRAM", "")
-    term = os.environ.get("TERM", "")
-
-    if term_program in ["iTerm.app", "WezTerm", "Hyper"]:
-        return True
-    if "konsole" in term_program.lower():
-        return True
-    if "kitty" in term or "xterm" in term:
-        return True
-    if "vscode" in term_program.lower():
-        return True
-
-    return False
-
-
-# Constants for OSC control sequences
-OSC_START = "\x1b]"
-ST_CODE = "\x1b\\"  # String Terminator
-BEL_CODE = "\x07"  # Bell character
-
-OSC_HYPERLINK = "8"
-
-
-class OscStr(str):
-    """
-    Marker class for strings that contain OSC codes.
-    """
-
-    pass
-
-
-def osc_code(code: int | str, data: str) -> OscStr:
-    """
-    Return an extended OSC code.
-    """
-    return OscStr(f"{OSC_START}{code};{data}{ST_CODE}")
-
-
-def osc8_link_codes(uri: str, metadata_str: str = "") -> tuple[str, str]:
-    safe_uri = uri.replace(";", "%3B")  # Escape semicolons in the URL.
-    safe_metadata = metadata_str.replace(";", "%3B")
-    escape_start = f"{OSC_START}{OSC_HYPERLINK};{safe_metadata};{safe_uri}{ST_CODE}"
-    escape_end = f"{OSC_START}{OSC_HYPERLINK};;{ST_CODE}"
-    return escape_start, escape_end
-
-
-def osc8_link(uri: str, text: str, metadata_str: str = "") -> OscStr:
-    r"""
-    Return a string with the OSC 8 hyperlink escape sequence.
-
-    Format: ESC ] 8 ; params ; URI ST text ESC ] 8 ; ; ST
-
-    ST (String Terminator) is either ESC \ or BEL but the former is more common.
-
-    Spec: https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda
-
-    :param uri: The URI or URL for the hyperlink.
-    :param text: The clickable text to display.
-    :param metadata_str: Optional metadata between the semicolons.
-    """
-    escape_start, escape_end = osc8_link_codes(uri, metadata_str)
-
-    return OscStr(f"{escape_start}{text}{escape_end}")
-
-
-def osc8_link_graceful(uri: str, text: str, id: str = "") -> OscStr | str:
-    """
-    Generate clickable text for terminal emulators supporting OSC 8 with a fallback
-    for non-supporting terminals to make the link visible.
-    """
-    if terminal_supports_osc8():
-        metadata_str = f"id={id}" if id else ""
-        return osc8_link(uri, text, metadata_str)
-    else:
-        # Fallback for non-supporting terminals.
-        return f"{text} ({uri})"
-
-
-def osc8_link_rich(uri: str, text: str, metadata_str: str = "", style: str | Style = "") -> Text:
-    """
-    Must use Text.from_ansi() for Rich to handle links correctly!
-    """
-    return Text.from_ansi(osc8_link(uri, text, metadata_str), style=style)