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

ommlds/minichain/backends/impls/transformers/tokens.py

@@ -1,17 +1,20 @@
 import typing as ta
 
-import transformers as tfm
-
 from omlish import check
 from omlish import collections as col
+from omlish import lang
 
 from .... import tokens as tks
 
 
+with lang.auto_proxy_import(globals()):
+    import transformers as tfm
+
+
 ##
 
 
-def build_vocab(tfm_tokenizer: tfm.PreTrainedTokenizerBase) -> tks.Vocab:
+def build_vocab(tfm_tokenizer: 'tfm.PreTrainedTokenizerBase') -> tks.Vocab:
     return tks.Vocab([
         (ta.cast(tks.Token, i), tks.TokenStr(s))
         for s, i in tfm_tokenizer.get_vocab().items()
@@ -32,7 +35,7 @@ SPECIAL_TOKEN_ATTR_MAP: col.BiMap[type[tks.SpecialToken], str] = col.make_bi_map
 })
 
 
-def build_specials(tfm_tokenizer: tfm.PreTrainedTokenizerBase) -> tks.SpecialTokens:
+def build_specials(tfm_tokenizer: 'tfm.PreTrainedTokenizerBase') -> tks.SpecialTokens:
     return tks.SpecialTokens.from_dict({
         st: getattr(tfm_tokenizer, a)
         for st, a in SPECIAL_TOKEN_ATTR_MAP.items()
@@ -45,7 +48,7 @@ def build_specials(tfm_tokenizer: tfm.PreTrainedTokenizerBase) -> tks.SpecialTok
 class TransformersTokenizer(tks.BaseTokenizer):
     def __init__(
             self,
-            tfm_tokenizer: tfm.PreTrainedTokenizerBase,
+            tfm_tokenizer: 'tfm.PreTrainedTokenizerBase',
     ) -> None:
         self._tfm_tokenizer = check.isinstance(tfm_tokenizer, tfm.PreTrainedTokenizerBase)
 
@@ -55,7 +58,7 @@ class TransformersTokenizer(tks.BaseTokenizer):
         )
 
     @property
-    def tfm_tokenizer(self) -> tfm.PreTrainedTokenizerBase:
+    def tfm_tokenizer(self) -> 'tfm.PreTrainedTokenizerBase':
         return self._tfm_tokenizer
 
     #

ommlds/minichain/backends/impls/transformers/transformers.py

@@ -7,15 +7,11 @@ import sys
 import threading
 import typing as ta
 
-import transformers as tfm
-
 from omlish import check
 from omlish import lang
 from omlish import typedvalues as tv
 from omlish.asyncs.asyncio.sync import AsyncioBufferRelay
 
-from .....backends.transformers.filecache import file_cache_patch_context
-from .....backends.transformers.streamers import CancellableTextStreamer
 from ....chat.choices.services import ChatChoicesRequest
 from ....chat.choices.services import ChatChoicesResponse
 from ....chat.choices.services import static_check_is_chat_choices_service
@@ -44,6 +40,12 @@ from ....stream.services import new_stream_response
 from ...impls.huggingface.configs import HuggingfaceHubToken
 
 
+with lang.auto_proxy_import(globals()):
+    import transformers as tfm
+
+    from .....backends import transformers as tfm_u
+
+
 ##
 
 
@@ -168,7 +170,7 @@ class BaseTransformersChatChoicesService(lang.ExitStacked):
             self._huggingface_hub_token = HuggingfaceHubToken.pop_secret(cc, env='HUGGINGFACE_HUB_TOKEN')
 
     @lang.cached_function(transient=True)
-    def _load_pipeline(self) -> tfm.Pipeline:
+    def _load_pipeline(self) -> 'tfm.Pipeline':
         # FIXME: unload
         check.not_none(self._exit_stack)
 
@@ -181,7 +183,7 @@ class BaseTransformersChatChoicesService(lang.ExitStacked):
         for pkw_cfg in self._pipeline_kwargs:
             pkw.update(pkw_cfg.v)
 
-        with file_cache_patch_context(
+        with tfm_u.file_cache_patch_context(
                 local_first=True,
                 local_config_present_is_authoritative=True,
         ):
@@ -246,7 +248,7 @@ class TransformersChatChoicesStreamService(BaseTransformersChatChoicesService):
             if text or stream_end:
                 relay.push(text, *([None] if stream_end else []))
 
-        streamer = CancellableTextStreamer(
+        streamer = tfm_u.CancellableTextStreamer(
             check.not_none(pipeline.tokenizer),  # type: ignore[arg-type]
             streamer_callback,  # noqa
             skip_prompt=True,
@@ -255,7 +257,7 @@ class TransformersChatChoicesStreamService(BaseTransformersChatChoicesService):
 
         async with UseResources.or_new(request.options) as rs:
             thread = threading.Thread(
-                target=CancellableTextStreamer.ignoring_cancelled(pipeline),
+                target=tfm_u.CancellableTextStreamer.ignoring_cancelled(pipeline),
                 args=(
                     inputs,
                 ),

ommlds/minichain/backends/strings/resolving.py

@@ -4,9 +4,9 @@ TODO:
   - interop with registry somehow, probably? or is it strictly a different concern?
 """
 import abc
-import dataclasses as dc
 import typing as ta
 
+from omlish import dataclasses as dc
 from omlish import lang
 from omlish.manifests.globals import GlobalManifestLoader
 

ommlds/minichain/chat/content.py

@@ -0,0 +1,42 @@
+import typing as ta
+
+from ..content.content import Content
+from ..content.transform.strings import transform_content_strings
+from .messages import AiMessage
+from .messages import Message
+from .messages import SystemMessage
+from .messages import ToolUseMessage
+from .messages import ToolUseResultMessage
+from .messages import UserMessage
+
+
+MessageT = ta.TypeVar('MessageT', bound=Message)
+
+
+##
+
+
+def transform_message_content(fn: ta.Callable[[Content], Content], m: MessageT) -> MessageT:
+    if isinstance(m, UserMessage):
+        return m.replace(c=fn(m.c))
+
+    elif isinstance(m, AiMessage):
+        return m.replace(c=fn(m.c))
+
+    elif isinstance(m, SystemMessage):
+        return m.replace(c=fn(m.c))
+
+    elif isinstance(m, ToolUseMessage):
+        # TODO: m.tu.args?
+        return m
+
+    elif isinstance(m, ToolUseResultMessage):
+        # TODO: m.tur.c?
+        return m
+
+    else:
+        raise TypeError(m)
+
+
+def transform_message_content_strings(fn: ta.Callable[[str], str], m: MessageT) -> MessageT:
+    return transform_message_content(lambda c: transform_content_strings(fn, c), m)

ommlds/minichain/chat/messages.py

@@ -1,20 +1,20 @@
+"""
+TODO:
+ - channel? reasoning / thinking?
+"""
 import operator
 import typing as ta
 
 from omlish import check
 from omlish import dataclasses as dc
-from omlish import dispatch
 from omlish import lang
 from omlish import marshal as msh
-from omlish import typedvalues as tv
 
-from .._typedvalues import _tv_field_metadata
-from ..content.materialize import CanContent
-from ..content.transforms.base import ContentTransform
-from ..content.types import Content
-from ..metadata import MetadataContainer
+from ..content.content import Content
+from ..metadata import MetadataContainerDataclass
 from ..tools.types import ToolUse
 from ..tools.types import ToolUseResult
+from .metadata import MessageMetadata
 from .metadata import MessageMetadatas
 
 
@@ -26,7 +26,7 @@ msh.register_global_module_import('._marshal', __package__)
 
 @dc.dataclass(frozen=True)
 class Message(  # noqa
-    MetadataContainer[MessageMetadatas],
+    MetadataContainerDataclass[MessageMetadatas],
     lang.Abstract,
     lang.Sealed,
 ):
@@ -34,18 +34,14 @@ class Message(  # noqa
         default=(),
         kw_only=True,
         repr=False,
-        metadata=_tv_field_metadata(
-            MessageMetadatas,
-            marshal_name='metadata',
-        ),
     )
 
-    @property
-    def metadata(self) -> tv.TypedValues[MessageMetadatas]:
-        return check.isinstance(self._metadata, tv.TypedValues)
+    MetadataContainerDataclass._configure_metadata_field(_metadata, MessageMetadatas)  # noqa
 
-    def with_metadata(self, *mds: MessageMetadatas, override: bool = False) -> ta.Self:
-        return dc.replace(self, _metadata=tv.TypedValues(*self._metadata, *mds, override=override))
+    def replace(self, **kwargs: ta.Any) -> ta.Self:
+        if (n := dc.replace_is_not(self, **kwargs)) is self:
+            return self
+        return n.with_metadata(MessageOriginal(self), discard=[MessageOriginal], override=True)
 
 
 Chat: ta.TypeAlias = ta.Sequence[Message]
@@ -54,6 +50,14 @@ Chat: ta.TypeAlias = ta.Sequence[Message]
 ##
 
 
+@dc.dataclass(frozen=True)
+class MessageOriginal(MessageMetadata, lang.Final):
+    c: Message
+
+
+##
+
+
 @dc.dataclass(frozen=True)
 class AnyUserMessage(Message, lang.Abstract):
     pass
@@ -90,7 +94,7 @@ def check_ai_chat(chat: Chat) -> AiChat:
 
 @dc.dataclass(frozen=True)
 class SystemMessage(AnyUserMessage, lang.Final):
-    c: CanContent
+    c: Content
 
 
 #
@@ -99,7 +103,7 @@ class SystemMessage(AnyUserMessage, lang.Final):
 @dc.dataclass(frozen=True)
 @msh.update_fields_metadata(['name'], omit_if=operator.not_)
 class UserMessage(AnyUserMessage, lang.Final):
-    c: CanContent
+    c: Content
 
     name: str | None = dc.xfield(None, repr_fn=dc.opt_repr)
 
@@ -128,23 +132,23 @@ class ToolUseResultMessage(AnyUserMessage, lang.Final):
 ##
 
 
-class _MessageContentTransform(ContentTransform, lang.Final, lang.NotInstantiable):
-    @dispatch.install_method(ContentTransform.apply)
-    def apply_system_message(self, m: SystemMessage) -> SystemMessage:
-        return dc.replace(m, c=self.apply(m.c))
-
-    @dispatch.install_method(ContentTransform.apply)
-    def apply_user_message(self, m: UserMessage) -> UserMessage:
-        return dc.replace(m, c=self.apply(m.c))
-
-    @dispatch.install_method(ContentTransform.apply)
-    def apply_ai_message(self, m: AiMessage) -> AiMessage:
-        return dc.replace(m, c=self.apply(m.c))
-
-    @dispatch.install_method(ContentTransform.apply)
-    def apply_tool_use_message(self, m: ToolUseMessage) -> ToolUseMessage:
-        return dc.replace(m, tu=self.apply(m.tu))
-
-    @dispatch.install_method(ContentTransform.apply)
-    def apply_tool_use_result_message(self, m: ToolUseResultMessage) -> ToolUseResultMessage:
-        return dc.replace(m, tur=self.apply(m.tur))
+# class _MessageContentTransform(ContentTransform, lang.Final, lang.NotInstantiable):
+#     @dispatch.install_method(ContentTransform.apply)
+#     def apply_system_message(self, m: SystemMessage) -> SystemMessage:
+#         return dc.replace(m, c=self.apply(m.c))
+#
+#     @dispatch.install_method(ContentTransform.apply)
+#     def apply_user_message(self, m: UserMessage) -> UserMessage:
+#         return dc.replace(m, c=self.apply(m.c))
+#
+#     @dispatch.install_method(ContentTransform.apply)
+#     def apply_ai_message(self, m: AiMessage) -> AiMessage:
+#         return dc.replace(m, c=self.apply(m.c))
+#
+#     @dispatch.install_method(ContentTransform.apply)
+#     def apply_tool_use_message(self, m: ToolUseMessage) -> ToolUseMessage:
+#         return dc.replace(m, tu=self.apply(m.tu))
+#
+#     @dispatch.install_method(ContentTransform.apply)
+#     def apply_tool_use_result_message(self, m: ToolUseResultMessage) -> ToolUseResultMessage:
+#         return dc.replace(m, tur=self.apply(m.tur))

ommlds/minichain/chat/stream/joining.py

@@ -22,8 +22,9 @@ class AiDeltaJoiner:
     def __init__(self) -> None:
         super().__init__()
 
-        self._deltas: list[AiDelta] = []
-        self._messages: list[AnyAiMessage] = []
+        self._all: list[AiDelta] = []
+        self._queue: list[AiDelta] = []
+        self._out: list[AnyAiMessage] = []
 
     def _build_joined(self, deltas: ta.Sequence[AiDelta]) -> AnyAiMessage:
         dty = check.single(set(map(type, check.not_empty(deltas))))
@@ -43,6 +44,9 @@ class AiDeltaJoiner:
 
             ra = ''.join(filter(None, (td.raw_args for td in tds)))
 
+            if not ra:
+                ra = '{}'
+
             return ToolUseMessage(ToolUse(
                 id=tds[0].id,
                 name=check.non_empty_str(tds[0].name),
@@ -53,19 +57,39 @@ class AiDeltaJoiner:
         else:
             raise TypeError(dty)
 
-    def _maybe_join(self) -> None:
-        if not self._deltas:
+    def _join(self) -> None:
+        if not self._queue:
             return
 
-        self._messages.append(self._build_joined(self._deltas))
-        self._deltas.clear()
+        self._out.append(self._build_joined(self._queue))
+        self._queue.clear()
+
+    def _should_join(self, *, new: AiDelta | None = None) -> bool:
+        if not self._queue:
+            return False
+
+        if new is not None and type(self._queue[0]) is not type(new):
+            return True
+
+        if (
+                isinstance(d0 := self._queue[0], PartialToolUseAiDelta) and
+                isinstance(new, PartialToolUseAiDelta) and
+                d0.id is not None and
+                new.id is not None and
+                d0.id != new.id
+        ):
+            return True
+
+        return False
 
     def _add_one(self, d: AiDelta) -> None:
-        if self._deltas and type(self._deltas[0]) is not type(d):
-            self._maybe_join()
+        if self._should_join(new=d):
+            self._join()
+
+        self._all.append(d)
 
         if isinstance(d, ToolUseAiDelta):
-            self._messages.append(ToolUseMessage(ToolUse(
+            self._out.append(ToolUseMessage(ToolUse(
                 id=d.id,
                 name=check.not_none(d.name),
                 args=d.args or {},
@@ -73,13 +97,13 @@ class AiDeltaJoiner:
             )))
 
         else:
-            self._deltas.append(d)
+            self._queue.append(d)
 
     def add(self, deltas: AiDeltas) -> None:
         for d in deltas:
             self._add_one(d)
 
     def build(self) -> AiChat:
-        self._maybe_join()
+        self._join()
 
-        return list(self._messages)
+        return list(self._out)

ommlds/minichain/chat/stream/types.py

@@ -4,7 +4,7 @@ from omlish import dataclasses as dc
 from omlish import lang
 from omlish import marshal as msh
 
-from ...content.types import Content
+from ...content.content import Content
 from ...stream.services import StreamOptions
 from ...types import Option
 from ...types import Output

ommlds/minichain/chat/templating.py

@@ -10,9 +10,9 @@ from omlish import dataclasses as dc
 from omlish import lang
 from omlish.text import templating as tpl
 
-from ..content.transforms.strings import transform_content_strings
 from ..envs import Env
 from ..envs import EnvKey
+from .content import transform_message_content_strings
 from .messages import Chat
 from .messages import Message
 
@@ -81,7 +81,7 @@ class ChatTemplater:
                 t = self.d[s]
                 return t.render(tpl.Templater.Context(env))
 
-            return [transform_content_strings(render_content_str, self.m)]
+            return [transform_message_content_strings(render_content_str, self.m)]
 
     @dc.dataclass(frozen=True)
     class _PlaceholderStep(_Step):
@@ -110,7 +110,7 @@ class ChatTemplater:
                 content_strs.add(s)
                 return s
 
-            transform_content_strings(visit_content_str, p.v)
+            transform_message_content_strings(visit_content_str, p.v)
 
             d: dict[str, tpl.Templater] = {
                 s: self._template_factory(s)

ommlds/minichain/content/__init__.py

@@ -8,11 +8,27 @@ _msh.register_global_module_import('._marshal', __package__)
 ##
 
 
-# This is everything _marshal.py references - it must all be imported before the conditional import.
+# These are all of the Content subtypes - it must all be imported before the conditional import.
+
 from . import (  # noqa
+    code as _code,
+    composite as _composite,
+    content as _content,
+    dynamic as _dynamic,
+    emphasis as _emphasis,
     images as _images,
-    materialize as _materialize,
+    json as _json,
+    link as _link,
+    markdown as _markdown,
+    namespaces as _namespaces,
+    placeholders as _placeholders,
+    quote as _quote,
+    raw as _raw,
+    recursive as _recursive,
+    section as _section,
     sequence as _sequence,
+    standard as _standard,
+    tag as _tag,
+    templates as _templates,
     text as _text,
-    types as _types,
 )