ommlds 0.0.0.dev480__py3-none-any.whl → 0.0.0.dev503__py3-none-any.whl

ommlds/cli/sessions/chat/facades/inject.py

@@ -0,0 +1,35 @@
+from omlish import inject as inj
+from omlish import lang
+
+from .configs import FacadeConfig
+
+
+with lang.auto_proxy_import(globals()):
+    from . import facade as _facade
+    from . import ui as _ui
+    from .commands import inject as _commands
+
+
+##
+
+
+def bind_facade(cfg: FacadeConfig = FacadeConfig()) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    #
+
+    els.extend([
+        _commands.bind_commands(cfg.commands),
+    ])
+
+    #
+
+    els.append(inj.bind(_facade.ChatFacade, singleton=True))
+
+    #
+
+    els.append(inj.bind(_ui.UiQuitSignal(_ui.raise_system_exit_ui_quit_signal)))
+
+    #
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/chat/facades/ui.py

@@ -0,0 +1,34 @@
+import abc
+import typing as ta
+
+from omlish import lang
+
+
+##
+
+
+class UiMessageDisplayer(lang.Abstract):
+    @abc.abstractmethod
+    def display_ui_message(self, content: str) -> ta.Awaitable[None]:
+        pass
+
+
+class NopUiMessageDisplayer(UiMessageDisplayer):
+    async def display_ui_message(self, content: str) -> None:
+        pass
+
+
+class PrintMessageDisplayer(UiMessageDisplayer):
+    async def display_ui_message(self, content: str) -> None:
+        print(content)
+
+
+##
+
+
+class UiQuitSignal(lang.Func0[ta.Awaitable[None]]):
+    pass
+
+
+async def raise_system_exit_ui_quit_signal() -> None:
+    raise SystemExit

ommlds/cli/sessions/chat/inject.py

@@ -1,66 +1,43 @@
-from omlish import dataclasses as dc
 from omlish import inject as inj
 from omlish import lang
 
-from ...backends.types import DefaultBackendName
 from ..base import Session
-from .configs import DEFAULT_BACKEND
 from .configs import ChatConfig
 
 
 with lang.auto_proxy_import(globals()):
-    from ...backends import inject as _backends
     from ...rendering import inject as _rendering
-    from . import driver as _driver
     from . import session as _session
-    from .chat.ai import inject as _chat_ai
-    from .chat.state import inject as _chat_state
-    from .chat.user import inject as _chat_user
-    from .phases import inject as _phases
-    from .tools import inject as _tools
+    from .drivers import inject as _drivers
+    from .facades import inject as _facades
+    from .interfaces import inject as _interfaces
 
 
 ##
 
 
-def bind_chat(cfg: ChatConfig) -> inj.Elements:
+def bind_chat(cfg: ChatConfig = ChatConfig()) -> inj.Elements:
     els: list[inj.Elemental] = []
 
     #
 
     els.extend([
-        _backends.bind_backends(cfg.backend),
+        _drivers.bind_driver(cfg.driver),
 
-        _chat_ai.bind_ai(cfg.ai),
+        _facades.bind_facade(cfg.facade),
 
-        _chat_user.bind_user(cfg.user),
-
-        _chat_state.bind_state(cfg.state),
-
-        _phases.bind_phases(),
+        _interfaces.bind_interface(cfg.interface),
 
         _rendering.bind_rendering(cfg.rendering),
-
-        _tools.bind_tools(cfg.tools),
     ])
 
     #
 
     els.extend([
-        inj.bind(_driver.ChatDriver, singleton=True),
-    ])
-
-    #
-
-    els.extend([
-        inj.bind(_session.ChatSession.Config(**dc.asdict(cfg))),
+        # inj.bind(cfg),  # NOTE: *not* done - the code is properly structured around not needing it.
         inj.bind(Session, to_ctor=_session.ChatSession, singleton=True),
     ])
 
     #
 
-    els.append(inj.bind(DefaultBackendName, to_const=DEFAULT_BACKEND))
-
-    #
-
     return inj.as_elements(*els)

ommlds/cli/sessions/chat/interfaces/bare/configs.py

@@ -0,0 +1,15 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+
+from ..configs import InterfaceConfig
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class BareInterfaceConfig(InterfaceConfig):
+    interactive: bool = False
+
+    use_readline: bool | ta.Literal['auto'] = 'auto'

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

@@ -0,0 +1,69 @@
+from omlish import inject as inj
+from omlish import lang
+
+from ..base import ChatInterface
+from .configs import BareInterfaceConfig
+
+
+with lang.auto_proxy_import(globals()):
+    from .....inputs import asyncs as _inputs_asyncs
+    from .....inputs import sync as _inputs_sync
+    from ...drivers.tools import confirmation as _tools_confirmation
+    from ...facades import ui as _facades_ui
+    from . import interactive as _interactive
+    from . import oneshot as _oneshot
+    from . import tools as _tools
+
+
+##
+
+
+def bind_bare(cfg: BareInterfaceConfig = BareInterfaceConfig()) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    #
+
+    if cfg.interactive:
+        els.extend([
+            inj.bind(_interactive.InteractiveBareChatInterface, singleton=True),
+            inj.bind(ChatInterface, to_key=_interactive.InteractiveBareChatInterface),
+        ])
+
+        els.extend([
+            inj.bind(_inputs_sync.SyncStringInput, to_const=_inputs_sync.InputSyncStringInput(use_readline=cfg.use_readline)),  # noqa
+            inj.bind(_inputs_asyncs.AsyncStringInput, to_ctor=_inputs_asyncs.ThreadAsyncStringInput, singleton=True),
+        ])
+
+    else:
+        els.extend([
+            inj.bind(_oneshot.OneshotBareChatInterface, singleton=True),
+            inj.bind(ChatInterface, to_key=_oneshot.OneshotBareChatInterface),
+        ])
+
+    #
+
+    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,
+            ))
+
+    #
+
+    els.extend([
+        inj.bind(_facades_ui.PrintMessageDisplayer, singleton=True),
+        inj.bind(_facades_ui.UiMessageDisplayer, to_key=_facades_ui.PrintMessageDisplayer),
+    ])
+
+    #
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/chat/interfaces/bare/interactive.py

@@ -0,0 +1,49 @@
+import typing as ta
+
+from .....inputs.asyncs import AsyncStringInput
+from .....inputs.asyncs import SyncAsyncStringInput
+from .....inputs.sync import InputSyncStringInput
+from ...drivers.types import ChatDriver
+from ...facades.facade import ChatFacade
+from ..base import ChatInterface
+
+
+##
+
+
+class InteractiveBareChatInterface(ChatInterface):
+    DEFAULT_STRING_INPUT: ta.ClassVar[AsyncStringInput] = SyncAsyncStringInput(InputSyncStringInput())
+
+    def __init__(
+            self,
+            *,
+            driver: ChatDriver,
+            facade: ChatFacade,
+            string_input: AsyncStringInput | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._driver = driver
+        self._facade = facade
+        if string_input is None:
+            string_input = self.DEFAULT_STRING_INPUT
+        self._string_input = string_input
+
+    async def run(self) -> None:
+        await self._driver.start()
+
+        while True:
+            try:
+                s = await self._string_input()
+            except EOFError:
+                break
+
+            print()
+            print('<')
+            print()
+
+            await self._facade.handle_user_input(s)
+
+            print()
+
+        await self._driver.stop()

ommlds/cli/sessions/chat/interfaces/bare/oneshot.py

@@ -0,0 +1,21 @@
+from ...drivers.types import ChatDriver
+from ..base import ChatInterface
+
+
+##
+
+
+class OneshotBareChatInterface(ChatInterface):
+    def __init__(
+            self,
+            *,
+            driver: ChatDriver,
+    ) -> None:
+        super().__init__()
+
+        self._driver = driver
+
+    async def run(self) -> None:
+        await self._driver.start()
+
+        await self._driver.stop()

ommlds/cli/sessions/chat/{tools/confirmation.py → interfaces/bare/tools.py}

@@ -1,28 +1,9 @@
-import abc
-import typing as ta
-
-from omlish import lang
 from omlish.formats import json
 from omlish.term.confirm import confirm_action
 
-from ..... import minichain as mc
-
-
-##
-
-
-class ToolExecutionRequestDeniedError(Exception):
-    pass
-
-
-class ToolExecutionConfirmation(lang.Abstract):
-    @abc.abstractmethod
-    def confirm_tool_execution_or_raise(
-            self,
-            use: 'mc.ToolUse',
-            entry: 'mc.ToolCatalogEntry',
-    ) -> ta.Awaitable[None]:
-        raise NotImplementedError
+from ...... import minichain as mc
+from ...drivers.tools.confirmation import ToolExecutionConfirmation
+from ...drivers.tools.confirmation import ToolExecutionRequestDeniedError
 
 
 ##

ommlds/cli/sessions/chat/interfaces/base.py

@@ -0,0 +1,13 @@
+import abc
+import typing as ta
+
+from omlish import lang
+
+
+##
+
+
+class ChatInterface(lang.Abstract):
+    @abc.abstractmethod
+    def run(self) -> ta.Awaitable[None]:
+        raise NotImplementedError

ommlds/cli/sessions/chat/interfaces/configs.py

@@ -0,0 +1,11 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class InterfaceConfig(lang.Abstract):
+    enable_tools: bool = False
+    dangerous_no_tool_confirmation: bool = False

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

@@ -0,0 +1,29 @@
+from omlish import inject as inj
+from omlish import lang
+
+from .bare.configs import BareInterfaceConfig
+from .configs import InterfaceConfig
+from .textual.configs import TextualInterfaceConfig
+
+
+with lang.auto_proxy_import(globals()):
+    from .bare import inject as _bare
+    from .textual import inject as _textual
+
+
+##
+
+
+def bind_interface(cfg: InterfaceConfig = BareInterfaceConfig()) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    if isinstance(cfg, TextualInterfaceConfig):
+        els.append(_textual.bind_textual(cfg))
+
+    elif isinstance(cfg, BareInterfaceConfig):
+        els.append(_bare.bind_bare(cfg))
+
+    else:
+        raise TypeError(cfg)
+
+    return inj.as_elements(*els)