ommlds 0.0.0.dev414__tar.gz → 0.0.0.dev415__tar.gz

{ommlds-0.0.0.dev414/ommlds.egg-info → ommlds-0.0.0.dev415}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommlds
-Version: 0.0.0.dev414
+Version: 0.0.0.dev415
 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.dev414
-Requires-Dist: omlish==0.0.0.dev414
+Requires-Dist: omdev==0.0.0.dev415
+Requires-Dist: omlish==0.0.0.dev415
 Provides-Extra: all
 Requires-Dist: llama-cpp-python~=0.3; extra == "all"
 Requires-Dist: mlx~=0.27; extra == "all"

{ommlds-0.0.0.dev414 → ommlds-0.0.0.dev415}/ommlds/.manifests.json

@@ -122,7 +122,7 @@
     "module": ".minichain.backends.impls.huggingface.repos",
     "attr": null,
     "file": "ommlds/minichain/backends/impls/huggingface/repos.py",
-    "line": 11,
+    "line": 19,
     "value": {
       "!.minichain.registries.manifests.RegistryManifest": {
         "module": "ommlds.minichain.backends.impls.huggingface.repos",

ommlds-0.0.0.dev415/ommlds/cli/backends/inject.py

@@ -0,0 +1,76 @@
+import typing as ta
+
+from omlish import inject as inj
+from omlish import lang
+
+from ...minichain.backends.catalogs.base import BackendCatalog
+from ...minichain.backends.catalogs.strings import BackendStringBackendCatalog
+
+
+##
+
+
+def bind_strings_backends() -> inj.Elements:
+    lst: list[inj.Elemental] = []
+
+    lst.extend([
+        inj.bind(BackendStringBackendCatalog, singleton=True),
+        inj.bind(BackendCatalog, to_key=BackendStringBackendCatalog),
+    ])
+
+    from ...minichain.backends.impls.huggingface.repos import HuggingfaceModelRepoResolver
+    from ...minichain.models.repos.resolving import ModelRepoResolver
+
+    lst.extend([
+        inj.bind(HuggingfaceModelRepoResolver, singleton=True),
+        inj.bind(ModelRepoResolver, to_key=HuggingfaceModelRepoResolver),
+
+    ])
+
+    return inj.as_elements(*lst)
+
+
+def bind_simple_backends() -> inj.Elements:
+    lst: list[inj.Elemental] = []
+
+    from ...minichain.backends.catalogs.simple import SimpleBackendCatalog
+    from ...minichain.backends.catalogs.simple import SimpleBackendCatalogEntries
+    from ...minichain.backends.catalogs.simple import SimpleBackendCatalogEntry
+
+    lst.extend([
+        inj.set_binder[SimpleBackendCatalogEntry](),
+        inj.bind(
+            lang.typed_lambda(SimpleBackendCatalogEntries, s=ta.AbstractSet[SimpleBackendCatalogEntry])(
+                lambda s: list(s),
+            ),
+            singleton=True,
+        ),
+    ])
+
+    lst.extend([
+        inj.bind(SimpleBackendCatalog, singleton=True),
+        inj.bind(BackendCatalog, to_key=SimpleBackendCatalog),
+    ])
+
+    from .standard import STANDARD_BACKEND_CATALOG_ENTRIES
+
+    lst.extend([
+        inj.bind_set_entry_const(ta.AbstractSet[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())
+    else:
+        lst.append(bind_simple_backends())
+
+    return inj.as_elements(*lst)

ommlds-0.0.0.dev415/ommlds/cli/backends/standard.py

@@ -0,0 +1,22 @@
+import typing as ta
+
+from ... import minichain as mc
+from ...minichain.backends.catalogs.simple import SimpleBackendCatalogEntry
+from ...minichain.backends.catalogs.simple import simple_backend_catalog_entry
+
+
+##
+
+
+STANDARD_BACKEND_CATALOG_ENTRIES: ta.Sequence[SimpleBackendCatalogEntry] = [
+    simple_backend_catalog_entry(mc.ChatChoicesService, 'openai'),
+
+    simple_backend_catalog_entry(mc.ChatChoicesStreamService, 'openai'),
+
+    simple_backend_catalog_entry(mc.CompletionService, 'llamacpp'),
+    simple_backend_catalog_entry(mc.CompletionService, 'openai'),
+    simple_backend_catalog_entry(mc.CompletionService, 'tfm'),
+
+    simple_backend_catalog_entry(mc.EmbeddingService, 'openai'),
+    simple_backend_catalog_entry(mc.EmbeddingService, 'stfm'),
+]

{ommlds-0.0.0.dev414 → ommlds-0.0.0.dev415}/ommlds/cli/sessions/chat/interactive.py

@@ -4,7 +4,7 @@ import typing as ta
 from omlish import lang
 
 from .... import minichain as mc
-from ...backends.catalog import BackendCatalog
+from ....minichain.backends.catalogs.base import BackendCatalog
 from .base import DEFAULT_CHAT_MODEL_BACKEND
 from .base import ChatSession
 from .printing import ChatSessionPrinter

{ommlds-0.0.0.dev414 → ommlds-0.0.0.dev415}/ommlds/cli/sessions/chat/prompt.py

@@ -4,7 +4,7 @@ from omlish import check
 from omlish import lang
 
 from .... import minichain as mc
-from ...backends.catalog import BackendCatalog
+from ....minichain.backends.catalogs.base import BackendCatalog
 from .base import DEFAULT_CHAT_MODEL_BACKEND
 from .base import ChatOptions
 from .base import ChatSession

{ommlds-0.0.0.dev414 → ommlds-0.0.0.dev415}/ommlds/cli/sessions/completion/completion.py

@@ -4,7 +4,7 @@ from omlish import check
 from omlish import lang
 
 from .... import minichain as mc
-from ...backends.catalog import BackendCatalog
+from ....minichain.backends.catalogs.base import BackendCatalog
 from ..base import Session
 
 

{ommlds-0.0.0.dev414 → ommlds-0.0.0.dev415}/ommlds/cli/sessions/embedding/embedding.py

@@ -4,7 +4,7 @@ from omlish import lang
 from omlish.formats import json
 
 from .... import minichain as mc
-from ...backends.catalog import BackendCatalog
+from ....minichain.backends.catalogs.base import BackendCatalog
 from ..base import Session
 
 

ommlds-0.0.0.dev415/ommlds/minichain/backends/catalogs/base.py

@@ -0,0 +1,31 @@
+import abc
+import typing as ta
+
+from omlish import lang
+
+
+##
+
+
+class BackendCatalog(lang.Abstract):
+    @abc.abstractmethod
+    def get_backend(self, service_cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+    # #
+    #
+    # class Bound(lang.Final, ta.Generic[T]):
+    #     def __init__(self, catalog: 'BackendCatalog', service_cls: ta.Any) -> None:
+    #         super().__init__()
+    #
+    #         self._catalog = catalog
+    #         self._service_cls = service_cls
+    #
+    #     def get_backend(self, name: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+    #         return ta.cast(T, self._catalog.get_backend(self._service_cls, name, *args, **kwargs))
+    #
+    # def __getitem__(
+    #         self,
+    #         service_cls: type[T],
+    # ) -> Bound[T]:
+    #     return BackendCatalog.Bound(self, service_cls)

ommlds-0.0.0.dev415/ommlds/minichain/backends/catalogs/simple.py

@@ -0,0 +1,61 @@
+import functools
+import typing as ta
+
+from omlish import check
+from omlish import dataclasses as dc
+
+from ...registries.globals import registry_of
+from .base import BackendCatalog
+
+
+##
+
+
+@dc.dataclass(frozen=True, eq=False)
+class SimpleBackendCatalogEntry:
+    service_cls: ta.Any
+    name: str
+    factory_fn: ta.Callable[..., ta.Any]
+
+
+SimpleBackendCatalogEntries = ta.NewType('SimpleBackendCatalogEntries', ta.Sequence[SimpleBackendCatalogEntry])
+
+
+##
+
+
+class SimpleBackendCatalog(BackendCatalog):
+    def __init__(
+            self,
+            entries: SimpleBackendCatalogEntries,
+    ) -> None:
+        super().__init__()
+
+        self._entries: list[SimpleBackendCatalogEntry] = list(entries)
+
+        dct: dict[ta.Any, dict[str, SimpleBackendCatalogEntry]] = {}
+        for e in self._entries:
+            sc_dct = dct.setdefault(e.service_cls, {})
+            check.not_in(e.name, sc_dct)
+            sc_dct[e.name] = e
+        self._dct = dct
+
+    def get_backend(self, service_cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> ta.Any:
+        e = self._dct[service_cls][name]
+        return e.factory_fn(*args, **kwargs)
+
+
+##
+
+
+def simple_backend_catalog_entry(
+        service_cls: ta.Any,
+        name: str,
+        *args: ta.Any,
+        **kwargs: ta.Any,
+) -> SimpleBackendCatalogEntry:
+    return SimpleBackendCatalogEntry(
+        service_cls,
+        name,
+        functools.partial(registry_of[service_cls].new, name, *args, **kwargs),
+    )

ommlds-0.0.0.dev415/ommlds/minichain/backends/catalogs/strings.py

@@ -0,0 +1,55 @@
+import typing as ta
+
+from omlish import check
+
+from ...models.configs import ModelPath
+from ...models.configs import ModelRepo
+from ...models.repos.resolving import ModelRepoResolver
+from ...registries.globals import registry_new
+from ..strings.parsing import parse_backend_string
+from ..strings.resolving import BackendStringResolver
+from ..strings.resolving import ResolveBackendStringArgs
+from ..strings.resolving import build_manifest_backend_string_resolver
+from .base import BackendCatalog
+
+
+##
+
+
+class BackendStringBackendCatalog(BackendCatalog):
+    def __init__(
+            self,
+            string_resolver: BackendStringResolver | None = None,
+            *,
+            model_repo_resolver: ModelRepoResolver | None = None,
+    ) -> None:
+        super().__init__()
+
+        if string_resolver is None:
+            string_resolver = build_manifest_backend_string_resolver()
+        self._string_resolver = string_resolver
+        self._model_repo_resolver = model_repo_resolver
+
+    def get_backend(self, service_cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> ta.Any:
+        ps = parse_backend_string(name)
+        rs = check.not_none(self._string_resolver.resolve_backend_string(ResolveBackendStringArgs(
+            service_cls,
+            ps,
+        )))
+
+        al = list(rs.args or [])
+
+        # FIXME: lol
+        if al and isinstance(al[0], ModelRepo):
+            [mr] = al
+            mrr = check.not_none(self._model_repo_resolver)
+            mrp = check.not_none(mrr.resolve(mr))
+            al = [ModelPath(mrp.path), *al[1:]]
+
+        return registry_new(
+            service_cls,
+            rs.name,
+            *al,
+            *args,
+            **kwargs,
+        )

{ommlds-0.0.0.dev414 → ommlds-0.0.0.dev415}/ommlds/minichain/backends/impls/huggingface/repos.py

@@ -1,10 +1,18 @@
-import huggingface_hub as hf
+import typing as ta
+
+from omlish import lang
 
 from ....models.configs import ModelRepo
 from ....models.repos.resolving import ModelRepoResolver
 from ....models.repos.resolving import ResolvedModelRepo
 
 
+if ta.TYPE_CHECKING:
+    import huggingface_hub as hf
+else:
+    hf = lang.proxy_import('huggingface_hub')
+
+
 ##
 
 

{ommlds-0.0.0.dev414 → ommlds-0.0.0.dev415}/ommlds/minichain/backends/strings/resolving.py

@@ -13,6 +13,7 @@ from omlish.manifests.globals import GlobalManifestLoader
 from ...models.configs import ModelName
 from ...models.configs import ModelPath
 from ...models.configs import ModelRepo
+from ...registries.globals import get_global_registry
 from .manifests import BackendStringsManifest
 from .parsing import ParsedBackendString
 
@@ -21,15 +22,30 @@ from .parsing import ParsedBackendString
 
 
 @dc.dataclass(frozen=True)
-class ResolvedBackend:
-    backend_name: str
+class ResolveBackendStringArgs:
+    service_cls: ta.Any
+    parsed: ParsedBackendString
+
+
+@dc.dataclass(frozen=True)
+class ResolveBackendStringResult:
+    service_cls: ta.Any
+    name: str
+
+    _: dc.KW_ONLY
 
     args: ta.Sequence[ta.Any] | None = None
 
 
+@dc.dataclass()
+class AmbiguousBackendStringResolutionError(Exception):
+    ra: ResolveBackendStringArgs
+    lst: list[tuple['BackendStringResolver', ResolveBackendStringResult]]
+
+
 class BackendStringResolver(lang.Abstract):
     @abc.abstractmethod
-    def resolve_backend_string(self, ps: ParsedBackendString) -> ResolvedBackend | None:
+    def resolve_backend_string(self, args: ResolveBackendStringArgs) -> ResolveBackendStringResult | None:
         raise NotImplementedError
 
 
@@ -47,29 +63,23 @@ class CompositeBackendStringResolver(BackendStringResolver, lang.Abstract):  # n
 
 
 class FirstCompositeBackendStringResolver(CompositeBackendStringResolver):
-    def resolve_backend_string(self, ps: ParsedBackendString) -> ResolvedBackend | None:
+    def resolve_backend_string(self, args: ResolveBackendStringArgs) -> ResolveBackendStringResult | None:
         for c in self._children:
-            if (r := c.resolve_backend_string(ps)) is not None:
+            if (r := c.resolve_backend_string(args)) is not None:
                 return r
         return None
 
 
-@dc.dataclass()
-class AmbiguousResolvedBackendStringError(Exception):
-    ps: ParsedBackendString
-    lst: list[tuple[BackendStringResolver, ResolvedBackend]]
-
-
 class UniqueCompositeBackendStringResolver(CompositeBackendStringResolver):
-    def resolve_backend_string(self, ps: ParsedBackendString) -> ResolvedBackend | None:
-        lst: list[tuple[BackendStringResolver, ResolvedBackend]] = []
+    def resolve_backend_string(self, args: ResolveBackendStringArgs) -> ResolveBackendStringResult | None:
+        lst: list[tuple[BackendStringResolver, ResolveBackendStringResult]] = []
         for c in self._children:
-            if (r := c.resolve_backend_string(ps)) is not None:
+            if (r := c.resolve_backend_string(args)) is not None:
                 lst.append((c, r))
         if not lst:
             return None
         elif len(lst) > 1:
-            raise AmbiguousResolvedBackendStringError(ps, lst)
+            raise AmbiguousBackendStringResolutionError(args, lst)
         else:
             return lst[0][1]
 
@@ -82,14 +92,18 @@ class ManifestBackendStringResolver(BackendStringResolver):
         super().__init__()
 
         self._manifest = manifest
+        self._service_cls_set = {
+            get_global_registry().get_registry_type_cls(scn)
+            for scn in manifest.service_cls_names
+        }
 
     def _resolve_name_model(
             self,
-            ps: ParsedBackendString,
+            args: ResolveBackendStringArgs,
             mdl: ParsedBackendString.NameModel,
-    ) -> ResolvedBackend | None:
+    ) -> ResolveBackendStringResult | None:
         m = self._manifest
-        if ps.backend is not None and ps.backend != m.backend_name:
+        if args.parsed.backend is not None and args.parsed.backend != m.backend_name:
             return None
 
         mn: str | None = mdl.name
@@ -110,38 +124,41 @@ class ManifestBackendStringResolver(BackendStringResolver):
             elif mdl.name in m.model_names.alias_map:
                 mn = m.model_names.alias_map[mdl.name]
 
-            elif ps.backend is None:
+            elif args.parsed.backend is None:
                 return None
 
-        return ResolvedBackend(
+        return ResolveBackendStringResult(
+            args.service_cls,
             m.backend_name,
-            [ModelName(mn)] if mn is not None else [],
+            args=[ModelName(mn)] if mn is not None else None,
         )
 
     def _resolve_path_model(
             self,
-            ps: ParsedBackendString,
+            args: ResolveBackendStringArgs,
             mdl: ParsedBackendString.PathModel,
-    ) -> ResolvedBackend | None:
-        if ps.backend is not None and ps.backend != self._manifest.backend_name:
+    ) -> ResolveBackendStringResult | None:
+        if args.parsed.backend is not None and args.parsed.backend != self._manifest.backend_name:
             return None
 
-        return ResolvedBackend(
+        return ResolveBackendStringResult(
+            args.service_cls,
             self._manifest.backend_name,
-            [ModelPath(mdl.path)],
+            args=[ModelPath(mdl.path)],
         )
 
     def _resolve_repo_model(
             self,
-            ps: ParsedBackendString,
+            args: ResolveBackendStringArgs,
             mdl: ParsedBackendString.RepoModel,
-    ) -> ResolvedBackend | None:
-        if ps.backend is not None and ps.backend != self._manifest.backend_name:
+    ) -> ResolveBackendStringResult | None:
+        if args.parsed.backend is not None and args.parsed.backend != self._manifest.backend_name:
             return None
 
-        return ResolvedBackend(
+        return ResolveBackendStringResult(
+            args.service_cls,
             self._manifest.backend_name,
-            [ModelRepo(
+            args=[ModelRepo(
                 namespace=mdl.namespace,
                 repo=mdl.repo,
                 tag=mdl.tag,
@@ -149,14 +166,17 @@ class ManifestBackendStringResolver(BackendStringResolver):
             )],
         )
 
-    def resolve_backend_string(self, ps: ParsedBackendString) -> ResolvedBackend | None:
-        mdl = ps.model
+    def resolve_backend_string(self, args: ResolveBackendStringArgs) -> ResolveBackendStringResult | None:
+        if args.service_cls not in self._service_cls_set:
+            return None
+
+        mdl = args.parsed.model
         if isinstance(mdl, ParsedBackendString.NameModel):
-            return self._resolve_name_model(ps, mdl)
+            return self._resolve_name_model(args, mdl)
         elif isinstance(mdl, ParsedBackendString.PathModel):
-            return self._resolve_path_model(ps, mdl)
+            return self._resolve_path_model(args, mdl)
         elif isinstance(mdl, ParsedBackendString.RepoModel):
-            return self._resolve_repo_model(ps, mdl)
+            return self._resolve_repo_model(args, mdl)
         else:
             raise TypeError(mdl)
 

{ommlds-0.0.0.dev414 → ommlds-0.0.0.dev415}/ommlds/minichain/registries/globals.py

@@ -68,7 +68,7 @@ class _GlobalRegistry(lang.Final, lang.NotInstantiable):
         with cls._lock:
             if (i := cls._instance) is not None:
                 i.register_type(
-                    cls,
+                    clz,
                     module=module,
                 )
             else:
@@ -81,6 +81,10 @@ class _GlobalRegistry(lang.Final, lang.NotInstantiable):
 ##
 
 
+def get_global_registry() -> Registry:
+    return _GlobalRegistry.instance()
+
+
 def register_type(
         cls: T,
         *,

{ommlds-0.0.0.dev414 → ommlds-0.0.0.dev415}/ommlds/minichain/registries/registry.py

@@ -51,7 +51,7 @@ class Registry:
         }
 
         self._registry_type_cls_by_name: dict[str, type] = {}
-        self._registry_cls_by_name_by_type: dict[str, dict[str, type]] = {}
+        self._registry_cls_by_name_by_type_name: dict[str, dict[str, type]] = {}
 
         self._registered_types: dict[ta.Any, Registry._RegisteredType] = {}
         self._resolved_registry_type_names_by_registered_type: dict[ta.Any, str] = {}
@@ -120,8 +120,9 @@ class Registry:
                 return self._registry_type_cls_by_name[name]
             except KeyError:
                 pass
+
             m = self._registry_type_manifests_by_name[name]
-            cls = m.load()
+            cls = m.resolve()
             self._registry_type_cls_by_name[name] = cls
             return cls
 
@@ -135,9 +136,9 @@ class Registry:
                 type_name = self._resolved_registry_type_names_by_registered_type[selector]
 
             try:
-                d = self._registry_cls_by_name_by_type[type_name]
+                d = self._registry_cls_by_name_by_type_name[type_name]
             except KeyError:
-                d = self._registry_cls_by_name_by_type[type_name] = {}
+                d = self._registry_cls_by_name_by_type_name[type_name] = {}
 
             try:
                 return d[name]
@@ -145,7 +146,7 @@ class Registry:
                 pass
 
             m = self._registry_manifests_by_name_by_type[type_name][name]
-            cls = m.load()
+            cls = m.resolve()
             d[name] = cls
 
             return cls

{ommlds-0.0.0.dev414 → ommlds-0.0.0.dev415/ommlds.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommlds
-Version: 0.0.0.dev414
+Version: 0.0.0.dev415
 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.dev414
-Requires-Dist: omlish==0.0.0.dev414
+Requires-Dist: omdev==0.0.0.dev415
+Requires-Dist: omlish==0.0.0.dev415
 Provides-Extra: all
 Requires-Dist: llama-cpp-python~=0.3; extra == "all"
 Requires-Dist: mlx~=0.27; extra == "all"

{ommlds-0.0.0.dev414 → ommlds-0.0.0.dev415}/ommlds.egg-info/SOURCES.txt

@@ -85,11 +85,8 @@ ommlds/cli/inject.py
 ommlds/cli/main.py
 ommlds/cli/state.py
 ommlds/cli/backends/__init__.py
-ommlds/cli/backends/catalog.py
 ommlds/cli/backends/inject.py
-ommlds/cli/backends/registry.py
 ommlds/cli/backends/standard.py
-ommlds/cli/backends/strings.py
 ommlds/cli/sessions/__init__.py
 ommlds/cli/sessions/base.py
 ommlds/cli/sessions/inject.py
@@ -112,7 +109,6 @@ ommlds/cli/tools/weather.py
 ommlds/datasets/__init__.py
 ommlds/datasets/lib/__init__.py
 ommlds/datasets/lib/movies.py
-ommlds/minichain/.dataclasses.json
 ommlds/minichain/__init__.py
 ommlds/minichain/_abc.py
 ommlds/minichain/_typedvalues.py
@@ -126,6 +122,10 @@ ommlds/minichain/search.py
 ommlds/minichain/standard.py
 ommlds/minichain/types.py
 ommlds/minichain/backends/__init__.py
+ommlds/minichain/backends/catalogs/__init__.py
+ommlds/minichain/backends/catalogs/base.py
+ommlds/minichain/backends/catalogs/simple.py
+ommlds/minichain/backends/catalogs/strings.py
 ommlds/minichain/backends/impls/__init__.py
 ommlds/minichain/backends/impls/mistral.py
 ommlds/minichain/backends/impls/sqlite.py

{ommlds-0.0.0.dev414 → ommlds-0.0.0.dev415}/ommlds.egg-info/requires.txt

@@ -1,5 +1,5 @@
-omdev==0.0.0.dev414
-omlish==0.0.0.dev414
+omdev==0.0.0.dev415
+omlish==0.0.0.dev415
 
 [all]
 llama-cpp-python~=0.3

{ommlds-0.0.0.dev414 → ommlds-0.0.0.dev415}/pyproject.toml

@@ -13,7 +13,7 @@ urls = {source = 'https://github.com/wrmsr/omlish'}
 license = 'BSD-3-Clause'
 readme = 'README.md'
 requires-python = '>=3.13'
-version = '0.0.0.dev414'
+version = '0.0.0.dev415'
 classifiers = [
     'Development Status :: 2 - Pre-Alpha',
     'Intended Audience :: Developers',
@@ -24,8 +24,8 @@ classifiers = [
 ]
 description = 'ommlds'
 dependencies = [
-    'omdev == 0.0.0.dev414',
-    'omlish == 0.0.0.dev414',
+    'omdev == 0.0.0.dev415',
+    'omlish == 0.0.0.dev415',
 ]
 
 [project.optional-dependencies]
@@ -108,7 +108,6 @@ exclude = [
     '*.cu',
     '*.g4',
     '*.h',
-    '.dataclasses.json',
     '.manifests.json',
     'LICENSE',
     'LICENSE.txt',