batrachian-toad 0.5.22__py3-none-any.whl

toad/version.py

@@ -0,0 +1,80 @@
+from typing import NamedTuple
+
+
+VERSION_TOML_URL = "https://www.batrachian.ai/toad.toml"
+
+
+class VersionMeta(NamedTuple):
+    """Information about the current version of Toad."""
+
+    version: str
+    upgrade_message: str
+    visit_url: str
+
+
+class VersionCheckFailed(Exception):
+    """Something went wrong in the version check."""
+
+
+async def check_version() -> tuple[bool, VersionMeta]:
+    """Check for a new version of Toad.
+
+    Returns:
+        A tuple containing a boolean that indicates if there is a newer version,
+            and a `VersionMeta` structure with meta information.
+    """
+    import httpx
+    import packaging.version
+    import tomllib
+
+    from toad import get_version
+
+    try:
+        current_version = packaging.version.parse(get_version())
+    except packaging.version.InvalidVersion as error:
+        raise VersionCheckFailed(f"Invalid version;{error}")
+
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.get(VERSION_TOML_URL)
+            version_toml_bytes = await response.aread()
+    except Exception as error:
+        raise VersionCheckFailed(f"Failed to retrieve version;{error}")
+
+    try:
+        version_toml = version_toml_bytes.decode("utf-8", "replace")
+        version_meta = tomllib.loads(version_toml)
+    except Exception as error:
+        raise VersionCheckFailed(f"Failed to decode version TOML;{error}")
+
+    if not isinstance(version_meta, dict):
+        raise VersionCheckFailed("Response isn't TOML")
+
+    toad_version = str(version_meta.get("version", "0"))
+    version_message = str(version_meta.get("upgrade_message", ""))
+    version_message = version_message.replace("$VERSION", toad_version)
+    verison_meta = VersionMeta(
+        version=toad_version,
+        upgrade_message=version_message,
+        visit_url=str(version_meta.get("visit_url", "")),
+    )
+
+    try:
+        new_version = packaging.version.parse(verison_meta.version)
+    except packaging.version.InvalidVersion as error:
+        raise VersionCheckFailed(f"Invalid remote version;{error}")
+
+    return new_version > current_version, verison_meta
+
+
+if __name__ == "__main__":
+
+    async def run() -> None:
+        result = await check_version()
+        from rich import print
+
+        print(result)
+
+    import asyncio
+
+    asyncio.run(run())

toad/visuals/columns.py

@@ -0,0 +1,273 @@
+from __future__ import annotations
+
+from typing import Iterable, Iterator, Literal
+from fractions import Fraction
+
+import rich.repr
+from rich.segment import Segment
+
+from textual.cache import LRUCache
+from textual.content import Content
+from textual.css.styles import RulesMap
+from textual.visual import Visual, RenderOptions
+from textual.strip import Strip
+from textual.style import Style
+
+from toad._loop import loop_last
+
+
+from textual._profile import timer
+
+
+@rich.repr.auto
+class Row(Visual):
+    """A visual for a row produced by `columns`.
+
+    No need to construct these manually, they are returned from the Columns `__getindex__`
+
+    """
+
+    def __init__(self, columns: Columns, row_index: int) -> None:
+        """
+
+        Args:
+            columns: The parent Columns instance.
+            row_index: Index of the row within columns.
+        """
+        self.columns = columns
+        self.row_index = row_index
+
+    def __rich_repr__(self) -> rich.repr.Result:
+        yield self.columns
+        yield self.row_index
+
+    def render_strips(
+        self, width: int, height: int | None, style: Style, options: RenderOptions
+    ) -> list[Strip]:
+        strips = self.columns.render(self.row_index, width, style)
+        return strips
+
+    def get_optimal_width(self, rules: RulesMap, container_width: int) -> int:
+        return min(container_width, self.columns.get_optimal_width())
+
+    def get_height(self, rules: RulesMap, width: int) -> int:
+        return self.columns.get_row_height(width, self.row_index)
+
+
+@rich.repr.auto
+class Columns:
+    """Renders columns of Content."""
+
+    def __init__(
+        self,
+        *columns: Literal["auto", "flex"],
+        gutter: int = 1,
+        style: Style | str = "",
+    ) -> None:
+        """
+
+        Args:
+            *columns: "auto" to use the maximum width of the cells in a column,
+                or "flex" to use the remaining space.
+            gutter: Space between columns in cells.
+            style: Base style for the columns.
+        """
+        self.columns = columns
+        self.gutter = gutter
+        self.style = style
+        self.rows: list[list[Content]] = []
+        self._render_cache: LRUCache[tuple, list[list[Strip]]] = LRUCache(maxsize=64)
+        self._optimal_width_cache: int | None = None
+
+    def __rich_repr__(self) -> rich.repr.Result:
+        for column in self.columns:
+            yield column
+        yield "gutter", self.gutter, 1
+        yield "style", self.style, ""
+
+    def __getitem__(self, row_index: int) -> Row:
+        if row_index < 0:
+            row_index = len(self.rows) - row_index
+        if row_index >= len(self.rows):
+            raise IndexError(f"No row with index {row_index}")
+        return Row(self, row_index)
+
+    def __len__(self) -> int:
+        return len(self.rows)
+
+    def __iter__(self) -> Iterator[Row]:
+        return iter([self[row_index] for row_index in range(len(self))])
+
+    def get_optimal_width(self) -> int:
+        """Get optional width (Visual protocol).
+
+        Returns:
+            Width in cells.
+        """
+        if self._optimal_width_cache is not None:
+            return self._optimal_width_cache
+        gutter_width = (len(self.columns) - 1) * self.gutter
+        optimal_width = max(
+            sum(content.cell_length for content in row) + gutter_width
+            for row in self.rows
+        )
+        self._optimal_width_cache = optimal_width
+        return optimal_width
+
+    def get_row_height(self, width: int, row_index: int) -> int:
+        """Get the height of a row when rendered with the given width.
+
+        Args:
+            width: Available width.
+            row_index: Index of the row.
+
+        Returns:
+            Height in lines of the row.
+        """
+        if self._last_render is None:
+            row_strips = self._render(width, Style.null())
+        else:
+            row_strips = self._last_render
+        return len(row_strips[row_index])
+
+    def add_row(self, *cells: Content | str) -> Row:
+        """Add a row.
+
+        Args:
+            *cells: Cell content.
+
+        Returns:
+            A Row renderable.
+
+        """
+        assert len(cells) == len(self.columns)
+        new_cells = [
+            cell if isinstance(cell, Content) else Content(cell) for cell in cells
+        ]
+        self.rows.append(new_cells)
+        self._optimal_width_cache = None
+        self._last_render = None
+        self._render_cache.clear()
+        return Row(self, len(self.rows) - 1)
+
+    def render(
+        self, row_index: int, render_width: int, style: Style = Style.null()
+    ) -> list[Strip]:
+        """render a row given by its index.
+
+        Args:
+            row_index: Index of the row.
+            render_width: Width of the render.
+            style: Base style to render.
+
+        Returns:
+            A list of strips, which may be returned from a visual.
+        """
+        row_strips = self._render(render_width, style)
+        return row_strips[row_index]
+
+    def _render(self, render_width: int, style: Style) -> list[list[Strip]]:
+        """Render a row.
+
+        Args:
+            render_width: Width of render.
+            style: Base Style.
+
+        Returns:
+            A list of list of Strips (one list of strips per row).
+        """
+
+        cache_key = (render_width, style)
+        if (cached_render := self._render_cache.get(cache_key)) is not None:
+            return cached_render
+
+        gutter_width = (len(self.columns) - 1) * self.gutter
+        widths: list[int | None] = []
+
+        for index, column in enumerate(self.columns):
+            if column == "auto":
+                widths.append(max(row[index].cell_length for row in self.rows))
+            else:
+                widths.append(None)
+
+        if any(width is None for width in widths):
+            used_width = sum(width for width in widths if width is not None)
+            remaining_width = Fraction(render_width - gutter_width - used_width)
+            if remaining_width <= 0:
+                widths = [width or 0 for width in widths]
+            else:
+                remaining_count = sum(1 for width in widths if width is None)
+                cell_width = remaining_width / remaining_count
+
+                distribute: list[int] = []
+                previous_width = 0
+                total = Fraction(0)
+                for _ in range(remaining_count):
+                    total += cell_width
+                    distribute.append(int(total) - previous_width)
+                    previous_width = int(total)
+
+                iter_distribute = iter(distribute)
+                for index, column_width in enumerate(widths.copy()):
+                    if column_width is None:
+                        widths[index] = int(next(iter_distribute))
+
+        row_strips: list[list[Strip]] = []
+
+        for row in self.rows:
+            column_renders: list[list[list[Segment]]] = []
+            for content_width, content in zip(widths, row):
+                assert content_width is not None
+                segments = [
+                    line.truncate(content_width, pad=True).render_segments(style)
+                    for line in content.wrap(content_width)
+                ]
+
+                column_renders.append(segments)
+
+            height = max(len(lines) for lines in column_renders)
+            rich_style = style.rich_style
+            for width, lines in zip(widths, column_renders):
+                assert width is not None
+                while len(lines) < height:
+                    lines.append([Segment(" " * width, rich_style)])
+
+            gutter = Segment(" " * self.gutter, rich_style)
+            strips: list[Strip] = []
+            for line_no in range(height):
+                strip_segments: list[Segment] = []
+                for last, column in loop_last(column_renders):
+                    strip_segments.extend(column[line_no])
+                    if not last and gutter:
+                        strip_segments.append(gutter)
+                strips.append(Strip(strip_segments, render_width))
+
+            row_strips.append(strips)
+
+        self._render_cache[cache_key] = row_strips
+        return row_strips
+
+
+if __name__ == "__main__":
+    from rich import traceback
+
+    traceback.install(show_locals=True)
+
+    from textual.app import App, ComposeResult
+    from textual.widgets import Static
+
+    columns = Columns("auto", "flex")
+    columns.add_row("Foo", "Hello, World! " * 20)
+
+    class CApp(App):
+        DEFAULT_CSS = """
+        .row1 {
+            background: blue;
+           
+        }
+        """
+
+        def compose(self) -> ComposeResult:
+            yield Static(columns[0], classes="row1")
+
+    CApp().run()

toad/widgets/agent_response.py

@@ -0,0 +1,79 @@
+from pathlib import Path
+
+from textual.reactive import var
+from textual import work
+from textual.widget import Widget
+from textual.widgets import Markdown
+from textual.widgets.markdown import MarkdownStream
+
+from toad import messages
+
+
+SYSTEM = """\
+If asked to output code add inline documentation in the google style format, and always use type hinting where appropriate.
+Avoid using external libraries where possible, and favor code that writes output to the terminal.
+When asked for a table do not wrap it in a code fence.
+"""
+
+
+class AgentResponse(Markdown):
+    block_cursor_offset = var(-1)
+
+    def __init__(self, markdown: str | None = None) -> None:
+        super().__init__(markdown)
+        self._stream: MarkdownStream | None = None
+
+    def block_cursor_clear(self) -> None:
+        self.block_cursor_offset = -1
+
+    def block_cursor_up(self) -> Widget | None:
+        if self.block_cursor_offset == -1:
+            if self.children:
+                self.block_cursor_offset = len(self.children) - 1
+            else:
+                return None
+        else:
+            self.block_cursor_offset -= 1
+
+        if self.block_cursor_offset == -1:
+            return None
+        try:
+            return self.children[self.block_cursor_offset]
+        except IndexError:
+            self.block_cursor_offset = -1
+            return None
+
+    def block_cursor_down(self) -> Widget | None:
+        if self.block_cursor_offset == -1:
+            if self.children:
+                self.block_cursor_offset = 0
+            else:
+                return None
+        else:
+            self.block_cursor_offset += 1
+        if self.block_cursor_offset >= len(self.children):
+            self.block_cursor_offset = -1
+            return None
+        try:
+            return self.children[self.block_cursor_offset]
+        except IndexError:
+            self.block_cursor_offset = -1
+            return None
+
+    def get_cursor_block(self) -> Widget | None:
+        if self.block_cursor_offset == -1:
+            return None
+        return self.children[self.block_cursor_offset]
+
+    def block_select(self, widget: Widget) -> None:
+        self.block_cursor_offset = self.children.index(widget)
+
+    @property
+    def stream(self) -> MarkdownStream:
+        if self._stream is None:
+            self._stream = self.get_stream(self)
+        return self._stream
+
+    async def append_fragment(self, fragment: str) -> None:
+        self.loading = False
+        await self.stream.write(fragment)

toad/widgets/agent_thought.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+from typing import ClassVar
+
+from textual.binding import Binding, BindingType
+from textual.reactive import var
+from textual.widgets import Markdown
+from textual.widgets.markdown import MarkdownStream
+
+
+class AgentThought(Markdown, can_focus=True):
+    """The agent's 'thoughts'."""
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("up", "scroll_up", "Scroll Up", show=False),
+        Binding("down", "scroll_down", "Scroll Down", show=False),
+        Binding("left", "scroll_left", "Scroll Left", show=False),
+        Binding("right", "scroll_right", "Scroll Right", show=False),
+        Binding("home", "scroll_home", "Scroll Home", show=False),
+        Binding("end", "scroll_end", "Scroll End", show=False),
+        Binding("pageup", "page_up", "Page Up", show=False),
+        Binding("pagedown", "page_down", "Page Down", show=False),
+        Binding("ctrl+pageup", "page_left", "Page Left", show=False),
+        Binding("ctrl+pagedown", "page_right", "Page Right", show=False),
+    ]
+
+    ALLOW_MAXIMIZE = True
+    _stream: var[MarkdownStream | None] = var(None)
+
+    def watch_loading(self, loading: bool) -> None:
+        self.set_class(loading, "-loading")
+
+    @property
+    def stream(self) -> MarkdownStream:
+        if self._stream is None:
+            self._stream = self.get_stream(self)
+        return self._stream
+
+    async def append_fragment(self, fragment: str) -> None:
+        self.loading = False
+        await self.stream.write(fragment)
+        self.scroll_end()

toad/widgets/command_pane.py

@@ -0,0 +1,224 @@
+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 toad.shell_read import shell_read
+
+from toad.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
+
+    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 = COMMAND
+            command_pane.execute(COMMAND)
+
+    app = CommandApp()
+    app.run()