ommlds 0.0.0.dev463__py3-none-any.whl → 0.0.0.dev464__py3-none-any.whl

ommlds/cli/sessions/chat/printing.py

@@ -1,126 +0,0 @@
-import abc
-import typing as ta
-
-from omdev.tui import rich
-from omlish import check
-from omlish import lang
-from omlish.formats import json
-
-from .... import minichain as mc
-
-
-##
-
-
-class ChatSessionPrinter(lang.Abstract):
-    @abc.abstractmethod
-    def print(self, obj: mc.Message | mc.Content) -> None:
-        raise NotImplementedError
-
-
-#
-
-
-class StringChatSessionPrinter(ChatSessionPrinter, lang.Abstract):
-    @abc.abstractmethod
-    def _print_str(self, s: str) -> None:
-        raise NotImplementedError
-
-    def print(self, obj: mc.Message | mc.Content) -> None:
-        if obj is None:
-            pass
-
-        elif isinstance(obj, mc.Message):
-            if isinstance(obj, mc.SystemMessage):
-                if obj.c is not None:
-                    self._print_str(check.isinstance(obj.c, str))
-            elif isinstance(obj, mc.UserMessage):
-                if obj.c is not None:
-                    self._print_str(check.isinstance(obj.c, str))
-            elif isinstance(obj, mc.AiMessage):
-                if obj.c is not None:
-                    self._print_str(check.isinstance(obj.c, str))
-            elif isinstance(obj, mc.ToolUseResultMessage):
-                self._print_str(check.isinstance(obj.tur.c, str))
-            else:
-                raise TypeError(obj)
-
-        elif isinstance(obj, mc.JsonContent):
-            self._print_str(json.dumps_pretty(obj.v))
-
-        elif isinstance(obj, str):
-            self._print_str(obj)
-
-        else:
-            raise TypeError(obj)
-
-
-#
-
-
-class SimpleStringChatSessionPrinter(StringChatSessionPrinter):
-    def __init__(
-            self,
-            *,
-            str_printer: ta.Callable[[str], None] | None = None,
-    ) -> None:
-        super().__init__()
-
-        if str_printer is None:
-            str_printer = print
-        self._str_printer = str_printer
-
-    def _print_str(self, s: str) -> None:
-        s = s.strip()
-        if not s:
-            return
-
-        self._str_printer(s)
-
-
-#
-
-
-class MarkdownStringChatSessionPrinter(StringChatSessionPrinter):
-    def _print_str(self, s: str) -> None:
-        s = s.strip()
-        if not s:
-            return
-
-        rich.Console().print(rich.Markdown(s))
-
-
-##
-
-
-class StreamPrinter(lang.ExitStacked, lang.Abstract):
-    @abc.abstractmethod
-    def feed(self, s: str) -> None:
-        raise NotImplementedError
-
-
-#
-
-
-class SimpleStreamPrinter(StreamPrinter):
-    def feed(self, s: str) -> None:
-        print(s, end='', flush=True)
-
-    def _exit_contexts(self) -> None:
-        super()._exit_contexts()
-        print(flush=True)
-
-
-#
-
-
-class MarkdownStreamPrinter(StreamPrinter):
-    def __init__(self) -> None:
-        super().__init__()
-
-    def _enter_contexts(self) -> None:
-        super()._enter_contexts()
-        self._ir: rich.MarkdownLiveStream = self._enter_context(rich.IncrementalMarkdownLiveStream())
-
-    def feed(self, s: str) -> None:
-        self._ir.feed(s)

ommlds/cli/sessions/chat/prompt.py

@@ -1,161 +0,0 @@
-import dataclasses as dc
-import os
-
-from omlish import check
-from omlish import lang
-
-from .... import minichain as mc
-from .base import DEFAULT_CHAT_MODEL_BACKEND
-from .base import ChatOptions
-from .base import ChatSession
-from .printing import ChatSessionPrinter
-from .printing import MarkdownStreamPrinter
-from .printing import SimpleStreamPrinter
-from .printing import StreamPrinter
-from .state import ChatStateManager
-from .tools import ToolUseExecutor
-
-
-##
-
-
-class ToolExecutionRequestDeniedError(Exception):
-    pass
-
-
-class PromptChatSession(ChatSession['PromptChatSession.Config']):
-    @dc.dataclass(frozen=True)
-    class Config(ChatSession.Config):  # noqa
-        content: mc.Content
-
-        _: dc.KW_ONLY
-
-        new: bool = False
-
-        backend: str | None = None
-        model_name: str | None = None
-
-        stream: bool = False
-
-    def __init__(
-            self,
-            config: Config,
-            *,
-            state_manager: ChatStateManager,
-            chat_options: ChatOptions | None = None,
-            printer: ChatSessionPrinter,
-            backend_catalog: mc.BackendCatalog,
-            tool_exec_request_executor: ToolUseExecutor,
-    ) -> None:
-        super().__init__(config)
-
-        self._state_manager = state_manager
-        self._chat_options = chat_options
-        self._printer = printer
-        self._backend_catalog = backend_catalog
-        self._tool_exec_request_executor = tool_exec_request_executor
-
-    async def run(self) -> None:
-        if self._config.stream:
-            await self._run_stream()
-        else:
-            await self._run_immediate()
-
-    async def _run_stream(self) -> None:
-        prompt = check.isinstance(self._config.content, str)
-
-        if self._config.new:
-            state = self._state_manager.clear_state()
-        else:
-            state = self._state_manager.get_state()
-
-        new_chat: list[mc.Message] = [
-            mc.UserMessage(prompt),
-        ]
-
-        mdl: mc.ChatChoicesStreamService
-        async with lang.async_maybe_managing(self._backend_catalog.get_backend(
-            mc.ChatChoicesStreamService,
-            self._config.backend or DEFAULT_CHAT_MODEL_BACKEND,
-            *([mc.ModelName(mn)] if (mn := self._config.model_name) is not None else []),
-        )) as mdl:
-            async with (await mdl.invoke(mc.ChatChoicesStreamRequest(
-                    [*state.chat, *new_chat],
-                    (self._chat_options or []),
-            ))).v as st_resp:
-                lst: list[str] = []
-
-                sp_cls: type[StreamPrinter]
-                if self._config.markdown:
-                    sp_cls = MarkdownStreamPrinter
-                else:
-                    sp_cls = SimpleStreamPrinter
-                with sp_cls() as sp:
-                    async for o in st_resp:
-                        if o:
-                            c = check.isinstance(check.single(check.single(o.choices).deltas), mc.ContentAiChoiceDelta).c  # noqa
-                            if c is not None:
-                                s = check.isinstance(c, str)
-                                sp.feed(s)
-                                lst.append(s)
-
-            resp_m = mc.AiMessage(''.join(lst))
-            new_chat.append(resp_m)
-
-        self._state_manager.extend_chat(new_chat)
-
-    async def _run_immediate(self) -> None:
-        prompt = check.isinstance(self._config.content, str)
-
-        if self._config.new:
-            state = self._state_manager.clear_state()
-        else:
-            state = self._state_manager.get_state()
-
-        new_chat: list[mc.Message] = [
-            mc.UserMessage(prompt),
-        ]
-
-        mdl: mc.ChatChoicesService
-        async with lang.async_maybe_managing(self._backend_catalog.get_backend(
-            mc.ChatChoicesService,
-                self._config.backend or DEFAULT_CHAT_MODEL_BACKEND,
-                *([mc.ModelName(mn)] if (mn := self._config.model_name) is not None else []),
-        )) as mdl:
-            response: mc.ChatChoicesResponse = await mdl.invoke(mc.ChatChoicesRequest(
-                [*state.chat, *new_chat],
-                (self._chat_options or []),
-            ))
-
-            for resp_m in response.v[0].ms:
-                new_chat.append(resp_m)
-
-                if isinstance(resp_m, mc.AiMessage):
-                    self._printer.print(resp_m)
-
-                elif isinstance(resp_m, mc.ToolUseMessage):
-                    tr: mc.ToolUse = resp_m.tu
-
-                    # FIXME: lol
-                    from ....minichain.lib.fs.context import FsContext
-
-                    trm = await self._tool_exec_request_executor.execute_tool_use(
-                        tr,
-                        FsContext(root_dir=os.getcwd()),
-                    )
-
-                    print(trm.tur.c)
-                    new_chat.append(trm)
-
-                    response = await mdl.invoke(mc.ChatChoicesRequest(
-                        [*state.chat, *new_chat],
-                        (self._chat_options or []),
-                    ))
-
-                    resp_m = check.isinstance(check.single(response.v[0].ms), mc.AiMessage)
-                    new_chat.append(resp_m)
-
-                else:
-                    raise TypeError(resp_m)
-
-        self._state_manager.extend_chat(new_chat)

ommlds/cli/sessions/chat/state.py

@@ -1,110 +0,0 @@
-import abc
-import dataclasses as dc
-import datetime
-
-from omlish import check
-from omlish import lang
-
-from .... import minichain as mc
-from ...state import StateStorage
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class ChatState:
-    name: str | None = None
-
-    created_at: datetime.datetime = dc.field(default_factory=lang.utcnow)
-    updated_at: datetime.datetime = dc.field(default_factory=lang.utcnow)
-
-    chat: mc.Chat = ()
-
-
-##
-
-
-class ChatStateManager(lang.Abstract):
-    @abc.abstractmethod
-    def get_state(self) -> ChatState:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def clear_state(self) -> ChatState:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def extend_chat(self, chat_additions: mc.Chat) -> ChatState:
-        raise NotImplementedError
-
-
-##
-
-
-class InMemoryChatStateManager(ChatStateManager):
-    def __init__(self, initial_state: ChatState | None = None) -> None:
-        super().__init__()
-
-        if initial_state is None:
-            initial_state = ChatState()
-        self._state = initial_state
-
-    def get_state(self) -> ChatState:
-        return self._state
-
-    def clear_state(self) -> ChatState:
-        self._state = ChatState()
-        return self._state
-
-    def extend_chat(self, chat_additions: mc.Chat) -> ChatState:
-        self._state = dc.replace(
-            self._state,
-            chat=[*self._state.chat, *chat_additions],
-            updated_at=lang.utcnow(),
-        )
-        return self._state
-
-
-##
-
-
-class StateStorageChatStateManager(ChatStateManager):
-    def __init__(
-            self,
-            *,
-            storage: StateStorage,
-            key: str = 'chat',
-    ) -> None:
-        super().__init__()
-
-        self._storage = storage
-        self._key = check.non_empty_str(key)
-
-        self._state: ChatState | None = None
-
-    def get_state(self) -> ChatState:
-        if self._state is not None:
-            return self._state
-        state: ChatState | None = lang.sync_await(self._storage.load_state(self._key, ChatState))
-        if state is None:
-            state = ChatState()
-        self._state = state
-        return state
-
-    def clear_state(self) -> ChatState:
-        state = ChatState()
-        lang.sync_await(self._storage.save_state(self._key, state, ChatState))
-        self._state = state
-        return state
-
-    def extend_chat(self, chat_additions: mc.Chat) -> ChatState:
-        state = self.get_state()
-        state = dc.replace(
-            state,
-            chat=[*state.chat, *chat_additions],
-            updated_at=lang.utcnow(),
-        )
-        lang.sync_await(self._storage.save_state(self._key, state, ChatState))
-        self._state = state
-        return state

ommlds/cli/sessions/chat/tools.py

@@ -1,97 +0,0 @@
-import abc
-import typing as ta
-
-from omlish import check
-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,
-            tr: mc.ToolUse,
-            tce: mc.ToolCatalogEntry,
-    ) -> ta.Awaitable[None]:
-        raise NotImplementedError
-
-
-class NopToolExecutionConfirmation(ToolExecutionConfirmation):
-    async def confirm_tool_execution_or_raise(
-            self,
-            tr: mc.ToolUse,
-            tce: mc.ToolCatalogEntry,
-    ) -> None:
-        pass
-
-
-class AskingToolExecutionConfirmation(ToolExecutionConfirmation):
-    async def confirm_tool_execution_or_raise(
-            self,
-            tr: mc.ToolUse,
-            tce: mc.ToolCatalogEntry,
-    ) -> None:
-        tr_dct = dict(
-            id=tr.id,
-            name=tce.spec.name,
-            args=tr.args,
-            # spec=msh.marshal(tce.spec),
-        )
-        cr = confirm_action(f'Execute requested tool?\n\n{json.dumps_pretty(tr_dct)}')  # FIXME: async lol
-
-        if not cr:
-            raise ToolExecutionRequestDeniedError
-
-
-##
-
-
-class ToolUseExecutor(lang.Abstract):
-    @abc.abstractmethod
-    def execute_tool_use(
-            self,
-            tr: mc.ToolUse,
-            *ctx_items: ta.Any,
-    ) -> ta.Awaitable[mc.ToolUseResultMessage]:
-        raise NotImplementedError
-
-
-class ToolUseExecutorImpl(ToolUseExecutor):
-    def __init__(
-            self,
-            *,
-            catalog: mc.ToolCatalog,
-            confirmation: ToolExecutionConfirmation,
-    ) -> None:
-        super().__init__()
-
-        self._catalog = catalog
-        self._confirmation = confirmation
-
-    async def execute_tool_use(
-            self,
-            tr: mc.ToolUse,
-            *ctx_items: ta.Any,
-    ) -> mc.ToolUseResultMessage:
-        tce = self._catalog.by_name[check.non_empty_str(tr.name)]
-
-        await self._confirmation.confirm_tool_execution_or_raise(tr, tce)
-
-        return await mc.execute_tool_use(
-            mc.ToolContext(
-                tr,
-                *ctx_items,
-            ),
-            tce.executor(),
-            tr,
-        )

ommlds/cli/sessions/chat2/_inject.py

@@ -1,105 +0,0 @@
-from omlish import lang
-
-
-with lang.auto_proxy_init(globals()):
-    from .backends.catalog import (  # noqa
-        CatalogChatChoicesServiceBackendProvider,
-        CatalogChatChoicesStreamServiceBackendProvider,
-    )
-
-    from .backends.types import (  # noqa
-        BackendName,
-        BackendConfigs,
-        BackendProvider,
-        ChatChoicesServiceBackendProvider,
-        ChatChoicesStreamServiceBackendProvider,
-    )
-
-    from .chat.ai.rendering import (  # noqa
-        RenderingAiChatGenerator,
-        RenderingStreamAiChatGenerator,
-    )
-
-    from .chat.ai.services import (  # noqa
-        ChatChoicesServiceOptions,
-        ChatChoicesServiceAiChatGenerator,
-        ChatChoicesStreamServiceStreamAiChatGenerator,
-    )
-
-    from .chat.ai.types import (  # noqa
-        AiChatGenerator,
-        StreamAiChatGenerator,
-    )
-
-    from .chat.state.inmemory import (  # noqa
-        InMemoryChatStateManager,
-    )
-
-    from .chat.state.storage import (  # noqa
-        StateStorageChatStateManager,
-    )
-
-    from .chat.state.types import (  # noqa
-        ChatState,
-        ChatStateManager,
-    )
-
-    from .chat.user.interactive import (  # noqa
-        InteractiveUserChatInput,
-    )
-
-    from .chat.user.oneshot import (  # noqa
-        OneshotUserChatInputInitialChat,
-        OneshotUserChatInput,
-    )
-
-    from .chat.user.types import (  # noqa
-        UserChatInput,
-    )
-
-    from .content.messages import (  # noqa
-        MessageContentExtractor,
-        MessageContentExtractorImpl,
-    )
-
-    from .content.strings import (  # noqa
-        ContentStringifier,
-        ContentStringifierImpl,
-    )
-
-    from .rendering.markdown import (  # noqa
-        MarkdownContentRendering,
-        MarkdownStreamContentRendering,
-    )
-
-    from .rendering.raw import (  # noqa
-        RawContentRendering,
-        RawContentStreamRendering,
-    )
-
-    from .rendering.types import (  # noqa
-        ContentRendering,
-        StreamContentRendering,
-    )
-
-    from .tools.confirmation import (  # noqa
-        ToolExecutionRequestDeniedError,
-        ToolExecutionConfirmation,
-        InteractiveToolExecutionConfirmation,
-    )
-
-    from .tools.execution import (  # noqa
-        ToolUseExecutor,
-        ToolUseExecutorImpl,
-    )
-
-    from .driver import (  # noqa
-        ChatDriver,
-    )
-
-    from .phases import (  # noqa
-        ChatPhase,
-        ChatPhaseCallback,
-        ChatPhaseCallbacks,
-        ChatPhaseManager,
-    )

ommlds/cli/sessions/chat2/chat/ai/services.py

@@ -1,70 +0,0 @@
-import typing as ta
-
-from omlish import check
-
-from ...... import minichain as mc
-from ...backends.types import ChatChoicesServiceBackendProvider
-from .types import AiChatGenerator
-from .types import StreamAiChatGenerator
-
-
-##
-
-
-ChatChoicesServiceOptions = ta.NewType('ChatChoicesServiceOptions', ta.Sequence[mc.ChatChoicesOptions])
-
-
-##
-
-
-class ChatChoicesServiceAiChatGenerator(AiChatGenerator):
-    def __init__(
-            self,
-            service_provider: ChatChoicesServiceBackendProvider,
-            *,
-            options: ChatChoicesServiceOptions | None = None,
-    ) -> None:
-        super().__init__()
-
-        self._service_provider = service_provider
-        self._options = options
-
-    async def get_next_ai_messages(self, chat: mc.Chat) -> mc.AiChat:
-        async with self._service_provider.provide_backend() as service:
-            resp = await service.invoke(mc.ChatChoicesRequest(chat, self._options or []))
-
-        return check.single(resp.v).ms
-
-
-class ChatChoicesStreamServiceStreamAiChatGenerator(StreamAiChatGenerator):
-    def __init__(
-            self,
-            service: mc.ChatChoicesStreamService,
-            *,
-            options: ChatChoicesServiceOptions | None = None,
-    ) -> None:
-        super().__init__()
-
-        self._service = service
-        self._options = options
-
-    async def get_next_ai_messages_streamed(
-            self,
-            chat: mc.Chat,
-            delta_callback: ta.Callable[[mc.AiChoiceDelta], ta.Awaitable[None]] | None = None,
-    ) -> mc.AiChat:
-        lst: list[str] = []
-
-        async with (await self._service.invoke(mc.ChatChoicesStreamRequest(chat, self._options or []))).v as st_resp:
-            async for o in st_resp:
-                choice = check.single(o.choices)
-
-                for delta in choice.deltas:
-                    if delta_callback is not None:
-                        await delta_callback(delta)
-
-                c = check.isinstance(delta, mc.ContentAiChoiceDelta).c  # noqa
-                if c is not None:
-                    lst.append(check.isinstance(c, str))
-
-        return [mc.AiMessage(''.join(lst))]