ommlds 0.0.0.dev466__py3-none-any.whl → 0.0.0.dev512__py3-none-any.whl

ommlds/cli/sessions/chat/facades/commands/base.py

@@ -0,0 +1,83 @@
+import abc
+import typing as ta
+
+from omlish import dataclasses as dc
+from omlish import lang
+from omlish.argparse import all as argparse
+
+
+##
+
+
+class CommandError(Exception):
+    pass
+
+
+@dc.dataclass()
+class ArgsCommandError(CommandError):
+    command: 'Command'
+    argv: ta.Sequence[str]
+    help: str
+
+    arg_error: argparse.ArgumentError | None = None
+
+
+##
+
+
+class Command(lang.Abstract):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.__parser: argparse.ArgumentParser = argparse.NoExitArgumentParser(
+            prog=self.name,
+            description=self.description,
+            formatter_class=self._HelpFormatter,
+        )
+        self._configure_parser(self.__parser)
+
+    #
+
+    @property
+    def name(self) -> str:
+        return lang.camel_to_snake(type(self).__name__.removesuffix('Command'))
+
+    @property
+    def description(self) -> str | None:
+        return None
+
+    class _HelpFormatter(argparse.HelpFormatter):
+        def start_section(self, heading):
+            return super().start_section(heading.title())
+
+        def add_usage(self, usage, actions, groups, prefix=None):
+            if prefix is None:
+                prefix = 'Usage: '
+            return super().add_usage(usage, actions, groups, prefix)
+
+    def _configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        pass
+
+    #
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    class Context:
+        print: ta.Callable[[str], ta.Awaitable[None]]
+
+    @ta.final
+    async def run(self, ctx: Context, argv: list[str]) -> None:
+        try:
+            args = self.__parser.parse_args(argv)
+        except argparse.ArgumentError as ae:
+            raise ArgsCommandError(
+                self,
+                argv,
+                self.__parser.format_help(),
+                ae,
+            ) from ae
+
+        await self._run_args(ctx, args)
+
+    @abc.abstractmethod
+    def _run_args(self, ctx: Context, args: argparse.Namespace) -> ta.Awaitable[None]:
+        raise NotImplementedError

ommlds/cli/sessions/chat/facades/commands/configs.py

@@ -0,0 +1,9 @@
+from omlish import dataclasses as dc
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class CommandsConfig:
+    pass

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

@@ -0,0 +1,41 @@
+from omlish import inject as inj
+from omlish import lang
+
+from .configs import CommandsConfig
+from .injection import commands
+
+
+with lang.auto_proxy_import(globals()):
+    from . import manager as _manager
+    from . import simple as _simple
+
+
+##
+
+
+def bind_commands(cfg: CommandsConfig = CommandsConfig()) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    #
+
+    els.append(commands().bind_items_provider(singleton=True))
+
+    #
+
+    els.extend([
+        inj.bind(_manager.CommandsManager, singleton=True),
+    ])
+
+    #
+
+    els.extend([
+        inj.bind(_simple.EchoCommand, singleton=True),
+        commands().bind_item(to_key=_simple.EchoCommand),
+
+        inj.bind(_simple.QuitCommand, singleton=True),
+        commands().bind_item(to_key=_simple.QuitCommand),
+    ])
+
+    #
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/chat/facades/commands/injection.py

@@ -0,0 +1,15 @@
+from omlish import inject as inj
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    from . import base as _base
+    from . import types as _types
+
+
+##
+
+
+@lang.cached_function
+def commands() -> 'inj.ItemsBinderHelper[_base.Command]':
+    return inj.items_binder_helper[_base.Command](_types.Commands)

ommlds/cli/sessions/chat/facades/commands/manager.py

@@ -0,0 +1,59 @@
+import enum
+import shlex
+
+from omlish import collections as col
+
+from ..ui import UiMessageDisplayer
+from .base import Command
+from .types import Commands
+
+
+##
+
+
+class RunCommandResult(enum.StrEnum):
+    SUCCESS = 'success'
+    FAILURE = 'failure'
+
+
+class CommandsManager:
+    def __init__(
+            self,
+            *,
+            commands: Commands,
+            ui_message_displayer: UiMessageDisplayer,
+    ) -> None:
+        super().__init__()
+
+        self._commands = commands
+        self._ui_message_displayer = ui_message_displayer
+
+        self._commands_by_name = col.make_map((
+            (c.name, c) for c in commands
+        ), strict=True)
+
+    async def run_command_text(self, text: str) -> RunCommandResult:
+        try:
+            parts = shlex.split(text)
+        except ValueError as e:
+            await self._ui_message_displayer.display_ui_message(f'Invalid command syntax: {e}')
+            return RunCommandResult.FAILURE
+
+        if not parts:
+            return RunCommandResult.FAILURE
+
+        cmd = parts[0].lstrip('/').lower()
+        argv = parts[1:]
+
+        command = self._commands_by_name.get(cmd)
+        if not command:
+            await self._ui_message_displayer.display_ui_message(f'Unknown command: {cmd}')
+            return RunCommandResult.FAILURE
+
+        ctx = Command.Context(
+            print=self._ui_message_displayer.display_ui_message,
+        )
+
+        await command.run(ctx, argv)
+
+        return RunCommandResult.SUCCESS

ommlds/cli/sessions/chat/facades/commands/simple.py

@@ -0,0 +1,34 @@
+from omlish.argparse import all as argparse
+
+from ..ui import UiQuitSignal
+from .base import Command
+
+
+##
+
+
+class EchoCommand(Command):
+    def _configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        super()._configure_parser(parser)
+
+        parser.add_argument('message', help='Message to echo')
+
+    async def _run_args(self, ctx: Command.Context, args: argparse.Namespace) -> None:
+        await ctx.print(args.message)
+
+
+##
+
+
+class QuitCommand(Command):
+    def __init__(
+            self,
+            *,
+            quit_signal: UiQuitSignal,
+    ) -> None:
+        super().__init__()
+
+        self._quit_signal = quit_signal
+
+    async def _run_args(self, ctx: Command.Context, args: argparse.Namespace) -> None:
+        await self._quit_signal()

ommlds/cli/sessions/chat/facades/commands/types.py

@@ -0,0 +1,13 @@
+import typing as ta
+
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    from . import base as _base
+
+
+##
+
+
+Commands = ta.NewType('Commands', ta.Sequence['_base.Command'])

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

@@ -0,0 +1,11 @@
+from omlish import dataclasses as dc
+
+from .commands.configs import CommandsConfig
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class FacadeConfig:
+    commands: CommandsConfig = CommandsConfig()

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

@@ -0,0 +1,26 @@
+from ..... import minichain as mc
+from ..drivers.types import ChatDriver
+from .commands.manager import CommandsManager
+
+
+##
+
+
+class ChatFacade:
+    def __init__(
+            self,
+            *,
+            driver: ChatDriver,
+            commands: CommandsManager,
+    ) -> None:
+        super().__init__()
+
+        self._driver = driver
+        self._commands = commands
+
+    async def handle_user_input(self, text: str) -> None:
+        if text.startswith('/'):
+            await self._commands.run_command_text(text[1:])
+
+        else:
+            await self._driver.send_user_messages([mc.UserMessage(text)])

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,79 +1,40 @@
-from omlish import dataclasses as dc
 from omlish import inject as inj
 from omlish import lang
 
 from ..base import Session
-from .configs import DEFAULT_CHAT_MODEL_BACKEND
 from .configs import ChatConfig
 
 
 with lang.auto_proxy_import(globals()):
-    from . import driver as _driver
+    from ...rendering import inject as _rendering
     from . import session as _session
-    from .backends import inject as _backends
-    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 .rendering import inject as _rendering
-    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(
-            backend=cfg.backend or DEFAULT_CHAT_MODEL_BACKEND,
-        ),
-
-        _chat_ai.bind_ai(
-            stream=cfg.stream,
-            silent=cfg.silent,
-            enable_tools=cfg.enable_tools,
-        ),
-
-        _chat_user.bind_user(
-            initial_system_content=cfg.initial_system_content,
-            initial_user_content=cfg.initial_user_content,
-            interactive=cfg.interactive,
-        ),
-
-        _chat_state.bind_state(
-            state=cfg.state,
-        ),
-
-        _phases.bind_phases(),
-
-        _rendering.bind_rendering(
-            markdown=cfg.markdown,
-        ),
-    ])
+        _drivers.bind_driver(cfg.driver),
 
-    #
+        _facades.bind_facade(cfg.facade),
 
-    if cfg.enable_tools:
-        els.append(_tools.bind_tools(
-            silent=cfg.silent,
-            dangerous_no_confirmation=cfg.dangerous_no_tool_confirmation,
-            enabled_tools=cfg.enabled_tools,
-        ))
+        _interfaces.bind_interface(cfg.interface),
 
-    #
-
-    els.extend([
-        inj.bind(_driver.ChatDriver, singleton=True),
+        _rendering.bind_rendering(cfg.rendering),
     ])
 
     #
 
     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),
     ])
 

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