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

ommlds/minichain/tools/reflect.py

@@ -178,14 +178,14 @@ class ToolReflector:
         for o in md.get_object_metadata(fn, type=_ToolSpecOverride):
             ts_ovr.update({
                 k: v
-                for k, v in dc.asdict(o).items()
+                for k, v in dc.shallow_asdict(o).items()
                 if k != 'params'
                 and v is not None
             })
             for op in (o.params or []):
                 p_ovr_dct.setdefault(check.non_empty_str(op.name), {}).update({
                     k: v
-                    for k, v in dc.asdict(op).items()
+                    for k, v in dc.shallow_asdict(op).items()
                     if v is not None
                 })
 
@@ -286,7 +286,7 @@ class ToolReflector:
             if md_tp is not None:
                 tp_kw.update({
                     k: v
-                    for k, v in dc.asdict(md_tp).items()
+                    for k, v in dc.shallow_asdict(md_tp).items()
                     if v is not None
                 })
 

ommlds/minichain/wrappers/firstinwins.py

@@ -17,16 +17,24 @@ 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(frozen=True)
+@dc.dataclass()
 class FirstInWinsServiceCancelledError(Exception):
     e: BaseException
 
@@ -37,11 +45,14 @@ class FirstInWinsServiceExceptionGroup(ExceptionGroup):
 
 @dc.dataclass(frozen=True)
 class FirstInWinsServiceOutput(Output):
-    first_in_wins_service: 'FirstInWinsService'
+    first_in_wins_service: AnyFirstInWinsService
     response_service: Service
     service_exceptions: ta.Mapping[Service, Exception] | None = None
 
 
+##
+
+
 class FirstInWinsService(
     MultiWrapperService[
         WrappedRequestV,
@@ -57,6 +68,22 @@ class FirstInWinsService(
 ##
 
 
+class FirstInWinsStreamService(
+    WrapperStreamService[
+        WrappedRequestV,
+        WrappedOptionT,
+        WrappedResponseV,
+        WrappedOutputT,
+        WrappedStreamOutputT,
+    ],
+    lang.Abstract,
+):
+    pass
+
+
+##
+
+
 class AsyncioFirstInWinsService(
     FirstInWinsService[
         WrappedRequestV,

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

@@ -1,14 +1,25 @@
 """
 TODO:
  - tenacity shit
-  - exception filter
+  - 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
@@ -18,22 +29,35 @@ 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(frozen=True)
+@dc.dataclass()
 class RetryServiceMaxRetriesExceededError(Exception):
     pass
 
 
 @dc.dataclass(frozen=True)
 class RetryServiceOutput(Output):
-    retry_service: 'RetryService'
+    retry_service: AnyRetryService
     num_retries: int
 
 
+##
+
+
 class RetryService(
     WrapperService[
         WrappedRequestV,
@@ -76,3 +100,69 @@ class RetryService(
             ))
 
         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

@@ -10,6 +10,9 @@ from ..types import Option
 from ..types import Output
 
 
+P = ta.ParamSpec('P')
+
+
 WrappedRequestV = ta.TypeVar('WrappedRequestV')
 WrappedOptionT = ta.TypeVar('WrappedOptionT', bound=Option)
 
@@ -70,3 +73,26 @@ class MultiWrapperService(
         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-0.0.0.dev499.dist-info → ommlds-0.0.0.dev503.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommlds
-Version: 0.0.0.dev499
+Version: 0.0.0.dev503
 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.dev499
+Requires-Dist: omlish==0.0.0.dev503
 Provides-Extra: all
-Requires-Dist: omdev==0.0.0.dev499; extra == "all"
+Requires-Dist: omdev==0.0.0.dev503; 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"
@@ -32,13 +32,13 @@ Requires-Dist: regex>=2025.0; extra == "all"
 Requires-Dist: numpy>=1.26; extra == "all"
 Requires-Dist: pytesseract~=0.3; extra == "all"
 Requires-Dist: rapidocr-onnxruntime~=1.4; extra == "all"
-Requires-Dist: pillow~=12.0; extra == "all"
+Requires-Dist: pillow~=12.1; extra == "all"
 Requires-Dist: ddgs~=9.10; extra == "all"
 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.dev499; extra == "omdev"
+Requires-Dist: omdev==0.0.0.dev503; 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"
@@ -60,7 +60,7 @@ Provides-Extra: ocr
 Requires-Dist: pytesseract~=0.3; extra == "ocr"
 Requires-Dist: rapidocr-onnxruntime~=1.4; extra == "ocr"
 Provides-Extra: pillow
-Requires-Dist: pillow~=12.0; extra == "pillow"
+Requires-Dist: pillow~=12.1; extra == "pillow"
 Provides-Extra: search
 Requires-Dist: ddgs~=9.10; extra == "search"
 Provides-Extra: wiki