kash-shell 0.3.9__py3-none-any.whl → 0.3.11__py3-none-any.whl

kash/shell/utils/terminal_images.py

@@ -1,133 +0,0 @@
-import fcntl
-import os
-import select
-import shutil
-import subprocess
-import sys
-import termios
-from functools import cache
-from pathlib import Path
-
-from kash.config.text_styles import STYLE_HINT
-from kash.shell.output.shell_output import cprint
-from kash.utils.errors import SetupError
-
-
-@cache
-def terminal_supports_sixel() -> bool:
-    """
-    Modern terminals that support Sixel should respond with a sequence containing '4'
-    in their list of supported features. This is more reliable than checking terminal
-    names. Some terminals (like Hyper 4+ with xterm.js 5+) might require explicit
-    configuration to enable Sixel support.
-
-    See:
-    https://vt100.net/docs/vt510-rm/DA1.html
-    https://www.arewesixelyet.com/
-    """
-    # If not connected to a real terminal the answer is no (and in fact
-    # the test below may throw UnsupportedOperation).
-    if not (sys.stdin.isatty() and sys.stdout.isatty()):
-        return False
-
-    # Save the current terminal settings.
-    fd = sys.stdin.fileno()
-    old_settings = termios.tcgetattr(fd)
-    new_settings = termios.tcgetattr(fd)
-    new_settings[3] &= ~(termios.ICANON | termios.ECHO)
-    termios.tcsetattr(fd, termios.TCSANOW, new_settings)
-
-    # Set stdin to non-blocking.
-    old_flags = fcntl.fcntl(fd, fcntl.F_GETFL)
-    fcntl.fcntl(fd, fcntl.F_SETFL, old_flags | os.O_NONBLOCK)
-
-    try:
-        # Send the DA control sequence.
-        sys.stdout.write("\x1b[c")
-        sys.stdout.flush()
-
-        # Wait for the response.
-        ready, _, _ = select.select([fd], [], [], 1)
-        if ready:
-            response = os.read(fd, 1024).decode()
-            # Check if the response indicates SIXEL support.
-            return "4" in response
-        else:
-            return False
-    finally:
-        # Restore the terminal settings.
-        termios.tcsetattr(fd, termios.TCSANOW, old_settings)
-        fcntl.fcntl(fd, fcntl.F_SETFL, old_flags)
-
-
-# Direct detection method. Shouldn't be needed as better method above seems to work.
-# @cache
-# def terminal_supports_sixel() -> bool:
-#     term = os.environ.get("TERM", "")
-#     term_program = os.environ.get("TERM_PROGRAM", "")
-#     supported_terms = [
-#         "xterm",
-#         "xterm-256color",
-#         "screen.xterm-256color",
-#         "kitty",
-#         "iTerm.app",
-#         "wezterm",
-#         "foot",
-#         "mlterm",
-#     ]
-#     term_supports = any(supported_term in term for supported_term in supported_terms)
-#     # Old Hyper 3 does not support Sixel, new Hyper 4 does.
-#     term_program_supports = term_program not in ["Hyper"]
-#     return term_supports and term_program_supports
-
-
-@cache
-def terminal_is_kitty() -> bool:
-    return os.environ.get("TERM") == "xterm-kitty"
-
-
-def _terminal_show_image_sixel(image_path: str | Path, width: int = 600, height: int = 400) -> None:
-    if shutil.which("magick") is None:
-        raise SetupError("ImageMagick `magick` not found in path; check it is installed?")
-
-    try:
-        cmd = [
-            "magick",
-            str(image_path),
-            "-depth",
-            "8",
-            "-resize",
-            f"{width}x{height}",
-            "sixel:-",
-        ]
-        subprocess.run(cmd, check=True)
-    except subprocess.CalledProcessError as e:
-        raise SetupError(f"Failed to display image: {e}")
-
-
-def _terminal_show_image_kitty(filename: str | Path):
-    filename = str(filename)
-    try:
-        subprocess.run(["kitty", "+kitten", "icat", filename])
-    except subprocess.CalledProcessError as e:
-        raise SetupError(f"Failed to display image with kitty: {e}")
-
-
-def terminal_show_image(filename: str | Path):
-    """
-    Try to display an image in the terminal, using kitty or sixel.
-    Raise `SetupError` if not supported.
-    """
-    if terminal_is_kitty():
-        _terminal_show_image_kitty(filename)
-    elif terminal_supports_sixel():
-        _terminal_show_image_sixel(filename)
-    else:
-        raise SetupError("Image display in this terminal doesn't seem to be supported")
-
-
-def terminal_show_image_graceful(filename: str | Path):
-    try:
-        terminal_show_image(filename)
-    except SetupError:
-        cprint(f"[Image: {filename}]", style=STYLE_HINT)

kash/text_handling/markdown_util.py

@@ -1,167 +0,0 @@
-from textwrap import dedent
-from typing import Any
-
-import marko
-import regex
-from marko.block import Heading, HTMLBlock, ListItem
-from marko.inline import Link
-
-from kash.config.logger import get_logger
-
-log = get_logger(__name__)
-
-
-def as_bullet_points(values: list[str]) -> str:
-    """
-    Convert a list of strings to a Markdown bullet-point list.
-    """
-    return "\n\n".join([f"- {point}" for point in values])
-
-
-class CustomHTMLRenderer(marko.HTMLRenderer):
-    """
-    When wrapping paragraphs as divs in Markdown we usually want them to be paragraphs.
-    This handles that.
-    """
-
-    div_pattern = regex.compile(r"^\s*<div\b", regex.IGNORECASE)
-
-    def render_html_block(self, element: HTMLBlock) -> str:
-        if self.div_pattern.match(element.body.strip()):
-            return f"\n{element.body.strip()}\n"
-        else:
-            return element.body
-
-
-standard_markdown = marko.Markdown()
-
-custom_markdown = marko.Markdown(renderer=CustomHTMLRenderer)
-
-
-def markdown_to_html(markdown: str, converter: marko.Markdown = custom_markdown) -> str:
-    """
-    Convert Markdown to HTML. Markdown may contain embedded HTML.
-    """
-    return converter.convert(markdown)
-
-
-def is_markdown_header(markdown: str) -> bool:
-    """
-    Is the start of this content a Markdown header?
-    """
-    return regex.match(r"^#+ ", markdown) is not None
-
-
-def _tree_links(element, include_internal=False):
-    links = []
-
-    def _find_links(element):
-        match element:
-            case Link():
-                if include_internal or not element.dest.startswith("#"):
-                    links.append(element.dest)
-            case _:
-                if hasattr(element, "children"):
-                    for child in element.children:
-                        _find_links(child)
-
-    _find_links(element)
-    return links
-
-
-def extract_links(file_path: str, include_internal=False) -> list[str]:
-    """
-    Extract all links from a Markdown file. Future: Include textual and section context.
-    """
-
-    with open(file_path) as file:
-        content = file.read()
-        document = marko.parse(content)
-        return _tree_links(document, include_internal)
-
-
-def _extract_text(element: Any) -> str:
-    if isinstance(element, str):
-        return element
-    elif hasattr(element, "children"):
-        return "".join(_extract_text(child) for child in element.children)
-    else:
-        return ""
-
-
-def _tree_bullet_points(element: marko.block.Document) -> list[str]:
-    bullet_points: list[str] = []
-
-    def _find_bullet_points(element):
-        if isinstance(element, ListItem):
-            bullet_points.append(_extract_text(element).strip())
-        elif hasattr(element, "children"):
-            for child in element.children:
-                _find_bullet_points(child)
-
-    _find_bullet_points(element)
-    return bullet_points
-
-
-def extract_bullet_points(content: str) -> list[str]:
-    """
-    Extract list item values from a Markdown file.
-    """
-
-    document = marko.parse(content)
-    return _tree_bullet_points(document)
-
-
-def _type_from_heading(heading: Heading) -> str:
-    if heading.level in [1, 2, 3, 4, 5, 6]:
-        return f"h{heading.level}"
-    else:
-        raise ValueError(f"Unsupported heading: {heading}: level {heading.level}")
-
-
-## Tests
-
-
-def test_markdown_to_html():
-    markdown = dedent(
-        """
-        # Heading
-
-        This is a paragraph and a [link](https://example.com).
-
-        - Item 1
-        - Item 2
-
-        ## Subheading
-
-        This is a paragraph with a <span>span</span> tag.
-        This is a paragraph with a <div>div</div> tag.
-        This is a paragraph with an <a href='https://example.com'>example link</a>.
-
-        <div class="div1">This is a div.</div>
-
-        <div class="div2">This is a second div.</div>
-        """
-    )
-    print(markdown_to_html(markdown))
-
-    expected_html = dedent(
-        """
-        <h1>Heading</h1>
-        <p>This is a paragraph and a <a href="https://example.com">link</a>.</p>
-        <ul>
-        <li>Item 1</li>
-        <li>Item 2</li>
-        </ul>
-        <h2>Subheading</h2>
-        <p>This is a paragraph with a <span>span</span> tag.
-        This is a paragraph with a <div>div</div> tag.
-        This is a paragraph with an <a href='https://example.com'>example link</a>.</p>
-
-        <div class="div1">This is a div.</div>
-
-        <div class="div2">This is a second div.</div>
-        """
-    )
-
-    assert markdown_to_html(markdown).strip() == expected_html.strip()

kash/utils/common/atomic_var.py

@@ -1,171 +0,0 @@
-import copy as cpy
-import threading
-from collections.abc import Callable
-from contextlib import contextmanager
-from typing import Any, Generic, TypeVar
-
-T = TypeVar("T")
-
-
-def value_is_immutable(obj: Any) -> bool:
-    """
-    Check if a value is of a known immutable type. Just a heuristic for common
-    cases and not perfect.
-    """
-    immutable_types = (int, float, bool, str, tuple, frozenset, type(None), bytes, complex)
-    if isinstance(obj, immutable_types):
-        return True
-    if hasattr(obj, "__dataclass_params__") and getattr(obj.__dataclass_params__, "frozen", False):
-        return True
-    return False
-
-
-class AtomicVar(Generic[T]):
-    """
-    `AtomicVar` is a simple zero-dependency thread-safe variable that works
-    for any type.
-
-    Often the standard "Pythonic" approach is to use locks directly, but for
-    some common use cases, `AtomicVar` may be simpler and more readable.
-    Works on any type, including lists and dicts.
-
-    Other options include `threading.Event` (for shared booleans),
-    `threading.Queue` (for producer-consumer queues), and `multiprocessing.Value`
-    (for process-safe primitives).
-
-    Examples:
-
-    ```python
-    # Immutable types are always safe:
-    count = AtomicVar(0)
-    count.update(lambda x: x + 5)  # In any thread.
-    count.set(0)  # In any thread.
-    current_count = count.value  # In any thread.
-
-    # Useful for flags:
-    global_flag = AtomicVar(False)
-    global_flag.set(True)  # In any thread.
-    if global_flag:  # In any thread.
-        print("Flag is set")
-
-
-    # For mutable types,consider using `copy` or `deepcopy` to access the value:
-    my_list = AtomicVar([1, 2, 3])
-    my_list_copy = my_list.copy()  # In any thread.
-    my_list_deepcopy = my_list.deepcopy()  # In any thread.
-
-    # For mutable types, the `updates()` context manager gives a simple way to
-    # lock on updates:
-    with my_list.updates() as value:
-        value.append(5)
-
-    # Or if you prefer, via a function:
-    my_list.update(lambda x: x.append(4))  # In any thread.
-
-    # You can also use the var's lock directly. In particular, this encapsulates
-    # locked one-time initialization:
-    initialized = AtomicVar(False)
-    with initialized.lock:
-        if not initialized:  # checks truthiness of underlying value
-            expensive_setup()
-            initialized.set(True)
-
-    # Or:
-    lazy_var: AtomicVar[list[str] | None] = AtomicVar(None)
-    with lazy_var.lock:
-        if not lazy_var:
-            lazy_var.set(expensive_calculation())
-    ```
-    """
-
-    def __init__(self, initial_value: T, is_immutable: bool | None = None):
-        self._value: T = initial_value
-        # Use an RLock just in case we read from the var while in an update().
-        self.lock = threading.RLock()
-        if is_immutable is None:
-            self.is_immutable = value_is_immutable(initial_value)
-        else:
-            self.is_immutable = is_immutable
-
-    @property
-    def value(self) -> T:
-        """
-        Current value. For immutable types, this is thread safe. For mutable types,
-        this gives direct access to the value, so you should consider using `copy` or
-        `deepcopy` instead.
-        """
-        with self.lock:
-            return self._value
-
-    def copy(self) -> T:
-        """
-        Shallow copy of the current value.
-        """
-        with self.lock:
-            return cpy.copy(self._value)
-
-    def deepcopy(self) -> T:
-        """
-        Deep copy of the current value.
-        """
-        with self.lock:
-            return cpy.deepcopy(self._value)
-
-    def set(self, new_value: T) -> None:
-        with self.lock:
-            self._value = new_value
-
-    def swap(self, new_value: T) -> T:
-        """
-        Set to new value and return the old value.
-        """
-        with self.lock:
-            old_value = self._value
-            self._value = new_value
-            return old_value
-
-    def update(self, update_func: Callable[[T], T | None]) -> T:
-        """
-        Update value with a function and return the new value.
-
-        The `update_func` can either return a new value or update a mutable type in place,
-        in which case it should return None. Always returns the final value of the
-        variable after the update.
-        """
-        with self.lock:
-            result = update_func(self._value)
-            if result is not None:
-                self._value = result
-            # Always return the potentially updated self._value
-            return self._value
-
-    @contextmanager
-    def updates(self):
-        """
-        Context manager for convenient thread-safe updates. Only applicable to
-        mutable types.
-
-        Example usage:
-        ```
-        my_list = AtomicVar([1, 2, 3])
-        with my_list.updates() as value:
-            value.append(4)
-        ```
-        """
-        # Sanity check to avoid accidental use with atomic/immutable types.
-        if self.is_immutable:
-            raise ValueError("Cannot use AtomicVar.updates() context manager on an immutable value")
-        with self.lock:
-            yield self._value
-
-    def __bool__(self) -> bool:
-        """
-        Truthiness matches that of the underlying value.
-        """
-        return bool(self.value)
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}({self.value!r})"
-
-    def __str__(self) -> str:
-        return str(self.value)

kash/utils/common/string_replace.py

@@ -1,93 +0,0 @@
-from typing import TypeAlias
-
-Insertion = tuple[int, str]
-
-
-def insert_multiple(text: str, insertions: list[Insertion]) -> str:
-    """
-    Insert multiple strings into `text` at the given offsets, at once.
-    """
-    chunks = []
-    last_end = 0
-    for offset, insertion in sorted(insertions, key=lambda x: x[0]):
-        chunks.append(text[last_end:offset])
-        chunks.append(insertion)
-        last_end = offset
-    chunks.append(text[last_end:])
-    return "".join(chunks)
-
-
-Replacement: TypeAlias = tuple[int, int, str]
-
-
-def replace_multiple(text: str, replacements: list[Replacement]) -> str:
-    """
-    Replace multiple substrings in `text` with new strings, simultaneously.
-    The replacements are a list of tuples (start_offset, end_offset, new_string).
-    """
-    replacements = sorted(replacements, key=lambda x: x[0])
-    chunks = []
-    last_end = 0
-    for start, end, new_text in replacements:
-        if start < last_end:
-            raise ValueError("Overlapping replacements are not allowed.")
-        chunks.append(text[last_end:start])
-        chunks.append(new_text)
-        last_end = end
-    chunks.append(text[last_end:])
-    return "".join(chunks)
-
-
-## Tests
-
-
-def test_insert_multiple():
-    text = "hello world"
-    insertions = [(5, ",")]
-    expected = "hello, world"
-    assert insert_multiple(text, insertions) == expected, "Single insertion failed"
-
-    text = "hello world"
-    insertions = [(0, "Start "), (11, " End")]
-    expected = "Start hello world End"
-    assert insert_multiple(text, insertions) == expected, "Multiple insertions failed"
-
-    text = "short"
-    insertions = [(10, " end")]
-    expected = "short end"
-    assert insert_multiple(text, insertions) == expected, "Out of bounds insertion failed"
-
-    text = "negative test"
-    insertions = [(-1, "ss")]
-    expected = "negative tessst"
-    assert insert_multiple(text, insertions) == expected, "Negative offset insertion failed"
-
-    text = "no change"
-    insertions = []
-    expected = "no change"
-    assert insert_multiple(text, insertions) == expected, "Empty insertions failed"
-
-
-def test_replace_multiple():
-    text = "The quick brown fox"
-    replacements = [(4, 9, "slow"), (16, 19, "dog")]
-    expected = "The slow brown dog"
-    assert replace_multiple(text, replacements) == expected, "Multiple replacements failed"
-
-    text = "overlap test"
-    replacements = [(0, 6, "start"), (5, 10, "end")]
-    try:
-        replace_multiple(text, replacements)
-        raise AssertionError("Overlapping replacements did not raise ValueError")
-    except ValueError:
-        pass  # Expected exception
-
-    text = "short text"
-    replacements = [(5, 10, " longer text")]
-    expected = "short longer text"
-    assert replace_multiple(text, replacements) == expected, "Out of bounds replacement failed"
-
-    text = "no change"
-    replacements = []
-    expected = "no change"
-    assert replace_multiple(text, replacements) == expected, "Empty replacements failed"

kash/utils/common/string_template.py

@@ -1,101 +0,0 @@
-from collections.abc import Sequence
-from dataclasses import dataclass
-from typing import Any
-
-
-@dataclass(frozen=True)
-class StringTemplate:
-    """
-    A validated template string that supports only specified fields.
-    Can subclass to have a type with a given set of `allowed_fields`.
-    Provide a type with a field name to allow validation of int/float format strings.
-
-    Examples:
-    >>> t = StringTemplate("{name} is {age} years old", ["name", "age"])
-    >>> t.format(name="Alice", age=30)
-    'Alice is 30 years old'
-
-    >>> t = StringTemplate("{count:3d}@{price:.2f}", [("count", int), ("price", float)])
-    >>> t.format(count=10, price=19.99)
-    ' 10@19.99'
-    """
-
-    template: str
-
-    allowed_fields: Sequence[str | tuple[str, type | None]]
-    """List of allowed field names. If `d` or `f` formats are used, give tuple with the type."""
-    # Sequence is covariant so compatible with List[str]
-
-    strict: bool = False
-    """If True, raise a ValueError if the template is missing an allowed field."""
-
-    def __post_init__(self):
-        if not isinstance(self.template, str):
-            raise ValueError("Template must be a string")
-
-        # Confirm only the allowed fields are in the template.
-        field_types = self._field_types()
-        try:
-            placeholder_values = {field: (type or str)(123) for field, type in field_types.items()}
-            self.template.format(**placeholder_values)
-        except KeyError as e:
-            raise ValueError(f"Template contains unsupported variable: {e}")
-        except ValueError as e:
-            raise ValueError(
-                f"Invalid template (forgot to provide a type when using non-str format strings?): {e}"
-            )
-
-    def _field_types(self) -> dict[str, type | None]:
-        return {
-            field[0] if isinstance(field, tuple) else field: (
-                field[1] if isinstance(field, tuple) else None
-            )
-            for field in self.allowed_fields
-        }
-
-    def format(self, **kwargs: Any) -> str:
-        field_types = self._field_types()
-        allowed_keys = field_types.keys()
-        unexpected_keys = set(kwargs.keys()) - allowed_keys
-        if self.strict and unexpected_keys:
-            raise ValueError(f"Unexpected keyword arguments: {', '.join(unexpected_keys)}")
-
-        # Type check the values, if types were provided.
-        for f, expected_type in field_types.items():
-            if f in kwargs and expected_type:
-                if not isinstance(kwargs[f], expected_type):
-                    raise ValueError(
-                        f"Invalid type for '{f}': expected {expected_type.__name__} but got {repr(kwargs[f])} ({type(kwargs[f]).__name__})"
-                    )
-
-        return self.template.format(**kwargs)
-
-    def __bool__(self) -> bool:
-        return bool(self.template)
-
-
-## Tests
-
-
-def test_string_template():
-    t = StringTemplate("{name} is {age} years old", ["name", "age"])
-    assert t.format(name="Alice", age=30) == "Alice is 30 years old"
-
-    t = StringTemplate("{count:3d}@{price:.2f}", [("count", int), ("price", float)])
-    assert t.format(count=10, price=19.99) == " 10@19.99"
-
-    try:
-        StringTemplate("{name} {age}", ["name"])
-        raise AssertionError("Should have raised ValueError")
-    except ValueError as e:
-        assert "Template contains unsupported variable: 'age'" in str(e)
-
-    t = StringTemplate("{count:d}", [("count", int)])
-    try:
-        t.format(count="not an int")
-        raise AssertionError("Should have raised ValueError")
-    except ValueError as e:
-        assert "Invalid type for 'count': expected int but got 'not an int' (str)" in str(e)
-
-    assert not StringTemplate("", [])
-    assert StringTemplate("not empty", [])