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

ommlds/cli/asyncs.py

@@ -0,0 +1,30 @@
+import abc
+import functools
+import typing as ta
+
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    import anyio
+
+
+T = ta.TypeVar('T')
+P = ta.ParamSpec('P')
+
+
+##
+
+
+class AsyncThreadRunner(lang.Abstract):
+    @abc.abstractmethod
+    def run_in_thread(self, fn: ta.Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> ta.Awaitable[T]:
+        raise NotImplementedError
+
+
+##
+
+
+class AnyioAsyncThreadRunner(AsyncThreadRunner):
+    def run_in_thread(self, fn: ta.Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> ta.Awaitable[T]:
+        return anyio.to_thread.run_sync(functools.partial(fn, *args, **kwargs))

ommlds/cli/backends/catalog.py

@@ -0,0 +1,93 @@
+import contextlib
+import typing as ta
+
+from omlish import lang
+
+from ... import minichain as mc
+from .types import BackendConfigs
+from .types import BackendName
+from .types import BackendProvider
+from .types import ChatChoicesServiceBackendProvider
+from .types import ChatChoicesStreamServiceBackendProvider
+from .types import CompletionServiceBackendProvider
+from .types import DefaultBackendName
+from .types import EmbeddingServiceBackendProvider
+from .types import ServiceT
+
+
+##
+
+
+class CatalogBackendProvider(BackendProvider[ServiceT], lang.Abstract):
+    class Instantiator(lang.Func2['mc.BackendCatalog.Backend', BackendConfigs | None, ta.Awaitable[ta.Any]]):
+        pass
+
+    def __init__(
+            self,
+            *,
+            name: BackendName | None = None,
+            default_name: DefaultBackendName | None = None,
+            catalog: 'mc.BackendCatalog',
+            configs: BackendConfigs | None = None,
+            instantiator: Instantiator | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._name = name
+        self._default_name = default_name
+        self._catalog = catalog
+        self._configs = configs
+        if instantiator is None:
+            instantiator = CatalogBackendProvider.Instantiator(lang.as_async(lambda be, cfgs: be.factory(*cfgs or [])))
+        self._instantiator = instantiator
+
+    @contextlib.asynccontextmanager
+    async def _provide_backend(self, cls: type[ServiceT]) -> ta.AsyncIterator[ServiceT]:
+        name: str
+        if self._name is not None:
+            name = self._name
+        elif self._default_name is not None:
+            name = self._default_name
+        else:
+            raise RuntimeError('No backend name specified')
+
+        be = self._catalog.get_backend(cls, name)
+
+        service: ServiceT
+        async with lang.async_or_sync_maybe_managing(await self._instantiator(be, self._configs)) as service:
+            yield service
+
+
+##
+
+
+class CatalogChatChoicesServiceBackendProvider(
+    CatalogBackendProvider['mc.ChatChoicesService'],
+    ChatChoicesServiceBackendProvider,
+):
+    def provide_backend(self) -> ta.AsyncContextManager['mc.ChatChoicesService']:
+        return self._provide_backend(mc.ChatChoicesService)  # type: ignore[type-abstract]
+
+
+class CatalogChatChoicesStreamServiceBackendProvider(
+    CatalogBackendProvider['mc.ChatChoicesStreamService'],
+    ChatChoicesStreamServiceBackendProvider,
+):
+    def provide_backend(self) -> ta.AsyncContextManager['mc.ChatChoicesStreamService']:
+        return self._provide_backend(mc.ChatChoicesStreamService)  # type: ignore[type-abstract]
+
+
+class CatalogCompletionServiceBackendProvider(
+    CatalogBackendProvider['mc.CompletionService'],
+    CompletionServiceBackendProvider,
+):
+    def provide_backend(self) -> ta.AsyncContextManager['mc.CompletionService']:
+        return self._provide_backend(mc.CompletionService)  # type: ignore[type-abstract]
+
+
+class CatalogEmbeddingServiceBackendProvider(
+    CatalogBackendProvider['mc.EmbeddingService'],
+    EmbeddingServiceBackendProvider,
+):
+    def provide_backend(self) -> ta.AsyncContextManager['mc.EmbeddingService']:
+        return self._provide_backend(mc.EmbeddingService)  # type: ignore[type-abstract]

ommlds/cli/backends/configs.py

@@ -0,0 +1,9 @@
+from omlish import dataclasses as dc
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class BackendConfig:
+    backend: str | None = None

ommlds/cli/backends/inject.py

@@ -2,69 +2,64 @@ import typing as ta
 
 from omlish import inject as inj
 from omlish import lang
+from omlish import typedvalues as tv
 
 from ... import minichain as mc
+from .configs import BackendConfig
+from .injection import backend_configs
+
+
+with lang.auto_proxy_import(globals()):
+    from ...minichain.backends.impls.huggingface import repos as hf_repos
+    from . import catalog as _catalog
+    from . import types as _types
 
 
 ##
 
 
-def bind_strings_backends() -> inj.Elements:
+def bind_backends(cfg: BackendConfig = BackendConfig()) -> inj.Elements:
     lst: list[inj.Elemental] = []
 
+    #
+
     lst.extend([
         inj.bind(mc.BackendStringBackendCatalog, singleton=True),
         inj.bind(mc.BackendCatalog, to_key=mc.BackendStringBackendCatalog),
     ])
 
-    from ...minichain.backends.impls.huggingface.repos import HuggingfaceModelRepoResolver
-
     lst.extend([
-        inj.bind(HuggingfaceModelRepoResolver, singleton=True),
-        inj.bind(mc.ModelRepoResolver, to_key=HuggingfaceModelRepoResolver),
+        inj.bind(hf_repos.HuggingfaceModelRepoResolver, singleton=True),
+        inj.bind(mc.ModelRepoResolver, to_key=hf_repos.HuggingfaceModelRepoResolver),
 
     ])
 
-    return inj.as_elements(*lst)
-
-
-def bind_simple_backends() -> inj.Elements:
-    lst: list[inj.Elemental] = []
+    #
 
-    lst.extend([
-        inj.set_binder[mc.SimpleBackendCatalogEntry](),
-        inj.bind(
-            lang.typed_lambda(mc.SimpleBackendCatalogEntries, s=ta.AbstractSet[mc.SimpleBackendCatalogEntry])(
-                lambda s: list(s),
-            ),
-            singleton=True,
-        ),
-    ])
+    lst.append(backend_configs().bind_items_provider(singleton=True))
 
-    lst.extend([
-        inj.bind(mc.SimpleBackendCatalog, singleton=True),
-        inj.bind(mc.BackendCatalog, to_key=mc.SimpleBackendCatalog),
-    ])
+    #
 
-    from .standard import STANDARD_BACKEND_CATALOG_ENTRIES
+    if cfg.backend is not None:
+        lst.append(inj.bind(_types.BackendName, to_const=cfg.backend))
 
     lst.extend([
-        inj.bind_set_entry_const(ta.AbstractSet[mc.SimpleBackendCatalogEntry], e)
-        for e in STANDARD_BACKEND_CATALOG_ENTRIES
+        inj.bind(_types.ChatChoicesServiceBackendProvider, to_ctor=_catalog.CatalogChatChoicesServiceBackendProvider, singleton=True),  # noqa
+        inj.bind(_types.ChatChoicesStreamServiceBackendProvider, to_ctor=_catalog.CatalogChatChoicesStreamServiceBackendProvider, singleton=True),  # noqa
+        inj.bind(_types.CompletionServiceBackendProvider, to_ctor=_catalog.CatalogCompletionServiceBackendProvider, singleton=True),  # noqa
+        inj.bind(_types.EmbeddingServiceBackendProvider, to_ctor=_catalog.CatalogEmbeddingServiceBackendProvider, singleton=True),  # noqa
     ])
 
-    return inj.as_elements(*lst)
+    #
 
+    async def catalog_backend_instantiator_provider(injector: inj.AsyncInjector) -> _catalog.CatalogBackendProvider.Instantiator:  # noqa
+        async def inner(be: 'mc.BackendCatalog.Backend', cfgs: _types.BackendConfigs | None) -> ta.Any:
+            kwt = inj.build_kwargs_target(be.factory, non_strict=True)
+            kw = await injector.provide_kwargs(kwt)
+            return be.factory(*tv.collect(*(be.configs or []), *(cfgs or []), override=True), **kw)
 
-def bind_backends(
-        *,
-        enable_backend_strings: bool = False,
-) -> inj.Elements:
-    lst: list[inj.Elemental] = []
+        return _catalog.CatalogBackendProvider.Instantiator(inner)
 
-    if enable_backend_strings:
-        lst.append(bind_strings_backends())
-    else:
-        lst.append(bind_simple_backends())
+    lst.append(inj.bind(_catalog.CatalogBackendProvider.Instantiator, to_async_fn=catalog_backend_instantiator_provider))  # noqa
 
     return inj.as_elements(*lst)

ommlds/cli/backends/injection.py

@@ -0,0 +1,16 @@
+from omlish import inject as inj
+from omlish import lang
+
+from ... import minichain as mc
+
+
+with lang.auto_proxy_import(globals()):
+    from . import types as _types
+
+
+##
+
+
+@lang.cached_function
+def backend_configs() -> 'inj.ItemsBinderHelper[mc.Config]':
+    return inj.items_binder_helper[mc.Config](_types.BackendConfigs)

ommlds/cli/backends/types.py

@@ -0,0 +1,46 @@
+import abc
+import typing as ta
+
+from omlish import lang
+
+from ... import minichain as mc
+
+
+ServiceT = ta.TypeVar('ServiceT', bound=mc.Service)
+
+
+##
+
+
+BackendName = ta.NewType('BackendName', str)
+DefaultBackendName = ta.NewType('DefaultBackendName', str)
+
+BackendConfigs = ta.NewType('BackendConfigs', ta.Sequence['mc.Config'])
+
+
+##
+
+
+class BackendProvider(lang.Abstract, ta.Generic[ServiceT]):
+    @abc.abstractmethod
+    def provide_backend(self) -> ta.AsyncContextManager[ServiceT]:
+        raise NotImplementedError
+
+
+##
+
+
+class ChatChoicesServiceBackendProvider(BackendProvider['mc.ChatChoicesService'], lang.Abstract):
+    pass
+
+
+class ChatChoicesStreamServiceBackendProvider(BackendProvider['mc.ChatChoicesStreamService'], lang.Abstract):
+    pass
+
+
+class CompletionServiceBackendProvider(BackendProvider['mc.CompletionService'], lang.Abstract):
+    pass
+
+
+class EmbeddingServiceBackendProvider(BackendProvider['mc.EmbeddingService'], lang.Abstract):
+    pass

ommlds/cli/content/messages.py

@@ -0,0 +1,34 @@
+import abc
+import typing as ta
+
+from omlish import check
+from omlish import lang
+
+from ... import minichain as mc
+
+
+##
+
+
+class MessageContentExtractor(lang.Abstract):
+    @abc.abstractmethod
+    def extract_message_content(self, message: 'mc.Message') -> ta.Optional['mc.Content']:
+        raise NotImplementedError
+
+
+class MessageContentExtractorImpl(MessageContentExtractor):
+    def extract_message_content(self, message: 'mc.Message') -> ta.Optional['mc.Content']:
+        if isinstance(message, (mc.SystemMessage, mc.UserMessage, mc.AiMessage)):
+            if message.c is not None:
+                return check.isinstance(message.c, str)
+            else:
+                return None
+
+        elif isinstance(message, mc.ToolUseMessage):
+            return None
+
+        elif isinstance(message, mc.ToolUseResultMessage):
+            return check.isinstance(message.tur.c, str)
+
+        else:
+            raise TypeError(message)

ommlds/cli/content/strings.py

@@ -0,0 +1,42 @@
+import abc
+import typing as ta
+
+from omlish import lang
+from omlish.formats import json
+
+from ... import minichain as mc
+
+
+##
+
+
+class ContentStringifier(lang.Abstract):
+    @abc.abstractmethod
+    def stringify_content(self, content: 'mc.Content') -> str | None:
+        raise NotImplementedError
+
+
+class ContentStringifierImpl(ContentStringifier):
+    def stringify_content(self, content: 'mc.Content') -> str | None:
+        if isinstance(content, str):
+            return content
+
+        elif isinstance(content, mc.JsonContent):
+            return json.dumps_pretty(content.v)
+
+        else:
+            raise TypeError(content)
+
+
+class HasContentStringifier(lang.Abstract):
+    def __init__(
+            self,
+            *args: ta.Any,
+            content_stringifier: ContentStringifier | None = None,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        if content_stringifier is None:
+            content_stringifier = ContentStringifierImpl()
+        self._content_stringifier = content_stringifier

ommlds/cli/inject.py

@@ -1,30 +1,13 @@
-import os.path
+import typing as ta
 
-from omdev.home.paths import get_home_paths
 from omlish import inject as inj
 from omlish import lang
 
 
 with lang.auto_proxy_import(globals()):
-    from . import state
-    from .backends import inject as backends_inj
-    from .sessions import base as sessions_base
-    from .sessions import inject as sessions_inj
-    from .tools import config as tools_cfg
-    from .tools import inject as tools_inj
-
-
-##
-
-
-def _provide_state_storage() -> 'state.StateStorage':
-    state_dir = os.path.join(get_home_paths().state_dir, 'minichain', 'cli')
-    if not os.path.exists(state_dir):
-        os.makedirs(state_dir, exist_ok=True)
-        os.chmod(state_dir, 0o770)  # noqa
-
-    state_file = os.path.join(state_dir, 'state.json')
-    return state.JsonFileStateStorage(state_file)
+    from . import asyncs
+    from .sessions import inject as _sessions
+    from .state import inject as _state
 
 
 ##
@@ -32,23 +15,23 @@ def _provide_state_storage() -> 'state.StateStorage':
 
 def bind_main(
         *,
-        session_cfg: 'sessions_base.Session.Config',
-        tools_config: 'tools_cfg.ToolsConfig',
-        enable_backend_strings: bool = False,
+        session_cfg: ta.Any,
 ) -> inj.Elements:
-    els: list[inj.Elemental] = [
-        backends_inj.bind_backends(
-            enable_backend_strings=enable_backend_strings,
-        ),
+    els: list[inj.Elemental] = []
+
+    #
 
-        sessions_inj.bind_sessions(session_cfg),
+    els.extend([
+        _sessions.bind_sessions(session_cfg),
 
-        tools_inj.bind_tools(tools_config),
-    ]
+        _state.bind_state(),
+    ])
 
     #
 
-    els.append(inj.bind(_provide_state_storage, singleton=True))
+    els.extend([
+        inj.bind(asyncs.AsyncThreadRunner, to_ctor=asyncs.AnyioAsyncThreadRunner),
+    ])
 
     #
 

ommlds/cli/inputs/asyncs.py

@@ -0,0 +1,32 @@
+import typing as ta
+
+from .. import asyncs
+from .sync import SyncStringInput
+
+
+##
+
+
+class AsyncStringInput(ta.Protocol):
+    def __call__(self) -> ta.Awaitable[str]: ...
+
+
+class ThreadAsyncStringInput:
+    def __init__(self, child: SyncStringInput, runner: asyncs.AsyncThreadRunner) -> None:
+        super().__init__()
+
+        self._child = child
+        self._runner = runner
+
+    async def __call__(self) -> str:
+        return await self._runner.run_in_thread(self._child)
+
+
+class SyncAsyncStringInput:
+    def __init__(self, child: SyncStringInput) -> None:
+        super().__init__()
+
+        self._child = child
+
+    async def __call__(self) -> str:
+        return self._child()

ommlds/cli/inputs/sync.py

@@ -0,0 +1,75 @@
+import sys
+import typing as ta
+
+from omlish import check
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    from omlish.subprocesses import editor
+    from omlish.subprocesses import sync as sync_subprocesses
+
+
+##
+
+
+class SyncStringInput(ta.Protocol):
+    def __call__(self) -> str: ...
+
+
+class InputSyncStringInput:
+    DEFAULT_PROMPT: ta.ClassVar[str] = '> '
+
+    def __init__(
+            self,
+            prompt: str | None = None,
+            *,
+            use_readline: bool | ta.Literal['auto'] = False,
+    ) -> None:
+        super().__init__()
+
+        if prompt is None:
+            prompt = self.DEFAULT_PROMPT
+        self._prompt = prompt
+        self._use_readline = use_readline
+
+        self._handled_readline = False
+
+    def _handle_readline(self) -> None:
+        if self._handled_readline:
+            return
+        self._handled_readline = True
+
+        if not self._use_readline:
+            return
+
+        if self._use_readline == 'auto':
+            if not sys.stdin.isatty():
+                return
+
+        try:
+            import readline  # noqa
+        except ImportError:
+            pass
+
+    def __call__(self) -> str:
+        self._handle_readline()
+        return input(self._prompt)
+
+
+class FileSyncStringInput(InputSyncStringInput):
+    def __init__(self, path: str) -> None:
+        super().__init__()
+
+        self._path = check.non_empty_str(path)
+
+    def __call__(self) -> str:
+        with open(self._path) as f:
+            return f.read()
+
+
+class UserEditorSyncStringInput(InputSyncStringInput):
+    def __call__(self) -> str:
+        if (ec := editor.edit_text_with_user_editor('', sync_subprocesses.subprocesses)) is None:
+            raise EOFError
+        return ec