@scemoon/cdh 1.0.9 → 1.0.10-beta.1

package/tui/widgets/command_pane.py

@@ -1,223 +0,0 @@
-import asyncio
-import codecs
-from dataclasses import dataclass
-
-import os
-import fcntl
-import pty
-import struct
-import termios
-
-
-from textual import events
-from textual.message import Message
-
-from tui.shell_read import shell_read
-
-from tui.widgets.terminal import Terminal
-
-
-class CommandError(Exception):
-    """An error occurred running the command."""
-
-
-class CommandPane(Terminal):
-    DEFAULT_CSS = """
-    CommandPane {
-        scrollbar-size: 0 0;
-    }
-    """
-
-    def __init__(
-        self,
-        name: str | None = None,
-        id: str | None = None,
-        classes: str | None = None,
-    ):
-        self._execute_task: asyncio.Task | None = None
-        self._return_code: int | None = None
-        self._master: int | None = None
-        super().__init__(name=name, id=id, classes=classes)
-
-    @property
-    def return_code(self) -> int | None:
-        return self._return_code
-
-    @dataclass
-    class CommandComplete(Message):
-        return_code: int
-
-    def execute(self, command: str, *, final: bool = True) -> asyncio.Task:
-        self._execute_task = asyncio.create_task(self._execute(command, final=final))
-        self.anchor()
-        return self._execute_task
-
-    def on_resize(self, event: events.Resize):
-        event.prevent_default()
-        if self._master is None:
-            return
-        self._size_changed()
-
-    def _size_changed(self):
-        if self._master is None:
-            return
-        width, height = self.scrollable_content_region.size
-        try:
-            size = struct.pack("HHHH", height, width, 0, 0)
-            fcntl.ioctl(self._master, termios.TIOCSWINSZ, size)
-        except OSError:
-            pass
-        self.update_size(width, height)
-
-    @property
-    def is_cooked(self) -> bool:
-        """Is the terminal in 'cooked' mode?"""
-        if self._master is None:
-            return True
-        attrs = termios.tcgetattr(self._master)
-        lflag = attrs[3]
-        return bool(lflag & termios.ICANON)
-
-    async def write_stdin(self, text: str | bytes, hide_echo: bool = False) -> int:
-        if self._master is None:
-            return 0
-        text_bytes = text.encode("utf-8", "ignore") if isinstance(text, str) else text
-        try:
-            return await asyncio.to_thread(os.write, self._master, text_bytes)
-        except OSError:
-            return 0
-
-    async def _execute(self, command: str, *, final: bool = True) -> None:
-        # width, height = self.scrollable_content_region.size
-
-        await self.wait_for_refresh()
-
-        master, slave = pty.openpty()
-        self._master = master
-
-        flags = fcntl.fcntl(master, fcntl.F_GETFL)
-        fcntl.fcntl(master, fcntl.F_SETFL, flags | os.O_NONBLOCK)
-
-        # # Get terminal attributes
-        # attrs = termios.tcgetattr(slave)
-
-        # # Apply the changes
-        # termios.tcsetattr(slave, termios.TCSANOW, attrs)
-
-        env = os.environ.copy()
-        env["FORCE_COLOR"] = "1"
-        env["TTY_COMPATIBLE"] = "1"
-        env["TERM"] = "xterm-256color"
-        env["COLORTERM"] = "truecolor"
-        env["TOAD"] = "1"
-        env["CLICOLOR"] = "1"
-
-        try:
-            process = await asyncio.create_subprocess_shell(
-                command,
-                stdin=slave,
-                stdout=slave,
-                stderr=slave,
-                env=env,
-                start_new_session=True,  # Linux / macOS only
-            )
-        except Exception as error:
-            raise CommandError(f"Failed to execute {command!r}; {error}")
-
-        os.close(slave)
-
-        self._size_changed()
-
-        self.set_write_to_stdin(self.write_stdin)
-
-        BUFFER_SIZE = 64 * 1024
-        reader = asyncio.StreamReader(BUFFER_SIZE)
-        protocol = asyncio.StreamReaderProtocol(reader)
-
-        loop = asyncio.get_event_loop()
-        transport, _ = await loop.connect_read_pipe(
-            lambda: protocol, os.fdopen(master, "rb", 0)
-        )
-
-        # Create write transport
-        writer_protocol = asyncio.BaseProtocol()
-        self.write_transport, _ = await loop.connect_write_pipe(
-            lambda: writer_protocol,
-            os.fdopen(os.dup(master), "wb", 0),
-        )
-        unicode_decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
-        try:
-            while True:
-                data = await shell_read(reader, BUFFER_SIZE)
-                if line := unicode_decoder.decode(data, final=not data):
-                    try:
-                        await self.write(line)
-                    except Exception as error:
-                        print(repr(line))
-                        print(error)
-                        from traceback import print_exc
-
-                        print_exc()
-
-                if not data:
-                    break
-        finally:
-            transport.close()
-
-        await process.wait()
-        return_code = self._return_code = process.returncode
-        if final:
-            self.set_class(return_code == 0, "-success")
-            self.set_class(return_code != 0, "-fail")
-        self.post_message(self.CommandComplete(return_code or 0))
-        self.hide_cursor = True
-
-
-if __name__ == "__main__":
-    from textual.app import App, ComposeResult
-    from textual.content import Content
-
-    COMMAND = os.environ["SHELL"]
-    # COMMAND = "python test_input.py"
-
-    # COMMAND = "htop"
-    # COMMAND = "python test_scroll_margins.py"
-
-    # COMMAND = "python cpr.py"
-
-    COMMAND = "python test_input.py"
-
-    class CommandApp(App):
-        CSS = """
-        Screen {
-            align: center middle;
-        }
-        CommandPane {
-            # background: blue 20%;
-            scrollbar-gutter: stable;
-            background: black 10%;
-            max-height: 40;
-            # border: green;
-            border: tab $text-primary;            
-            margin: 0 2;
-        }
-        # CommandPane {
-        #     width: 1fr;
-        #     height: 1fr;
-        #     # background: black 10%;
-        #     # color: white;
-        #     background: ansi_default;
-        #     # color: ansi_default;
-        # }
-        """
-
-        def compose(self) -> ComposeResult:
-            yield CommandPane()
-
-        def on_mount(self) -> None:
-            command_pane = self.query_one(CommandPane)
-            command_pane.border_title = Content(COMMAND)
-            command_pane.execute(COMMAND)
-
-    app = CommandApp()
-    app.run()

package/tui/widgets/condensed_path.py

@@ -1,115 +0,0 @@
-from functools import lru_cache
-import os.path
-from typing import Iterable
-
-from rich.cells import cell_len
-from textual.geometry import Size
-from textual.reactive import reactive
-from textual.content import Content
-from textual.widget import Widget
-
-
-def radiate_range(total: int) -> Iterable[tuple[int, int]]:
-    """Generate pairs of indexes, gradually growing from the center.
-
-    Args:
-        total: Total size of range.
-
-    Yields:
-        Pairs of indexes.
-    """
-    if not total:
-        return
-    left = right = total // 2
-    yield (left, right)
-    while left >= 0 or right < total:
-        left -= 1
-        if left >= 0:
-            yield (left + 1, right)
-        right += 1
-        if right <= total:
-            yield (left + 1, right)
-
-
-@lru_cache(maxsize=16)
-def condense_path(path: str, width: int, *, prefix: str = "") -> str:
-    """Condense a path to fit within the given cell width.
-
-    Args:
-        path: The path to condense.
-        width: Maximum cell width.
-        prefix: A string to be prepended to the result.
-
-    Returns:
-        A condensed string.
-    """
-    # TODO: handle OS separators and path issues
-    if cell_len(path) <= width:
-        return path
-    components = path.split("/")
-    condensed = components
-    trailing_slash = path.endswith("/")
-    candidate = prefix + "/".join(condensed)
-    if trailing_slash and candidate and not candidate.endswith("/"):
-        candidate += "/"
-
-    for left, right in radiate_range(len(components)):
-        if cell_len(candidate) < width:
-            return candidate
-        condensed = [*components[:left], "…", *components[right:]]
-        candidate = prefix + "/".join(condensed)
-        if trailing_slash and candidate and not candidate.endswith("/"):
-            candidate += "/"
-
-    return candidate
-
-
-class CondensedPath(Widget):
-    path = reactive("")
-    display_path = reactive("")
-
-    DEFAULT_CSS = """
-    CondensedPath {
-        height: 1;
-    }
-    """
-
-    def __init__(
-        self,
-        path: str = "",
-        *,
-        directory: bool = False,
-        id: str | None = None,
-        classes: str | None = None
-    ) -> None:
-        super().__init__(id=id, classes=classes)
-        self.set_reactive(CondensedPath.path, path)
-        self._directory = directory
-
-    def on_resize(self) -> None:
-        self.watch_path(self.path)
-
-    def watch_path(self, path: str) -> None:
-        if not path or not self.size.width:
-            return
-        path = os.path.abspath(os.path.expanduser(path))
-        if not self.tooltip:
-            self.tooltip = str(path)
-        user_root = os.path.abspath(os.path.expanduser("~/"))
-        if not user_root.endswith("/"):
-            user_root += "/"
-        if path.startswith(user_root):
-            path = "~/" + path[len(user_root) :]
-        if self._directory and not path.endswith("/"):
-            path += "/"
-        self.display_path = path
-
-    def render(self) -> Content:
-        self.watch_path(self.path)
-        return Content(condense_path(self.display_path, self.size.width))
-
-    def get_content_width(self, container: Size, viewport: Size) -> int:
-        if self.display_path:
-            return Content(self.display_path).cell_length
-        else:
-            return container.width

package/tui/widgets/context_stats.py

@@ -1,66 +0,0 @@
-from __future__ import annotations
-
-from textual.app import ComposeResult
-from textual.reactive import reactive
-from textual.widgets import Static, ProgressBar
-
-
-class ContextStats(Static):
-    DEFAULT_CSS = """
-    ContextStats {
-        height: auto;
-        padding: 0 1;
-
-        Static {
-            color: $text-secondary;
-            margin: 0;
-            padding: 0;
-        }
-
-        ProgressBar {
-            margin: 0;
-            padding: 0;
-        }
-    }
-    """
-
-    used_tokens: reactive[int] = reactive(0)
-    max_tokens: reactive[int] = reactive(0)
-
-    def __init__(
-        self,
-        name: str | None = None,
-        id: str | None = None,
-        classes: str | None = None,
-    ) -> None:
-        super().__init__(name=name, id=id, classes=classes)
-
-    def update_stats(self, used: int, max_tokens: int) -> None:
-        self.used_tokens = used
-        self.max_tokens = max_tokens
-
-    def compose(self) -> ComposeResult:
-        yield Static("0 tokens", id="context-tokens")
-        yield ProgressBar(total=100, show_eta=False, show_percentage=False, id="context-progress")
-        yield Static("0% used", id="context-percent")
-
-    def watch_used_tokens(self, used: int) -> None:
-        self._refresh_display()
-
-    def watch_max_tokens(self, mx: int) -> None:
-        self._refresh_display()
-
-    def _refresh_display(self) -> None:
-        used = self.used_tokens
-        mx = self.max_tokens
-
-        pct = (used / mx * 100) if mx > 0 else 0
-
-        bar = self.query_one("#context-progress", ProgressBar)
-        bar.update(progress=min(pct, 100), total=100)
-
-        tokens = self.query_one("#context-tokens", Static)
-        tokens.update(f"{used:,} tokens")
-
-        pct_label = self.query_one("#context-percent", Static)
-        pct_label.update(f"{pct:.0f}% used")