ommlds 0.0.0.dev468__tar.gz → 0.0.0.dev470__tar.gz

{ommlds-0.0.0.dev468/ommlds.egg-info → ommlds-0.0.0.dev470}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommlds
-Version: 0.0.0.dev468
+Version: 0.0.0.dev470
 Summary: ommlds
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,8 +14,8 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omdev==0.0.0.dev468
-Requires-Dist: omlish==0.0.0.dev468
+Requires-Dist: omdev==0.0.0.dev470
+Requires-Dist: omlish==0.0.0.dev470
 Provides-Extra: all
 Requires-Dist: llama-cpp-python~=0.3; extra == "all"
 Requires-Dist: mlx~=0.29; extra == "all"

{ommlds-0.0.0.dev468 → ommlds-0.0.0.dev470}/ommlds/.omlish-manifests.json

@@ -321,7 +321,7 @@
     "module": ".minichain.backends.impls.ollama.chat",
     "attr": null,
     "file": "ommlds/minichain/backends/impls/ollama/chat.py",
-    "line": 93,
+    "line": 96,
     "value": {
       "!.minichain.registries.manifests.RegistryManifest": {
         "module": "ommlds.minichain.backends.impls.ollama.chat",
@@ -336,7 +336,7 @@
     "module": ".minichain.backends.impls.ollama.chat",
     "attr": null,
     "file": "ommlds/minichain/backends/impls/ollama/chat.py",
-    "line": 139,
+    "line": 143,
     "value": {
       "!.minichain.registries.manifests.RegistryManifest": {
         "module": "ommlds.minichain.backends.impls.ollama.chat",
@@ -526,7 +526,7 @@
     "module": ".minichain.backends.impls.transformers.transformers",
     "attr": null,
     "file": "ommlds/minichain/backends/impls/transformers/transformers.py",
-    "line": 46,
+    "line": 50,
     "value": {
       "!.minichain.backends.strings.manifests.BackendStringsManifest": {
         "service_cls_names": [
@@ -542,7 +542,7 @@
     "module": ".minichain.backends.impls.transformers.transformers",
     "attr": null,
     "file": "ommlds/minichain/backends/impls/transformers/transformers.py",
-    "line": 62,
+    "line": 66,
     "value": {
       "!.minichain.registries.manifests.RegistryManifest": {
         "module": "ommlds.minichain.backends.impls.transformers.transformers",
@@ -559,7 +559,7 @@
     "module": ".minichain.backends.impls.transformers.transformers",
     "attr": null,
     "file": "ommlds/minichain/backends/impls/transformers/transformers.py",
-    "line": 189,
+    "line": 197,
     "value": {
       "!.minichain.registries.manifests.RegistryManifest": {
         "module": "ommlds.minichain.backends.impls.transformers.transformers",
@@ -576,7 +576,7 @@
     "module": ".minichain.backends.impls.transformers.transformers",
     "attr": null,
     "file": "ommlds/minichain/backends/impls/transformers/transformers.py",
-    "line": 219,
+    "line": 227,
     "value": {
       "!.minichain.registries.manifests.RegistryManifest": {
         "module": "ommlds.minichain.backends.impls.transformers.transformers",
@@ -714,7 +714,7 @@
     "module": ".tools.git",
     "attr": null,
     "file": "ommlds/tools/git.py",
-    "line": 186,
+    "line": 189,
     "value": {
       "!omdev.tools.git.messages.GitMessageGeneratorManifest": {
         "module": "ommlds.tools.git",

ommlds-0.0.0.dev470/ommlds/_hacks/__init__.py

@@ -0,0 +1,4 @@
+"""
+Currently, and ideally, the only thing this codebase will ever interact with requiring these kinds of awful hacks is ML
+code - thus these 'helpers' are kept here, not in the core library.
+"""

ommlds-0.0.0.dev470/ommlds/_hacks/funcs.py

@@ -0,0 +1,110 @@
+import dataclasses as dc
+import linecache
+import textwrap
+import threading
+import types
+import typing as ta
+import uuid
+import warnings
+
+from omlish import check
+from omlish import lang
+
+from .names import NamespaceBuilder
+from .params import render_param_spec_call
+from .params import render_param_spec_def
+
+
+##
+
+
+@dc.dataclass()
+class _ReservedFilenameEntry:
+    unique_id: str
+    seq: int = 0
+
+
+_RESERVED_FILENAME_UUID_TLS = threading.local()
+
+
+def reserve_linecache_filename(prefix: str) -> str:
+    try:
+        e = _RESERVED_FILENAME_UUID_TLS.unique_id
+    except AttributeError:
+        e = _RESERVED_FILENAME_UUID_TLS.unique_id = _ReservedFilenameEntry(str(uuid.uuid4()))
+
+    while True:
+        unique_filename = f'<generated:{prefix}:{e.seq}>'
+        cache_line = (1, None, (e.unique_id,), unique_filename)
+        e.seq += 1
+        if linecache.cache.setdefault(unique_filename, cache_line) == cache_line:  # type: ignore
+            return unique_filename
+
+
+##
+
+
+def create_function(
+        name: str,
+        params: lang.CanParamSpec,
+        body: str,
+        *,
+        globals: ta.Mapping[str, ta.Any] | None = None,  # noqa
+        locals: ta.Mapping[str, ta.Any] | None = None,  # noqa
+        indent: str = '    ',
+) -> types.FunctionType:
+    params = lang.ParamSpec.of(params)
+    check.isinstance(body, str)
+    locals = dict(locals or {})  # noqa
+
+    nsb = NamespaceBuilder(reserved_names=set(locals) | set(globals or []))
+    sig = render_param_spec_def(params, nsb)
+    for k, v in nsb.items():
+        check.not_in(k, locals)
+        locals[k] = v
+
+    body_txt = '\n'.join([
+        f'def {name}{sig}:',
+        textwrap.indent(textwrap.dedent(body.strip()), indent),
+    ])
+
+    exec_txt = '\n'.join([
+        f'def __create_fn__({", ".join(locals.keys())}):',
+        textwrap.indent(body_txt, indent),
+        f'{indent}return {name}',
+    ])
+
+    ns: dict = {}
+    filename = reserve_linecache_filename(name)
+    bytecode = compile(exec_txt, filename, 'exec')
+    eval(bytecode, globals or {}, ns)  # type: ignore  # noqa
+
+    fn = ns['__create_fn__'](**locals)
+    fn.__source__ = body_txt
+    linecache.cache[filename] = (len(exec_txt), None, exec_txt.splitlines(True), filename)
+    return fn
+
+
+##
+
+
+def create_detour(
+        params: lang.CanParamSpec,
+        target: ta.Callable,
+        *,
+        as_kwargs: bool = False,
+) -> types.CodeType:
+    params = lang.ParamSpec.of(params)
+    check.callable(target)
+
+    with warnings.catch_warnings():
+        warnings.filterwarnings('ignore', category=SyntaxWarning)
+
+        gfn = create_function(
+            '_',
+            params,
+            f'return 1{render_param_spec_call(params, as_kwargs=as_kwargs)}',
+        )
+
+    check.state(gfn.__code__.co_consts[:2] == (None, 1))
+    return gfn.__code__.replace(co_consts=(None, target, *gfn.__code__.co_consts[2:]))

ommlds-0.0.0.dev470/ommlds/_hacks/names.py

@@ -0,0 +1,158 @@
+"""
+TODO:
+ - releaseable names
+"""
+import string
+import typing as ta
+
+from omlish import check
+from omlish import collections as col
+
+
+##
+
+
+class NameGenerator(ta.Protocol):
+    def __call__(self, prefix: str = '') -> str: ...
+
+
+#
+
+
+class NameGeneratorImpl:
+    DEFAULT_PREFIX: ta.ClassVar[str] = '_'
+
+    def __init__(
+            self,
+            *,
+            reserved_names: ta.Iterable[str] | None = None,
+            global_prefix: str | None = None,
+            use_global_prefix_if_present: bool = False,
+            add_global_prefix_before_number: bool = False,
+    ) -> None:
+        super().__init__()
+
+        check.arg(not isinstance(reserved_names, str))
+        self._reserved_names = {check.isinstance(n, str) for n in (reserved_names or [])}
+        self._global_prefix = global_prefix if global_prefix is not None else self.DEFAULT_PREFIX
+        self._use_global_prefix_if_present = bool(use_global_prefix_if_present)
+        self._add_global_prefix_before_number = bool(add_global_prefix_before_number)
+
+        self._name_counts: dict[str, int] = {}
+
+    def __call__(self, prefix: str = '') -> str:
+        if self._use_global_prefix_if_present and prefix.startswith(self._global_prefix):
+            base_name = prefix
+        else:
+            base_name = self._global_prefix + prefix
+
+        base_count = -1
+        if base_name[-1] in string.digits:
+            i = len(base_name) - 2
+            while i >= 0 and base_name[i] in string.digits:
+                i -= 1
+            i += 1
+            base_count = int(base_name[i:])
+            base_name = base_name[:i]
+
+        if self._add_global_prefix_before_number:
+            if not (self._use_global_prefix_if_present and base_name.endswith(self._global_prefix)):
+                base_name += self._global_prefix
+
+        if base_count >= 0:
+            count = self._name_counts.setdefault(base_name, 0)
+            if base_count > count:
+                self._name_counts[base_name] = base_count
+
+        while True:
+            count = self._name_counts.get(base_name, 0)
+            self._name_counts[base_name] = count + 1
+            name = base_name + str(count)
+            if name not in self._reserved_names:
+                return name
+
+
+name_generator = NameGeneratorImpl
+
+
+##
+
+
+class NamespaceBuilder(ta.Mapping[str, ta.Any]):
+    def __init__(
+            self,
+            *,
+            reserved_names: ta.Iterable[str] | None = None,
+            name_generator: NameGenerator | None = None,  # noqa
+    ) -> None:
+        super().__init__()
+
+        self._reserved_names = {
+            check.isinstance(n, str)
+            for n in (check.not_isinstance(reserved_names, str) or [])
+        }
+        self._name_generator = check.callable(name_generator) if name_generator is not None else \
+            NameGeneratorImpl(reserved_names=self._reserved_names, use_global_prefix_if_present=True)
+
+        self._dct: ta.MutableMapping[str, ta.Any] = {}
+        self._dedupe_dct: ta.MutableMapping[ta.Any, str] = col.IdentityKeyDict()
+
+    @property
+    def reserved_names(self) -> ta.AbstractSet[str]:
+        return self._reserved_names
+
+    @property
+    def name_generator(self) -> NameGenerator:
+        return self._name_generator
+
+    def __getitem__(self, k: str) -> ta.Any:
+        return self._dct[k]
+
+    def __len__(self):
+        return len(self._dct)
+
+    def __iter__(self) -> ta.Iterator[str]:
+        return iter(self._dct)
+
+    def items(self) -> ta.ItemsView[str, ta.Any]:
+        return self._dct.items()
+
+    def put(
+            self,
+            value: ta.Any,
+            name: str | None = None,
+            *,
+            exact: bool = False,
+            dedupe: bool = False,
+    ) -> str:
+        check.arg(not (name is None and exact))
+        if name is not None:
+            check.isinstance(name, str)
+
+        if dedupe:
+            try:
+                return self._dedupe_dct[value]
+            except KeyError:
+                pass
+
+        if name is not None:
+            if name not in self._reserved_names:
+                try:
+                    existing = self._dct[name]
+                except KeyError:
+                    self._dct[name] = value
+                    if dedupe:
+                        self._dedupe_dct[value] = name
+                    return name
+                else:
+                    if existing is value:
+                        return name
+            if exact:
+                raise KeyError(name)
+
+        gen_name = self._name_generator(name or '')
+        check.not_in(gen_name, self._dct)
+        self._dct[gen_name] = value
+        if dedupe:
+            self._dedupe_dct[value] = gen_name
+        return gen_name

ommlds-0.0.0.dev470/ommlds/_hacks/params.py

@@ -0,0 +1,73 @@
+import typing as ta
+
+from omlish import lang
+
+from .names import NamespaceBuilder
+
+
+##
+
+
+def render_param_spec_call(
+        params: lang.ParamSpec,
+        *,
+        as_kwargs: bool = False,
+) -> str:
+    src = ['(']
+
+    for i, p in enumerate(params):
+        if isinstance(p, lang.ParamSeparator):
+            continue
+
+        if i:
+            src.append(', ')
+
+        if as_kwargs:
+            if isinstance(p, lang.Param):
+                src.append(f'{p.name}={p.name}')
+            else:
+                raise TypeError(p)
+
+        else:
+            if isinstance(p, lang.ArgsParam):
+                src.append(f'*{p.name}')
+            elif isinstance(p, lang.KwargsParam):
+                src.append(f'**{p.name}')
+            elif isinstance(p, lang.PosOnlyParam):
+                src.append(p.name)
+            elif isinstance(p, lang.KwOnlyParam):
+                src.append(f'{p.name}={p.name}')
+            elif isinstance(p, lang.ValParam):
+                src.append(p.name)
+            else:
+                raise TypeError(p)
+
+    src.append(')')
+
+    return ''.join(src)
+
+
+def render_param_spec_def(
+        params: lang.ParamSpec,
+        nsb: NamespaceBuilder,
+        *,
+        return_ann: lang.Maybe[ta.Any] = lang.empty(),
+) -> str:
+    src = ['(']
+
+    for i, p in enumerate(params):
+        if i:
+            src.append(', ')
+
+        src.append(lang.param_render(
+            p,
+            render_annotation=lambda ann: nsb.put(ann, f'ann_{p.name}'),  # noqa
+            render_default=lambda dfl: nsb.put(dfl, f'dfl_{p.name}'),  # noqa
+        ))
+
+    src.append(')')
+
+    if return_ann.present:
+        src.append(f' -> {nsb.put(return_ann.must(), "ann_return")}')
+
+    return ''.join(src)

{ommlds-0.0.0.dev468 → ommlds-0.0.0.dev470}/ommlds/_hacks/patches.py

@@ -1,7 +1,4 @@
 """
-Currently, and ideally, the only thing this codebase will ever interact with requiring these kinds of awful hacks is ML
-code - thus these 'helpers' are kept here, not in the core library.
-
 TODO:
  - patch lock
  - thread / context local gating

ommlds-0.0.0.dev470/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-0.0.0.dev468 → ommlds-0.0.0.dev470}/ommlds/cli/main.py

@@ -39,10 +39,6 @@ else:
 
 
 async def _a_main(args: ta.Any = None) -> None:
-    logs.configure_standard_logging('INFO')
-
-    #
-
     parser = argparse.ArgumentParser()
     parser.add_argument('prompt', nargs='*')
 
@@ -64,6 +60,8 @@ async def _a_main(args: ta.Any = None) -> None:
     parser.add_argument('-E', '--embed', action='store_true')
     parser.add_argument('-j', '--image', action='store_true')
 
+    parser.add_argument('-v', '--verbose', action='store_true')
+
     parser.add_argument('--enable-fs-tools', action='store_true')
     parser.add_argument('--enable-todo-tools', action='store_true')
     parser.add_argument('--enable-unsafe-tools-do-not-use-lol', action='store_true')
@@ -74,6 +72,14 @@ async def _a_main(args: ta.Any = None) -> None:
 
     #
 
+    if args.verbose:
+        logs.configure_standard_logging('DEBUG')
+    else:
+        logs.configure_standard_logging('INFO')
+        logs.silence_noisy_loggers()
+
+    #
+
     content: mc.Content | None
 
     if args.image:
@@ -161,7 +167,7 @@ async def _a_main(args: ta.Any = None) -> None:
                 args.enable_test_weather_tool or
                 args.code
             ),
-            enabled_tools={
+            enabled_tools={  # noqa
                 *(['fs'] if args.enable_fs_tools else []),
                 *(['todo'] if args.enable_todo_tools else []),
                 *(['weather'] if args.enable_test_weather_tool else []),

{ommlds-0.0.0.dev468 → ommlds-0.0.0.dev470}/ommlds/cli/sessions/chat/backends/catalog.py

@@ -15,33 +15,38 @@ from .types import ServiceT
 ##
 
 
-class _CatalogBackendProvider(BackendProvider[ServiceT], lang.Abstract):
+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,
             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]:
+        be = self._catalog.get_backend(cls, self._name)
+
         service: ServiceT
-        async with lang.async_or_sync_maybe_managing(self._catalog.get_backend(
-                cls,
-                self._name,
-                *(self._configs or []),
-        )) as service:
+        async with lang.async_or_sync_maybe_managing(await self._instantiator(be, self._configs)) as service:
             yield service
 
 
 class CatalogChatChoicesServiceBackendProvider(
-    _CatalogBackendProvider['mc.ChatChoicesService'],
+    CatalogBackendProvider['mc.ChatChoicesService'],
     ChatChoicesServiceBackendProvider,
 ):
     def provide_backend(self) -> ta.AsyncContextManager['mc.ChatChoicesService']:
@@ -49,7 +54,7 @@ class CatalogChatChoicesServiceBackendProvider(
 
 
 class CatalogChatChoicesStreamServiceBackendProvider(
-    _CatalogBackendProvider['mc.ChatChoicesStreamService'],
+    CatalogBackendProvider['mc.ChatChoicesStreamService'],
     ChatChoicesStreamServiceBackendProvider,
 ):
     def provide_backend(self) -> ta.AsyncContextManager['mc.ChatChoicesStreamService']:

{ommlds-0.0.0.dev468 → ommlds-0.0.0.dev470}/ommlds/cli/sessions/chat/backends/inject.py

@@ -1,6 +1,9 @@
+import typing as ta
+
 from omlish import inject as inj
 from omlish import lang
 
+from ..... import minichain as mc
 from .injection import backend_configs
 
 
@@ -34,4 +37,16 @@ def bind_backends(
 
     #
 
+    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(*cfgs or [], **kw)
+
+        return _catalog.CatalogBackendProvider.Instantiator(inner)
+
+    els.append(inj.bind(_catalog.CatalogBackendProvider.Instantiator, to_async_fn=catalog_backend_instantiator_provider))  # noqa
+
+    #
+
     return inj.as_elements(*els)

{ommlds-0.0.0.dev468 → ommlds-0.0.0.dev470}/ommlds/cli/sessions/completion/session.py

@@ -31,7 +31,7 @@ class CompletionSession(Session['CompletionSession.Config']):
         prompt = check.isinstance(self._config.content, str)
 
         mdl: mc.CompletionService
-        async with lang.async_maybe_managing(self._backend_catalog.get_backend(
+        async with lang.async_maybe_managing(self._backend_catalog.new_backend(
                 mc.CompletionService,
                 self._config.backend or DEFAULT_COMPLETION_MODEL_BACKEND,
         )) as mdl:

{ommlds-0.0.0.dev468 → ommlds-0.0.0.dev470}/ommlds/cli/sessions/embedding/session.py

@@ -29,7 +29,7 @@ class EmbeddingSession(Session['EmbeddingSession.Config']):
 
     async def run(self) -> None:
         mdl: mc.EmbeddingService
-        async with lang.async_maybe_managing(self._backend_catalog.get_backend(
+        async with lang.async_maybe_managing(self._backend_catalog.new_backend(
             mc.EmbeddingService,
             self._config.backend or DEFAULT_EMBEDDING_MODEL_BACKEND,
         )) as mdl: