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

ommlds/minichain/chat/stream/joining.py

@@ -0,0 +1,85 @@
+import typing as ta
+
+from omlish import check
+from omlish.formats import json
+
+from ...tools.types import ToolUse
+from ..messages import AiChat
+from ..messages import AiMessage
+from ..messages import AnyAiMessage
+from ..messages import ToolUseMessage
+from .types import AiDelta
+from .types import AiDeltas
+from .types import ContentAiDelta
+from .types import PartialToolUseAiDelta
+from .types import ToolUseAiDelta
+
+
+##
+
+
+class AiDeltaJoiner:
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._deltas: list[AiDelta] = []
+        self._messages: list[AnyAiMessage] = []
+
+    def _build_joined(self, deltas: ta.Sequence[AiDelta]) -> AnyAiMessage:
+        dty = check.single(set(map(type, check.not_empty(deltas))))
+
+        if dty is ContentAiDelta:
+            cds = ta.cast(ta.Sequence[ContentAiDelta], deltas)
+            return AiMessage(''.join(check.isinstance(cd.c, str) for cd in cds))
+
+        elif dty is ToolUseAiDelta:
+            raise TypeError(dty)
+
+        elif dty is PartialToolUseAiDelta:
+            tds = ta.cast(ta.Sequence[PartialToolUseAiDelta], deltas)
+            for td in ta.cast(ta.Sequence[PartialToolUseAiDelta], deltas)[1:]:
+                check.none(td.id)
+                check.none(td.name)
+
+            ra = ''.join(filter(None, (td.raw_args for td in tds)))
+
+            return ToolUseMessage(ToolUse(
+                id=tds[0].id,
+                name=check.non_empty_str(tds[0].name),
+                args=json.loads(ra),
+                raw_args=ra,
+            ))
+
+        else:
+            raise TypeError(dty)
+
+    def _maybe_join(self) -> None:
+        if not self._deltas:
+            return
+
+        self._messages.append(self._build_joined(self._deltas))
+        self._deltas.clear()
+
+    def _add_one(self, d: AiDelta) -> None:
+        if self._deltas and type(self._deltas[0]) is not type(d):
+            self._maybe_join()
+
+        if isinstance(d, ToolUseAiDelta):
+            self._messages.append(ToolUseMessage(ToolUse(
+                id=d.id,
+                name=check.not_none(d.name),
+                args=d.args or {},
+                raw_args=json.dumps_compact(d.args),
+            )))
+
+        else:
+            self._deltas.append(d)
+
+    def add(self, deltas: AiDeltas) -> None:
+        for d in deltas:
+            self._add_one(d)
+
+    def build(self) -> AiChat:
+        self._maybe_join()
+
+        return list(self._messages)

ommlds/minichain/chat/stream/services.py

@@ -7,39 +7,39 @@ from ...registries.globals import register_type
 from ...services import Request
 from ...services import Service
 from ...stream.services import StreamResponse
-from ..choices.types import ChatChoicesOutputs
 from ..messages import Chat
-from .types import AiChoicesDeltas
-from .types import ChatChoicesStreamOptions
-from .types import ChatChoicesStreamOutputs
+from ..types import ChatOutputs
+from .types import AiDeltas
+from .types import ChatStreamOptions
+from .types import ChatStreamOutputs
 
 
 ##
 
 
-ChatChoicesStreamRequest: ta.TypeAlias = Request[Chat, ChatChoicesStreamOptions]
+ChatStreamRequest: ta.TypeAlias = Request[Chat, ChatStreamOptions]
 
-ChatChoicesStreamResponse: ta.TypeAlias = StreamResponse[
-    AiChoicesDeltas,
-    ChatChoicesOutputs,
-    ChatChoicesStreamOutputs,
+ChatStreamResponse: ta.TypeAlias = StreamResponse[
+    AiDeltas,
+    ChatOutputs,
+    ChatStreamOutputs,
 ]
 
 # @omlish-manifest $.minichain.registries.manifests.RegistryTypeManifest
-ChatChoicesStreamService: ta.TypeAlias = Service[ChatChoicesStreamRequest, ChatChoicesStreamResponse]
+ChatStreamService: ta.TypeAlias = Service[ChatStreamRequest, ChatStreamResponse]
 
-register_type(ChatChoicesStreamService, module=__name__)
+register_type(ChatStreamService, module=__name__)
 
 
-def static_check_is_chat_choices_stream_service[T: ChatChoicesStreamService](t: type[T]) -> type[T]:
+def static_check_is_chat_stream_service[T: ChatStreamService](t: type[T]) -> type[T]:
     return t
 
 
 ##
 
 
-@static_check_is_chat_choices_stream_service
-class AbstractChatChoicesStreamService(lang.Abstract):
+@static_check_is_chat_stream_service
+class AbstractChatStreamService(lang.Abstract):
     @abc.abstractmethod
-    def invoke(self, request: ChatChoicesStreamRequest) -> ta.Awaitable[ChatChoicesStreamResponse]:
+    def invoke(self, request: ChatStreamRequest) -> ta.Awaitable[ChatStreamResponse]:
         raise NotImplementedError

ommlds/minichain/chat/stream/types.py

@@ -6,10 +6,9 @@ from omlish import marshal as msh
 
 from ...content.types import Content
 from ...stream.services import StreamOptions
-from ...tools.types import ToolUse
 from ...types import Option
 from ...types import Output
-from ..choices.types import ChatChoicesOptions
+from ..types import ChatOptions
 
 
 msh.register_global_module_import('._marshal', __package__)
@@ -18,49 +17,56 @@ msh.register_global_module_import('._marshal', __package__)
 ##
 
 
-class ChatChoicesStreamOption(Option, lang.Abstract, lang.PackageSealed):
+class ChatStreamOption(Option, lang.Abstract, lang.PackageSealed):
     pass
 
 
-ChatChoicesStreamOptions: ta.TypeAlias = ChatChoicesStreamOption | StreamOptions | ChatChoicesOptions
+ChatStreamOptions: ta.TypeAlias = ChatStreamOption | StreamOptions | ChatOptions
 
 
 ##
 
 
-class ChatChoicesStreamOutput(Output, lang.Abstract, lang.PackageSealed):
+class ChatStreamOutput(Output, lang.Abstract, lang.PackageSealed):
     pass
 
 
-ChatChoicesStreamOutputs: ta.TypeAlias = ChatChoicesStreamOutput
+ChatStreamOutputs: ta.TypeAlias = ChatStreamOutput
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class AiChoiceDelta(lang.Sealed, lang.Abstract):
+class AiDelta(lang.Sealed, lang.Abstract):
     pass
 
 
-@dc.dataclass(frozen=True)
-class ContentAiChoiceDelta(AiChoiceDelta, lang.Final):
-    c: Content
+AiDeltas: ta.TypeAlias = ta.Sequence[AiDelta]
+
+
+#
 
 
 @dc.dataclass(frozen=True)
-class ToolUseAiChoiceDelta(AiChoiceDelta, lang.Final):
-    tu: ToolUse
+class ContentAiDelta(AiDelta, lang.Final):
+    c: Content
 
 
 #
 
 
-@dc.dataclass(frozen=True)
-class AiChoiceDeltas(lang.Final):
-    deltas: ta.Sequence[AiChoiceDelta]
+@dc.dataclass(frozen=True, kw_only=True)
+class AnyToolUseAiDelta(AiDelta, lang.Abstract):
+    id: str | None = None
+    name: str | None = None
 
 
-@dc.dataclass(frozen=True)
-class AiChoicesDeltas(lang.Final):
-    choices: ta.Sequence[AiChoiceDeltas]
+@dc.dataclass(frozen=True, kw_only=True)
+class ToolUseAiDelta(AnyToolUseAiDelta, lang.Final):
+    args: ta.Mapping[str, ta.Any] | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class PartialToolUseAiDelta(AnyToolUseAiDelta, lang.Final):
+    raw_args: ta.Any | None = None

ommlds/minichain/llms/types.py

@@ -31,6 +31,10 @@ class MaxTokens(LlmOption, tv.UniqueScalarTypedValue[int]):
     pass
 
 
+class MaxCompletionTokens(LlmOption, tv.UniqueScalarTypedValue[int]):
+    pass
+
+
 ##
 
 

ommlds/minichain/registries/globals.py

@@ -98,20 +98,34 @@ def register_type(
 
 
 @ta.overload
-def registry_new(cls: type[T], name: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+def get_registry_cls(cls: type[T], name: str) -> type[T]:
     ...
 
 
 @ta.overload
-def registry_new(cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> ta.Any:
+def get_registry_cls(cls: ta.Any, name: str) -> ta.Any:
     ...
 
 
-def registry_new(cls, name, *args, **kwargs):
+def get_registry_cls(cls, name, *args, **kwargs):
     be_cls = _GlobalRegistry.instance().get_registry_cls(cls, name)
     if isinstance(cls, type):
         be_cls = check.issubclass(be_cls, cls)  # noqa
-    return be_cls(*args, **kwargs)
+    return be_cls
+
+
+@ta.overload
+def registry_new(cls: type[T], name: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+    ...
+
+
+@ta.overload
+def registry_new(cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> ta.Any:
+    ...
+
+
+def registry_new(cls, name, *args, **kwargs):
+    return get_registry_cls(cls, name)(*args, **kwargs)
 
 
 #

ommlds/minichain/resources.py

@@ -31,6 +31,7 @@ class ResourcesRefNotRegisteredError(Exception):
     pass
 
 
+@ta.final
 class Resources(lang.Final, lang.NotPicklable):
     def __init__(
             self,
@@ -145,24 +146,48 @@ class Resources(lang.Final, lang.NotPicklable):
 ##
 
 
+@ta.final
 class ResourceManaged(ResourcesRef, lang.Final, lang.NotPicklable, ta.Generic[T]):
+    """
+    A class to 'handoff' a ref to a `Resources`, allowing the `Resources` to temporarily survive being passed from
+    instantiation within a callee to being `__aenter__`'d in the caller.
+
+    The ref to the `Resources` is allocated in the ctor, so the contract is that an instance of this must be immediately
+    `__aenter__`'d before doing anything else with the return value of the call. Failure to do so leaks the `Resources`.
+    """
+
     def __init__(self, v: T, resources: Resources) -> None:
         super().__init__()
 
-        self._v = v
+        self.__v = v
         self.__resources = resources
 
         resources.add_ref(self)
 
+    __state: ta.Literal['new', 'entered', 'exited'] = 'new'
+
     def __repr__(self) -> str:
-        return f'{self.__class__.__name__}<{self._v!r}>'
+        return f'{self.__class__.__name__}<{self.__v!r}, {self.__state}>'
 
     async def __aenter__(self) -> T:
-        return self._v
+        check.state(self.__state == 'new')
+        self.__state = 'entered'
+        return self.__v
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
+        check.state(self.__state == 'entered')
+        self.__state = 'exited'
         await self.__resources.remove_ref(self)
 
+    def __del__(self) -> None:
+        if self.__state != 'exited':
+            log.error(
+                f'{__package__}.{self.__class__.__name__}.__del__: '  # noqa
+                f'%r deleted without being entered and exited! '
+                f'resources: %s',
+                repr(self),
+                repr(self.__resources),
+            )
 
 ##
 

ommlds/minichain/search.py

@@ -19,7 +19,7 @@ class SearchHit(lang.Final):
     title: str | None
     url: str | None
     description: str | None = None
-    snippets: lang.SequenceNotStr[str] | None
+    snippets: lang.SequenceNotStr[str] | None = None
 
 
 @dc.dataclass(frozen=True, kw_only=True)

ommlds/minichain/standard.py

@@ -25,6 +25,14 @@ class Device(tv.UniqueScalarTypedValue[ta.Any], Config):
 ##
 
 
+# TODO: ApiEndpointPath, ApiEndpointUrl, ApiBaseUrl, ...
+class ApiUrl(tv.UniqueScalarTypedValue[str], Config):
+    pass
+
+
+##
+
+
 @dc.dataclass(frozen=True)
 class SecretConfig(Config, lang.Abstract):
     v: sec.SecretRefOrStr = dc.field() | sec.secret_field

ommlds/minichain/stream/services.py

@@ -125,17 +125,18 @@ class _StreamServiceResponse(StreamResponseIterator[V, OutputT]):
             return
         if self._cr.cr_running or self._cr.cr_suspended:
             cex = StreamServiceCancelledError()
-            for i in itertools.count():
+            i = None
+            for n in itertools.count():
                 try:
-                    if not i:
+                    if not n:
                         x = self._g.throw(cex)
                     else:
-                        x = self._g.send(None)
+                        x = self._g.send(i)
                 except StreamServiceCancelledError as cex2:
                     if cex2 is cex:
                         break
                     raise
-                yield x
+                i = yield x
         if self._cr.cr_running:
             raise RuntimeError(f'Coroutine {self._cr!r} not terminated')
         if self._g is not self._a:
@@ -155,9 +156,10 @@ class _StreamServiceResponse(StreamResponseIterator[V, OutputT]):
     @types.coroutine
     def _anext(self):
         check.state(self._state == 'running')
+        i = None
         while True:
             try:
-                x = self._g.send(None)
+                x = self._g.send(i)
             except StopIteration as e:
                 if e.value is not None:
                     self._outputs = tv.TypedValues(*check.isinstance(e.value, ta.Sequence))
@@ -170,7 +172,7 @@ class _StreamServiceResponse(StreamResponseIterator[V, OutputT]):
                 x.done = True
                 return x.value
 
-            yield x
+            i = yield x
 
     async def __anext__(self) -> V:
         return await self._anext()
@@ -195,13 +197,14 @@ async def new_stream_response(
         fn: ta.Callable[[StreamResponseSink[V]], ta.Awaitable[ta.Sequence[OutputT] | None]],
         outputs: ta.Sequence[StreamOutputT] | None = None,
 ) -> StreamResponse[V, OutputT, StreamOutputT]:
-    return StreamResponse(
-        rs.new_managed(
-            await rs.enter_async_context(
-                _StreamServiceResponse(
-                    fn,
-                ),
-            ),
-        ),
-        outputs or [],
-    )
+    ssr = _StreamServiceResponse(fn)
+
+    v = rs.new_managed(await rs.enter_async_context(ssr))
+    try:
+        return StreamResponse(v, outputs or [])
+    except BaseException:  # noqa
+        # The StreamResponse ctor can raise - for example in `_tv_field_coercer` - in which case we need to clean up the
+        # resources ref we have already allocated before reraising.
+        async with v:
+            pass
+        raise

ommlds/minichain/tools/reflect.py

@@ -15,10 +15,10 @@ import textwrap
 import types
 import typing as ta
 
-from omdev.py import docstrings
 from omlish import check
 from omlish import collections as col
 from omlish import dataclasses as dc
+from omlish import lang
 from omlish import metadata as md
 from omlish import reflect as rfl
 from omlish.lite.cached import cached_nullary
@@ -37,6 +37,10 @@ from .types import TupleToolDtype
 from .types import UnionToolDtype
 
 
+with lang.auto_proxy_import(globals()):
+    from omdev.py import docstrings
+
+
 ##
 
 

ommlds/nanochat/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Andrej Karpathy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ommlds/nanochat/rustbpe/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Andrej Karpathy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.