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

ommlds/backends/transformers/filecache.py

@@ -0,0 +1,109 @@
+import contextlib
+import dataclasses as dc
+import os
+import threading
+import typing as ta
+
+import transformers as tfm
+
+from omlish import lang
+
+from ..._hacks.funcs import create_detour
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class _FileCachePatchContext:
+    local_first: bool = False
+    local_config_present_is_authoritative: bool = False
+
+
+_FILE_CACHE_PATCH_CONTEXT_TLS = threading.local()
+
+
+def _get_file_cache_patch_context() -> _FileCachePatchContext:
+    try:
+        return _FILE_CACHE_PATCH_CONTEXT_TLS.context
+    except AttributeError:
+        ctx = _FILE_CACHE_PATCH_CONTEXT_TLS.context = _FileCachePatchContext()
+        return ctx
+
+
+_FILE_CACHE_PATCH_LOCK = threading.Lock()
+
+
+@lang.cached_function(lock=_FILE_CACHE_PATCH_LOCK)
+def patch_file_cache() -> None:
+    """
+    I tried to make a `local_first_pipeline` function to be called instead of `tfm.pipeline`, I really did, but the
+    transformers code is such a disgusting rat's nest full of direct static calls to the caching code strewn about at
+    every layer with no concern whatsoever for forwarding kwargs where they need to go.
+    """
+
+    from transformers.utils.hub import cached_files
+
+    orig_cached_files: ta.Callable[..., str | None] = lang.copy_function(cached_files)  # type: ignore
+
+    get_file_cache_patch_context = _get_file_cache_patch_context
+
+    def new_cached_files(
+            path_or_repo_id: str | os.PathLike,
+            filenames: list[str],
+            **kwargs: ta.Any,
+    ) -> str | None:
+        ctx = get_file_cache_patch_context()
+
+        if ctx.local_first and not kwargs.get('local_files_only'):
+            try:
+                local = orig_cached_files(
+                    path_or_repo_id,
+                    filenames,
+                    **{**kwargs, 'local_files_only': True},
+                )
+            except OSError as e:  # noqa
+                pass
+            else:
+                return local
+
+            if ctx.local_config_present_is_authoritative:
+                try:
+                    local_config = orig_cached_files(
+                        path_or_repo_id,
+                        [tfm.CONFIG_NAME],
+                        **{**kwargs, 'local_files_only': True},
+                    )
+                except OSError as e:  # noqa
+                    pass
+                else:
+                    raise OSError(
+                        f'Files {filenames!r} requested under local_first '
+                        f'but local_config present at {local_config!r}, '
+                        f'assuming files do not exist.',
+                    )
+
+        return orig_cached_files(path_or_repo_id, filenames, **kwargs)
+
+    cached_files.__code__ = create_detour(cached_files, new_cached_files, as_kwargs=True)
+
+
+@contextlib.contextmanager
+def file_cache_patch_context(
+        *,
+        local_first: bool = False,
+        local_config_present_is_authoritative: bool = False,
+) -> ta.Generator[None]:
+    patch_file_cache()
+
+    new_ctx = dc.replace(
+        old_ctx := _get_file_cache_patch_context(),
+        local_first=local_first,
+        local_config_present_is_authoritative=local_config_present_is_authoritative,
+    )
+
+    _FILE_CACHE_PATCH_CONTEXT_TLS.context = new_ctx
+    try:
+        yield
+    finally:
+        _FILE_CACHE_PATCH_CONTEXT_TLS.context = old_ctx

ommlds/backends/transformers/streamers.py

@@ -0,0 +1,73 @@
+import functools
+import typing as ta
+
+import transformers as tfm
+
+
+T = ta.TypeVar('T')
+P = ta.ParamSpec('P')
+
+
+##
+
+
+class CancellableTextStreamer(tfm.TextStreamer):
+    class Callback(ta.Protocol):
+        def __call__(self, text: str, *, stream_end: bool) -> None: ...
+
+    def __init__(
+            self,
+            tokenizer: tfm.AutoTokenizer,
+            callback: Callback,
+            *,
+            skip_prompt: bool = False,
+            **decode_kwargs: ta.Any,
+    ) -> None:
+        super().__init__(
+            tokenizer,
+            skip_prompt=skip_prompt,
+            **decode_kwargs,
+        )
+
+        self.callback = callback
+
+    _cancelled: bool = False
+
+    #
+
+    @property
+    def cancelled(self) -> bool:
+        return self._cancelled
+
+    def cancel(self) -> None:
+        self._cancelled = True
+
+    class Cancelled(BaseException):  # noqa
+        pass
+
+    @staticmethod
+    def ignoring_cancelled(fn: ta.Callable[P, T]) -> ta.Callable[P, T | None]:
+        @functools.wraps(fn)
+        def inner(*args, **kwargs):
+            try:
+                return fn(*args, **kwargs)
+            except CancellableTextStreamer.Cancelled:
+                pass
+
+        return inner
+
+    def _maybe_raise_cancelled(self) -> None:
+        if self._cancelled:
+            raise CancellableTextStreamer.Cancelled
+
+    #
+
+    def put(self, value: ta.Any) -> None:
+        self._maybe_raise_cancelled()
+        super().put(value)
+        self._maybe_raise_cancelled()
+
+    def on_finalized_text(self, text: str, stream_end: bool = False) -> None:
+        self._maybe_raise_cancelled()
+        self.callback(text, stream_end=stream_end)
+        self._maybe_raise_cancelled()

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()