ommlds 0.0.0.dev466__py3-none-any.whl → 0.0.0.dev512__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,88 @@
+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 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,
+            catalog: 'mc.BackendCatalog',
+            configs: BackendConfigs | None = None,
+            instantiator: Instantiator | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._name = 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
+        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,127 @@ 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 meta as _meta
+    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)
+    #
 
+    lst.append(backend_configs().bind_items_provider(singleton=True))
 
-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.extend([
-        inj.bind(mc.SimpleBackendCatalog, singleton=True),
-        inj.bind(mc.BackendCatalog, to_key=mc.SimpleBackendCatalog),
-    ])
-
-    from .standard import STANDARD_BACKEND_CATALOG_ENTRIES
-
-    lst.extend([
-        inj.bind_set_entry_const(ta.AbstractSet[mc.SimpleBackendCatalogEntry], e)
-        for e in STANDARD_BACKEND_CATALOG_ENTRIES
-    ])
-
-    return inj.as_elements(*lst)
-
-
-def bind_backends(
-        *,
-        enable_backend_strings: bool = False,
-) -> inj.Elements:
-    lst: list[inj.Elemental] = []
+    #
 
-    if enable_backend_strings:
-        lst.append(bind_strings_backends())
+    if cfg.backend is not None:
+        lst.append(inj.bind(_types.BackendName, to_const=cfg.backend))
     else:
-        lst.append(bind_simple_backends())
+        lst.append(inj.bind(_types.BackendName, to_fn=inj.target(dbn=_types.DefaultBackendName)(lambda dbn: dbn)))
+
+    backend_provider_pairs: list = [
+        (_types.ChatChoicesServiceBackendProvider, _catalog.CatalogChatChoicesServiceBackendProvider),
+        (_types.ChatChoicesStreamServiceBackendProvider, _catalog.CatalogChatChoicesStreamServiceBackendProvider),
+        (_types.CompletionServiceBackendProvider, _catalog.CatalogCompletionServiceBackendProvider),
+        (_types.EmbeddingServiceBackendProvider, _catalog.CatalogEmbeddingServiceBackendProvider),
+    ]
+
+    for bp_iface, bp_impl in backend_provider_pairs:
+        bp_stack = inj.wrapper_binder_helper(bp_iface)
+
+        if bp_iface is _types.ChatChoicesServiceBackendProvider:
+            fiw_ben_lst: list[str] = [
+                # 'openai',
+                # 'anthropic',
+                # 'groq',
+                # 'cerebras',
+            ]
+
+            if fiw_ben_lst:
+                for ben in fiw_ben_lst:
+                    ben_bp_key: inj.Key = inj.Key(bp_impl, tag=ben)
+                    lst.extend([
+                        inj.private(
+                            inj.bind(_types.BackendName, to_const=ben),
+                            inj.bind(ben_bp_key, to_ctor=bp_impl, singleton=True, expose=True),
+                            inj.bind(bp_iface, to_key=ben_bp_key),
+                        ),
+                        bp_stack.push_bind(to_key=ben_bp_key),
+                    ])
+
+                fiw_key: inj.Key = inj.Key(_meta.FirstInWinsBackendProvider, tag=bp_iface)
+                lst.extend([
+                    inj.private(
+                        inj.set_binder[_types.BackendProvider]().bind(bp_stack.top),
+                        inj.bind(fiw_key, to_ctor=_meta.FirstInWinsBackendProvider, singleton=True, expose=True),
+                    ),
+                    bp_stack.push_bind(to_key=fiw_key),
+                ])
+
+            else:
+                lst.append(bp_stack.push_bind(to_ctor=bp_impl, singleton=True))
+
+        else:
+            lst.append(bp_stack.push_bind(to_ctor=bp_impl, singleton=True))
+
+        if bp_iface is _types.ChatChoicesServiceBackendProvider:
+            rt_key: inj.Key = inj.Key(_meta.RetryBackendProvider, tag=bp_iface)
+            lst.extend([
+                inj.private(
+                    inj.bind(_types.BackendProvider, to_key=bp_stack.top),
+                    inj.bind(rt_key, to_ctor=_meta.RetryBackendProvider, singleton=True, expose=True),
+                ),
+                bp_stack.push_bind(to_key=rt_key),
+            ])
+
+        elif bp_iface is _types.ChatChoicesStreamServiceBackendProvider:
+            rts_key: inj.Key = inj.Key(_meta.RetryStreamBackendProvider, tag=bp_iface)
+            lst.extend([
+                inj.private(
+                    inj.bind(_types.BackendProvider, to_key=bp_stack.top),
+                    inj.bind(rts_key, to_ctor=_meta.RetryStreamBackendProvider, singleton=True, expose=True),
+                ),
+                bp_stack.push_bind(to_key=rts_key),
+            ])
+
+        lst.append(inj.bind(bp_iface, to_key=bp_stack.top))
+
+    #
+
+    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)
+
+        return _catalog.CatalogBackendProvider.Instantiator(inner)
+
+    lst.append(inj.bind(_catalog.CatalogBackendProvider.Instantiator, to_async_fn=catalog_backend_instantiator_provider))  # noqa
 
     return inj.as_elements(*lst)

ommlds/cli/{sessions/chat/backends → backends}/injection.py

@@ -1,7 +1,7 @@
 from omlish import inject as inj
 from omlish import lang
 
-from ..... import minichain as mc
+from ... import minichain as mc
 
 
 with lang.auto_proxy_import(globals()):

ommlds/cli/backends/meta.py

@@ -0,0 +1,82 @@
+import contextlib
+import typing as ta
+
+from ... import minichain as mc
+from .types import BackendProvider
+
+
+ServiceT = ta.TypeVar('ServiceT', bound=mc.Service)
+StreamServiceT = ta.TypeVar('StreamServiceT', bound=mc.Service)
+
+
+##
+
+
+class FirstInWinsBackendProvider(BackendProvider[ServiceT]):
+    def __init__(
+            self,
+            backend_providers: ta.AbstractSet[BackendProvider],
+    ) -> None:
+        super().__init__()
+
+        self._backend_providers = [ta.cast(BackendProvider[ServiceT], bp) for bp in backend_providers]
+
+    def provide_backend(self) -> ta.AsyncContextManager[ServiceT]:
+        @contextlib.asynccontextmanager
+        async def inner():
+            from ...minichain.wrappers.firstinwins import AsyncioFirstInWinsService
+
+            async with contextlib.AsyncExitStack() as aes:
+                svcs = [
+                    await aes.enter_async_context(bp.provide_backend())
+                    for bp in self._backend_providers
+                ]
+                yield AsyncioFirstInWinsService(*svcs)
+
+        return inner()
+
+
+##
+
+
+class RetryBackendProvider(BackendProvider):
+    def __init__(
+            self,
+            backend_provider: BackendProvider,
+    ) -> None:
+        super().__init__()
+
+        self._backend_provider = backend_provider
+
+    def provide_backend(self) -> ta.AsyncContextManager:
+        @contextlib.asynccontextmanager
+        async def inner():
+            async with contextlib.AsyncExitStack() as aes:
+                yield mc.RetryService(
+                    await aes.enter_async_context(self._backend_provider.provide_backend()),
+                )
+
+        return inner()
+
+
+##
+
+
+class RetryStreamBackendProvider(BackendProvider):
+    def __init__(
+            self,
+            backend_provider: BackendProvider,
+    ) -> None:
+        super().__init__()
+
+        self._backend_provider = backend_provider
+
+    def provide_backend(self) -> ta.AsyncContextManager:
+        @contextlib.asynccontextmanager
+        async def inner():
+            async with contextlib.AsyncExitStack() as aes:
+                yield mc.RetryStreamService(
+                    await aes.enter_async_context(self._backend_provider.provide_backend()),
+                )
+
+        return inner()

ommlds/cli/{sessions/chat/backends → backends}/types.py

@@ -3,7 +3,7 @@ import typing as ta
 
 from omlish import lang
 
-from ..... import minichain as mc
+from ... import minichain as mc
 
 
 ServiceT = ta.TypeVar('ServiceT', bound=mc.Service)
@@ -13,6 +13,8 @@ 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'])
 
 
@@ -34,3 +36,11 @@ class ChatChoicesServiceBackendProvider(BackendProvider['mc.ChatChoicesService']
 
 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/{sessions/chat/content → content}/messages.py

@@ -4,7 +4,7 @@ import typing as ta
 from omlish import check
 from omlish import lang
 
-from ..... import minichain as mc
+from ... import minichain as mc
 
 
 ##
@@ -19,7 +19,7 @@ class MessageContentExtractor(lang.Abstract):
 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:
+            if message.c:
                 return check.isinstance(message.c, str)
             else:
                 return None

ommlds/cli/{sessions/chat/content → content}/strings.py

@@ -4,7 +4,7 @@ import typing as ta
 from omlish import lang
 from omlish.formats import json
 
-from ..... import minichain as mc
+from ... import minichain as mc
 
 
 ##

ommlds/cli/inject.py

@@ -1,11 +1,12 @@
-import typing as ta
-
 from omlish import inject as inj
 from omlish import lang
+from omlish import lifecycles as lc
+
+from .sessions.configs import SessionConfig
 
 
 with lang.auto_proxy_import(globals()):
-    from .backends import inject as _backends
+    from . import asyncs
     from .sessions import inject as _sessions
     from .state import inject as _state
 
@@ -15,18 +16,20 @@ with lang.auto_proxy_import(globals()):
 
 def bind_main(
         *,
-        session_cfg: ta.Any,
-        enable_backend_strings: bool = False,
+        session_cfg: SessionConfig,
 ) -> inj.Elements:
     els: list[inj.Elemental] = []
 
     #
 
     els.extend([
-        _backends.bind_backends(
-            enable_backend_strings=enable_backend_strings,
-        ),
+        lc.bind_async_lifecycle_registrar(),
+        lc.bind_async_managed_lifecycle_manager(eager=True),
+    ])
 
+    #
+
+    els.extend([
         _sessions.bind_sessions(session_cfg),
 
         _state.bind_state(),
@@ -34,4 +37,10 @@ def bind_main(
 
     #
 
+    els.extend([
+        inj.bind(asyncs.AsyncThreadRunner, to_ctor=asyncs.AnyioAsyncThreadRunner),
+    ])
+
+    #
+
     return inj.as_elements(*els)

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