ommlds 0.0.0.dev426__py3-none-any.whl → 0.0.0.dev485__py3-none-any.whl

ommlds/minichain/backends/impls/tinygrad/chat.py

@@ -4,28 +4,33 @@ import typing as ta
 from omlish import check
 from omlish import lang
 
-from .....backends.tinygrad.models import llama3 as tgl3
 from ....chat.choices.services import ChatChoicesOptions
 from ....chat.choices.services import ChatChoicesRequest
 from ....chat.choices.services import ChatChoicesResponse
 from ....chat.choices.services import static_check_is_chat_choices_service
+from ....chat.choices.stream.services import ChatChoicesStreamRequest
+from ....chat.choices.stream.services import ChatChoicesStreamResponse
+from ....chat.choices.stream.services import static_check_is_chat_choices_stream_service
+from ....chat.choices.stream.types import AiChoiceDeltas
+from ....chat.choices.stream.types import AiChoicesDeltas
 from ....chat.choices.types import AiChoice
+from ....chat.choices.types import ChatChoicesOutputs
 from ....chat.messages import AiMessage
 from ....chat.messages import Chat
 from ....chat.messages import SystemMessage
 from ....chat.messages import UserMessage
-from ....chat.stream.services import ChatChoicesStreamGenerator
-from ....chat.stream.services import ChatChoicesStreamRequest
-from ....chat.stream.services import ChatChoicesStreamResponse
-from ....chat.stream.services import static_check_is_chat_choices_stream_service
-from ....chat.stream.types import AiChoiceDelta
-from ....chat.stream.types import AiMessageDelta
+from ....chat.stream.types import ContentAiDelta
 from ....chat.types import ChatOption
 from ....llms.types import LlmOption
 from ....resources import UseResources
+from ....stream.services import StreamResponseSink
 from ....stream.services import new_stream_response
 
 
+with lang.auto_proxy_import(globals()):
+    from .....backends.tinygrad.models import llama3 as tgl3
+
+
 ##
 
 
@@ -37,7 +42,7 @@ def _load_model(
         *,
         size: str | None = None,
         temperature: float | None = None,
-) -> tgl3.Llama3Llm:
+) -> 'tgl3.Llama3Llm':
     if size is None:
         size = DEFAULT_SIZE
     if temperature is None:
@@ -56,7 +61,7 @@ def _load_model(
 
 
 def _prepare_toks(
-        llm: tgl3.Llama3Llm,
+        llm: 'tgl3.Llama3Llm',
         chat: Chat,
         options: ta.Sequence[ChatChoicesOptions],
 ) -> list[int]:
@@ -98,7 +103,7 @@ class BaseTinygradLlama3ChatService(lang.ExitStacked, lang.Abstract):
         self._temperature = temperature
 
     @lang.cached_function(transient=True)
-    def _load_model(self) -> tgl3.Llama3Llm:
+    def _load_model(self) -> 'tgl3.Llama3Llm':
         check.not_none(self._exit_stack)
 
         return _load_model(
@@ -111,12 +116,12 @@ class BaseTinygradLlama3ChatService(lang.ExitStacked, lang.Abstract):
 
 
 # @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
-#     name='tinygrad_llama3',
+#     name='tinygrad-llama3',
 #     type='ChatChoicesService',
 # )
 @static_check_is_chat_choices_service
 class TinygradLlama3ChatChoicesService(BaseTinygradLlama3ChatService):
-    def invoke(self, request: ChatChoicesRequest) -> ChatChoicesResponse:
+    async def invoke(self, request: ChatChoicesRequest) -> ChatChoicesResponse:
         llm = self._load_model()
         toks = _prepare_toks(llm, request.v, request.options)
 
@@ -124,20 +129,20 @@ class TinygradLlama3ChatChoicesService(BaseTinygradLlama3ChatService):
         for s in tgl3.run_llm(llm, toks):
             out.append(s)
 
-        return ChatChoicesResponse([AiChoice(AiMessage(''.join(out)))])
+        return ChatChoicesResponse([AiChoice([AiMessage(''.join(out))])])
 
 
 ##
 
 
 # @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
-#     name='tinygrad_llama3',
+#     name='tinygrad-llama3',
 #     type='ChatChoicesStreamService',
 # )
 @static_check_is_chat_choices_stream_service
 class TinygradLlama3ChatChoicesStreamService(BaseTinygradLlama3ChatService):
-    def invoke(self, request: ChatChoicesStreamRequest) -> ChatChoicesStreamResponse:
-        with UseResources.or_new(request.options) as rs:
+    async def invoke(self, request: ChatChoicesStreamRequest) -> ChatChoicesStreamResponse:
+        async with UseResources.or_new(request.options) as rs:
             llm = self._load_model()
             toks = _prepare_toks(
                 llm,
@@ -145,12 +150,17 @@ class TinygradLlama3ChatChoicesStreamService(BaseTinygradLlama3ChatService):
                 request.options.get_any((ChatOption, LlmOption)),  # FIXME  # noqa
             )
 
-            def yield_choices() -> ChatChoicesStreamGenerator:
+            async def inner(sink: StreamResponseSink[AiChoicesDeltas]) -> ta.Sequence[ChatChoicesOutputs]:
                 for s in tgl3.run_llm(llm, toks):
-                    yield [AiChoiceDelta(AiMessageDelta(s))]
+                    await sink.emit(AiChoicesDeltas([
+                        AiChoiceDeltas([
+                            ContentAiDelta(s),
+                        ]),
+                    ]))
+
                 return []
 
-            return new_stream_response(rs, yield_choices())
+            return await new_stream_response(rs, inner)
 
 
 ##
@@ -161,5 +171,5 @@ class TinygradLlama3ChatChoicesStreamService(BaseTinygradLlama3ChatService):
 #         'ChatChoicesService',
 #         'ChatChoicesStreamService',
 #     ],
-#     'tinygrad_llama3',
+#     'tinygrad-llama3',
 # )

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

@@ -1,23 +1,26 @@
 import typing as ta
 
-import tokenizers as tos
-
 from omlish import check
+from omlish import lang
 
 from .... import tokens as tks
 
 
+with lang.auto_proxy_import(globals()):
+    import tokenizers as tos
+
+
 ##
 
 
-def build_vocab(tos_tokenizer: tos.Tokenizer) -> tks.Vocab:
+def build_vocab(tos_tokenizer: 'tos.Tokenizer') -> tks.Vocab:
     return tks.Vocab([
         (ta.cast(tks.Token, i), tks.TokenStr(s))
         for s, i in tos_tokenizer.get_vocab().items()
     ])
 
 
-def build_specials(tos_tokenizer: tos.Tokenizer) -> tks.SpecialTokens:
+def build_specials(tos_tokenizer: 'tos.Tokenizer') -> tks.SpecialTokens:
     # FIXME
     return tks.SpecialTokens([])
 
@@ -28,7 +31,7 @@ def build_specials(tos_tokenizer: tos.Tokenizer) -> tks.SpecialTokens:
 class TokenizersTokenizer(tks.BaseTokenizer):
     def __init__(
             self,
-            tos_tokenizer: tos.Tokenizer,
+            tos_tokenizer: 'tos.Tokenizer',
     ) -> None:
         self._tos_tokenizer = check.isinstance(tos_tokenizer, tos.Tokenizer)
 
@@ -38,7 +41,7 @@ class TokenizersTokenizer(tks.BaseTokenizer):
         )
 
     @property
-    def tos_tokenizer(self) -> tos.Tokenizer:
+    def tos_tokenizer(self) -> 'tos.Tokenizer':
         return self._tos_tokenizer
 
     #

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

@@ -1,7 +1,6 @@
 import typing as ta
 
-import sentence_transformers as stfm
-
+from omlish import lang
 from omlish import typedvalues as tv
 
 from ....configs import Config
@@ -13,6 +12,10 @@ from ....vectors.embeddings import static_check_is_embedding_service
 from ....vectors.types import Vector
 
 
+with lang.auto_proxy_import(globals()):
+    import sentence_transformers as stfm
+
+
 ##
 
 
@@ -33,7 +36,7 @@ class SentenceTransformersEmbeddingService:
         with tv.consume(*configs) as cc:
             self._model_path = cc.pop(ModelPath(self.DEFAULT_MODEL))
 
-    def invoke(self, request: EmbeddingRequest) -> EmbeddingResponse:
+    async def invoke(self, request: EmbeddingRequest) -> EmbeddingResponse:
         mdl = stfm.SentenceTransformer(
             self._model_path.v,
         )

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
 
     #
@@ -72,7 +75,7 @@ class TransformersTokenizer(tks.BaseTokenizer):
             self,
             tokens: ta.Iterable[tks.Token],
     ) -> str:
-        return self._tfm_tokenizer.decode(tokens)
+        return self._tfm_tokenizer.decode(tokens)  # type: ignore[arg-type]
 
 
 ##

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

@@ -4,30 +4,57 @@ TODO:
  - https://huggingface.co/blog/aifeifei798/transformers-streaming-output
 """
 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 ....chat.choices.services import ChatChoicesRequest
 from ....chat.choices.services import ChatChoicesResponse
 from ....chat.choices.services import static_check_is_chat_choices_service
+from ....chat.choices.stream.services import ChatChoicesStreamRequest
+from ....chat.choices.stream.services import ChatChoicesStreamResponse
+from ....chat.choices.stream.services import static_check_is_chat_choices_stream_service
+from ....chat.choices.stream.types import AiChoiceDeltas  # noqa
+from ....chat.choices.stream.types import AiChoicesDeltas  # noqa
+from ....chat.choices.types import AiChoice
+from ....chat.choices.types import ChatChoicesOutputs
 from ....chat.messages import AiMessage
 from ....chat.messages import Message
 from ....chat.messages import SystemMessage
-from ....chat.messages import ToolExecResultMessage
+from ....chat.messages import ToolUseMessage
+from ....chat.messages import ToolUseResultMessage
 from ....chat.messages import UserMessage
+from ....chat.stream.types import ContentAiDelta  # noqa
 from ....completion import CompletionRequest
 from ....completion import CompletionResponse
 from ....completion import static_check_is_completion_service
 from ....configs import Config
 from ....models.configs import ModelPath
+from ....resources import UseResources
+from ....stream.services import StreamResponseSink
+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
+
+
+##
+
+
+# @omlish-manifest $.minichain.backends.strings.manifests.BackendStringsManifest(
+#     ['ChatChoicesService', 'ChatChoicesStreamService'],
+#     'transformers',
+# )
+
+
 ##
 
 
@@ -59,7 +86,7 @@ class TransformersCompletionService(lang.ExitStacked):
             self._pipeline_kwargs = cc.pop(TransformersPipelineKwargs, [])
             self._huggingface_hub_token = HuggingfaceHubToken.pop_secret(cc, env='HUGGINGFACE_HUB_TOKEN')
 
-    def invoke(self, request: CompletionRequest) -> CompletionResponse:
+    async def invoke(self, request: CompletionRequest) -> CompletionResponse:
         pkw: dict[str, ta.Any] = dict(
             model=self._model_path.v,
             device='mps' if sys.platform == 'darwin' else 'cuda',
@@ -94,17 +121,19 @@ def build_chat_message(m: Message) -> ta.Mapping[str, ta.Any]:
         return dict(
             role='assistant',
             content=check.isinstance(m.c, str),
-            **(dict(tool_calls=[
-                dict(
-                    id=te.id,
-                    function=dict(
-                        arguments=te.args,
-                        name=te.name,
-                    ),
-                    type='function',
-                )
-                for te in m.tool_exec_requests
-            ]) if m.tool_exec_requests else {}),
+        )
+
+    elif isinstance(m, ToolUseMessage):
+        return dict(
+            role='assistant',
+            tool_calls=[dict(
+                id=m.tu.id,
+                function=dict(
+                    arguments=m.tu.args,
+                    name=m.tu.name,
+                ),
+                type='function',
+            )],
         )
 
     elif isinstance(m, UserMessage):
@@ -113,24 +142,21 @@ def build_chat_message(m: Message) -> ta.Mapping[str, ta.Any]:
             content=check.isinstance(m.c, str),
         )
 
-    elif isinstance(m, ToolExecResultMessage):
+    elif isinstance(m, ToolUseResultMessage):
         return dict(
             role='tool',
-            tool_call_id=m.id,
-            content=check.isinstance(m.c, str),
+            tool_call_id=m.tur.id,
+            content=check.isinstance(m.tur.c, str),
         )
 
     else:
         raise TypeError(m)
 
 
-# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
-#     name='transformers',
-#     aliases=['tfm'],
-#     type='ChatChoicesService',
-# )
-@static_check_is_chat_choices_service
-class TransformersChatChoicesService(lang.ExitStacked):
+##
+
+
+class BaseTransformersChatChoicesService(lang.ExitStacked):
     DEFAULT_MODEL: ta.ClassVar[str] = (
         'meta-llama/Llama-3.2-1B-Instruct'
     )
@@ -144,7 +170,7 @@ class TransformersChatChoicesService(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)
 
@@ -157,21 +183,118 @@ class TransformersChatChoicesService(lang.ExitStacked):
         for pkw_cfg in self._pipeline_kwargs:
             pkw.update(pkw_cfg.v)
 
-        return tfm.pipeline(
-            'text-generation',
-            **pkw,
-        )
+        with tfm_u.file_cache_patch_context(
+                local_first=True,
+                local_config_present_is_authoritative=True,
+        ):
+            return tfm.pipeline(
+                'text-generation',
+                **pkw,
+            )
+
 
-    def invoke(self, request: ChatChoicesRequest) -> ChatChoicesResponse:
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='transformers',
+#     aliases=['tfm'],
+#     type='ChatChoicesService',
+# )
+@static_check_is_chat_choices_service
+class TransformersChatChoicesService(BaseTransformersChatChoicesService):
+    async def invoke(self, request: ChatChoicesRequest) -> ChatChoicesResponse:
         check.empty(request.options)
 
         pipeline = self._load_pipeline()
 
-        output = pipeline(
-            [
-                build_chat_message(m)
-                for m in request.v
-            ],
+        inputs = [
+            build_chat_message(m)
+            for m in request.v
+        ]
+
+        outputs = pipeline(inputs)
+
+        gts = check.single(outputs)['generated_text']
+        ugt, agt = gts
+        check.state(ugt['role'] == 'user')
+        check.state(agt['role'] == 'assistant')
+
+        return ChatChoicesResponse([AiChoice([AiMessage(agt['content'])])])
+
+
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='transformers',
+#     type='ChatChoicesStreamService',
+# )
+@static_check_is_chat_choices_stream_service
+class TransformersChatChoicesStreamService(BaseTransformersChatChoicesService):
+    async def invoke(self, request: ChatChoicesStreamRequest) -> ChatChoicesStreamResponse:
+        check.empty(request.options)
+
+        pipeline = self._load_pipeline()  # noqa
+
+        inputs = [  # noqa
+            build_chat_message(m)
+            for m in request.v
+        ]
+
+        relay: AsyncioBufferRelay = AsyncioBufferRelay()
+
+        def streamer_callback(text: str, *, stream_end: bool) -> None:
+            if text or stream_end:
+                relay.push(text, *([None] if stream_end else []))
+
+        streamer = tfm_u.CancellableTextStreamer(
+            check.not_none(pipeline.tokenizer),  # type: ignore[arg-type]
+            streamer_callback,  # noqa
+            skip_prompt=True,
+            skip_special_tokens=True,
         )
 
-        return ChatChoicesResponse(output)
+        async with UseResources.or_new(request.options) as rs:
+            thread = threading.Thread(
+                target=tfm_u.CancellableTextStreamer.ignoring_cancelled(pipeline),
+                args=(
+                    inputs,
+                ),
+                kwargs=dict(
+                    streamer=streamer,
+                ),
+            )
+
+            def stop_thread() -> None:
+                streamer.cancel()
+                # thread.join()
+
+            rs.enter_context(lang.defer(stop_thread))
+
+            thread.start()
+
+            async def inner(sink: StreamResponseSink[AiChoicesDeltas]) -> ta.Sequence[ChatChoicesOutputs] | None:
+                while True:
+                    await relay.wait()
+                    got = relay.swap()
+
+                    if not got:
+                        raise RuntimeError
+
+                    if got[-1] is None:
+                        out = ''.join(got[:-1])
+                        end = True
+                    else:
+                        out = ''.join(got)
+                        end = False
+
+                    if out:
+                        await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiDelta(out)])]))
+
+                    if end:
+                        break
+
+                return []
+
+            return await new_stream_response(rs, inner)

ommlds/minichain/backends/strings/parsing.py

@@ -56,7 +56,7 @@ _REPO_MODEL_PAT = re.compile(
 def parse_backend_string(s: str) -> ParsedBackendString:
     backend: str | None
     if ':' in s:
-        backend, s = s.split(':')
+        backend, _, s = s.partition(':')
     else:
         backend = None
 

ommlds/minichain/backends/strings/resolving.py

@@ -108,7 +108,10 @@ class ManifestBackendStringResolver(BackendStringResolver):
 
         mn: str | None = mdl.name
 
-        if mn == m.backend_name:
+        if args.parsed.backend == m.backend_name and mn is not None:
+            pass
+
+        elif mn == m.backend_name:
             if m.model_names is not None:
                 mn = m.model_names.resolved_default
             else:

ommlds/minichain/chat/_marshal.py

@@ -5,6 +5,8 @@ TODO:
 from omlish import lang
 from omlish import marshal as msh
 
+from .messages import AnyAiMessage
+from .messages import AnyUserMessage
 from .messages import Message
 
 
@@ -12,13 +14,18 @@ from .messages import Message
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
-    msgs_poly = msh.polymorphism_from_subclasses(
+def _install_standard_marshaling() -> None:
+    for cls in [
+        AnyAiMessage,
+        AnyUserMessage,
         Message,
-        naming=msh.Naming.SNAKE,
-        strip_suffix=True,
-    )
-    msh.install_standard_factories(
-        msh.PolymorphismMarshalerFactory(msgs_poly),
-        msh.PolymorphismUnmarshalerFactory(msgs_poly),
-    )
+    ]:
+        cls_poly = msh.polymorphism_from_subclasses(
+            cls,
+            naming=msh.Naming.SNAKE,
+            strip_suffix='Message',
+        )
+        msh.install_standard_factories(
+            msh.PolymorphismMarshalerFactory(cls_poly),
+            msh.PolymorphismUnmarshalerFactory(cls_poly),
+        )

ommlds/minichain/chat/choices/adapters.py

@@ -2,7 +2,7 @@ from omlish import check
 from omlish import dataclasses as dc
 
 from ...services import Response
-from ..messages import AiMessage
+from ..messages import AiChat
 from ..services import ChatRequest
 from ..services import static_check_is_chat_service
 from .services import ChatChoicesService
@@ -17,6 +17,6 @@ from .types import ChatChoicesOutputs
 class ChatChoicesServiceChatService:
     service: ChatChoicesService
 
-    def invoke(self, request: ChatRequest) -> Response[AiMessage, ChatChoicesOutputs]:
-        resp = self.service.invoke(request)
-        return Response(check.single(resp.v).m, resp.outputs)
+    async def invoke(self, request: ChatRequest) -> Response[AiChat, ChatChoicesOutputs]:
+        resp = await self.service.invoke(request)
+        return Response(check.single(resp.v).ms, resp.outputs)

ommlds/minichain/chat/choices/services.py

@@ -36,5 +36,5 @@ def static_check_is_chat_choices_service[T: ChatChoicesService](t: type[T]) -> t
 @static_check_is_chat_choices_service
 class AbstractChatChoicesService(lang.Abstract):
     @abc.abstractmethod
-    def invoke(self, request: ChatChoicesRequest) -> ChatChoicesResponse:
+    def invoke(self, request: ChatChoicesRequest) -> ta.Awaitable[ChatChoicesResponse]:
         raise NotImplementedError

ommlds/minichain/chat/choices/stream/adapters.py

@@ -0,0 +1,35 @@
+from omlish import dataclasses as dc
+
+from ....services import Response
+from ..services import ChatChoicesRequest
+from ..services import static_check_is_chat_choices_service
+from ..types import AiChoice
+from ..types import AiChoices
+from .joining import AiChoicesDeltaJoiner
+from .services import ChatChoicesOutputs
+from .services import ChatChoicesStreamOutputs
+from .services import ChatChoicesStreamService
+
+
+##
+
+
+@static_check_is_chat_choices_service
+@dc.dataclass(frozen=True)
+class ChatChoicesStreamServiceChatChoicesService:
+    service: ChatChoicesStreamService
+
+    async def invoke(self, request: ChatChoicesRequest) -> Response[
+        AiChoices,
+        ChatChoicesOutputs | ChatChoicesStreamOutputs,
+    ]:
+        joiner = AiChoicesDeltaJoiner()
+
+        async with (resp := await self.service.invoke(request)).v as it:  # noqa
+            async for cs in it:
+                joiner.add(cs.choices)
+
+        # check.state(resp_v.is_done)
+
+        # FIXME: outputs lol
+        return Response([AiChoice(ms) for ms in joiner.build()])