ommlds 0.0.0.dev466__py3-none-any.whl → 0.0.0.dev512__py3-none-any.whl

ommlds/minichain/wrappers/firstinwins.py

@@ -0,0 +1,144 @@
+"""
+TODO:
+ - stream lol
+  - take first open vs take first chunk
+"""
+import typing as ta
+
+from omlish import dataclasses as dc
+from omlish import lang
+
+from ..services.services import Service
+from ..types import Output
+from .services import MultiWrapperService
+from .services import WrappedOptionT
+from .services import WrappedOutputT
+from .services import WrappedRequest
+from .services import WrappedRequestV
+from .services import WrappedResponse
+from .services import WrappedResponseV
+from .stream import WrappedStreamOutputT
+from .stream import WrapperStreamService
+
+
+with lang.auto_proxy_import(globals()):
+    import asyncio
+
+
+AnyFirstInWinsService: ta.TypeAlias = ta.Union[
+    'FirstInWinsService',
+    'FirstInWinsStreamService',
+]
+
+
+##
+
+
+@dc.dataclass()
+class FirstInWinsServiceCancelledError(Exception):
+    e: BaseException
+
+
+class FirstInWinsServiceExceptionGroup(ExceptionGroup):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class FirstInWinsServiceOutput(Output):
+    first_in_wins_service: AnyFirstInWinsService
+    response_service: Service
+    service_exceptions: ta.Mapping[Service, Exception] | None = None
+
+
+##
+
+
+class FirstInWinsService(
+    MultiWrapperService[
+        WrappedRequestV,
+        WrappedOptionT,
+        WrappedResponseV,
+        WrappedOutputT,
+    ],
+    lang.Abstract,
+):
+    pass
+
+
+##
+
+
+class FirstInWinsStreamService(
+    WrapperStreamService[
+        WrappedRequestV,
+        WrappedOptionT,
+        WrappedResponseV,
+        WrappedOutputT,
+        WrappedStreamOutputT,
+    ],
+    lang.Abstract,
+):
+    pass
+
+
+##
+
+
+class AsyncioFirstInWinsService(
+    FirstInWinsService[
+        WrappedRequestV,
+        WrappedOptionT,
+        WrappedResponseV,
+        WrappedOutputT,
+    ],
+):
+    async def invoke(self, request: WrappedRequest) -> WrappedResponse:
+        tasks: list = []
+        services_by_task: dict = {}
+        for svc in self._services:
+            task: asyncio.Task = asyncio.create_task(svc.invoke(request))  # type: ignore[arg-type]
+            tasks.append(task)
+            services_by_task[task] = svc
+
+        failures_by_service: dict[Service, Exception] = {}
+
+        try:
+            pending = set(tasks)
+
+            while pending:
+                done, pending = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)
+
+                for t in done:
+                    svc = services_by_task[t]
+
+                    try:
+                        response = t.result()
+                    except asyncio.CancelledError as exc:
+                        failures_by_service[svc] = FirstInWinsServiceCancelledError(exc)
+                        continue
+                    except Exception as exc:  # noqa
+                        failures_by_service[svc] = exc
+                        continue
+
+                    for p in pending:
+                        p.cancel()
+
+                    await asyncio.gather(*pending, return_exceptions=True)
+
+                    return response.with_outputs(FirstInWinsServiceOutput(
+                        self,
+                        svc,
+                        failures_by_service,
+                    ))
+
+            raise FirstInWinsServiceExceptionGroup(
+                'All service calls failed',
+                list(failures_by_service.values()),
+            )
+
+        finally:
+            for t in tasks:
+                if not t.done():
+                    t.cancel()
+
+            await asyncio.gather(*tasks, return_exceptions=True)

ommlds/minichain/wrappers/instrument.py

@@ -0,0 +1,146 @@
+"""
+TODO:
+ - final stream outputs
+"""
+import datetime
+import typing as ta
+
+from omlish import dataclasses as dc
+from omlish import lang
+
+from ..services.requests import Request
+from ..services.responses import Response
+from .services import WrappedOptionT
+from .services import WrappedOutputT
+from .services import WrappedRequest
+from .services import WrappedRequestV
+from .services import WrappedResponse
+from .services import WrappedResponseV
+from .services import WrappedService
+from .services import WrapperService
+from .stream import WrappedStreamOutputT
+from .stream import WrappedStreamResponse
+from .stream import WrappedStreamService
+from .stream import WrapperStreamService
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@dc.extra_class_params(default_repr_fn=lang.opt_or_just_repr)
+class InstrumentedServiceEvent:
+    dt: datetime.datetime = dc.field(default_factory=lang.utcnow)
+
+    req: Request | None = None
+
+    resp: Response | None = None
+    exc: BaseException | None = None
+
+    stream_v: lang.Maybe[ta.Any] = lang.empty()
+
+
+class InstrumentedServiceEventSink(ta.Protocol):
+    def __call__(self, ev: InstrumentedServiceEvent) -> ta.Awaitable[None]: ...
+
+
+class ListInstrumentedServiceEventSink:
+    def __init__(self, lst: list[InstrumentedServiceEvent] | None = None) -> None:
+        super().__init__()
+
+        if lst is None:
+            lst = []
+        self._lst = lst
+
+    @property
+    def events(self) -> ta.Sequence[InstrumentedServiceEvent]:
+        return self._lst
+
+    async def __call__(self, ev: InstrumentedServiceEvent) -> None:
+        self._lst.append(ev)
+
+
+##
+
+
+class InstrumentedService(
+    WrapperService[
+        WrappedRequestV,
+        WrappedOptionT,
+        WrappedResponseV,
+        WrappedOutputT,
+    ],
+):
+    def __init__(
+            self,
+            service: WrappedService,
+            sink: InstrumentedServiceEventSink | None = None,
+    ) -> None:
+        super().__init__(service)
+
+        if sink is None:
+            sink = ListInstrumentedServiceEventSink()
+        self._sink = sink
+
+    async def invoke(self, request: WrappedRequest) -> WrappedResponse:
+        await self._sink(InstrumentedServiceEvent(req=request))
+
+        try:
+            resp = await self._service.invoke(request)
+
+        except Exception as e:  # noqa
+            await self._sink(InstrumentedServiceEvent(req=request, exc=e))
+
+            raise
+
+        await self._sink(InstrumentedServiceEvent(req=request, resp=resp))
+
+        return resp
+
+
+##
+
+
+class InstrumentedStreamService(
+    WrapperStreamService[
+        WrappedRequestV,
+        WrappedOptionT,
+        WrappedResponseV,
+        WrappedOutputT,
+        WrappedStreamOutputT,
+    ],
+):
+    def __init__(
+            self,
+            service: WrappedStreamService,
+            sink: InstrumentedServiceEventSink | None = None,
+    ) -> None:
+        super().__init__(service)
+
+        if sink is None:
+            sink = ListInstrumentedServiceEventSink()
+        self._sink = sink
+
+    async def invoke(self, request: WrappedRequest) -> WrappedStreamResponse:
+        await self._sink(InstrumentedServiceEvent(req=request))
+
+        try:
+            resp = await self._service.invoke(request)
+
+        except Exception as e:  # noqa
+            await self._sink(InstrumentedServiceEvent(req=request, exc=e))
+
+            raise
+
+        await self._sink(InstrumentedServiceEvent(req=request, resp=resp))
+
+        async def inner(sink):  # noqa
+            async with resp.v as st:
+                async for v in st:
+                    await self._sink(InstrumentedServiceEvent(req=request, resp=resp, stream_v=v))
+
+                    await sink(v)
+
+        # return resp.with_v(inner())
+
+        raise NotImplementedError

ommlds/minichain/wrappers/retry.py

@@ -0,0 +1,168 @@
+"""
+TODO:
+ - tenacity shit
+  - exception filter - retryable vs not
+   - explicit RetryableError wrapper?
+  - sleep
+   - jitter
+ - log, on retry / on except callbacks, blah blah
+ - stream retry:
+  - failed to open
+  - failed during stream
+   - buffer and replay??
+  - accept death mid-stream?
+  - ** probably **: cannot sanely impose any nontrivial stream retry strat at this layer -
+"""
+import typing as ta
+
+from omlish import dataclasses as dc
+
+from ..resources import Resources
+from ..stream.services import StreamResponseSink
+from ..stream.services import new_stream_response
+from ..types import Output
+from .services import WrappedOptionT
+from .services import WrappedOutputT
+from .services import WrappedRequest
+from .services import WrappedRequestV
+from .services import WrappedResponse
+from .services import WrappedResponseV
+from .services import WrappedService
+from .services import WrapperService
+from .stream import WrappedStreamOutputT
+from .stream import WrappedStreamResponse
+from .stream import WrappedStreamService
+from .stream import WrapperStreamService
+
+
+AnyRetryService: ta.TypeAlias = ta.Union[
+    'RetryService',
+    'RetryStreamService',
+]
+
+
+##
+
+
+@dc.dataclass()
+class RetryServiceMaxRetriesExceededError(Exception):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class RetryServiceOutput(Output):
+    retry_service: AnyRetryService
+    num_retries: int
+
+
+##
+
+
+class RetryService(
+    WrapperService[
+        WrappedRequestV,
+        WrappedOptionT,
+        WrappedResponseV,
+        WrappedOutputT,
+    ],
+):
+    DEFAULT_MAX_RETRIES: ta.ClassVar[int] = 3
+
+    def __init__(
+            self,
+            service: WrappedService,
+            *,
+            max_retries: int | None = None,
+    ) -> None:
+        super().__init__(service)
+
+        if max_retries is None:
+            max_retries = self.DEFAULT_MAX_RETRIES
+        self._max_retries = max_retries
+
+    async def invoke(self, request: WrappedRequest) -> WrappedResponse:
+        n = 0
+
+        while True:
+            try:
+                resp = await self._service.invoke(request)
+
+            except Exception as e:  # noqa
+                if n < self._max_retries:
+                    n += 1
+                    continue
+
+                raise RetryServiceMaxRetriesExceededError from e
+
+            return resp.with_outputs(RetryServiceOutput(
+                retry_service=self,
+                num_retries=n,
+            ))
+
+        raise RuntimeError  # unreachable
+
+
+##
+
+
+class RetryStreamService(
+    WrapperStreamService[
+        WrappedRequestV,
+        WrappedOptionT,
+        WrappedResponseV,
+        WrappedOutputT,
+        WrappedStreamOutputT,
+    ],
+):
+    DEFAULT_MAX_RETRIES: ta.ClassVar[int] = 3
+
+    def __init__(
+            self,
+            service: WrappedStreamService,
+            *,
+            max_retries: int | None = None,
+    ) -> None:
+        super().__init__(service)
+
+        if max_retries is None:
+            max_retries = self.DEFAULT_MAX_RETRIES
+        self._max_retries = max_retries
+
+    async def invoke(self, request: WrappedRequest) -> WrappedStreamResponse:
+        n = 0
+
+        while True:
+            try:
+                async with Resources.new() as rs:
+                    in_resp = await self._service.invoke(request)
+                    in_vs = await rs.enter_async_context(in_resp.v)
+
+                    async def inner(sink: StreamResponseSink[WrappedResponseV]) -> ta.Sequence[WrappedOutputT] | None:
+                        async for v in in_vs:
+                            await sink.emit(v)
+
+                        return in_vs.outputs
+
+                    outs = [
+                        *in_resp.outputs,
+                        RetryServiceOutput(
+                            retry_service=self,
+                            num_retries=n,
+                        ),
+                    ]
+
+                    # FIXME: ??
+                    # if (ur := tv.as_collection(request.options).get(UseResources)) is not None:
+
+                    return await new_stream_response(
+                        rs,
+                        inner,
+                        outs,
+                    )
+
+            except Exception as e:  # noqa
+                if n < self._max_retries:
+                    n += 1
+                    continue
+
+                raise RetryServiceMaxRetriesExceededError from e

ommlds/minichain/wrappers/services.py

@@ -0,0 +1,98 @@
+import typing as ta
+
+from omlish import check
+from omlish import lang
+
+from ..services.requests import Request
+from ..services.responses import Response
+from ..services.services import Service
+from ..types import Option
+from ..types import Output
+
+
+P = ta.ParamSpec('P')
+
+
+WrappedRequestV = ta.TypeVar('WrappedRequestV')
+WrappedOptionT = ta.TypeVar('WrappedOptionT', bound=Option)
+
+WrappedResponseV = ta.TypeVar('WrappedResponseV')
+WrappedOutputT = ta.TypeVar('WrappedOutputT', bound=Output)
+
+
+WrappedRequest: ta.TypeAlias = Request[
+    WrappedRequestV,
+    WrappedOptionT,
+]
+
+WrappedResponse: ta.TypeAlias = Response[
+    WrappedResponseV,
+    WrappedOutputT,
+]
+
+WrappedService: ta.TypeAlias = Service[
+    WrappedRequest,
+    WrappedResponse,
+]
+
+
+##
+
+
+class WrapperService(
+    lang.Abstract,
+    ta.Generic[
+        WrappedRequestV,
+        WrappedOptionT,
+        WrappedResponseV,
+        WrappedOutputT,
+    ],
+):
+    def __init__(
+            self,
+            service: WrappedService,
+    ) -> None:
+        super().__init__()
+
+        self._service = service
+
+
+class MultiWrapperService(
+    lang.Abstract,
+    ta.Generic[
+        WrappedRequestV,
+        WrappedOptionT,
+        WrappedResponseV,
+        WrappedOutputT,
+    ],
+):
+    def __init__(
+            self,
+            *services: WrappedService,
+    ) -> None:
+        super().__init__()
+
+        self._services = check.not_empty(services)
+
+
+##
+
+
+def wrap_service(
+        wrapped: WrappedService,
+        wrapper: ta.Callable[
+            ta.Concatenate[
+                WrappedService,
+                P,
+            ],
+            WrapperService[
+                WrappedRequestV,
+                WrappedOptionT,
+                WrappedResponseV,
+                WrappedOutputT,
+            ],
+        ],
+        *args: P.args,
+        **kwargs: P.kwargs,
+) -> WrappedService:
+    return ta.cast(ta.Any, wrapper(wrapped, *args, **kwargs))

ommlds/minichain/wrappers/stream.py

@@ -0,0 +1,57 @@
+import typing as ta
+
+from omlish import lang
+
+from ..services.requests import Request
+from ..services.services import Service
+from ..stream.services import StreamOptions
+from ..stream.services import StreamResponse
+from ..types import Output
+from .services import WrappedOptionT
+from .services import WrappedOutputT
+from .services import WrappedRequestV
+from .services import WrappedResponseV
+
+
+WrappedStreamOutputT = ta.TypeVar('WrappedStreamOutputT', bound=Output)
+
+
+WrappedStreamOptions: ta.TypeAlias = WrappedOptionT | StreamOptions
+
+WrappedStreamRequest: ta.TypeAlias = Request[
+    WrappedRequestV,
+    WrappedStreamOptions,
+]
+
+WrappedStreamResponse: ta.TypeAlias = StreamResponse[
+    WrappedResponseV,
+    WrappedOutputT,
+    WrappedStreamOutputT,
+]
+
+WrappedStreamService: ta.TypeAlias = Service[
+    WrappedStreamRequest,
+    WrappedStreamResponse,
+]
+
+
+##
+
+
+class WrapperStreamService(
+    lang.Abstract,
+    ta.Generic[
+        WrappedRequestV,
+        WrappedOptionT,
+        WrappedResponseV,
+        WrappedOutputT,
+        WrappedStreamOutputT,
+    ],
+):
+    def __init__(
+            self,
+            service: WrappedStreamService,
+    ) -> None:
+        super().__init__()
+
+        self._service = service

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.

ommlds/nanochat/rustbpe/README.md

@@ -0,0 +1,10 @@
+# https://github.com/karpathy/rustbpe/tree/ddf848f6961a0655dc8693742fc338e5682c0d3b
+# https://github.com/karpathy/nanochat/tree/9467d83cf23dcc9a9b4ca6e35103142f48a55b27
+
+---
+
+# rustbpe
+
+> The missing tiktoken training code
+
+A very lightweight Rust library for training a GPT tokenizer. The issue is that the inference library [tiktoken](https://github.com/openai/tiktoken) is great, but only does inference. Separately, the huggingface [tokenizers](https://github.com/huggingface/tokenizers) library does training, but it is rather bloated and really hard to navigate because it has to support all the different historical baggage of how people dealt with tokenizers over the years. More recently, I also wrote the [minbpe](https://github.com/karpathy/minbpe) library which does both training and inference, but only in inefficient Python. Basically what I really want is a non-fancy, super simple, but still relatively efficient training code for GPT tokenizer (more efficient than minbpe, much cleaner/simpler than tokenizers), and then export the trained vocab for inference with tiktoken. Does that make sense? So here we are. There are more opportunities for optimization here, I just stopped a bit early because unlike minbpe before it, rustbpe is now simple and fast enough, and not a significant bottleneck for nanochat.