ommlds 0.0.0.dev496__py3-none-any.whl → 0.0.0.dev498__py3-none-any.whl

ommlds/minichain/content/visitors.py

@@ -0,0 +1,231 @@
+import collections.abc
+import inspect
+import typing as ta
+
+from omlish import check
+from omlish import lang
+
+from .code import BlockCodeContent
+from .code import CodeContent
+from .code import InlineCodeContent
+from .composite import CompositeContent
+from .content import BaseContent
+from .content import Content
+from .dynamic import DynamicContent
+from .emphasis import BoldContent
+from .emphasis import BoldItalicContent
+from .emphasis import EmphasisContent
+from .emphasis import ItalicContent
+from .images import ImageContent
+from .json import JsonContent
+from .link import LinkContent
+from .markdown import MarkdownContent
+from .namespaces import NamespaceContent
+from .placeholders import PlaceholderContent
+from .quote import QuoteContent
+from .recursive import RecursiveContent
+from .section import SectionContent
+from .sequence import BlockContent
+from .sequence import InlineContent
+from .sequence import ItemListContent
+from .sequence import SequenceContent
+from .standard import StandardContent
+from .tag import TagContent
+from .templates import TemplateContent
+from .text import TextContent
+
+
+C = ta.TypeVar('C')
+R = ta.TypeVar('R')
+
+
+##
+
+
+class ContentVisitor(lang.Abstract, ta.Generic[C, R]):
+    _visit_method_map: ta.ClassVar[ta.Mapping[ta.Any, str]]
+
+    def visit(self, c: Content, ctx: C) -> R:
+        if isinstance(c, str):
+            return self.visit_str(c, ctx)
+
+        if isinstance(c, collections.abc.Sequence):
+            return self.visit_sequence(c, ctx)
+
+        try:
+            a = self._visit_method_map[type(c)]
+        except KeyError:
+            raise TypeError(c) from None
+
+        return getattr(self, a)(c, ctx)
+
+    ##
+    # per-type visit methods
+
+    def visit_content(self, c: Content, ctx: C) -> R:
+        raise TypeError(c)
+
+    ##
+    # non-BaseContent
+
+    def visit_str(self, c: str, ctx: C) -> R:
+        return self.visit_content(c, ctx)
+
+    def visit_sequence(self, c: ta.Sequence[Content], ctx: C) -> R:
+        return self.visit_content(c, ctx)
+
+    ##
+    # BaseContent
+
+    def visit_base_content(self, c: BaseContent, ctx: C) -> R:
+        return self.visit_content(c, ctx)
+
+    ##
+    # StandardContent
+
+    def visit_standard_content(self, c: StandardContent, ctx: C) -> R:
+        return self.visit_base_content(c, ctx)
+
+    ##
+    # leaf StandardContent
+
+    def visit_image_content(self, c: ImageContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    def visit_json_content(self, c: JsonContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    def visit_link_content(self, c: LinkContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    def visit_markdown_content(self, c: MarkdownContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    def visit_quote_content(self, c: QuoteContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    def visit_text_content(self, c: TextContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    ##
+    # CompositeContent
+
+    def visit_composite_content(self, c: CompositeContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    def visit_section_content(self, c: SectionContent, ctx: C) -> R:
+        return self.visit_composite_content(c, ctx)
+
+    def visit_tag_content(self, c: TagContent, ctx: C) -> R:
+        return self.visit_composite_content(c, ctx)
+
+    ##
+    # CodeContent
+
+    def visit_code_content(self, c: CodeContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    def visit_inline_code_content(self, c: InlineCodeContent, ctx: C) -> R:
+        return self.visit_code_content(c, ctx)
+
+    def visit_block_code_content(self, c: BlockCodeContent, ctx: C) -> R:
+        return self.visit_code_content(c, ctx)
+
+    ##
+    # DynamicContent
+
+    def visit_dynamic_content(self, c: DynamicContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    def visit_recursive_content(self, c: RecursiveContent, ctx: C) -> R:
+        return self.visit_dynamic_content(c, ctx)
+
+    def visit_namespace_content(self, c: NamespaceContent, ctx: C) -> R:
+        return self.visit_recursive_content(c, ctx)
+
+    def visit_placeholder_content(self, c: PlaceholderContent, ctx: C) -> R:
+        return self.visit_recursive_content(c, ctx)
+
+    def visit_template_content(self, c: TemplateContent, ctx: C) -> R:
+        return self.visit_dynamic_content(c, ctx)
+
+    ##
+    # EmphasisContent
+
+    def visit_emphasis_content(self, c: EmphasisContent, ctx: C) -> R:
+        return self.visit_standard_content(c, ctx)
+
+    def visit_bold_content(self, c: BoldContent, ctx: C) -> R:
+        return self.visit_emphasis_content(c, ctx)
+
+    def visit_italic_content(self, c: ItalicContent, ctx: C) -> R:
+        return self.visit_emphasis_content(c, ctx)
+
+    def visit_bold_italic_content(self, c: BoldItalicContent, ctx: C) -> R:
+        return self.visit_emphasis_content(c, ctx)
+
+    ##
+    # SequenceContent
+
+    def visit_sequence_content(self, c: SequenceContent, ctx: C) -> R:
+        return self.visit_composite_content(c, ctx)
+
+    def visit_inline_content(self, c: InlineContent, ctx: C) -> R:
+        return self.visit_sequence_content(c, ctx)
+
+    def visit_block_content(self, c: BlockContent, ctx: C) -> R:
+        return self.visit_sequence_content(c, ctx)
+
+    def visit_item_list_content(self, c: ItemListContent, ctx: C) -> R:
+        return self.visit_sequence_content(c, ctx)
+
+
+ContentVisitor._visit_method_map = {  # noqa
+    list(inspect.signature(o).parameters.values())[1].annotation: a
+    for a, o in ContentVisitor.__dict__.items()
+    if a.startswith('visit_')
+}
+
+
+##
+
+
+class StandardContentVisitorTypeError(TypeError):
+    pass
+
+
+class StandardContentVisitor(ContentVisitor[C, R], lang.Abstract):
+    def visit_str(self, c: str, ctx: C) -> R:
+        raise StandardContentVisitorTypeError(c)
+
+    def visit_sequence(self, c: ta.Sequence[Content], ctx: C) -> R:
+        raise StandardContentVisitorTypeError(c)
+
+
+##
+
+
+class StaticContentVisitorTypeError(TypeError):
+    pass
+
+
+class StaticContentVisitor(ContentVisitor[C, R], lang.Abstract):
+    def visit_dynamic_content(self, c: DynamicContent, ctx: C) -> R:
+        raise StaticContentVisitorTypeError(c)
+
+
+##
+
+
+class ContentTransform(ContentVisitor[C, Content], lang.Abstract):
+    def visit_content(self, c: Content, ctx: C) -> Content:
+        return c
+
+    def visit_sequence(self, c: ta.Sequence[Content], ctx: C) -> Content:
+        return [self.visit(cc, ctx) for cc in c]
+
+    def visit_composite_content(self, c: CompositeContent, ctx: C) -> Content:
+        cc = c.child_content()
+        ncc = self.visit_sequence(cc, ctx)
+        nc = c.replace_child_content(check.isinstance(ncc, collections.abc.Sequence))
+        return super().visit_composite_content(nc, ctx)

ommlds/minichain/metadata.py

@@ -3,9 +3,13 @@ import datetime
 import typing as ta
 import uuid
 
+from omlish import check
+from omlish import dataclasses as dc
 from omlish import lang
 from omlish import typedvalues as tv
 
+from ._typedvalues import _tv_field_metadata
+
 
 ##
 
@@ -31,13 +35,66 @@ class MetadataContainer(
         raise NotImplementedError
 
     @abc.abstractmethod
-    def with_metadata(self, *mds: MetadataT, override: bool = False) -> ta.Self:
+    def update_metadata(self, *mds: MetadataT, override: bool = False) -> ta.Self:
         raise NotImplementedError
 
 
 ##
 
 
+@dc.dataclass(frozen=True)
+class MetadataContainerDataclass(  # noqa
+    MetadataContainer[MetadataT],
+    lang.Abstract,
+):
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        check.state(hasattr(cls, '_metadata'))
+
+    @staticmethod
+    def _configure_metadata_field(md_fld, md_cls):
+        dc.set_field_metadata(
+            check.isinstance(md_fld, dc.Field),
+            _tv_field_metadata(
+                check.not_none(md_cls),
+                marshal_name='metadata',
+            ),
+        )
+
+    @property
+    def metadata(self) -> tv.TypedValues[MetadataT]:
+        return check.isinstance(getattr(self, '_metadata'), tv.TypedValues)
+
+    def discard_metadata(self, *tys: type) -> ta.Self:
+        nmd = (md := self.metadata).discard(*tys)
+
+        if nmd is md:
+            return self
+
+        return dc.replace(self, _metadata=nmd)  # type: ignore[call-arg]  # noqa
+
+    def update_metadata(
+            self,
+            *mds: MetadataT,
+            discard: ta.Iterable[type] | None = None,
+            override: bool = False,
+    ) -> ta.Self:
+        nmd = (md := self.metadata).update(
+            *mds,
+            discard=discard,
+            override=override,
+        )
+
+        if nmd is md:
+            return self
+
+        return dc.replace(self, _metadata=nmd)  # type: ignore[call-arg]  # noqa
+
+
+##
+
+
 class CommonMetadata(Metadata, lang.Abstract):
     pass
 

ommlds/minichain/tools/execution/catalog.py

@@ -4,7 +4,7 @@ from omlish import check
 from omlish import dataclasses as dc
 from omlish import lang
 
-from ...content.types import Content
+from ...content.content import Content
 from ..fns import ToolFn
 from ..types import ToolSpec
 from .context import ToolContext

ommlds/minichain/tools/execution/errorhandling.py

@@ -1,7 +1,8 @@
 import typing as ta
 
+from ...content.content import Content
 from ...content.transform.materialize import ContentMaterializer
-from ...content.types import Content
+from ...content.transform.materialize import DefaultContentMaterializer
 from .context import ToolContext
 from .errors import ToolExecutionError
 from .executors import ToolExecutor
@@ -15,7 +16,7 @@ class ErrorHandlingToolExecutor(ToolExecutor):
             self,
             *,
             wrapped: ToolExecutor,
-            content_materializer: ContentMaterializer = ContentMaterializer(),
+            content_materializer: ContentMaterializer = DefaultContentMaterializer(),
     ) -> None:
         super().__init__()
 

ommlds/minichain/tools/execution/errors.py

@@ -2,7 +2,7 @@ import abc
 
 from omlish import lang
 
-from ...content.types import Content
+from ...content.content import Content
 
 
 ##

ommlds/minichain/tools/execution/executors.py

@@ -8,7 +8,7 @@ import typing as ta
 from omlish import dataclasses as dc
 from omlish import lang
 
-from ...content.types import Content
+from ...content.content import Content
 from ..fns import ToolFn
 from ..fns import execute_tool_fn
 from .context import ToolContext

ommlds/minichain/tools/fns.py

@@ -10,8 +10,8 @@ from omlish import lang
 from omlish import marshal as msh
 from omlish import reflect as rfl
 
+from ..content.content import Content
 from ..content.json import JsonContent
-from ..content.types import Content
 
 
 D = ta.TypeVar('D')

ommlds/minichain/tools/reflect.py

@@ -23,7 +23,7 @@ from omlish import metadata as md
 from omlish import reflect as rfl
 from omlish.lite.cached import cached_nullary
 
-from ..content.types import Content
+from ..content.content import Content
 from .types import EnumToolDtype
 from .types import MappingToolDtype
 from .types import NullableToolDtype

ommlds/minichain/tools/types.py

@@ -10,7 +10,7 @@ from omlish import lang
 from omlish import marshal as msh
 from omlish import reflect as rfl
 
-from ..content.types import Content
+from ..content.content import Content
 
 
 msh.register_global_module_import('._marshal', __package__)

ommlds/minichain/vectors/embeddings.py

@@ -2,7 +2,7 @@ import typing as ta
 
 from omlish import lang
 
-from ..content.types import Content
+from ..content.content import Content
 from ..registries.globals import register_type
 from ..services import Request
 from ..services import Response

ommlds/tools/git.py

@@ -3,15 +3,12 @@ TODO:
  - move omit magic to omdev lol
 """
 import abc
-import concurrent.futures as cf
 import dataclasses as dc
-import os.path
 import re
 import typing as ta
 import urllib.request
 
 from omdev.git.magic import GIT_DIFF_OMIT_MAGIC_COMMENT
-from omdev.home.secrets import load_secrets
 from omdev.py.srcheaders import get_py_header_lines
 from omdev.tools.git.messages import GitMessageGenerator
 from omlish import check
@@ -21,14 +18,10 @@ from omlish.http import all as http
 from omlish.subprocesses.sync import subprocesses
 
 from .. import minichain as mc
-from ..minichain.backends.impls.openai.chat import OpenaiChatChoicesService
+from ..cli.secrets import install_env_secrets
 from ..server.client import McServerClient
 
 
-with lang.auto_proxy_import(globals()):
-    from ..minichain.backends.impls.mlx import chat as mc_mlx_chat
-
-
 GitAiBackendConfigT = ta.TypeVar('GitAiBackendConfigT', bound='GitAiBackend.Config')
 
 
@@ -36,7 +29,7 @@ GitAiBackendConfigT = ta.TypeVar('GitAiBackendConfigT', bound='GitAiBackend.Conf
 
 
 class GitAiBackend(Configurable[GitAiBackendConfigT], lang.Abstract):
-    @dc.dataclass(frozen=True)
+    @dc.dataclass(frozen=True, kw_only=True)
     class Config(Configurable.Config):
         max_tokens: int | None = 128
 
@@ -64,22 +57,35 @@ def _get_single_ai_message_str(resp: mc.ChatChoicesResponse) -> str:
 #
 
 
-class OpenaiGitAiBackend(GitAiBackend['OpenaiGitAiBackend.Config']):
-    @dc.dataclass(frozen=True)
+class StandardGitAiBackend(GitAiBackend['StandardGitAiBackend.Config']):
+    @dc.dataclass(frozen=True, kw_only=True)
     class Config(GitAiBackend.Config):
-        pass
+        backend: str | None = None
 
-    def __init__(self, config: Config = Config()) -> None:
+    DEFAULT_BACKEND_NAME: str = 'openai'
+
+    def __init__(
+            self,
+            config: Config = Config(),
+            *,
+            backend_catalog: ta.Optional['mc.BackendCatalog'] = None,
+    ) -> None:
         super().__init__(config)
 
+        if backend_catalog is None:
+            backend_catalog = mc.BackendStringBackendCatalog()
+        self._backend_catalog = backend_catalog
+
     def run_prompt(self, prompt: str) -> str:
-        # FIXME:
-        for key in ['OPENAI_API_KEY']:
-            if (sec := load_secrets().try_get(key.lower())) is not None:
-                os.environ[key] = sec.reveal()
+        install_env_secrets()  # FIXME
+
+        be = self._backend_catalog.get_backend(
+            mc.ChatChoicesService,  # type: ignore[type-abstract]
+            self._config.backend or self.DEFAULT_BACKEND_NAME,
+        )
 
-        llm = OpenaiChatChoicesService(
-            http_client=http.SyncAsyncHttpClient(http.client()),
+        llm = be.factory(
+            http_client=http.SyncAsyncHttpClient(http.client()),  # FIXME
         )
 
         resp = lang.sync_await(llm.invoke(mc.ChatChoicesRequest(
@@ -98,51 +104,51 @@ def _strip_markdown_code_block(text: str) -> str:
     return match.group(1)
 
 
-class MlxGitAiBackend(GitAiBackend['MlxGitAiBackend.Config']):
-    @dc.dataclass(frozen=True)
-    class Config(GitAiBackend.Config):
-        model: str = 'mlx-community/Qwen2.5-Coder-32B-Instruct-8bit'
-
-        run_in_subprocess: bool = True
-        subprocess_timeout: float | None = 60.
-
-    def __init__(self, config: Config = Config()) -> None:
-        super().__init__(config)
-
-    def _run_prompt(self, prompt: str) -> str:
-        with mc_mlx_chat.MlxChatChoicesService(mc.ModelRepo.parse(self._config.model)) as llm:
-            resp = lang.sync_await(llm.invoke(mc.ChatChoicesRequest(
-                [mc.UserMessage(prompt)],
-                # FIXME: *((MaxTokens(self._config.max_tokens),) if self._config.max_tokens is not None else ()),
-            )))
-            text = _get_single_ai_message_str(resp)
-
-            text = _strip_markdown_code_block(text)
-
-            return text
-
-    def run_prompt(self, prompt: str) -> str:
-        if self._config.run_in_subprocess:
-            # tokenizers installs a pthread_atfork callback at *import* time:
-            #   https://github.com/huggingface/tokenizers/blob/4f1a810aa258d287e6936315e63fbf58bde2a980/bindings/python/src/lib.rs#L57
-            # then complains about `TOKENIZERS_PARALLELISM` at the next fork (which presumably will happen immediately
-            # after this to `git commit`, despite it being conceptually just a fork/exe).
-            # TODO: a generic subprocessing minichain service wrapper?
-            with cf.ProcessPoolExecutor() as exe:
-                return exe.submit(
-                    self._run_prompt,
-                    prompt,
-                ).result(timeout=self._config.subprocess_timeout)
-
-        else:
-            return self._run_prompt(prompt)
+# class MlxGitAiBackend(GitAiBackend['MlxGitAiBackend.Config']):
+#     @dc.dataclass(frozen=True, kw_only=True)
+#     class Config(GitAiBackend.Config):
+#         model: str = 'mlx-community/Qwen2.5-Coder-32B-Instruct-8bit'
+#
+#         run_in_subprocess: bool = True
+#         subprocess_timeout: float | None = 60.
+#
+#     def __init__(self, config: Config = Config()) -> None:
+#         super().__init__(config)
+#
+#     def _run_prompt(self, prompt: str) -> str:
+#         with mc_mlx_chat.MlxChatChoicesService(mc.ModelRepo.parse(self._config.model)) as llm:
+#             resp = lang.sync_await(llm.invoke(mc.ChatChoicesRequest(
+#                 [mc.UserMessage(prompt)],
+#                 # FIXME: *((MaxTokens(self._config.max_tokens),) if self._config.max_tokens is not None else ()),
+#             )))
+#             text = _get_single_ai_message_str(resp)
+#
+#             text = _strip_markdown_code_block(text)
+#
+#             return text
+#
+#     def run_prompt(self, prompt: str) -> str:
+#         if self._config.run_in_subprocess:
+#             # tokenizers installs a pthread_atfork callback at *import* time:
+#             #   https://github.com/huggingface/tokenizers/blob/4f1a810aa258d287e6936315e63fbf58bde2a980/bindings/python/src/lib.rs#L57  # noqa
+#             # then complains about `TOKENIZERS_PARALLELISM` at the next fork (which presumably will happen immediately
+#             # after this to `git commit`, despite it being conceptually just a fork/exe).
+#             # TODO: a generic subprocessing minichain service wrapper?
+#             with cf.ProcessPoolExecutor() as exe:
+#                 return exe.submit(
+#                     self._run_prompt,
+#                     prompt,
+#                 ).result(timeout=self._config.subprocess_timeout)
+#
+#         else:
+#             return self._run_prompt(prompt)
 
 
 #
 
 
 class LocalhostHttpPostGitAiBackend(GitAiBackend['LocalhostHttpPostGitAiBackend.Config']):
-    @dc.dataclass(frozen=True)
+    @dc.dataclass(frozen=True, kw_only=True)
     class Config(GitAiBackend.Config):
         port: int = 5067
         path: str = ''
@@ -166,7 +172,7 @@ class LocalhostHttpPostGitAiBackend(GitAiBackend['LocalhostHttpPostGitAiBackend.
 
 
 class McServerGitAiBackend(GitAiBackend['McServerGitAiBackend.Config']):
-    @dc.dataclass(frozen=True)
+    @dc.dataclass(frozen=True, kw_only=True)
     class Config(GitAiBackend.Config):
         pass
 
@@ -192,18 +198,23 @@ class AiGitMessageGenerator(GitMessageGenerator):
     def __init__(
             self,
             *,
-            backend: GitAiBackend | None = None,
+            backend: GitAiBackend | str | None = None,
     ) -> None:
         super().__init__()
 
         if backend is None:
             backend = self.DEFAULT_BACKEND
-        self._backend = backend
+        elif isinstance(backend, str):
+            backend = StandardGitAiBackend(
+                config=StandardGitAiBackend.Config(
+                    backend=backend,
+                ),
+            )
+        self._backend = check.isinstance(backend, GitAiBackend)
 
     DEFAULT_BACKEND: ta.ClassVar[GitAiBackend] = (
-        OpenaiGitAiBackend()
+        StandardGitAiBackend()
         # LocalhostHttpPostGitAiBackend()
-        # MlxGitAiBackend()
         # McServerGitAiBackend()
     )
 

{ommlds-0.0.0.dev496.dist-info → ommlds-0.0.0.dev498.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommlds
-Version: 0.0.0.dev496
+Version: 0.0.0.dev498
 Summary: ommlds
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,9 +14,9 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev496
+Requires-Dist: omlish==0.0.0.dev498
 Provides-Extra: all
-Requires-Dist: omdev==0.0.0.dev496; extra == "all"
+Requires-Dist: omdev==0.0.0.dev498; extra == "all"
 Requires-Dist: llama-cpp-python~=0.3; extra == "all"
 Requires-Dist: mlx~=0.30; sys_platform == "darwin" and extra == "all"
 Requires-Dist: mlx-lm~=0.29; sys_platform == "darwin" and extra == "all"
@@ -38,7 +38,7 @@ Requires-Dist: mwparserfromhell~=0.7; extra == "all"
 Requires-Dist: wikitextparser~=0.56; extra == "all"
 Requires-Dist: lxml>=5.3; python_version < "3.13" and extra == "all"
 Provides-Extra: omdev
-Requires-Dist: omdev==0.0.0.dev496; extra == "omdev"
+Requires-Dist: omdev==0.0.0.dev498; extra == "omdev"
 Provides-Extra: backends
 Requires-Dist: llama-cpp-python~=0.3; extra == "backends"
 Requires-Dist: mlx~=0.30; sys_platform == "darwin" and extra == "backends"