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

ommlds/minichain/services/_marshal.py

@@ -1,3 +1,8 @@
+"""
+FIXME:
+ - everything lol
+ - can this just do what metadata does
+"""
 import typing as ta
 
 from omlish import check
@@ -22,10 +27,21 @@ def _is_rr_rty(rty: rfl.Type) -> bool:
     )
 
 
-def _get_tv_fld(rty: rfl.Type) -> dc.Field:
+class _RrFlds(ta.NamedTuple):
+    v: dc.Field
+    tv: dc.Field
+    md: dc.Field
+
+
+def _get_rr_flds(rty: rfl.Type) -> _RrFlds:
     flds = col.make_map_by(lambda f: f.name, dc.fields(check.not_none(rfl.get_concrete_type(rty))), strict=True)
-    flds.pop('v')
-    return check.single(flds.values())
+    v_fld = flds.pop('v')
+    md_fld = flds.pop('_metadata')
+    return _RrFlds(
+        v=v_fld,
+        tv=check.single(flds.values()),
+        md=md_fld,
+    )
 
 
 ##
@@ -34,7 +50,7 @@ def _get_tv_fld(rty: rfl.Type) -> dc.Field:
 @dc.dataclass(frozen=True)
 class _RequestResponseMarshaler(msh.Marshaler):
     rty: rfl.Type
-    tv_fld: dc.Field
+    rr_flds: _RrFlds
     v_m: msh.Marshaler | None
 
     def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
@@ -51,9 +67,14 @@ class _RequestResponseMarshaler(msh.Marshaler):
         else:
             v_v = self.v_m.marshal(ctx, o.v)
 
+        md_fmd = self.rr_flds.md.metadata[msh.FieldMetadata]
+        md_m = md_fmd.marshaler_factory.make_marshaler(ctx.marshal_factory_context, self.rr_flds.md.type)()  # FIXME
+        md_v = md_m.marshal(ctx, o._metadata)  # noqa
+
         return {
             'v': v_v,
-            **({lang.strip_prefix(self.tv_fld.name, '_'): tv_v} if tv_v else {}),
+            **({lang.strip_prefix(self.rr_flds.tv.name, '_'): tv_v} if tv_v else {}),
+            **({'metadata': md_v} if md_v else {}),
         }
 
 
@@ -76,7 +97,7 @@ class _RequestResponseMarshalerFactory(msh.MarshalerFactory):
                 v_m = ctx.make_marshaler(v_rty)
             return _RequestResponseMarshaler(
                 rty,
-                _get_tv_fld(rty),
+                _get_rr_flds(rty),
                 v_m,
             )
 
@@ -89,9 +110,10 @@ class _RequestResponseMarshalerFactory(msh.MarshalerFactory):
 @dc.dataclass(frozen=True)
 class _RequestResponseUnmarshaler(msh.Unmarshaler):
     rty: rfl.Type
-    tv_fld: dc.Field
+    rr_flds: _RrFlds
     v_u: msh.Unmarshaler
     tv_u: msh.Unmarshaler
+    md_u: msh.Unmarshaler
 
     def unmarshal(self, ctx: msh.UnmarshalContext, v: msh.Value) -> ta.Any:
         dct = dict(check.isinstance(v, ta.Mapping))
@@ -99,9 +121,14 @@ class _RequestResponseUnmarshaler(msh.Unmarshaler):
         v_v = dct.pop('v')
         v = self.v_u.unmarshal(ctx, v_v)
 
+        if md_v := dct.pop('metadata', None):
+            md = self.md_u.unmarshal(ctx, md_v)
+        else:
+            md = []
+
         tvs: ta.Any
         if dct:
-            tv_vs = dct.pop(lang.strip_prefix(self.tv_fld.name, '_'))
+            tv_vs = dct.pop(lang.strip_prefix(self.rr_flds.tv.name, '_'))
             tvs = self.tv_u.unmarshal(ctx, tv_vs)
         else:
             tvs = []
@@ -109,7 +136,7 @@ class _RequestResponseUnmarshaler(msh.Unmarshaler):
         check.empty(dct)
 
         cty = rfl.get_concrete_type(self.rty)
-        return cty(v, tvs)  # type: ignore
+        return cty(v, tvs, _metadata=md)  # type: ignore
 
 
 class _RequestResponseUnmarshalerFactory(msh.UnmarshalerFactory):
@@ -123,15 +150,24 @@ class _RequestResponseUnmarshalerFactory(msh.UnmarshalerFactory):
             else:
                 # FIXME: ...
                 raise TypeError(rty)
+
+            rr_flds = _get_rr_flds(rty)
+
             tv_types_set = check.isinstance(tv_rty, rfl.Union).args
             tv_ta = tv.TypedValues[ta.Union[*tv_types_set]]  # type: ignore
             tv_u = ctx.make_unmarshaler(tv_ta)
+
             v_u = ctx.make_unmarshaler(v_rty)
+
+            md_fmd = rr_flds.md.metadata[msh.FieldMetadata]
+            md_u = md_fmd.unmarshaler_factory.make_unmarshaler(ctx, rr_flds.md.type)()  # FIXME
+
             return _RequestResponseUnmarshaler(
                 rty,
-                _get_tv_fld(rty),
+                _get_rr_flds(rty),
                 v_u,
                 tv_u,
+                md_u,
             )
 
         return inner

ommlds/minichain/services/_origclasses.py

@@ -43,3 +43,14 @@ class _OrigClassCapture:
         """Enforces that __orig_class__ has only been set once."""
 
         return check.single(object.__getattribute__(self, '__captured_orig_classes__'))
+
+
+def confer_orig_class(src, dst):
+    if src is not dst:
+        try:
+            oc = src.__orig_class__
+        except AttributeError:
+            pass
+        else:
+            dst.__orig_class__ = oc
+    return dst

ommlds/minichain/services/_typedvalues.py

@@ -45,14 +45,19 @@ class _TypedValues(
     lang.Abstract,
     ta.Generic[TypedValueT],
 ):
-    __typed_values_class__: ta.ClassVar[type[tv.TypedValue]]
+    """
+    The reason this is so complicated compared to any other TypedValues field (like metadata) is that the real set of
+    TypedValue types it accepts is known only via __orig_class__.
+    """
+
+    __typed_values_base__: ta.ClassVar[type[tv.TypedValue]]
 
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
 
         tvt = _get_typed_values_type_arg(cls)
         tvct = rfl.get_concrete_type(tvt, use_type_var_bound=True)
-        cls.__typed_values_class__ = check.issubclass(check.isinstance(tvct, type), tv.TypedValue)
+        cls.__typed_values_base__ = check.issubclass(check.isinstance(tvct, type), tv.TypedValue)
 
     #
 
@@ -77,7 +82,7 @@ class _TypedValues(
 
         tv_types_set = frozenset(tv.reflect_typed_values_impls(tvt))
         tv_types = tuple(sorted(
-            [check.issubclass(c, self.__typed_values_class__) for c in tv_types_set],
+            [check.issubclass(c, self.__typed_values_base__) for c in tv_types_set],
             key=lambda c: c.__qualname__,
         ))
 

ommlds/minichain/services/requests.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 Option
 from ..types import OptionT_co
+from ._origclasses import confer_orig_class
 from ._typedvalues import _TypedValues
 
 
@@ -19,6 +23,17 @@ OptionU = ta.TypeVar('OptionU', bound=Option)
 ##
 
 
+class RequestMetadata(Metadata, lang.Abstract):
+    pass
+
+
+RequestMetadatas: ta.TypeAlias = RequestMetadata | CommonMetadata
+
+
+##
+
+
+@ta.final
 @dc.dataclass(frozen=True)
 @dc.extra_class_params(
     allow_dynamic_dunder_attrs=True,
@@ -26,11 +41,32 @@ OptionU = ta.TypeVar('OptionU', bound=Option)
 )
 class Request(  # type: ignore[type-var]  # FIXME: _TypedValues param is invariant
     _TypedValues[OptionT_co],
+    MetadataContainerDataclass[RequestMetadatas],
     lang.Final,
     ta.Generic[V_co, OptionT_co],
 ):
+    """
+    Universal service request, comprised of:
+     - a value of type `V_co`
+     - a sequence of options of type `OptionT_co`
+     - metadata of type `RequestMetadatas`
+
+    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))
+
+    #
+
     _options: ta.Sequence[OptionT_co] = dc.field(
         default=(),
         metadata=_tv_field_metadata(
@@ -43,13 +79,47 @@ class Request(  # type: ignore[type-var]  # FIXME: _TypedValues param is invaria
     def options(self) -> tv.TypedValues[OptionT_co]:
         return check.isinstance(self._options, tv.TypedValues)
 
-    def with_options(self, *options: OptionU, override: bool = False) -> 'Request[V_co, OptionT_co | OptionU]':
-        return dc.replace(self, _options=self.options.update(*options, override=override))
-
     @property
     def _typed_values(self) -> tv.TypedValues[OptionT_co]:
         return check.isinstance(self._options, tv.TypedValues)
 
+    def with_options(
+            self,
+            *add: OptionU,
+            discard: ta.Iterable[type] | None = None,
+            override: bool = False,
+    ) -> 'Request[V_co, OptionT_co | OptionU]':
+        new = (old := self.options).update(
+            *add,
+            discard=discard,
+            override=override,
+        )
+
+        if new is old:
+            return self
+
+        return confer_orig_class(self, dc.replace(self, _options=new))
+
+    #
+
+    _metadata: ta.Sequence[RequestMetadatas] = dc.field(
+        default=(),
+        kw_only=True,
+        repr=False,
+    )
+
+    MetadataContainerDataclass._configure_metadata_field(_metadata, RequestMetadatas)  # noqa
+
+    def with_metadata(
+            self,
+            *add: RequestMetadatas,
+            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/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/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,8 +133,10 @@ 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()
+
             i = None
             for n in itertools.count():
                 try:
@@ -132,13 +144,18 @@ class _StreamServiceResponse(StreamResponseIterator[V, OutputT]):
                         x = self._g.throw(cex)
                     else:
                         x = self._g.send(i)
+
                 except StreamServiceCancelledError as cex2:
                     if cex2 is cex:
                         break
+
                     raise
+
                 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()
@@ -156,15 +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(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:
@@ -200,11 +220,14 @@ async def new_stream_response(
     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

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.apply(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