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

ommlds/cli/sessions/chat/printing.py

@@ -1,96 +0,0 @@
-import abc
-import typing as ta
-
-from omlish import check
-from omlish import lang
-
-from .... import minichain as mc
-
-
-if ta.TYPE_CHECKING:
-    from omdev import ptk
-    from omdev.ptk import markdown as ptk_md
-else:
-    ptk = lang.proxy_import('omdev.ptk')
-    ptk_md = lang.proxy_import('omdev.ptk.markdown')
-
-
-##
-
-
-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.ToolExecResultMessage):
-                self._print_str(check.isinstance(obj.c, str))
-            else:
-                raise TypeError(obj)
-
-        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
-
-        ptk.print_formatted_text(
-            ptk_md.Markdown(s),
-            style=ptk.Style(list(ptk_md.MARKDOWN_STYLE)),
-        )

ommlds/cli/sessions/chat/prompt.py

@@ -1,143 +0,0 @@
-import dataclasses as dc
-
-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 .state import ChatStateManager
-from .tools import ToolExecRequestExecutor
-
-
-##
-
-
-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: ToolExecRequestExecutor,
-    ) -> 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
-        with lang.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:
-            with mdl.invoke(mc.ChatChoicesStreamRequest(
-                    [*state.chat, *new_chat],
-                    (self._chat_options or []),
-            )).v as st_resp:
-                lst: list[str] = []
-                for o in st_resp:
-                    if o:
-                        m = check.single(o).m
-                        if m.c is not None:
-                            print(check.isinstance(m.c, str), end='', flush=True)
-                            lst.append(check.isinstance(m.c, str))
-                        check.none(m.tool_exec_requests)
-                print()
-
-            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
-        with lang.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 = mdl.invoke(mc.ChatChoicesRequest(
-                [*state.chat, *new_chat],
-                (self._chat_options or []),
-            ))
-
-            resp_m = response.v[0].m
-            new_chat.append(resp_m)
-
-            if (trs := resp_m.tool_exec_requests):
-                check.state(resp_m.c is None)
-
-                tr: mc.ToolExecRequest = check.single(check.not_none(trs))
-
-                trm = await self._tool_exec_request_executor.execute_tool_request(tr)
-
-                print(trm.c)
-                new_chat.append(trm)
-
-                response = mdl.invoke(mc.ChatChoicesRequest(
-                    [*state.chat, *new_chat],
-                    (self._chat_options or []),
-                ))
-
-                resp_m = response.v[0].m
-                new_chat.append(resp_m)
-
-            self._printer.print(resp_m)
-
-        self._state_manager.extend_chat(new_chat)

ommlds/cli/sessions/chat/state.py

@@ -1,109 +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 = 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()
-        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(),
-        )
-        self._storage.save_state(self._key, state, ChatState)
-        return state

ommlds/cli/sessions/chat/tools.py

@@ -1,91 +0,0 @@
-import abc
-import typing as ta
-
-from omlish import check
-from omlish import lang
-from omlish import marshal as msh
-from omlish.formats import json
-
-from .... import minichain as mc
-
-
-if ta.TYPE_CHECKING:
-    from omdev import ptk
-else:
-    ptk = lang.proxy_import('omdev.ptk')
-
-
-##
-
-
-class ToolExecutionRequestDeniedError(Exception):
-    pass
-
-
-class ToolExecutionConfirmation(lang.Abstract):
-    @abc.abstractmethod
-    def confirm_tool_execution_or_raise(
-            self,
-            tr: mc.ToolExecRequest,
-            tce: mc.ToolCatalogEntry,
-    ) -> ta.Awaitable[None]:
-        raise NotImplementedError
-
-
-class NopToolExecutionConfirmation(ToolExecutionConfirmation):
-    async def confirm_tool_execution_or_raise(
-            self,
-            tr: mc.ToolExecRequest,
-            tce: mc.ToolCatalogEntry,
-    ) -> None:
-        pass
-
-
-class AskingToolExecutionConfirmation(ToolExecutionConfirmation):
-    async def confirm_tool_execution_or_raise(
-            self,
-            tr: mc.ToolExecRequest,
-            tce: mc.ToolCatalogEntry,
-    ) -> None:
-        tr_dct = dict(
-            id=tr.id,
-            spec=msh.marshal(tce.spec),
-            args=tr.args,
-        )
-        cr = await ptk.strict_confirm(f'Execute requested tool?\n\n{json.dumps_pretty(tr_dct)}\n\n')
-
-        if not cr:
-            raise ToolExecutionRequestDeniedError
-
-
-##
-
-
-class ToolExecRequestExecutor(lang.Abstract):
-    @abc.abstractmethod
-    def execute_tool_request(self, tr: mc.ToolExecRequest) -> ta.Awaitable[mc.ToolExecResultMessage]:
-        raise NotImplementedError
-
-
-class ToolExecRequestExecutorImpl(ToolExecRequestExecutor):
-    def __init__(
-            self,
-            *,
-            catalog: mc.ToolCatalog,
-            confirmation: ToolExecutionConfirmation,
-    ) -> None:
-        super().__init__()
-
-        self._catalog = catalog
-        self._confirmation = confirmation
-
-    async def execute_tool_request(self, tr: mc.ToolExecRequest) -> mc.ToolExecResultMessage:
-        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_request(
-            mc.ToolContext(),
-            tce.executor(),
-            tr,
-        )

ommlds/cli/sessions/completion/completion.py

@@ -1,44 +0,0 @@
-import dataclasses as dc
-
-from omlish import check
-from omlish import lang
-
-from .... import minichain as mc
-from ..base import Session
-
-
-##
-
-
-DEFAULT_COMPLETION_MODEL_BACKEND = 'openai'
-
-
-class CompletionSession(Session['CompletionSession.Config']):
-    @dc.dataclass(frozen=True)
-    class Config(Session.Config):
-        content: mc.Content
-
-        _: dc.KW_ONLY
-
-        backend: str | None = None
-
-    def __init__(
-            self,
-            config: Config,
-            *,
-            backend_catalog: mc.BackendCatalog,
-    ) -> None:
-        super().__init__(config)
-
-        self._backend_catalog = backend_catalog
-
-    async def run(self) -> None:
-        prompt = check.isinstance(self._config.content, str)
-
-        mdl: mc.CompletionService
-        with lang.maybe_managing(self._backend_catalog.get_backend(
-                mc.CompletionService,
-                self._config.backend or DEFAULT_COMPLETION_MODEL_BACKEND,
-        )) as mdl:
-            response = mdl.invoke(mc.CompletionRequest(prompt))
-            print(response.v.strip())

ommlds/cli/sessions/embedding/embedding.py

@@ -1,42 +0,0 @@
-import dataclasses as dc
-
-from omlish import lang
-from omlish.formats import json
-
-from .... import minichain as mc
-from ..base import Session
-
-
-##
-
-
-DEFAULT_EMBEDDING_MODEL_BACKEND = 'openai'
-
-
-class EmbeddingSession(Session['EmbeddingSession.Config']):
-    @dc.dataclass(frozen=True)
-    class Config(Session.Config):
-        content: mc.Content
-
-        _: dc.KW_ONLY
-
-        backend: str | None = None
-
-    def __init__(
-            self,
-            config: Config,
-            *,
-            backend_catalog: mc.BackendCatalog,
-    ) -> None:
-        super().__init__(config)
-
-        self._backend_catalog = backend_catalog
-
-    async def run(self) -> None:
-        mdl: mc.EmbeddingService
-        with lang.maybe_managing(self._backend_catalog.get_backend(
-            mc.EmbeddingService,
-            self._config.backend or DEFAULT_EMBEDDING_MODEL_BACKEND,
-        )) as mdl:
-            response = mdl.invoke(mc.EmbeddingRequest(self._config.content))
-            print(json.dumps_compact(list(map(float, response.v))))

ommlds/cli/tools/config.py

@@ -1,13 +0,0 @@
-from omlish import dataclasses as dc
-
-
-##
-
-
-@dc.dataclass(frozen=True, kw_only=True)
-class ToolsConfig:
-    enable_fs_tools: bool = False
-
-    enable_unsafe_bash_tool: bool = False
-
-    enable_test_weather_tool: bool = False

ommlds/cli/tools/inject.py

@@ -1,64 +0,0 @@
-import dataclasses as dc
-import typing as ta
-
-from omlish import inject as inj
-from omlish import lang
-
-from ... import minichain as mc
-from ..sessions.chat.inject import bind_chat_options
-from .config import ToolsConfig
-from .weather import WEATHER_TOOL
-
-
-##
-
-
-@dc.dataclass(frozen=True, eq=False)
-class _InjectedTool:
-    tce: mc.ToolCatalogEntry
-
-
-def bind_tool(tce: mc.ToolCatalogEntry) -> inj.Element | inj.Elements:
-    return inj.as_elements(
-        inj.bind_set_entry_const(ta.AbstractSet[_InjectedTool], _InjectedTool(tce)),
-
-        bind_chat_options(mc.Tool(tce.spec)),
-    )
-
-
-##
-
-
-def bind_tools(tools_config: ToolsConfig) -> inj.Elements:
-    els: list[inj.Elemental] = [
-        inj.bind(tools_config),
-
-        inj.bind(mc.ToolCatalog, singleton=True),
-
-        inj.set_binder[_InjectedTool](),
-        inj.bind(
-            lang.typed_lambda(mc.ToolCatalogEntries, s=ta.AbstractSet[_InjectedTool])(
-                lambda s: [it.tce for it in s],
-            ),
-            singleton=True,
-        ),
-    ]
-
-    #
-
-    if tools_config.enable_fs_tools:
-        from ...minichain.lib.fs.ls.execution import ls_tool
-
-        els.append(bind_tool(ls_tool()))
-
-    if tools_config.enable_unsafe_bash_tool:
-        from ...minichain.lib.bash import bash_tool
-
-        els.append(bind_tool(bash_tool()))
-
-    if tools_config.enable_test_weather_tool:
-        els.append(bind_tool(WEATHER_TOOL))
-
-    #
-
-    return inj.as_elements(*els)

ommlds/minichain/chat/stream/adapters.py

@@ -1,69 +0,0 @@
-import typing as ta
-
-from omlish import check
-from omlish import dataclasses as dc
-
-from ...services import Response
-from ..choices.services import ChatChoicesRequest
-from ..choices.services import static_check_is_chat_choices_service
-from ..choices.types import AiChoice
-from ..choices.types import AiChoices
-from ..messages import AiMessage
-from ..messages import ToolExecRequest
-from .services import ChatChoicesOutputs
-from .services import ChatChoicesStreamOutputs
-from .services import ChatChoicesStreamService
-
-
-##
-
-
-@static_check_is_chat_choices_service
-@dc.dataclass(frozen=True)
-class ChatChoicesStreamServiceChatChoicesService:
-    service: ChatChoicesStreamService
-
-    class _Choice(ta.NamedTuple):
-        parts: list[str]
-        trs: list[ToolExecRequest]
-
-    def invoke(self, request: ChatChoicesRequest) -> Response[
-        AiChoices,
-        ChatChoicesOutputs | ChatChoicesStreamOutputs,
-    ]:
-        lst: list[ChatChoicesStreamServiceChatChoicesService._Choice] = []
-
-        resp = self.service.invoke(request)
-        with resp.v as resp_v:
-            i = -1  # noqa
-            for i, cs in enumerate(resp_v):
-                if i == 0:
-                    for c in cs:
-                        m = c.m
-                        lst.append(self._Choice(
-                            [check.isinstance(m.c, str)] if m.c is not None else [],
-                            # FIXME
-                            # list(m.tool_exec_requests or []),
-                            [],
-                        ))
-
-                else:
-                    for ch, c in zip(lst, cs, strict=True):
-                        m = c.m
-                        if m.c is not None:
-                            ch.parts.append(check.isinstance(m.c, str))
-                        # FIXME
-                        # if m.tool_exec_requests:
-                        #     ch.trs.extend(m.tool_exec_requests)
-
-        check.state(resp_v.is_done)
-
-        ret: list[AiChoice] = []
-        for ch in lst:
-            ret.append(AiChoice(AiMessage(
-                ''.join(ch.parts) if ch.parts else None,
-                ch.trs or None,
-            )))
-
-        # FIXME: outputs lol
-        return Response(ret)

ommlds/minichain/lib/fs/ls/execution.py

@@ -1,32 +0,0 @@
-from omlish import lang
-
-from ....tools.execution.catalog import ToolCatalogEntry
-from ....tools.execution.reflect import reflect_tool_catalog_entry
-from .rendering import LsLinesRenderer
-from .running import LsRunner
-
-
-##
-
-
-def execute_ls_tool(
-        base_path: str,
-) -> str:
-    """
-    Recursively lists the directory contents of the given base path.
-
-    Args:
-        base_path: The path of the directory to list the contents of.
-
-    Returns:
-        A formatted string of the recursive directory contents.
-    """
-
-    root = LsRunner().run(base_path)
-    lines = LsLinesRenderer().render(root)
-    return '\n'.join(lines.lines)
-
-
-@lang.cached_function
-def ls_tool() -> ToolCatalogEntry:
-    return reflect_tool_catalog_entry(execute_ls_tool)