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

ommlds/minichain/services/responses.py

@@ -6,8 +6,12 @@ from omlish import lang
 from omlish import typedvalues as tv
 
 from .._typedvalues import _tv_field_metadata
+from ..metadata import CommonMetadata
+from ..metadata import Metadata
+from ..metadata import MetadataContainerDataclass
 from ..types import Output
 from ..types import OutputT_contra
+from ._origclasses import confer_orig_class
 from ._typedvalues import _TypedValues
 
 
@@ -17,6 +21,17 @@ V_co = ta.TypeVar('V_co', covariant=True)
 ##
 
 
+class ResponseMetadata(Metadata, lang.Abstract):
+    pass
+
+
+ResponseMetadatas: ta.TypeAlias = ResponseMetadata | CommonMetadata
+
+
+##
+
+
+@ta.final
 @dc.dataclass(frozen=True)
 @dc.extra_class_params(
     allow_dynamic_dunder_attrs=True,
@@ -24,11 +39,32 @@ V_co = ta.TypeVar('V_co', covariant=True)
 )
 class Response(  # type: ignore[type-var]  # FIXME: _TypedValues param is invariant
     _TypedValues[OutputT_contra],
+    MetadataContainerDataclass[ResponseMetadatas],
     lang.Final,
     ta.Generic[V_co, OutputT_contra],
 ):
+    """
+    Universal service response, comprised of:
+     - a value of type `V_co`
+     - a sequence of outputs of type `OutputT_contra`
+     - metadata of type `ResponseMetadatas`
+
+    Refer to the package README.md for an explanation of its type var variance.
+
+    This class is final, but each instance's `__orig_class__` (if present) is significant. It is encouraged to construct
+    these through a pre-parameterized type alias, and the provided `with_` methods should be used rather than
+    `dc.replace` (as they will propagate `__orig_class__`).
+    """
+
+    #
+
     v: V_co  # type: ignore[misc]  # FIXME: Cannot use a covariant type variable as a parameter
 
+    def with_v(self, v: V_co) -> ta.Self:  # type: ignore[misc]
+        return confer_orig_class(self, dc.replace(self, v=v))
+
+    #
+
     _outputs: ta.Sequence[OutputT_contra] = dc.field(
         default=(),
         metadata=_tv_field_metadata(
@@ -41,13 +77,47 @@ class Response(  # type: ignore[type-var]  # FIXME: _TypedValues param is invari
     def outputs(self) -> tv.TypedValues[OutputT_contra]:
         return check.isinstance(self._outputs, tv.TypedValues)
 
-    def with_outputs(self, *outputs: OutputT_contra, override: bool = False) -> ta.Self:
-        return dc.replace(self, _outputs=self.outputs.update(*outputs, override=override))
-
     @property
     def _typed_values(self) -> tv.TypedValues[OutputT_contra]:
         return check.isinstance(self._outputs, tv.TypedValues)
 
+    def with_outputs(
+            self,
+            *add: OutputT_contra,
+            discard: ta.Iterable[type] | None = None,
+            override: bool = False,
+    ) -> ta.Self:
+        new = (old := self.outputs).update(
+            *add,
+            discard=discard,
+            override=override,
+        )
+
+        if new is old:
+            return self
+
+        return confer_orig_class(self, dc.replace(self, _outputs=new))
+
+    #
+
+    _metadata: ta.Sequence[ResponseMetadatas] = dc.field(
+        default=(),
+        kw_only=True,
+        repr=False,
+    )
+
+    MetadataContainerDataclass._configure_metadata_field(_metadata, ResponseMetadatas)  # noqa
+
+    def with_metadata(
+            self,
+            *add: ResponseMetadatas,
+            discard: ta.Iterable[type] | None = None,
+            override: bool = False,
+    ) -> ta.Self:
+        return confer_orig_class(self, super().with_metadata(*add, discard=discard, override=override))
+
+    #
+
     def validate(self) -> ta.Self:
         self._check_typed_values()
         return self

ommlds/minichain/services/services.py

@@ -11,4 +11,13 @@ from .responses import ResponseT_co
 
 @ta.runtime_checkable
 class Service(lang.ProtocolForbiddenAsBaseClass, ta.Protocol[RequestT_contra, ResponseT_co]):
+    """
+    Universal service protocol, comprised of a single method `invoke`, accepting a request of type `RequestT_contra` and
+    returning a response of type `ResponseT_co`.
+
+    Refer to the package README.md for an explanation of its type var variance.
+
+    This class is final, but each instance's `__orig_class__` (if present) is significant.
+    """
+
     def invoke(self, request: RequestT_contra) -> ta.Awaitable[ResponseT_co]: ...

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

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - new_stream_response carry TypeAlias __orig_type__ somehow
+"""
 import abc
 import itertools
 import types
@@ -104,17 +108,23 @@ class _StreamServiceResponse(StreamResponseIterator[V, OutputT]):
             return _StreamServiceResponse._Emit(self._ssr, item)
 
     _state: ta.Literal['new', 'running', 'closed'] = 'new'
+
     _sink: _Sink[V]
-    _a: ta.Any
+
     _cr: ta.Any
+    _a: ta.Any
+    _g: ta.Any
 
     async def __aenter__(self) -> ta.Self:
         check.state(self._state == 'new')
         self._state = 'running'
+
         self._sink = _StreamServiceResponse._Sink(self)
+
         self._cr = self._fn(self._sink)
         self._a = self._cr.__await__()
         self._g = iter(self._a)
+
         return self
 
     @types.coroutine
@@ -123,21 +133,29 @@ class _StreamServiceResponse(StreamResponseIterator[V, OutputT]):
         self._state = 'closed'
         if old_state != 'running':
             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:
             self._g.close()
         self._a.close()
@@ -155,14 +173,18 @@ 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))
                 else:
                     self._outputs = tv.TypedValues()
+
                 raise StopAsyncIteration from None
 
             if isinstance(x, _StreamServiceResponse._Emit) and x.ssr is self:
@@ -170,7 +192,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 +217,17 @@ 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/text/applypatch.py

@@ -20,11 +20,12 @@
 A self-contained **pure-Python 3.9+** utility for applying human-readable "pseudo-diff" patch files to a collection of
 text files.
 """
-import dataclasses as dc
 import enum
 import pathlib
 import typing as ta
 
+from omlish import dataclasses as dc
+
 
 ##
 # Domain objects

ommlds/minichain/text/toolparsing/llamacpp/types.py

@@ -1,4 +1,4 @@
-import dataclasses as dc
+from omlish import dataclasses as dc
 
 
 ##

ommlds/minichain/tokens/specials.py

@@ -1,7 +1,7 @@
-import dataclasses as dc
 import typing as ta
 
 from omlish import check
+from omlish import dataclasses as dc
 from omlish import lang
 
 from .types import NonSpecialToken

ommlds/minichain/tools/execution/catalog.py

@@ -4,7 +4,7 @@ from omlish import check
 from omlish import dataclasses as dc
 from omlish import lang
 
-from ...content.types import Content
+from ...content.content import Content
 from ..fns import ToolFn
 from ..types import ToolSpec
 from .context import ToolContext
@@ -22,7 +22,7 @@ class ToolCatalogEntry(lang.Final):
 
     _: dc.KW_ONLY
 
-    name_override: str | None = dc.xfield(default=None, repr_fn=dc.opt_repr)
+    name_override: str | None = dc.xfield(default=None, repr_fn=lang.opt_repr)
 
     @property
     def name(self) -> str:

ommlds/minichain/tools/execution/errorhandling.py

@@ -0,0 +1,36 @@
+import typing as ta
+
+from ...content.content import Content
+from ...content.transform.materialize import ContentMaterializer
+from ...content.transform.materialize import DefaultContentMaterializer
+from .context import ToolContext
+from .errors import ToolExecutionError
+from .executors import ToolExecutor
+
+
+##
+
+
+class ErrorHandlingToolExecutor(ToolExecutor):
+    def __init__(
+            self,
+            *,
+            wrapped: ToolExecutor,
+            content_materializer: ContentMaterializer = DefaultContentMaterializer(),
+    ) -> None:
+        super().__init__()
+
+        self._wrapped = wrapped
+        self._content_materializer = content_materializer
+
+    async def execute_tool(
+            self,
+            ctx: ToolContext,
+            name: str,
+            args: ta.Mapping[str, ta.Any],
+    ) -> Content:
+        try:
+            return await self._wrapped.execute_tool(ctx, name, args)
+
+        except ToolExecutionError as txe:
+            return self._content_materializer.materialize(txe.content)

ommlds/minichain/tools/execution/errors.py

@@ -2,7 +2,7 @@ import abc
 
 from omlish import lang
 
-from ...content.materialize import CanContent
+from ...content.content import Content
 
 
 ##
@@ -11,5 +11,5 @@ from ...content.materialize import CanContent
 class ToolExecutionError(Exception, lang.Abstract):
     @property
     @abc.abstractmethod
-    def content(self) -> CanContent:
+    def content(self) -> Content:
         raise NotImplementedError

ommlds/minichain/tools/execution/executors.py

@@ -8,7 +8,7 @@ import typing as ta
 from omlish import dataclasses as dc
 from omlish import lang
 
-from ...content.types import Content
+from ...content.content import Content
 from ..fns import ToolFn
 from ..fns import execute_tool_fn
 from .context import ToolContext

ommlds/minichain/tools/fns.py

@@ -10,8 +10,8 @@ from omlish import lang
 from omlish import marshal as msh
 from omlish import reflect as rfl
 
+from ..content.content import Content
 from ..content.json import JsonContent
-from ..content.types import Content
 
 
 D = ta.TypeVar('D')

ommlds/minichain/tools/jsonschema.py

@@ -4,8 +4,8 @@ TODO:
 """
 from omlish import check
 
-from ..content.prepare import ContentStrPreparer
-from ..content.prepare import default_content_str_preparer
+from ..content.transform.prepare import ContentStrPreparer
+from ..content.transform.prepare import default_content_str_preparer
 from .types import EnumToolDtype
 from .types import MappingToolDtype
 from .types import NullableToolDtype

ommlds/minichain/tools/reflect.py

@@ -15,15 +15,15 @@ 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
 
-from ..content.materialize import CanContent
+from ..content.content import Content
 from .types import EnumToolDtype
 from .types import MappingToolDtype
 from .types import NullableToolDtype
@@ -37,6 +37,10 @@ from .types import TupleToolDtype
 from .types import UnionToolDtype
 
 
+with lang.auto_proxy_import(globals()):
+    from omdev.py import docstrings
+
+
 ##
 
 
@@ -155,7 +159,7 @@ class ToolReflector:
 
     #
 
-    def _prepare_desc(self, s: CanContent) -> CanContent:
+    def _prepare_desc(self, s: Content | None) -> Content | None:
         if s is None:
             return None
         if not self._raw_descs and isinstance(s, str):
@@ -174,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
                 })
 
@@ -236,7 +240,7 @@ class ToolReflector:
                 ds_p = ds_p_dct.get(pn)
                 sig_p = sig_p_dct.get(pn)
 
-                p_desc: CanContent
+                p_desc: Content | None
                 if (p_desc := ovr_p.get('desc')) is None:
                     if ds_p is not None:
                         p_desc = ds_p.description
@@ -282,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/tools/types.py

@@ -6,14 +6,11 @@ from omlish import cached
 from omlish import check
 from omlish import collections as col
 from omlish import dataclasses as dc
-from omlish import dispatch
 from omlish import lang
 from omlish import marshal as msh
 from omlish import reflect as rfl
 
-from ..content.materialize import CanContent
-from ..content.transforms.base import ContentTransform
-from ..content.types import Content
+from ..content.content import Content
 
 
 msh.register_global_module_import('._marshal', __package__)
@@ -143,14 +140,14 @@ class ObjectToolDtype(ToolDtype):
 
 
 @dc.dataclass(frozen=True)
-@msh.update_fields_metadata(['name', 'desc', 'type'], omit_if=lang.is_none)
-@msh.update_fields_metadata(['required'], omit_if=operator.not_)
+@msh.update_fields_options(['name', 'desc', 'type'], omit_if=lang.is_none)
+@msh.update_fields_options(['required'], omit_if=operator.not_)
 class ToolParam:
     name: str | None = None
 
     _: dc.KW_ONLY
 
-    desc: CanContent = None
+    desc: Content | None = None
 
     type: ToolDtype | None = None
 
@@ -161,19 +158,19 @@ class ToolParam:
 
 
 @dc.dataclass(frozen=True)
-@msh.update_fields_metadata(['name', 'desc', 'params', 'returns_desc', 'returns_type'], omit_if=lang.is_none)
-@msh.update_fields_metadata(['allow_additional_params'], omit_if=operator.not_)
+@msh.update_fields_options(['name', 'desc', 'params', 'returns_desc', 'returns_type'], omit_if=lang.is_none)
+@msh.update_fields_options(['allow_additional_params'], omit_if=operator.not_)
 class ToolSpec:
     name: str | None = None
 
     _: dc.KW_ONLY
 
-    desc: CanContent = None
+    desc: Content | None = None
 
     params: ta.Sequence[ToolParam] | None = None
     allow_additional_params: bool | None = None
 
-    returns_desc: CanContent = None
+    returns_desc: Content | None = None
     returns_type: ToolDtype | None = None
 
     @cached.property
@@ -207,11 +204,11 @@ class ToolUseResult(lang.Final):
 ##
 
 
-class _ToolUseContentTransform(ContentTransform, lang.Final, lang.NotInstantiable):
-    @dispatch.install_method(ContentTransform.apply)
-    def apply_tool_use(self, tu: ToolUse) -> ToolUse:
-        return tu  # TODO: args are Content
-
-    @dispatch.install_method(ContentTransform.apply)
-    def apply_tool_use_result(self, tur: ToolUseResult) -> ToolUseResult:
-        return dc.replace(tur, c=self.apply(tur.c))  # noqa
+# class _ToolUseContentTransform(ContentTransform, lang.Final, lang.NotInstantiable):
+#     @dispatch.install_method(ContentTransform.apply)
+#     def apply_tool_use(self, tu: ToolUse) -> ToolUse:
+#         return tu  # TODO: args are Content
+#
+#     @dispatch.install_method(ContentTransform.apply)
+#     def apply_tool_use_result(self, tur: ToolUseResult) -> ToolUseResult:
+#         return dc.replace(tur, c=self.apply(tur.c))  # noqa

ommlds/minichain/vectors/_marshal.py

@@ -2,10 +2,10 @@
 TODO:
  - serialize as base64 bytes? at least support deserializing as it
 """
-import dataclasses as dc
 import typing as ta
 
 from omlish import check
+from omlish import dataclasses as dc
 from omlish import lang
 from omlish import marshal as msh
 from omlish import reflect as rfl

ommlds/minichain/vectors/embeddings.py

@@ -2,7 +2,7 @@ import typing as ta
 
 from omlish import lang
 
-from ..content.types import Content
+from ..content.content import Content
 from ..registries.globals import register_type
 from ..services import Request
 from ..services import Response

ommlds/minichain/wrappers/__init__.py

@@ -0,0 +1,7 @@
+"""
+TODO:
+ - ratelimit
+ - option - output injection / removal
+ - 'switch'
+ - ** reflection passthrough **
+"""