ommlds 0.0.0.dev456__py3-none-any.whl → 0.0.0.dev485__py3-none-any.whl

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
-        async with lang.async_maybe_managing(self._backend_catalog.get_backend(
-            mc.EmbeddingService,
-            self._config.backend or DEFAULT_EMBEDDING_MODEL_BACKEND,
-        )) as mdl:
-            response = await mdl.invoke(mc.EmbeddingRequest(self._config.content))
-            print(json.dumps_compact(list(map(float, response.v))))

ommlds/cli/tools/config.py

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

ommlds/cli/tools/inject.py

@@ -1,75 +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.tools.ls import ls_tool
-        els.append(bind_tool(ls_tool()))
-
-        from ...minichain.lib.fs.tools.read import read_tool
-        els.append(bind_tool(read_tool()))
-
-    if tools_config.enable_todo_tools:
-        from ...minichain.lib.todo.tools.read import todo_read_tool
-        els.append(bind_tool(todo_read_tool()))
-
-        from ...minichain.lib.todo.tools.write import todo_write_tool
-        els.append(bind_tool(todo_write_tool()))
-
-    if tools_config.enable_unsafe_tools_do_not_use_lol:
-        from ...minichain.lib.bash import bash_tool
-        els.append(bind_tool(bash_tool()))
-
-        from ...minichain.lib.fs.tools.edit import edit_tool
-        els.append(bind_tool(edit_tool()))
-
-    if tools_config.enable_test_weather_tool:
-        els.append(bind_tool(WEATHER_TOOL))
-
-    #
-
-    return inj.as_elements(*els)

ommlds/minichain/backends/impls/openai/format2.py

@@ -1,210 +0,0 @@
-import typing as ta
-
-from omlish import cached
-from omlish import check
-from omlish import typedvalues as tv
-from omlish.formats import json
-
-from .....backends.openai import protocol as pt
-from ....chat.choices.services import ChatChoicesResponse
-from ....chat.choices.types import AiChoice
-from ....chat.choices.types import AiChoices
-from ....chat.choices.types import ChatChoicesOptions
-from ....chat.messages import AiMessage
-from ....chat.messages import AnyAiMessage
-from ....chat.messages import Chat
-from ....chat.messages import SystemMessage
-from ....chat.messages import ToolUseMessage
-from ....chat.messages import ToolUseResultMessage
-from ....chat.messages import UserMessage
-from ....chat.tools.types import Tool
-from ....content.json import JsonContent
-from ....content.prepare import prepare_content_str
-from ....llms.types import MaxTokens
-from ....llms.types import Temperature
-from ....llms.types import TokenUsage
-from ....llms.types import TokenUsageOutput
-from ....tools.jsonschema import build_tool_spec_params_json_schema
-from ....tools.types import ToolSpec
-from ....tools.types import ToolUse
-from ....types import Option
-
-
-##
-
-
-def build_oai_request_msgs(mc_chat: Chat) -> ta.Sequence[pt.ChatCompletionMessage]:
-    oai_msgs: list[pt.ChatCompletionMessage] = []
-
-    for mc_msg in mc_chat:
-        if isinstance(mc_msg, SystemMessage):
-            oai_msgs.append(pt.SystemChatCompletionMessage(
-                content=check.isinstance(mc_msg.c, str),
-            ))
-
-        elif isinstance(mc_msg, AiMessage):
-            oai_msgs.append(pt.AssistantChatCompletionMessage(
-                content=check.isinstance(mc_msg.c, (str, None)),
-            ))
-
-        elif isinstance(mc_msg, ToolUseMessage):
-            oai_msgs.append(pt.AssistantChatCompletionMessage(
-                tool_calls=[pt.AssistantChatCompletionMessage.ToolCall(
-                    id=check.not_none(mc_msg.tu.id),
-                    function=pt.AssistantChatCompletionMessage.ToolCall.Function(
-                        arguments=check.not_none(mc_msg.tu.raw_args),
-                        name=mc_msg.tu.name,
-                    ),
-                )],
-            ))
-
-        elif isinstance(mc_msg, UserMessage):
-            oai_msgs.append(pt.UserChatCompletionMessage(
-                content=prepare_content_str(mc_msg.c),
-            ))
-
-        elif isinstance(mc_msg, ToolUseResultMessage):
-            tc: str
-            if isinstance(mc_msg.tur.c, str):
-                tc = mc_msg.tur.c
-            elif isinstance(mc_msg.tur.c, JsonContent):
-                tc = json.dumps_compact(mc_msg.tur.c)
-            else:
-                raise TypeError(mc_msg.tur.c)
-            oai_msgs.append(pt.ToolChatCompletionMessage(
-                tool_call_id=check.not_none(mc_msg.tur.id),
-                content=tc,
-            ))
-
-        else:
-            raise TypeError(mc_msg)
-
-    return oai_msgs
-
-
-#
-
-
-def build_mc_ai_choice(oai_choice: pt.ChatCompletionResponseChoice) -> AiChoice:
-    cur: list[AnyAiMessage] = []
-
-    oai_msg = oai_choice.message
-
-    if (oai_c := oai_msg.content) is not None:
-        cur.append(AiMessage(check.isinstance(oai_c, str)))
-
-    for oai_tc in oai_msg.tool_calls or []:
-        cur.append(ToolUseMessage(ToolUse(
-            id=oai_tc.id,
-            name=oai_tc.function.name,
-            args=json.loads(oai_tc.function.arguments or '{}'),
-            raw_args=oai_tc.function.arguments,
-        )))
-
-    return AiChoice(cur)
-
-
-def build_mc_ai_choices(oai_resp: pt.ChatCompletionResponse) -> AiChoices:
-    return [
-        build_mc_ai_choice(oai_choice)
-        for oai_choice in oai_resp.choices
-    ]
-
-
-def build_mc_choices_response(oai_resp: pt.ChatCompletionResponse) -> ChatChoicesResponse:
-    return ChatChoicesResponse(
-        build_mc_ai_choices(oai_resp),
-
-        tv.TypedValues(
-            *([TokenUsageOutput(TokenUsage(
-                input=tu.prompt_tokens,
-                output=tu.completion_tokens,
-                total=tu.total_tokens,
-            ))] if (tu := oai_resp.usage) is not None else []),
-        ),
-    )
-
-
-##
-
-
-class OpenaiChatRequestHandler:
-    def __init__(
-            self,
-            chat: Chat,
-            *options: ChatChoicesOptions,
-            model: str,
-            mandatory_kwargs: ta.Mapping[str, ta.Any] | None = None,
-    ) -> None:
-        super().__init__()
-
-        self._chat = chat
-        self._options = options
-        self._model = model
-        self._mandatory_kwargs = mandatory_kwargs
-
-    DEFAULT_OPTIONS: ta.ClassVar[tv.TypedValues[Option]] = tv.TypedValues[Option](
-        Temperature(0.),
-        MaxTokens(1024),
-    )
-
-    _OPTION_KWARG_NAMES_MAP: ta.ClassVar[ta.Mapping[str, type[ChatChoicesOptions]]] = dict(
-        temperature=Temperature,
-        max_tokens=MaxTokens,
-    )
-
-    class _ProcessedOptions(ta.NamedTuple):
-        kwargs: dict[str, ta.Any]
-        tools_by_name: dict[str, ToolSpec]
-
-    @cached.function
-    def _process_options(self) -> _ProcessedOptions:
-        kwargs: dict = dict(
-            temperature=0,
-            max_tokens=1024,
-        )
-
-        tools_by_name: dict[str, ToolSpec] = {}
-
-        with tv.TypedValues(*self._options).consume() as oc:
-            kwargs.update(oc.pop_scalar_kwargs(**self._OPTION_KWARG_NAMES_MAP))
-
-            for t in oc.pop(Tool, []):
-                if t.spec.name in tools_by_name:
-                    raise NameError(t.spec.name)
-                tools_by_name[check.non_empty_str(t.spec.name)] = t.spec
-
-        if (mk := self._mandatory_kwargs):
-            for k, v in mk.items():
-                check.not_in(k, kwargs)
-                kwargs[k] = v
-
-        return self._ProcessedOptions(
-            kwargs=kwargs,
-            tools_by_name=tools_by_name,
-        )
-
-    @cached.function
-    def oai_request(self) -> pt.ChatCompletionRequest:
-        po = self._process_options()
-
-        tools: list[pt.ChatCompletionRequestTool] = [
-            pt.ChatCompletionRequestTool(
-                function=pt.ChatCompletionRequestTool.Function(
-                    name=check.not_none(ts.name),
-                    description=prepare_content_str(ts.desc),
-                    parameters=build_tool_spec_params_json_schema(ts),
-                ),
-            )
-            for ts in po.tools_by_name.values()
-        ]
-
-        return pt.ChatCompletionRequest(
-            model=self._model,
-            messages=build_oai_request_msgs(self._chat),
-            top_p=1,
-            tools=tools or None,
-            frequency_penalty=0.0,
-            presence_penalty=0.0,
-            **po.kwargs,
-        )

ommlds/minichain/chat/stream/adapters.py

@@ -1,80 +0,0 @@
-from omlish import check
-from omlish import dataclasses as dc
-from omlish import lang
-
-from ...services import Response
-from ...tools.types import ToolUse
-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 AnyAiMessage
-from ..messages import ToolUseMessage
-from .services import ChatChoicesOutputs
-from .services import ChatChoicesStreamOutputs
-from .services import ChatChoicesStreamService
-from .types import AiChoiceDelta
-from .types import ContentAiChoiceDelta
-from .types import ToolUseAiChoiceDelta
-
-
-##
-
-
-@static_check_is_chat_choices_service
-@dc.dataclass(frozen=True)
-class ChatChoicesStreamServiceChatChoicesService:
-    service: ChatChoicesStreamService
-
-    async def invoke(self, request: ChatChoicesRequest) -> Response[
-        AiChoices,
-        ChatChoicesOutputs | ChatChoicesStreamOutputs,
-    ]:
-        choice_lsts: list[list[list[str] | ToolUse]] = []
-
-        def add(l: list[list[str] | ToolUse], d: AiChoiceDelta) -> None:
-            if isinstance(d, ContentAiChoiceDelta):
-                s = check.isinstance(d.c, str)
-                if l and isinstance(l[-1], list):
-                    l[-1].append(s)
-                else:
-                    l.append([s])
-
-            elif isinstance(d, ToolUseAiChoiceDelta):
-                l.append(d.tu)
-
-            else:
-                raise TypeError(d)
-
-        async with (resp := await self.service.invoke(request)).v as it:  # noqa
-            i = -1  # noqa
-            l: list[list[str] | ToolUse]
-            async for i, cs in lang.async_enumerate(it):
-                if i == 0:
-                    for c in cs.choices:
-                        choice_lsts.append(l := [])
-                        for d in c.deltas:
-                            add(l, d)
-
-                else:
-                    for l, c in zip(choice_lsts, cs.choices, strict=True):
-                        for d in c.deltas:
-                            add(l, d)
-
-        # check.state(resp_v.is_done)
-
-        ret: list[AiChoice] = []
-        for cl in choice_lsts:
-            cc: list[AnyAiMessage] = []
-            for e in cl:
-                if isinstance(e, list):
-                    cc.append(AiMessage(''.join(e)))
-                elif isinstance(e, ToolUse):
-                    cc.append(ToolUseMessage(e))
-                else:
-                    raise TypeError(e)
-            ret.append(AiChoice(cc))
-
-        # FIXME: outputs lol
-        return Response(ret)