ommlds 0.0.0.dev492__py3-none-any.whl → 0.0.0.dev493__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

@@ -42,6 +42,8 @@ def bind_backends(cfg: BackendConfig = BackendConfig()) -> inj.Elements:
 
     if cfg.backend is not None:
         lst.append(inj.bind(_types.BackendName, to_const=cfg.backend))
+    else:
+        lst.append(inj.bind(_types.BackendName, to_fn=inj.KwargsTarget.of(lambda dbn: dbn, dbn=_types.DefaultBackendName)))  # noqa
 
     lst.extend([
         inj.bind(_types.ChatChoicesServiceBackendProvider, to_ctor=_catalog.CatalogChatChoicesServiceBackendProvider, singleton=True),  # noqa

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(),
+    ])
+
+    #
+
     els.extend([
         _sessions.bind_sessions(session_cfg),
 

ommlds/cli/main.py

@@ -19,7 +19,11 @@ from .inject import bind_main
 from .secrets import install_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
 
 
@@ -45,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
 
 
@@ -94,12 +98,13 @@ class ChatProfile(Profile):
             raise NotImplementedError
 
         if self._args.textual:
+            check.isinstance(cfg.interface, BareInterfaceConfig)
             cfg = dc.replace(
                 cfg,
-                interface=dc.replace(
-                    cfg.interface,
-                    use_textual=True,
-                ),
+                interface=TextualInterfaceConfig(**{
+                    f.name: getattr(cfg.interface, f.name)
+                    for f in dc.fields(InterfaceConfig)
+                }),
             )
 
         else:
@@ -113,7 +118,7 @@ class ChatProfile(Profile):
                     ),
                 ),
                 interface=dc.replace(
-                    cfg.interface,
+                    check.isinstance(cfg.interface, BareInterfaceConfig),
                     interactive=self._args.interactive,
                 ),
             )
@@ -273,7 +278,7 @@ 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 [
@@ -300,17 +305,14 @@ class ChatProfile(Profile):
         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')
@@ -319,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')
@@ -342,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
 
 
 ##
@@ -365,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),
@@ -385,7 +391,10 @@ async def _a_main(argv: ta.Any = None) -> None:
 
     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/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

ommlds/cli/sessions/chat/configs.py

@@ -1,21 +1,19 @@
 from omlish import dataclasses as dc
 
 from ...rendering.configs import RenderingConfig
+from ..configs import SessionConfig
 from .drivers.configs import DriverConfig
+from .facades.configs import FacadeConfig
+from .interfaces.bare.configs import BareInterfaceConfig
 from .interfaces.configs import InterfaceConfig
 
 
 ##
 
 
-DEFAULT_BACKEND = 'openai'
-
-
-##
-
-
 @dc.dataclass(frozen=True, kw_only=True)
-class ChatConfig:
+class ChatConfig(SessionConfig):
     driver: DriverConfig = DriverConfig()
-    interface: InterfaceConfig = InterfaceConfig()
+    facade: FacadeConfig = FacadeConfig()
+    interface: InterfaceConfig = BareInterfaceConfig()
     rendering: RenderingConfig = RenderingConfig()

ommlds/cli/sessions/chat/drivers/driver.py

@@ -3,6 +3,8 @@ TODO:
  - lifecycles
  - StreamService
 """
+import typing as ta
+
 from omlish import lang
 
 from ..... import minichain as mc
@@ -17,7 +19,7 @@ from .state.types import ChatStateManager
 ##
 
 
-class ChatDriverGetter(lang.Func0['ChatDriver']):
+class ChatDriverGetter(lang.Func0[ta.Awaitable['ChatDriver']]):
     pass
 
 

ommlds/cli/sessions/chat/drivers/inject.py

@@ -27,7 +27,7 @@ with lang.auto_proxy_import(globals()):
 ##
 
 
-def bind_driver(cfg: DriverConfig) -> inj.Elements:
+def bind_driver(cfg: DriverConfig = DriverConfig()) -> inj.Elements:
     els: list[inj.Elemental] = []
 
     #
@@ -52,8 +52,7 @@ def bind_driver(cfg: DriverConfig) -> inj.Elements:
 
     els.extend([
         inj.bind(_driver.ChatDriver, singleton=True),
-
-        inj.bind_late(_driver.ChatDriver, _driver.ChatDriverGetter),
+        inj.bind_async_late(_driver.ChatDriver, _driver.ChatDriverGetter),
     ])
 
     #

ommlds/cli/sessions/chat/drivers/state/configs.py

@@ -9,3 +9,5 @@ from omlish import dataclasses as dc
 @dc.dataclass(frozen=True, kw_only=True)
 class StateConfig:
     state: ta.Literal['new', 'continue', 'ephemeral'] = 'continue'
+
+    chat_id: str | None = None

ommlds/cli/sessions/chat/drivers/state/ids.py

@@ -0,0 +1,25 @@
+from .storage import StateStorage
+from .types import ChatId
+
+
+##
+
+
+_LAST_CHAT_ID_STATE_KEY: str = 'last_chat_id'
+
+
+class LastChatIdManager:
+    def __init__(
+            self,
+            *,
+            state_storage: StateStorage,
+    ) -> None:
+        super().__init__()
+
+        self._state_storage = state_storage
+
+    async def get_last_chat_id(self) -> ChatId | None:
+        return await self._state_storage.load_state(_LAST_CHAT_ID_STATE_KEY, ChatId)
+
+    async def set_last_chat_id(self, chat_id: ChatId | None) -> None:
+        await self._state_storage.save_state(_LAST_CHAT_ID_STATE_KEY, chat_id, ChatId)

ommlds/cli/sessions/chat/drivers/state/inject.py

@@ -1,3 +1,10 @@
+"""
+TODO:
+ - given chat-id + ephemeral = continue in mem
+ - fork chats
+"""
+import uuid
+
 from omlish import inject as inj
 from omlish import lang
 
@@ -8,6 +15,7 @@ from .configs import StateConfig
 
 
 with lang.auto_proxy_import(globals()):
+    from . import ids as _ids
     from . import inmemory as _inmemory
     from . import storage as _storage
     from . import types as _types
@@ -16,21 +24,61 @@ with lang.auto_proxy_import(globals()):
 ##
 
 
+def _new_chat_id() -> '_types.ChatId':
+    return _types.ChatId(uuid.uuid4())
+
+
+async def _get_last_or_new_chat_id(lcim: '_ids.LastChatIdManager') -> '_types.ChatId':
+    return lcid if (lcid := await lcim.get_last_chat_id()) is not None else _new_chat_id()
+
+
+##
+
+
 def bind_state(cfg: StateConfig = StateConfig()) -> inj.Elements:
     els: list[inj.Elemental] = []
 
     if cfg.state in ('continue', 'new'):
-        els.append(inj.bind(_types.ChatStateManager, to_ctor=_storage.StateStorageChatStateManager, singleton=True))
-
         if cfg.state == 'new':
-            els.append(phase_callbacks().bind_item(to_fn=lang.typed_lambda(cm=_types.ChatStateManager)(
-                lambda cm: ChatPhaseCallback(ChatPhase.STARTING, cm.clear_state),
-            )))
+            els.append(inj.bind(_types.ChatId(uuid.UUID(cfg.chat_id)) if cfg.chat_id is not None else _new_chat_id()))
+
+        elif cfg.chat_id is not None:
+            els.append(inj.bind(_types.ChatId(uuid.UUID(cfg.chat_id))))
+
+        else:
+            els.append(inj.bind(_types.ChatId, to_async_fn=_get_last_or_new_chat_id, singleton=True))
+
+        els.extend([
+            inj.bind(_storage.build_chat_storage_key),
+
+            inj.bind(_types.ChatStateManager, to_ctor=_storage.StateStorageChatStateManager, singleton=True),
+        ])
+
+        #
+
+        els.extend([
+            inj.bind(_ids.LastChatIdManager, singleton=True),
+
+            phase_callbacks().bind_item(to_fn=inj.KwargsTarget.of(
+                lambda lcim, cid: ChatPhaseCallback(ChatPhase.STARTED, lambda: lcim.set_last_chat_id(cid)),
+                lcim=_ids.LastChatIdManager,
+                cid=_types.ChatId,
+            )),
+        ])
 
     elif cfg.state == 'ephemeral':
-        els.append(inj.bind(_types.ChatStateManager, to_ctor=_inmemory.InMemoryChatStateManager, singleton=True))
+        if cfg.chat_id is not None:
+            raise ValueError('chat-id is not allowed for ephemeral state')
+
+        els.extend([
+            inj.bind(_new_chat_id()),
+
+            inj.bind(_types.ChatStateManager, to_ctor=_inmemory.InMemoryChatStateManager, singleton=True),
+        ])
 
     else:
         raise TypeError(cfg.state)
 
+    #
+
     return inj.as_elements(*els)

ommlds/cli/sessions/chat/drivers/state/inmemory.py

@@ -20,10 +20,6 @@ class InMemoryChatStateManager(ChatStateManager):
     async def get_state(self) -> ChatState:
         return self._state
 
-    async def clear_state(self) -> ChatState:
-        self._state = ChatState()
-        return self._state
-
     async def extend_chat(self, chat_additions: 'mc.Chat') -> ChatState:
         self._state = dc.replace(
             self._state,

ommlds/cli/sessions/chat/drivers/state/storage.py

@@ -1,9 +1,11 @@
 from omlish import check
 from omlish import dataclasses as dc
 from omlish import lang
+from omlish import typedvalues as tv
 
 from ...... import minichain as mc
 from .....state.storage import StateStorage
+from .types import ChatId
 from .types import ChatState
 from .types import ChatStateManager
 
@@ -11,35 +13,40 @@ from .types import ChatStateManager
 ##
 
 
+class ChatStateStorageKey(tv.UniqueScalarTypedValue[str]):
+    pass
+
+
+def build_chat_storage_key(chat_id: ChatId) -> ChatStateStorageKey:
+    return ChatStateStorageKey(f'chat:{chat_id.v}')
+
+
+##
+
+
 class StateStorageChatStateManager(ChatStateManager):
     def __init__(
             self,
             *,
             storage: StateStorage,
-            key: str = 'chat',
+            key: ChatStateStorageKey,
     ) -> None:
         super().__init__()
 
         self._storage = storage
-        self._key = check.non_empty_str(key)
+        self._key = check.isinstance(key, ChatStateStorageKey)
 
         self._state: ChatState | None = None
 
     async def get_state(self) -> ChatState:
         if self._state is not None:
             return self._state
-        state: ChatState | None = await self._storage.load_state(self._key, ChatState)
+        state: ChatState | None = await self._storage.load_state(self._key.v, ChatState)
         if state is None:
             state = ChatState()
         self._state = state
         return state
 
-    async def clear_state(self) -> ChatState:
-        state = ChatState()
-        await self._storage.save_state(self._key, state, ChatState)
-        self._state = state
-        return state
-
     async def extend_chat(self, chat_additions: 'mc.Chat') -> ChatState:
         state = await self.get_state()
         state = dc.replace(
@@ -47,6 +54,6 @@ class StateStorageChatStateManager(ChatStateManager):
             chat=[*state.chat, *chat_additions],
             updated_at=lang.utcnow(),
         )
-        await self._storage.save_state(self._key, state, ChatState)
+        await self._storage.save_state(self._key.v, state, ChatState)
         self._state = state
         return state

ommlds/cli/sessions/chat/drivers/state/types.py

@@ -1,9 +1,11 @@
 import abc
 import datetime
 import typing as ta
+import uuid
 
 from omlish import dataclasses as dc
 from omlish import lang
+from omlish import typedvalues as tv
 
 from ...... import minichain as mc
 
@@ -11,6 +13,13 @@ from ...... import minichain as mc
 ##
 
 
+class ChatId(tv.UniqueScalarTypedValue[uuid.UUID]):
+    pass
+
+
+##
+
+
 @dc.dataclass(frozen=True)
 class ChatState:
     name: str | None = None
@@ -29,10 +38,6 @@ class ChatStateManager(lang.Abstract):
     def get_state(self) -> ta.Awaitable[ChatState]:
         raise NotImplementedError
 
-    @abc.abstractmethod
-    def clear_state(self) -> ta.Awaitable[ChatState]:
-        raise NotImplementedError
-
     @abc.abstractmethod
     def extend_chat(self, chat_additions: 'mc.Chat') -> ta.Awaitable[ChatState]:
         raise NotImplementedError

ommlds/cli/sessions/chat/drivers/user/inject.py

@@ -29,11 +29,11 @@ def bind_user(cfg: UserConfig = UserConfig()) -> inj.Elements:
         )))
 
     if cfg.initial_user_content is not None:
-        async def add_initial_user_content(cd: '_driver.ChatDriver') -> None:
-            await cd.send_user_messages([mc.UserMessage(cfg.initial_user_content)])
+        async def add_initial_user_content(cdg: '_driver.ChatDriverGetter') -> None:
+            await (await cdg()).send_user_messages([mc.UserMessage(cfg.initial_user_content)])
 
         els.append(phase_callbacks().bind_item(to_fn=inj.KwargsTarget.of(
-            lambda cdg: ChatPhaseCallback(ChatPhase.STARTED, lambda: add_initial_user_content(cdg())),
+            lambda cdg: ChatPhaseCallback(ChatPhase.STARTED, lambda: add_initial_user_content(cdg)),
             cdg=_driver.ChatDriverGetter,
         )))
 

ommlds/cli/sessions/chat/facades/configs.py

@@ -0,0 +1,9 @@
+from omlish import dataclasses as dc
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class FacadeConfig:
+    pass

ommlds/cli/sessions/chat/facades/facade.py

@@ -0,0 +1,19 @@
+from ..... import minichain as mc
+from ..drivers.driver import ChatDriver
+
+
+##
+
+
+class ChatFacade:
+    def __init__(
+            self,
+            *,
+            driver: ChatDriver,
+    ) -> None:
+        super().__init__()
+
+        self._driver = driver
+
+    async def handle_user_input(self, text: str) -> None:
+        await self._driver.send_user_messages([mc.UserMessage(text)])

ommlds/cli/sessions/chat/facades/inject.py

@@ -0,0 +1,23 @@
+from omlish import inject as inj
+from omlish import lang
+
+from .configs import FacadeConfig
+
+
+with lang.auto_proxy_import(globals()):
+    from . import facade as _facade
+
+
+##
+
+
+def bind_facade(cfg: FacadeConfig = FacadeConfig()) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    #
+
+    els.append(inj.bind(_facade.ChatFacade, singleton=True))
+
+    #
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/chat/inject.py

@@ -1,4 +1,3 @@
-from omlish import dataclasses as dc
 from omlish import inject as inj
 from omlish import lang
 
@@ -10,13 +9,14 @@ with lang.auto_proxy_import(globals()):
     from ...rendering import inject as _rendering
     from . import session as _session
     from .drivers import inject as _drivers
+    from .facades import inject as _facades
     from .interfaces import inject as _interfaces
 
 
 ##
 
 
-def bind_chat(cfg: ChatConfig) -> inj.Elements:
+def bind_chat(cfg: ChatConfig = ChatConfig()) -> inj.Elements:
     els: list[inj.Elemental] = []
 
     #
@@ -24,6 +24,8 @@ def bind_chat(cfg: ChatConfig) -> inj.Elements:
     els.extend([
         _drivers.bind_driver(cfg.driver),
 
+        _facades.bind_facade(cfg.facade),
+
         _interfaces.bind_interface(cfg.interface),
 
         _rendering.bind_rendering(cfg.rendering),
@@ -32,7 +34,7 @@ def bind_chat(cfg: ChatConfig) -> inj.Elements:
     #
 
     els.extend([
-        inj.bind(_session.ChatSession.Config(**dc.asdict(cfg))),
+        # inj.bind(cfg),  # NOTE: *not* done - the code is properly structured around not needing it.
         inj.bind(Session, to_ctor=_session.ChatSession, singleton=True),
     ])
 

ommlds/cli/sessions/chat/interfaces/bare/configs.py

@@ -0,0 +1,15 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+
+from ..configs import InterfaceConfig
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class BareInterfaceConfig(InterfaceConfig):
+    interactive: bool = False
+
+    use_readline: bool | ta.Literal['auto'] = 'auto'