ommlds 0.0.0.dev489__py3-none-any.whl → 0.0.0.dev491__py3-none-any.whl

ommlds/cli/sessions/chat/interfaces/textual/app.py

@@ -0,0 +1,217 @@
+import asyncio
+import typing as ta
+
+from omdev.tui import textual as tx
+from omlish import check
+
+from ...... import minichain as mc
+from ...drivers.driver import ChatDriver
+from ...drivers.events.types import AiDeltaChatEvent
+from ...drivers.events.types import AiMessagesChatEvent
+from .styles import read_app_css
+from .widgets.input import InputOuter
+from .widgets.input import InputTextArea
+from .widgets.messages import AiMessage
+from .widgets.messages import StaticAiMessage
+from .widgets.messages import StreamAiMessage
+from .widgets.messages import UserMessage
+from .widgets.messages import WelcomeMessage
+
+
+##
+
+
+ChatDriverEventQueue = ta.NewType('ChatDriverEventQueue', asyncio.Queue)
+
+
+##
+
+
+class ChatApp(tx.App):
+    ENABLE_COMMAND_PALETTE: ta.ClassVar[bool] = False
+
+    def __init__(
+            self,
+            *,
+            driver: ChatDriver,
+            event_queue: ChatDriverEventQueue,
+    ) -> None:
+        super().__init__()
+
+        self._chat_driver = driver
+        self._event_queue = event_queue
+
+    def get_driver_class(self) -> type[tx.Driver]:
+        return tx.get_pending_writes_driver_class(super().get_driver_class())
+
+    CSS: ta.ClassVar[str] = read_app_css()
+
+    #
+
+    def compose(self) -> tx.ComposeResult:
+        with tx.VerticalScroll(id='messages-scroll'):
+            yield tx.Static(id='messages-container')
+
+        yield InputOuter(id='input-outer')
+
+    #
+
+    def _get_input_text_area(self) -> InputTextArea:
+        return self.query_one('#input', InputTextArea)
+
+    def _get_messages_scroll(self) -> tx.VerticalScroll:
+        return self.query_one('#messages-scroll', tx.VerticalScroll)
+
+    def _get_messages_container(self) -> tx.Static:
+        return self.query_one('#messages-container', tx.Static)
+
+    #
+
+    def _is_messages_at_bottom(self, threshold: int = 3) -> bool:
+        return (ms := self._get_messages_scroll()).scroll_y >= (ms.max_scroll_y - threshold)
+
+    def _scroll_messages_to_bottom(self) -> None:
+        self._get_messages_scroll().scroll_end(animate=False)
+
+    def _anchor_messages(self) -> None:
+        if (ms := self._get_messages_scroll()).max_scroll_y:
+            ms.anchor()
+
+    #
+
+    _pending_mount_messages: list[tx.Widget] | None = None
+
+    async def _enqueue_mount_messages(self, *messages: tx.Widget) -> None:
+        if (lst := self._pending_mount_messages) is None:
+            lst = self._pending_mount_messages = []
+
+        lst.extend(messages)
+
+    _stream_ai_message: StreamAiMessage | None = None
+
+    async def _finalize_stream_ai_message(self) -> None:
+        if self._stream_ai_message is None:
+            return
+
+        await self._stream_ai_message.stop_stream()
+        self._stream_ai_message = None
+
+    async def _append_stream_ai_message_content(self, content: str) -> None:
+        if (sam := self._stream_ai_message) is not None:
+            was_at_bottom = self._is_messages_at_bottom()
+
+            await sam.append_content(content)
+
+            self.call_after_refresh(lambda: self._get_messages_container().scroll_end(animate=False))
+
+            if was_at_bottom:
+                self.call_after_refresh(self._anchor_messages)
+
+        else:
+            await self._mount_messages(StreamAiMessage(content))
+
+    async def _mount_messages(self, *messages: tx.Widget) -> None:
+        was_at_bottom = self._is_messages_at_bottom()
+
+        msg_ctr = self._get_messages_container()
+
+        for msg in [*(self._pending_mount_messages or []), *messages]:
+            if isinstance(msg, AiMessage):
+                await self._finalize_stream_ai_message()
+
+            await msg_ctr.mount(msg)
+
+            if isinstance(msg, StreamAiMessage):
+                self._stream_ai_message = check.replacing_none(self._stream_ai_message, msg)
+                await msg.write_initial_content()
+
+        self._pending_mount_messages = None
+
+        self.call_after_refresh(lambda: msg_ctr.scroll_end(animate=False))
+
+        if was_at_bottom:
+            self.call_after_refresh(self._anchor_messages)
+
+    #
+
+    _event_queue_task: asyncio.Task[None] | None = None
+
+    async def _event_queue_task_main(self) -> None:
+        while True:
+            ev = await self._event_queue.get()
+            if ev is None:
+                break
+
+            if isinstance(ev, AiMessagesChatEvent):
+                wx: list[tx.Widget] = []
+
+                for ai_msg in ev.chat:
+                    if isinstance(ai_msg, mc.AiMessage):
+                        wx.append(
+                            StaticAiMessage(
+                                check.isinstance(ai_msg.c, str),
+                                markdown=True,
+                            ),
+                        )
+
+                if wx:
+                    await self._enqueue_mount_messages(*wx)
+                    self.call_later(self._mount_messages)
+
+            elif isinstance(ev, AiDeltaChatEvent):
+                cd = check.isinstance(ev.delta, mc.ContentAiDelta)
+                cc = check.isinstance(cd.c, str)
+                self.call_later(self. _append_stream_ai_message_content, cc)
+
+    #
+
+    # def _schedule_after_refresh(self) -> None:
+    #     self.call_after_refresh(self._after_refresh)
+
+    # def _after_refresh(self) -> None:
+    #     self.after_repaint()
+    #
+    #     self._schedule_after_refresh()
+
+    # def after_repaint(self) -> None:
+    #     # from omdev.tui.textual.debug.dominfo import inspect_dom_node  # noqa
+    #
+    #     pass
+
+    #
+
+    async def on_mount(self) -> None:
+        # self._schedule_after_refresh()
+
+        check.state(self._event_queue_task is None)
+        self._event_queue_task = asyncio.create_task(self._event_queue_task_main())
+
+        await self._chat_driver.start()
+
+        self._get_input_text_area().focus()
+
+        await self._mount_messages(
+            WelcomeMessage(
+                'Hello!',
+            ),
+        )
+
+    async def on_unmount(self) -> None:
+        await self._chat_driver.stop()
+
+        if (eqt := self._event_queue_task) is not None:
+            await self._event_queue.put(None)
+            await eqt
+
+    async def on_input_text_area_submitted(self, event: InputTextArea.Submitted) -> None:
+        self._get_input_text_area().clear()
+
+        await self._finalize_stream_ai_message()
+
+        await self._mount_messages(
+            UserMessage(
+                event.text,
+            ),
+        )
+
+        await self._chat_driver.send_user_messages([mc.UserMessage(event.text)])

ommlds/cli/sessions/chat/interfaces/textual/inject.py

@@ -0,0 +1,67 @@
+"""
+FIXME:
+ - too lazy to lazy import guts like every other proper inject module lol >_<
+"""
+import asyncio
+
+from omlish import inject as inj
+from omlish import lang
+
+from ...drivers.events.injection import event_callbacks
+from ..base import ChatInterface
+from ..configs import InterfaceConfig
+from .app import ChatApp
+from .app import ChatDriverEventQueue
+from .interface import TextualChatInterface
+
+
+with lang.auto_proxy_import(globals()):
+    from ...drivers.tools import confirmation as _tools_confirmation
+
+
+##
+
+
+def bind_textual(cfg: InterfaceConfig = InterfaceConfig()) -> inj.Elements:
+    els: list[inj.Elemental] = [
+        inj.bind(ChatInterface, to_ctor=TextualChatInterface, singleton=True),
+    ]
+
+    #
+
+    els.extend([
+        inj.bind(ChatApp, singleton=True),
+    ])
+
+    #
+
+    els.extend([
+        inj.bind(ChatDriverEventQueue, to_const=asyncio.Queue()),
+
+        event_callbacks().bind_item(to_fn=inj.KwargsTarget.of(
+            lambda eq: lambda ev: eq.put(ev),
+            eq=ChatDriverEventQueue,
+        )),
+    ])
+
+    #
+
+    if cfg.enable_tools:
+        if cfg.dangerous_no_tool_confirmation:
+            els.append(inj.bind(
+                _tools_confirmation.ToolExecutionConfirmation,
+                to_ctor=_tools_confirmation.UnsafeAlwaysAllowToolExecutionConfirmation,
+                singleton=True,
+            ))
+
+        else:
+            # els.append(inj.bind(
+            #     _tools_confirmation.ToolExecutionConfirmation,
+            #     to_ctor=_tools.InteractiveToolExecutionConfirmation,
+            #     singleton=True,
+            # ))
+            raise NotImplementedError
+
+    #
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/chat/{interface → interfaces}/textual/interface.py

@@ -1,4 +1,3 @@
-from ...driver import ChatDriver
 from ..base import ChatInterface
 from .app import ChatApp
 
@@ -10,12 +9,10 @@ class TextualChatInterface(ChatInterface):
     def __init__(
             self,
             *,
-            driver: ChatDriver,
             app: ChatApp,
     ) -> None:
         super().__init__()
 
-        self._driver = driver
         self._app = app
 
     async def run(self) -> None:

ommlds/cli/sessions/chat/interfaces/textual/styles/__init__.py

@@ -0,0 +1,29 @@
+import io as _io
+
+from omlish import lang as _lang
+
+
+##
+
+
+@_lang.cached_function
+def read_app_css() -> str:
+    tcss_rsrcs = [
+        rsrc
+        for rsrc in _lang.get_relative_resources(globals=globals()).values()
+        if rsrc.name.endswith('.tcss')
+    ]
+
+    out = _io.StringIO()
+
+    for i, rsrc in enumerate(tcss_rsrcs):
+        if i:
+            out.write('\n\n')
+
+        out.write(f'/*** {rsrc.name} ***/\n')
+        out.write('\n')
+
+        out.write(rsrc.read_text().strip())
+        out.write('\n')
+
+    return out.getvalue()

ommlds/cli/sessions/chat/interfaces/textual/styles/input.tcss

@@ -0,0 +1,51 @@
+#input-outer {
+    width: 100%;
+    height: auto;
+}
+
+#input-vertical {
+    width: 100%;
+    height: auto;
+
+    margin: 0 2 1 2;
+
+    padding: 0;
+}
+
+#input-vertical2 {
+    width: 100%;
+    height: auto;
+
+    border: round $foreground-muted;
+
+    padding: 0 1;
+}
+
+#input-horizontal {
+    width: 100%;
+    height: auto;
+}
+
+#input-glyph {
+    width: auto;
+
+    padding: 0 1 0 0;
+
+    background: transparent;
+    color: $primary;
+
+    text-style: bold;
+}
+
+#input {
+    width: 1fr;
+    height: auto;
+    max-height: 16;
+
+    border: none;
+
+    padding: 0;
+
+    background: transparent;
+    color: $text;
+}

ommlds/cli/sessions/chat/interfaces/textual/styles/markdown.tcss

@@ -0,0 +1,7 @@
+Markdown MarkdownFence {
+    max-width: 95%;
+
+    overflow-x: auto;
+
+    scrollbar-size-horizontal: 1;
+}

ommlds/cli/sessions/chat/interfaces/textual/styles/messages.tcss

@@ -0,0 +1,104 @@
+/* Container */
+
+#messages-scroll {
+    width: 100%;
+    height: 1fr;
+
+    padding: 0 2 0 2;
+}
+
+#messages-container {
+    width: 100%;
+    height: auto;
+
+    margin-top: 1;
+    margin-bottom: 0;
+
+    layout: stream;
+    text-align: left;
+}
+
+
+/* Welcome */
+
+.welcome-message {
+    margin: 1;
+
+    border: round;
+
+    padding: 1;
+
+    text-align: center;
+}
+
+
+/* User */
+
+.user-message {
+    width: 100%;
+    height: auto;
+
+    margin-top: 1;
+}
+
+.user-message-outer {
+    width: 100%;
+    height: auto;
+}
+
+.user-message-glyph {
+    width: auto;
+    height: auto;
+
+    background: transparent;
+    color: $primary;
+
+    text-style: bold;
+}
+
+.user-message-inner {
+    width: 100%;
+    height: auto;
+}
+
+
+/* Ai */
+
+.ai-message {
+    width: 100%;
+    height: auto;
+
+    margin-top: 1;
+}
+
+.ai-message-outer {
+    width: 100%;
+    height: auto;
+
+    align: left top;
+}
+
+.ai-message-glyph {
+    width: auto;
+    height: auto;
+
+    background: transparent;
+    color: $primary;
+
+    text-style: bold;
+}
+
+.ai-message-inner {
+    width: 100%;
+    height: auto;
+
+    padding: 0;
+
+    Markdown {
+        width: 100%;
+        height: auto;
+
+        margin: 0;
+        padding: 0;
+    }
+}

ommlds/cli/sessions/chat/interfaces/textual/widgets/input.py

@@ -0,0 +1,36 @@
+import dataclasses as dc
+import typing as ta
+
+from omdev.tui import textual as tx
+
+
+##
+
+
+class InputTextArea(tx.TextArea):
+    @dc.dataclass()
+    class Submitted(tx.Message):
+        text: str
+
+    def __init__(self, **kwargs: ta.Any) -> None:
+        super().__init__(**kwargs)
+
+    async def _on_key(self, event: tx.Key) -> None:
+        if event.key == 'enter':
+            event.prevent_default()
+            event.stop()
+
+            if text := self.text.strip():
+                self.post_message(self.Submitted(text))
+
+        else:
+            await super()._on_key(event)
+
+
+class InputOuter(tx.Static):
+    def compose(self) -> tx.ComposeResult:
+        with tx.Vertical(id='input-vertical'):
+            with tx.Vertical(id='input-vertical2'):
+                with tx.Horizontal(id='input-horizontal'):
+                    yield tx.Static('>', id='input-glyph')
+                    yield InputTextArea(placeholder='...', id='input')

ommlds/cli/sessions/chat/interfaces/textual/widgets/messages.py

@@ -0,0 +1,114 @@
+import abc
+import typing as ta
+
+from omdev.tui import textual as tx
+from omlish import lang
+
+
+##
+
+
+class Message(tx.Static, lang.Abstract):
+    pass
+
+
+##
+
+
+class WelcomeMessage(Message):
+    def __init__(self, content: str) -> None:
+        super().__init__(content)
+
+        self.add_class('welcome-message')
+
+
+##
+
+
+class UserMessage(Message):
+    def __init__(self, content: str) -> None:
+        super().__init__()
+
+        self.add_class('user-message')
+
+        self._content = content
+
+    def compose(self) -> tx.ComposeResult:
+        with tx.Horizontal(classes='user-message-outer'):
+            yield tx.Static('> ', classes='user-message-glyph')
+            with tx.Vertical(classes='user-message-inner'):
+                yield tx.Static(self._content)
+
+
+##
+
+
+class AiMessage(Message, lang.Abstract):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.add_class('ai-message')
+
+    def compose(self) -> tx.ComposeResult:
+        with tx.Horizontal(classes='ai-message-outer'):
+            yield tx.Static('< ', classes='ai-message-glyph')
+            with tx.Vertical(classes='ai-message-inner'):
+                yield from self._compose_content()
+
+    @abc.abstractmethod
+    def _compose_content(self) -> ta.Generator:
+        raise NotImplementedError
+
+
+class StaticAiMessage(AiMessage):
+    def __init__(
+            self,
+            content: str,
+            *,
+            markdown: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._content = content
+        self._markdown = markdown
+
+    def _compose_content(self) -> ta.Generator:
+        if self._markdown:
+            yield tx.Markdown(self._content)
+        else:
+            yield tx.Static(self._content)
+
+
+class StreamAiMessage(AiMessage):
+    def __init__(self, content: str) -> None:
+        super().__init__()
+
+        self._content = content
+
+    def _compose_content(self) -> ta.Generator:
+        yield tx.Markdown('')
+
+    _stream_: tx.MarkdownStream | None = None
+
+    def _stream(self) -> tx.MarkdownStream:
+        if self._stream_ is None:
+            self._stream_ = tx.Markdown.get_stream(self.query_one(tx.Markdown))
+        return self._stream_
+
+    async def write_initial_content(self) -> None:
+        if self._content:
+            await self._stream().write(self._content)
+
+    async def append_content(self, content: str) -> None:
+        if not content:
+            return
+
+        self._content += content
+        await self._stream().write(content)
+
+    async def stop_stream(self) -> None:
+        if (stream := self._stream_) is None:
+            return
+
+        await stream.stop()
+        self._stream_ = None

ommlds/cli/sessions/chat/session.py

@@ -4,7 +4,7 @@ from omlish import dataclasses as dc
 
 from ..base import Session
 from .configs import ChatConfig
-from .interface.base import ChatInterface
+from .interfaces.base import ChatInterface
 
 
 ##