ommlds 0.0.0.dev332__py3-none-any.whl → 0.0.0.dev334__py3-none-any.whl

ommlds/minichain/_typedvalues.py

@@ -0,0 +1,93 @@
+import operator
+import typing as ta
+
+from omlish import check
+from omlish import dataclasses as dc
+from omlish import marshal as msh
+from omlish import reflect as rfl
+from omlish import typedvalues as tv
+from omlish.funcs import match as mfs
+from omlish.typedvalues.marshal import build_typed_values_marshaler
+from omlish.typedvalues.marshal import build_typed_values_unmarshaler
+
+
+##
+
+
+@dc.dataclass()
+class _TypedValuesFieldMarshalerFactory(msh.MarshalerFactoryMatchClass):
+    tvs_rty: rfl.Type
+
+    @mfs.simple(lambda _, ctx, rty: True)
+    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
+        return build_typed_values_marshaler(ctx, self.tvs_rty)
+
+
+@dc.dataclass()
+class _TypedValuesFieldUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
+    tvs_rty: rfl.Type
+
+    @mfs.simple(lambda _, ctx, rty: True)
+    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
+        return build_typed_values_unmarshaler(ctx, self.tvs_rty)
+
+
+##
+
+
+def _tv_field_coercer(
+        tvc: type[tv.TypedValue] | tuple[type[tv.TypedValue], ...],
+) -> ta.Callable[[ta.Sequence], tv.TypedValues]:
+    if isinstance(tvc, tuple):
+        check.arg(all(issubclass(e, tv.TypedValue) for e in tvc))
+    else:
+        check.issubclass(tvc, tv.TypedValue)
+
+    def inner(seq):
+        return tv.TypedValues(*[
+            check.isinstance(e, tvc)
+            for e in check.isinstance(seq, ta.Sequence)
+        ])
+
+    return inner
+
+
+def _tv_field_repr(tvs: tv.TypedValues) -> str | None:
+    if not tvs:
+        return None
+
+    return repr(list(tvs))
+
+
+def _tv_field_metadata(
+        tvc: ta.Any,
+        *,
+        marshal_name: str | None = None,
+) -> ta.Mapping:
+    tvc_rty = rfl.type_(tvc)
+
+    ct: ta.Any
+    if isinstance(tvc_rty, type):
+        ct = check.issubclass(tvc, tv.TypedValue)
+    elif isinstance(tvc_rty, rfl.Union):
+        ct = tuple(check.issubclass(check.not_none(rfl.get_concrete_type(a)), tv.TypedValue) for a in tvc_rty.args)
+    else:
+        raise TypeError(tvc_rty)
+
+    tvs_rty = rfl.type_(tv.TypedValues[tvc])
+
+    return {
+        **dc.extra_field_params(
+            coerce=_tv_field_coercer(ct),
+            repr_fn=_tv_field_repr,
+        ),
+
+        msh.FieldMetadata: msh.FieldMetadata(
+            name=marshal_name,
+            options=msh.FieldOptions(
+                omit_if=operator.not_,
+            ),
+            marshaler_factory=_TypedValuesFieldMarshalerFactory(tvs_rty),
+            unmarshaler_factory=_TypedValuesFieldUnmarshalerFactory(tvs_rty),
+        ),
+    }

ommlds/minichain/backends/tinygrad/chat.py

@@ -36,7 +36,7 @@ class TinygradLlama3ChatService(ChatService, lang.ExitStacked):
     def _load_model(self) -> tgl3.Llama3Llm:
         check.not_none(self._exit_stack)
 
-        from ....backends.tinygrad.models.llama3.repl import fetch_model
+        from ....backends.tinygrad.models.llama3.fetch import fetch_model
         model = fetch_model(self._size)
 
         llm = tgl3.Llama3Llm(

ommlds/minichain/backends/transformers/sentence.py

@@ -4,7 +4,7 @@ import sentence_transformers as stfm
 
 from ...configs import Config
 from ...configs import consume_configs
-from ...content.images import Image
+from ...content.images import ImageContent
 from ...standard import ModelPath
 from ...vectors.embeddings import EmbeddingRequest
 from ...vectors.embeddings import EmbeddingResponse
@@ -40,7 +40,7 @@ class SentenceTransformersEmbeddingService(EmbeddingService):
         v = request.v
         if isinstance(v, str):
             obj = v
-        elif isinstance(v, Image):
+        elif isinstance(v, ImageContent):
             obj = v.i
         else:
             raise TypeError(v)

ommlds/minichain/chat/messages.py

@@ -1,19 +1,48 @@
+import operator
 import typing as ta
 
+from omlish import check
 from omlish import dataclasses as dc
 from omlish import dispatch
 from omlish import lang
+from omlish import marshal as msh
+from omlish import typedvalues as tv
 
+from .._typedvalues import _tv_field_metadata
 from ..content.content import Content
 from ..content.transforms import ContentTransform
+from ..metadata import MetadataContainer
 from ..tools.types import ToolExecRequest
+from .metadata import MessageMetadatas
 
 
 ##
 
 
-class Message(lang.Abstract, lang.Sealed):
-    pass
+@dc.dataclass(frozen=True)
+class Message(  # noqa
+    MetadataContainer[MessageMetadatas],
+    lang.Abstract,
+    lang.Sealed,
+):
+    _metadata: ta.Sequence[MessageMetadatas] = dc.field(
+        default=(),
+        kw_only=True,
+        metadata=_tv_field_metadata(
+            MessageMetadatas,
+            marshal_name='metadata',
+        ),
+    )
+
+    @property
+    def metadata(self) -> tv.TypedValues[MessageMetadatas]:
+        return check.isinstance(self._metadata, tv.TypedValues)
+
+    def with_metadata(self, *mds: MessageMetadatas, override: bool = False) -> ta.Self:
+        return dc.replace(self, _metadata=tv.TypedValues(*self._metadata, *mds, override=override))
+
+
+#
 
 
 @dc.dataclass(frozen=True)
@@ -21,18 +50,31 @@ class SystemMessage(Message, lang.Final):
     s: str
 
 
+#
+
+
 @dc.dataclass(frozen=True)
+@msh.update_fields_metadata(['name'], omit_if=operator.not_)
 class UserMessage(Message, lang.Final):
     c: Content
+
     name: str | None = dc.xfield(None, repr_fn=dc.opt_repr)
 
 
+#
+
+
 @dc.dataclass(frozen=True)
+@msh.update_fields_metadata(['tool_exec_requests'], omit_if=operator.not_)
 class AiMessage(Message, lang.Final):
     s: str | None = dc.xfield(None, repr_fn=dc.opt_repr)
+
     tool_exec_requests: ta.Sequence['ToolExecRequest'] | None = dc.xfield(None, repr_fn=dc.opt_repr)
 
 
+#
+
+
 @dc.dataclass(frozen=True)
 class ToolExecResultMessage(Message, lang.Final):
     id: str

ommlds/minichain/chat/metadata.py

@@ -0,0 +1,16 @@
+import typing as ta
+
+from omlish import lang
+
+from ..metadata import CommonMetadata
+from ..metadata import Metadata
+
+
+##
+
+
+class MessageMetadata(Metadata, lang.Abstract):
+    pass
+
+
+MessageMetadatas: ta.TypeAlias = MessageMetadata | CommonMetadata

ommlds/minichain/content/{marshal.py → _marshal.py}

@@ -10,7 +10,9 @@ from omlish.funcs import match as mfs
 from .content import Content
 from .content import ExtendedContent
 from .content import SingleContent
-from .images import Image
+from .images import ImageContent  # noqa
+from .list import ListContent  # noqa
+from .text import TextContent  # noqa
 
 
 ##
@@ -75,12 +77,12 @@ class _ContentUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
 ##
 
 
-class _ImageMarshaler(msh.Marshaler):
+class _ImageContentMarshaler(msh.Marshaler):
     def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
         raise NotImplementedError
 
 
-class _ImageUnmarshaler(msh.Unmarshaler):
+class _ImageContentUnmarshaler(msh.Unmarshaler):
     def unmarshal(self, ctx: msh.UnmarshalContext, v: msh.Value) -> ta.Any:
         raise NotImplementedError
 
@@ -90,15 +92,24 @@ class _ImageUnmarshaler(msh.Unmarshaler):
 
 @lang.static_init
 def _install_standard_marshalling() -> None:
-    extended_content_poly = msh.polymorphism_from_subclasses(ExtendedContent, naming=msh.Naming.SNAKE)
+    extended_content_poly = msh.Polymorphism(
+        ExtendedContent,
+        [
+            msh.Impl(ImageContent, 'image'),
+            msh.Impl(ListContent, 'list'),
+            msh.Impl(TextContent, 'text'),
+        ],
+    )
+
     msh.install_standard_factories(
         msh.PolymorphismMarshalerFactory(extended_content_poly),
-        msh.TypeMapMarshalerFactory({Image: _ImageMarshaler()}),
+        msh.TypeMapMarshalerFactory({ImageContent: _ImageContentMarshaler()}),
         _ContentMarshalerFactory(),
     )
+
     msh.install_standard_factories(
         msh.PolymorphismUnmarshalerFactory(extended_content_poly),
-        msh.TypeMapUnmarshalerFactory({Image: _ImageUnmarshaler()}),
+        msh.TypeMapUnmarshalerFactory({ImageContent: _ImageContentUnmarshaler()}),
         _ContentUnmarshalerFactory(),
     )
 

ommlds/minichain/content/content.py

@@ -1,9 +1,3 @@
-"""
-TODO:
- - metadata?
-  - ContentDetail, TypedValues as RequestOption
- - ListOfContent? what to name
-"""
 import typing as ta
 
 from omlish import lang

ommlds/minichain/content/images.py

@@ -8,7 +8,7 @@ import typing as ta
 from omlish import dataclasses as dc
 from omlish import lang
 
-from .content import ExtendedContent
+from .simple import SimpleExtendedContent
 
 
 if ta.TYPE_CHECKING:
@@ -21,5 +21,5 @@ else:
 
 
 @dc.dataclass(frozen=True)
-class Image(ExtendedContent, lang.Final):
+class ImageContent(SimpleExtendedContent, lang.Final):
     i: 'pimg.Image' = dc.field()

ommlds/minichain/content/list.py

@@ -0,0 +1,15 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .content import Content
+from .simple import SimpleExtendedContent
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ListContent(SimpleExtendedContent, lang.Final):
+    l: ta.Sequence[Content]

ommlds/minichain/content/metadata.py

@@ -0,0 +1,16 @@
+import typing as ta
+
+from omlish import lang
+
+from ..metadata import CommonMetadata
+from ..metadata import Metadata
+
+
+##
+
+
+class ContentMetadata(Metadata, lang.Abstract):
+    pass
+
+
+ContentMetadatas: ta.TypeAlias = ContentMetadata | CommonMetadata

ommlds/minichain/content/simple.py

@@ -0,0 +1,38 @@
+import typing as ta
+
+from omlish import check
+from omlish import dataclasses as dc
+from omlish import lang
+from omlish import typedvalues as tv
+
+from .._typedvalues import _tv_field_metadata
+from ..metadata import MetadataContainer
+from .content import ExtendedContent
+from .metadata import ContentMetadatas
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class SimpleExtendedContent(  # noqa
+    MetadataContainer[ContentMetadatas],
+    ExtendedContent,
+    lang.Abstract,
+    lang.PackageSealed,
+):
+    _metadata: ta.Sequence[ContentMetadatas] = dc.field(
+        default=(),
+        kw_only=True,
+        metadata=_tv_field_metadata(
+            ContentMetadatas,
+            marshal_name='metadata',
+        ),
+    )
+
+    @property
+    def metadata(self) -> tv.TypedValues[ContentMetadatas]:
+        return check.isinstance(self._metadata, tv.TypedValues)
+
+    def with_metadata(self, *mds: ContentMetadatas, override: bool = False) -> ta.Self:
+        return dc.replace(self, _metadata=tv.TypedValues(*self._metadata, *mds, override=override))

ommlds/minichain/content/text.py

@@ -0,0 +1,12 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .simple import SimpleExtendedContent
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class TextContent(SimpleExtendedContent, lang.Final):
+    s: str

ommlds/minichain/content/transforms.py

@@ -5,7 +5,9 @@ from omlish import dataclasses as dc
 from omlish import dispatch
 from omlish import lang
 
-from .images import Image
+from .images import ImageContent
+from .list import ListContent
+from .text import TextContent
 
 
 T = ta.TypeVar('T')
@@ -19,6 +21,8 @@ class ContentTransform(lang.Abstract):
     def apply(self, o: T) -> T:
         raise TypeError(o)
 
+    #
+
     @apply.register  # noqa
     def apply_str(self, s: str) -> str:
         return s
@@ -27,10 +31,20 @@ class ContentTransform(lang.Abstract):
     def apply_sequence(self, l: collections.abc.Sequence[T]) -> collections.abc.Sequence[T]:
         return [self.apply(e) for e in l]
 
+    #
+
     @apply.register
-    def apply_image(self, c: Image) -> Image:
+    def apply_image(self, c: ImageContent) -> ImageContent:
         return c
 
+    @apply.register
+    def apply_list(self, c: ListContent) -> ListContent:
+        return dc.replace(c, l=self.apply(c.l))
+
+    @apply.register
+    def apply_text(self, c: TextContent) -> ListContent:
+        return dc.replace(c, s=self.apply(c.s))
+
 
 ##
 

ommlds/minichain/metadata.py

@@ -0,0 +1,48 @@
+import abc
+import typing as ta
+import uuid
+
+from omlish import lang
+from omlish import typedvalues as tv
+
+
+##
+
+
+class Metadata(tv.TypedValue, lang.Abstract, lang.PackageSealed):
+    pass
+
+
+MetadataT = ta.TypeVar('MetadataT', bound=Metadata)
+
+
+#
+
+
+class MetadataContainer(
+    tv.TypedValueGeneric[MetadataT],
+    lang.Abstract,
+    lang.PackageSealed,
+):
+    @property
+    @abc.abstractmethod
+    def metadata(self) -> tv.TypedValues[MetadataT]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def with_metadata(self, *mds: MetadataT, override: bool = False) -> ta.Self:
+        raise NotImplementedError
+
+
+##
+
+
+class CommonMetadata(Metadata, lang.Abstract):
+    pass
+
+
+#
+
+
+class Uuid(tv.ScalarTypedValue[uuid.UUID], CommonMetadata, lang.Final):
+    pass

ommlds/minichain/services/_marshal.py

@@ -1,6 +1,7 @@
 import typing as ta
 
 from omlish import check
+from omlish import collections as col
 from omlish import dataclasses as dc
 from omlish import lang
 from omlish import marshal as msh
@@ -21,9 +22,19 @@ def _is_rr_rty(rty: rfl.Type) -> bool:
     )
 
 
+def _get_tv_fld(rty: rfl.Type) -> dc.Field:
+    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())
+
+
+##
+
+
 @dc.dataclass(frozen=True)
 class _RequestResponseMarshaler(msh.Marshaler):
     rty: rfl.Type
+    tv_fld: dc.Field
     v_m: msh.Marshaler | None
 
     def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
@@ -31,6 +42,7 @@ class _RequestResponseMarshaler(msh.Marshaler):
         tv_ta = tv.TypedValues[ta.Union[*tv_types_set]]  # type: ignore
         tv_m = ctx.make(tv_ta)
         tv_v = check.isinstance(tv_m.marshal(ctx, o._typed_values), ta.Sequence)  # noqa
+
         if self.v_m is None:
             orty: rfl.Generic = check.isinstance(rfl.type_(rfl.get_orig_class(o)), rfl.Generic)
             check.state(orty.cls in (Request, Response))
@@ -38,7 +50,11 @@ class _RequestResponseMarshaler(msh.Marshaler):
             v_v = ctx.make(v_rty).marshal(ctx, o.v)
         else:
             v_v = self.v_m.marshal(ctx, o.v)
-        return [v_v, *tv_v]
+
+        return {
+            'v': v_v,
+            **({lang.strip_prefix(self.tv_fld.name, '_'): tv_v} if tv_v else {}),
+        }
 
 
 class _RequestResponseMarshalerFactory(msh.SimpleMarshalerFactory):
@@ -56,20 +72,38 @@ class _RequestResponseMarshalerFactory(msh.SimpleMarshalerFactory):
         v_m: msh.Marshaler | None = None
         if not isinstance(v_rty, ta.TypeVar):
             v_m = ctx.make(v_rty)
-        return _RequestResponseMarshaler(rty, v_m)
+        return _RequestResponseMarshaler(
+            rty,
+            _get_tv_fld(rty),
+            v_m,
+        )
+
+
+#
 
 
 @dc.dataclass(frozen=True)
 class _RequestResponseUnmarshaler(msh.Unmarshaler):
     rty: rfl.Type
+    tv_fld: dc.Field
     v_u: msh.Unmarshaler
     tv_u: msh.Unmarshaler
 
     def unmarshal(self, ctx: msh.UnmarshalContext, v: msh.Value) -> ta.Any:
-        check.not_isinstance(v, str)
-        v_v, *tv_vs = check.isinstance(v, ta.Sequence)
+        dct = dict(check.isinstance(v, ta.Mapping))
+
+        v_v = dct.pop('v')
         v = self.v_u.unmarshal(ctx, v_v)
-        tvs = self.tv_u.unmarshal(ctx, tv_vs)
+
+        tvs: ta.Any
+        if dct:
+            tv_vs = dct.pop(lang.strip_prefix(self.tv_fld.name, '_'))
+            tvs = self.tv_u.unmarshal(ctx, tv_vs)
+        else:
+            tvs = []
+
+        check.empty(dct)
+
         cty = rfl.get_concrete_type(self.rty)
         return cty(v, tvs)  # type: ignore
 
@@ -88,7 +122,15 @@ class _RequestResponseUnmarshalerFactory(msh.SimpleUnmarshalerFactory):
         tv_ta = tv.TypedValues[ta.Union[*tv_types_set]]  # type: ignore
         tv_u = ctx.make(tv_ta)
         v_u = ctx.make(v_rty)
-        return _RequestResponseUnmarshaler(rty, v_u, tv_u)
+        return _RequestResponseUnmarshaler(
+            rty,
+            _get_tv_fld(rty),
+            v_u,
+            tv_u,
+        )
+
+
+##
 
 
 @lang.static_init

ommlds/minichain/services/_typedvalues.py

@@ -101,36 +101,3 @@ class _TypedValues(
                     not isinstance(o, tvi.tv_types)
             ):
                 raise _TypedValuesTypeError(o)
-
-
-##
-
-
-def _tv_field_coercer(tvc: type[tv.TypedValue]) -> ta.Callable[[ta.Sequence], tv.TypedValues]:
-    check.issubclass(tvc, tv.TypedValue)
-
-    def inner(seq):
-        return tv.TypedValues(*[
-            check.isinstance(e, tvc)
-            for e in check.isinstance(seq, ta.Sequence)
-        ])
-
-    return inner
-
-
-def _tv_field_repr(tvs: tv.TypedValues) -> str | None:
-    if not tvs:
-        return None
-
-    return repr(list(tvs))
-
-
-def _tv_field_metadata(tvc: type[tv.TypedValue]) -> ta.Mapping:
-    check.issubclass(tvc, tv.TypedValue)
-
-    return {
-        **dc.extra_field_params(
-            coerce=_tv_field_coercer(tvc),
-            repr_fn=_tv_field_repr,
-        ),
-    }

ommlds/minichain/services/requests.py

@@ -5,7 +5,7 @@ from omlish import dataclasses as dc
 from omlish import lang
 from omlish import typedvalues as tv
 
-from ._typedvalues import _tv_field_metadata
+from .._typedvalues import _tv_field_metadata
 from ._typedvalues import _TypedValues
 
 
@@ -37,7 +37,10 @@ class Request(  # type: ignore[type-var]  # FIXME: _TypedValues param is invaria
 
     _options: ta.Sequence[RequestOptionT_co] = dc.field(
         default=(),
-        metadata=_tv_field_metadata(RequestOption),
+        metadata=_tv_field_metadata(
+            RequestOption,
+            marshal_name='options',
+        ),
     )
 
     @property

ommlds/minichain/services/responses.py

@@ -5,7 +5,7 @@ from omlish import dataclasses as dc
 from omlish import lang
 from omlish import typedvalues as tv
 
-from ._typedvalues import _tv_field_metadata
+from .._typedvalues import _tv_field_metadata
 from ._typedvalues import _TypedValues
 
 
@@ -37,7 +37,10 @@ class Response(  # type: ignore[type-var]  # FIXME: _TypedValues param is invari
 
     _outputs: ta.Sequence[ResponseOutputT_contra] = dc.field(
         default=(),
-        metadata=_tv_field_metadata(ResponseOutput),
+        metadata=_tv_field_metadata(
+            ResponseOutput,
+            marshal_name='outputs',
+        ),
     )
 
     @property

{ommlds-0.0.0.dev332.dist-info → ommlds-0.0.0.dev334.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommlds
-Version: 0.0.0.dev332
+Version: 0.0.0.dev334
 Summary: ommlds
 Author: wrmsr
 License: BSD-3-Clause
@@ -12,8 +12,8 @@ Classifier: Operating System :: OS Independent
 Classifier: Operating System :: POSIX
 Requires-Python: >=3.12
 License-File: LICENSE
-Requires-Dist: omdev==0.0.0.dev332
-Requires-Dist: omlish==0.0.0.dev332
+Requires-Dist: omdev==0.0.0.dev334
+Requires-Dist: omlish==0.0.0.dev334
 Provides-Extra: all
 Requires-Dist: llama-cpp-python~=0.3; extra == "all"
 Requires-Dist: mlx~=0.26; extra == "all"