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

ommlds/cli/backends/catalog.py

@@ -10,7 +10,6 @@ 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
 
@@ -26,7 +25,6 @@ class CatalogBackendProvider(BackendProvider[ServiceT], lang.Abstract):
             self,
             *,
             name: BackendName | None = None,
-            default_name: DefaultBackendName | None = None,
             catalog: 'mc.BackendCatalog',
             configs: BackendConfigs | None = None,
             instantiator: Instantiator | None = None,
@@ -34,7 +32,6 @@ class CatalogBackendProvider(BackendProvider[ServiceT], lang.Abstract):
         super().__init__()
 
         self._name = name
-        self._default_name = default_name
         self._catalog = catalog
         self._configs = configs
         if instantiator is None:
@@ -46,8 +43,6 @@ class CatalogBackendProvider(BackendProvider[ServiceT], lang.Abstract):
         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')
 

ommlds/cli/backends/inject.py

@@ -12,6 +12,7 @@ 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
 
 
@@ -42,13 +43,75 @@ def bind_backends(cfg: BackendConfig = BackendConfig()) -> inj.Elements:
 
     if cfg.backend is not None:
         lst.append(inj.bind(_types.BackendName, to_const=cfg.backend))
-
-    lst.extend([
-        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
-    ])
+    else:
+        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))
 
     #
 

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/content/messages.py

@@ -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/inject.py

@@ -1,7 +1,8 @@
-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()):
@@ -15,12 +16,19 @@ with lang.auto_proxy_import(globals()):
 
 def bind_main(
         *,
-        session_cfg: ta.Any,
+        session_cfg: SessionConfig,
 ) -> inj.Elements:
     els: list[inj.Elemental] = []
 
     #
 
+    els.extend([
+        lc.bind_async_lifecycle_registrar(),
+        lc.bind_async_managed_lifecycle_manager(eager=True),
+    ])
+
+    #
+
     els.extend([
         _sessions.bind_sessions(session_cfg),
 

ommlds/cli/main.py

@@ -16,10 +16,14 @@ from omlish.argparse import all as ap
 from omlish.logs import all as logs
 
 from .inject import bind_main
-from .secrets import install_secrets
+from .secrets import install_env_secrets
 from .sessions.base import Session
 from .sessions.chat.configs import ChatConfig
+from .sessions.chat.interfaces.bare.configs import BareInterfaceConfig
+from .sessions.chat.interfaces.configs import InterfaceConfig
+from .sessions.chat.interfaces.textual.configs import TextualInterfaceConfig
 from .sessions.completion.configs import CompletionConfig
+from .sessions.configs import SessionConfig
 from .sessions.embedding.configs import EmbeddingConfig
 
 
@@ -36,7 +40,8 @@ def _process_main_extra_args(args: ap.Namespace) -> None:
         logs.configure_standard_logging('DEBUG')
     else:
         logs.configure_standard_logging('INFO')
-        logs.silence_noisy_loggers()
+
+    logs.silence_noisy_loggers()
 
 
 ##
@@ -44,7 +49,7 @@ def _process_main_extra_args(args: ap.Namespace) -> None:
 
 class Profile(lang.Abstract):
     @abc.abstractmethod
-    def run(self, argv: ta.Sequence[str]) -> ta.Awaitable[None]:
+    def configure(self, argv: ta.Sequence[str]) -> SessionConfig:
         raise NotImplementedError
 
 
@@ -69,49 +74,85 @@ class ChatProfile(Profile):
     def configure_backend(self, cfg: ChatConfig) -> ChatConfig:
         return dc.replace(
             cfg,
-            backend=dc.replace(
-                cfg.backend,
-                backend=self._args.backend,
+            driver=dc.replace(
+                cfg.driver,
+                backend=dc.replace(
+                    cfg.driver.backend,
+                    backend=self._args.backend,
+                ),
             ),
         )
 
     #
 
-    INPUT_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
-        ap.arg('message', nargs='*', group='input'),
-        ap.arg('-i', '--interactive', action='store_true', group='input'),
-        ap.arg('-e', '--editor', action='store_true', group='input'),
+    INTERFACE_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('-i', '--interactive', action='store_true', group='interface'),
+        ap.arg('-T', '--textual', action='store_true', group='interface'),
+        ap.arg('-e', '--editor', action='store_true', group='interface'),
     ]
 
-    def configure_input(self, cfg: ChatConfig) -> ChatConfig:
+    def configure_interface(self, cfg: ChatConfig) -> ChatConfig:
         if self._args.editor:
             check.arg(not self._args.interactive)
             check.arg(not self._args.message)
             raise NotImplementedError
 
-        elif self._args.interactive:
-            check.arg(not self._args.message)
-            return dc.replace(
+        if self._args.textual:
+            check.isinstance(cfg.interface, BareInterfaceConfig)
+            cfg = dc.replace(
+                cfg,
+                interface=TextualInterfaceConfig(**{
+                    f.name: getattr(cfg.interface, f.name)
+                    for f in dc.fields(InterfaceConfig)
+                }),
+            )
+
+        else:
+            cfg = dc.replace(
                 cfg,
-                user=dc.replace(
-                    cfg.user,
-                    interactive=True,
+                driver=dc.replace(
+                    cfg.driver,
+                    ai=dc.replace(
+                        cfg.driver.ai,
+                        verbose=True,
+                    ),
+                ),
+                interface=dc.replace(
+                    check.isinstance(cfg.interface, BareInterfaceConfig),
+                    interactive=self._args.interactive,
                 ),
             )
 
+        return cfg
+
+    #
+
+    INPUT_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('message', nargs='*', group='input'),
+    ]
+
+    def configure_input(self, cfg: ChatConfig) -> ChatConfig:
+        if self._args.interactive or self._args.textual:
+            check.arg(not self._args.message)
+
         elif self._args.message:
             # TODO: '-' -> stdin
-            return dc.replace(
+            cfg = dc.replace(
                 cfg,
-                user=dc.replace(
-                    cfg.user,
-                    initial_user_content=' '.join(self._args.message),
+                driver=dc.replace(
+                    cfg.driver,
+                    user=dc.replace(
+                        cfg.driver.user,
+                        initial_user_content=' '.join(self._args.message),
+                    ),
                 ),
             )
 
         else:
             raise ValueError('Must specify input')
 
+        return cfg
+
     #
 
     STATE_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
@@ -122,9 +163,12 @@ class ChatProfile(Profile):
     def configure_state(self, cfg: ChatConfig) -> ChatConfig:
         return dc.replace(
             cfg,
-            state=dc.replace(
-                cfg.state,
-                state='ephemeral' if self._args.ephemeral else 'new' if self._args.new else 'continue',
+            driver=dc.replace(
+                cfg.driver,
+                state=dc.replace(
+                    cfg.driver.state,
+                    state='ephemeral' if self._args.ephemeral else 'new' if self._args.new else 'continue',
+                ),
             ),
         )
 
@@ -138,9 +182,12 @@ class ChatProfile(Profile):
     def configure_output(self, cfg: ChatConfig) -> ChatConfig:
         return dc.replace(
             cfg,
-            ai=dc.replace(
-                cfg.ai,
-                stream=bool(self._args.stream),
+            driver=dc.replace(
+                cfg.driver,
+                ai=dc.replace(
+                    cfg.driver.ai,
+                    stream=bool(self._args.stream),
+                ),
             ),
             rendering=dc.replace(
                 cfg.rendering,
@@ -158,26 +205,36 @@ class ChatProfile(Profile):
     ]
 
     def configure_tools(self, cfg: ChatConfig) -> ChatConfig:
+        if not (
+                self._args.enable_fs_tools or
+                self._args.enable_todo_tools or
+                # self._args.enable_unsafe_tools_do_not_use_lol or
+                self._args.enable_test_weather_tool or
+                self._args.code
+        ):
+            return cfg
+
         return dc.replace(
             cfg,
-            ai=dc.replace(
-                cfg.ai,
-                enable_tools=(
-                    self._args.enable_fs_tools or
-                    self._args.enable_todo_tools or
-                    # self._args.enable_unsafe_tools_do_not_use_lol or
-                    self._args.enable_test_weather_tool or
-                    self._args.code
+            driver=dc.replace(
+                cfg.driver,
+                ai=dc.replace(
+                    cfg.driver.ai,
+                    enable_tools=True,
+                ),
+                tools=dc.replace(
+                    cfg.driver.tools,
+                    enabled_tools={  # noqa
+                        *(cfg.driver.tools.enabled_tools or []),
+                        *(['fs'] if self._args.enable_fs_tools else []),
+                        *(['todo'] if self._args.enable_todo_tools else []),
+                        *(['weather'] if self._args.enable_test_weather_tool else []),
+                    },
                 ),
             ),
-            tools=dc.replace(
-                cfg.tools,
-                enabled_tools={  # noqa
-                    *(cfg.tools.enabled_tools or []),
-                    *(['fs'] if self._args.enable_fs_tools else []),
-                    *(['todo'] if self._args.enable_todo_tools else []),
-                    *(['weather'] if self._args.enable_test_weather_tool else []),
-                },
+            interface=dc.replace(
+                cfg.interface,
+                enable_tools=True,
             ),
         )
 
@@ -193,9 +250,12 @@ class ChatProfile(Profile):
 
         cfg = dc.replace(
             cfg,
-            ai=dc.replace(
-                cfg.ai,
-                enable_tools=True,
+            driver=dc.replace(
+                cfg.driver,
+                ai=dc.replace(
+                    cfg.driver.ai,
+                    enable_tools=True,
+                ),
             ),
         )
 
@@ -205,9 +265,12 @@ class ChatProfile(Profile):
 
             cfg = dc.replace(
                 cfg,
-                user=dc.replace(
-                    cfg.user,
-                    initial_system_content=system_content,
+                driver=dc.replace(
+                    cfg.driver,
+                    user=dc.replace(
+                        cfg.driver.user,
+                        initial_system_content=system_content,
+                    ),
                 ),
             )
 
@@ -215,11 +278,12 @@ class ChatProfile(Profile):
 
     #
 
-    async def run(self, argv: ta.Sequence[str]) -> None:
+    def configure(self, argv: ta.Sequence[str]) -> SessionConfig:
         parser = ap.ArgumentParser()
 
         for grp_name, grp_args in [
             ('backend', self.BACKEND_ARGS),
+            ('interface', self.INTERFACE_ARGS),
             ('input', self.INPUT_ARGS),
             ('state', self.STATE_ARGS),
             ('output', self.OUTPUT_ARGS),
@@ -234,23 +298,21 @@ class ChatProfile(Profile):
 
         cfg = ChatConfig()
         cfg = self.configure_backend(cfg)
+        cfg = self.configure_interface(cfg)
         cfg = self.configure_input(cfg)
         cfg = self.configure_state(cfg)
         cfg = self.configure_output(cfg)
         cfg = self.configure_tools(cfg)
         cfg = self.configure_code(cfg)
 
-        with inj.create_managed_injector(bind_main(
-                session_cfg=cfg,
-        )) as injector:
-            await injector[Session].run()
+        return cfg
 
 
 ##
 
 
 class CompletionProfile(Profile):
-    async def run(self, argv: ta.Sequence[str]) -> None:
+    def configure(self, argv: ta.Sequence[str]) -> SessionConfig:
         parser = ap.ArgumentParser()
         parser.add_argument('prompt', nargs='*')
         parser.add_argument('-b', '--backend', default='openai')
@@ -259,21 +321,18 @@ class CompletionProfile(Profile):
         content = ' '.join(args.prompt)
 
         cfg = CompletionConfig(
-            check.non_empty_str(content),
+            content=check.non_empty_str(content),
             backend=args.backend,
         )
 
-        with inj.create_managed_injector(bind_main(
-                session_cfg=cfg,
-        )) as injector:
-            await injector[Session].run()
+        return cfg
 
 
 ##
 
 
 class EmbedProfile(Profile):
-    async def run(self, argv: ta.Sequence[str]) -> None:
+    def configure(self, argv: ta.Sequence[str]) -> SessionConfig:
         parser = ap.ArgumentParser()
         parser.add_argument('prompt', nargs='*')
         parser.add_argument('-b', '--backend', default='openai')
@@ -282,14 +341,11 @@ class EmbedProfile(Profile):
         content = ' '.join(args.prompt)
 
         cfg = EmbeddingConfig(
-            check.non_empty_str(content),
+            content=check.non_empty_str(content),
             backend=args.backend,
         )
 
-        with inj.create_managed_injector(bind_main(
-                session_cfg=cfg,
-        )) as injector:
-            await injector[Session].run()
+        return cfg
 
 
 ##
@@ -305,6 +361,16 @@ PROFILE_TYPES: ta.Mapping[str, type[Profile]] = {
 ##
 
 
+async def _run_session_cfg(session_cfg: SessionConfig) -> None:
+    async with inj.create_async_managed_injector(bind_main(
+            session_cfg=session_cfg,
+    )) as injector:
+        await (await injector[Session]).run()
+
+
+##
+
+
 MAIN_PROFILE_ARGS: ta.Sequence[ap.Arg] = [
     ap.arg('-p', '--profile', default='chat'),
     ap.arg('args', nargs=ap.REMAINDER),
@@ -321,11 +387,14 @@ async def _a_main(argv: ta.Any = None) -> None:
 
     _process_main_extra_args(args)
 
-    install_secrets()
+    install_env_secrets()
 
     profile_cls = PROFILE_TYPES[args.profile]
     profile = profile_cls()
-    await profile.run([*unk_args, *args.args])
+
+    session_cfg = profile.configure([*unk_args, *args.args])
+
+    await _run_session_cfg(session_cfg)
 
 
 def _main(args: ta.Any = None) -> None:

ommlds/cli/rendering/types.py

@@ -1,3 +1,9 @@
+"""
+TODO:
+ - html?
+ - terminal?
+ - rich? textual.Content?
+"""
 import abc
 import typing as ta
 

ommlds/cli/secrets.py

@@ -6,10 +6,11 @@ from omdev.home.secrets import load_secrets
 ##
 
 
-def install_secrets() -> None:
+def install_env_secrets() -> None:
     # FIXME: lol garbage
     for key in [
         'ANTHROPIC_API_KEY',
+        'CEREBRAS_API_KEY',
         'GEMINI_API_KEY',
         'GROQ_API_KEY',
         'HUGGINGFACE_TOKEN',

ommlds/cli/sessions/base.py

@@ -1,22 +1,13 @@
 import abc
 import typing as ta
 
-from omlish import dataclasses as dc
 from omlish import lang
-from omlish.configs import all as cfgs
-
-
-SessionConfigT = ta.TypeVar('SessionConfigT', bound='Session.Config')
 
 
 ##
 
 
-class Session(cfgs.Configurable[SessionConfigT], lang.Abstract):
-    @dc.dataclass(frozen=True)
-    class Config(cfgs.Configurable.Config):
-        pass
-
+class Session(lang.Abstract):
     @abc.abstractmethod
     def run(self) -> ta.Awaitable[None]:
         raise NotImplementedError