ommlds 0.0.0.dev495__py3-none-any.whl → 0.0.0.dev497__py3-none-any.whl

ommlds/minichain/backends/impls/anthropic/protocol.py

@@ -12,7 +12,7 @@ from ....chat.messages import ToolUseMessage
 from ....chat.messages import ToolUseResultMessage
 from ....chat.messages import UserMessage
 from ....chat.tools.types import Tool
-from ....content.prepare import prepare_content_str
+from ....content.transform.prepare import prepare_content_str
 from ....tools.jsonschema import build_tool_spec_params_json_schema
 
 
@@ -104,6 +104,6 @@ def build_protocol_chat_messages(msgs: ta.Iterable[Message]) -> BuiltChatMessage
 def build_protocol_tool(t: Tool) -> pt.ToolSpec:
     return pt.ToolSpec(
         name=check.not_none(t.spec.name),
-        description=prepare_content_str(t.spec.desc),
+        description=prepare_content_str(t.spec.desc) if t.spec.desc is not None else '',
         input_schema=build_tool_spec_params_json_schema(t.spec),
     )

ommlds/minichain/backends/impls/cerebras/protocol.py

@@ -18,7 +18,7 @@ from ....chat.stream.types import AiDelta
 from ....chat.stream.types import ContentAiDelta
 from ....chat.stream.types import PartialToolUseAiDelta
 from ....chat.tools.types import Tool
-from ....content.prepare import prepare_content_str
+from ....content.transform.prepare import prepare_content_str
 from ....tools.jsonschema import build_tool_spec_params_json_schema
 from ....tools.types import ToolUse
 
@@ -89,7 +89,7 @@ def build_cer_request_tool(t: Tool) -> pt.ChatCompletionRequest.Tool:
     return pt.ChatCompletionRequest.Tool(
         function=pt.ChatCompletionRequest.Tool.Function(
             name=check.not_none(t.spec.name),
-            description=prepare_content_str(t.spec.desc),
+            description=prepare_content_str(t.spec.desc) if t.spec.desc is not None else None,
             parameters=build_tool_spec_params_json_schema(t.spec),
         ),
     )

ommlds/minichain/backends/impls/google/tools.py

@@ -7,8 +7,8 @@ from omlish import check
 from omlish import dataclasses as dc
 
 from .....backends.google.protocol import types as pt
-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 ....tools.types import EnumToolDtype
 from ....tools.types import MappingToolDtype
 from ....tools.types import NullableToolDtype

ommlds/minichain/backends/impls/groq/protocol.py

@@ -18,7 +18,7 @@ from ....chat.stream.types import AiDelta
 from ....chat.stream.types import ContentAiDelta
 from ....chat.stream.types import ToolUseAiDelta
 from ....chat.tools.types import Tool
-from ....content.prepare import prepare_content_str
+from ....content.transform.prepare import prepare_content_str
 from ....tools.jsonschema import build_tool_spec_params_json_schema
 from ....tools.types import ToolUse
 
@@ -89,7 +89,7 @@ def build_gq_request_tool(t: Tool) -> pt.ChatCompletionRequest.Tool:
     return pt.ChatCompletionRequest.Tool(
         function=pt.ChatCompletionRequest.Tool.Function(
             name=check.not_none(t.spec.name),
-            description=prepare_content_str(t.spec.desc),
+            description=prepare_content_str(t.spec.desc) if t.spec.desc is not None else None,
             parameters=build_tool_spec_params_json_schema(t.spec),
         ),
     )

ommlds/minichain/backends/impls/ollama/protocol.py

@@ -17,7 +17,7 @@ from ....chat.stream.types import AiDelta
 from ....chat.stream.types import ContentAiDelta
 from ....chat.stream.types import ToolUseAiDelta
 from ....chat.tools.types import Tool
-from ....content.prepare import prepare_content_str
+from ....content.transform.prepare import prepare_content_str
 from ....tools.jsonschema import build_tool_spec_params_json_schema
 from ....tools.types import ToolUse
 
@@ -92,7 +92,7 @@ def build_ol_request_tool(t: Tool) -> pt.Tool:
     return pt.Tool(
         function=pt.Tool.Function(
             name=check.not_none(t.spec.name),
-            description=prepare_content_str(t.spec.desc),
+            description=prepare_content_str(t.spec.desc) if t.spec.desc is not None else None,
             parameters=build_tool_spec_params_json_schema(t.spec),
         ),
     )

ommlds/minichain/backends/impls/openai/format.py

@@ -22,7 +22,7 @@ from ....chat.stream.types import ContentAiDelta
 from ....chat.stream.types import PartialToolUseAiDelta
 from ....chat.tools.types import Tool
 from ....content.json import JsonContent
-from ....content.prepare import prepare_content_str
+from ....content.transform.prepare import prepare_content_str
 from ....llms.types import MaxCompletionTokens
 from ....llms.types import MaxTokens
 from ....llms.types import Temperature
@@ -216,7 +216,7 @@ class OpenaiChatRequestHandler:
             pt.ChatCompletionRequestTool(
                 function=pt.ChatCompletionRequestTool.Function(
                     name=check.not_none(ts.name),
-                    description=prepare_content_str(ts.desc),
+                    description=prepare_content_str(ts.desc) if ts.desc is not None else None,
                     parameters=build_tool_spec_params_json_schema(ts),
                 ),
             )

ommlds/minichain/chat/messages.py

@@ -3,14 +3,11 @@ 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.cancontent import CanContent
-from ..content.transforms.base import ContentTransform
 from ..content.types import Content
 from ..metadata import MetadataContainer
 from ..tools.types import ToolUse
@@ -90,7 +87,7 @@ def check_ai_chat(chat: Chat) -> AiChat:
 
 @dc.dataclass(frozen=True)
 class SystemMessage(AnyUserMessage, lang.Final):
-    c: CanContent
+    c: Content
 
 
 #
@@ -99,7 +96,7 @@ class SystemMessage(AnyUserMessage, lang.Final):
 @dc.dataclass(frozen=True)
 @msh.update_fields_metadata(['name'], omit_if=operator.not_)
 class UserMessage(AnyUserMessage, lang.Final):
-    c: CanContent
+    c: Content
 
     name: str | None = dc.xfield(None, repr_fn=dc.opt_repr)
 
@@ -128,23 +125,23 @@ class ToolUseResultMessage(AnyUserMessage, lang.Final):
 ##
 
 
-class _MessageContentTransform(ContentTransform, lang.Final, lang.NotInstantiable):
-    @dispatch.install_method(ContentTransform.apply)
-    def apply_system_message(self, m: SystemMessage) -> SystemMessage:
-        return dc.replace(m, c=self.apply(m.c))
-
-    @dispatch.install_method(ContentTransform.apply)
-    def apply_user_message(self, m: UserMessage) -> UserMessage:
-        return dc.replace(m, c=self.apply(m.c))
-
-    @dispatch.install_method(ContentTransform.apply)
-    def apply_ai_message(self, m: AiMessage) -> AiMessage:
-        return dc.replace(m, c=self.apply(m.c))
-
-    @dispatch.install_method(ContentTransform.apply)
-    def apply_tool_use_message(self, m: ToolUseMessage) -> ToolUseMessage:
-        return dc.replace(m, tu=self.apply(m.tu))
-
-    @dispatch.install_method(ContentTransform.apply)
-    def apply_tool_use_result_message(self, m: ToolUseResultMessage) -> ToolUseResultMessage:
-        return dc.replace(m, tur=self.apply(m.tur))
+# class _MessageContentTransform(ContentTransform, lang.Final, lang.NotInstantiable):
+#     @dispatch.install_method(ContentTransform.apply)
+#     def apply_system_message(self, m: SystemMessage) -> SystemMessage:
+#         return dc.replace(m, c=self.apply(m.c))
+#
+#     @dispatch.install_method(ContentTransform.apply)
+#     def apply_user_message(self, m: UserMessage) -> UserMessage:
+#         return dc.replace(m, c=self.apply(m.c))
+#
+#     @dispatch.install_method(ContentTransform.apply)
+#     def apply_ai_message(self, m: AiMessage) -> AiMessage:
+#         return dc.replace(m, c=self.apply(m.c))
+#
+#     @dispatch.install_method(ContentTransform.apply)
+#     def apply_tool_use_message(self, m: ToolUseMessage) -> ToolUseMessage:
+#         return dc.replace(m, tu=self.apply(m.tu))
+#
+#     @dispatch.install_method(ContentTransform.apply)
+#     def apply_tool_use_result_message(self, m: ToolUseResultMessage) -> ToolUseResultMessage:
+#         return dc.replace(m, tur=self.apply(m.tur))

ommlds/minichain/chat/templating.py

@@ -10,7 +10,7 @@ from omlish import dataclasses as dc
 from omlish import lang
 from omlish.text import templating as tpl
 
-from ..content.transforms.strings import transform_content_strings
+from ..content.transform.strings import transform_content_strings
 from ..envs import Env
 from ..envs import EnvKey
 from .messages import Chat

ommlds/minichain/content/__init__.py

@@ -9,10 +9,17 @@ _msh.register_global_module_import('._marshal', __package__)
 
 
 # This is everything _marshal.py references - it must all be imported before the conditional import.
+
 from . import (  # noqa
+    code as _code,
+    dynamic as _dynamic,
     images as _images,
-    materialize as _materialize,
+    json as _json,
+    quote as _quote,
+    raw as _raw,
+    section as _section,
     sequence as _sequence,
+    tag as _tag,
+    templates as _templates,
     text as _text,
-    types as _types,
 )

ommlds/minichain/content/_marshal.py

@@ -7,17 +7,24 @@ from omlish import lang
 from omlish import marshal as msh
 from omlish import reflect as rfl
 
-from .cancontent import CanContent
-from .cancontent import _InnerCanContent
+from .code import CodeContent  # noqa
+from .dynamic import DynamicContent  # noqa
 from .images import ImageContent  # noqa
 from .json import JsonContent  # noqa
+from .quote import QuoteContent  # noqa
+from .raw import NON_STR_SINGLE_RAW_CONTENT_TYPES
+from .raw import NonStrSingleRawContent
+from .raw import RawContent  # noqa
+from .raw import SingleRawContent  # noqa
+from .section import SectionContent  # noqa
 from .sequence import BlockContent  # noqa
 from .sequence import InlineContent  # noqa
+from .sequence import ItemListContent  # noqa
 from .tag import TagContent  # noqa
 from .text import TextContent  # noqa
-from .types import CONTENT_RUNTIME_TYPES
+from .types import CONTENT_TYPES  # noqa
+from .types import BaseContent
 from .types import Content
-from .types import ExtendedContent
 
 
 ##
@@ -30,7 +37,7 @@ class MarshalContent(lang.NotInstantiable, lang.Final):
 
 MarshalContentUnion: ta.TypeAlias = ta.Union[  # noqa
     str,
-    ExtendedContent,
+    BaseContent,
     ta.Sequence[MarshalContent],
 ]
 
@@ -40,15 +47,15 @@ _MARSHAL_CONTENT_UNION_RTY = rfl.type_(MarshalContentUnion)
 
 @dc.dataclass(frozen=True)
 class _ContentMarshaler(msh.Marshaler):
-    et: msh.Marshaler
+    bt: msh.Marshaler
 
     def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
         if isinstance(o, str):
             return o
         elif isinstance(o, ta.Sequence):
             return [self.marshal(ctx, e) for e in o]
-        elif isinstance(o, ExtendedContent):
-            return self.et.marshal(ctx, o)
+        elif isinstance(o, BaseContent):
+            return self.bt.marshal(ctx, o)
         else:
             raise TypeError(o)
 
@@ -57,12 +64,12 @@ class _ContentMarshalerFactory(msh.MarshalerFactory):
     def make_marshaler(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
         if not (rty is MarshalContent or rty == _MARSHAL_CONTENT_UNION_RTY):
             return None
-        return lambda: _ContentMarshaler(ctx.make_marshaler(ExtendedContent))
+        return lambda: _ContentMarshaler(ctx.make_marshaler(BaseContent))
 
 
 @dc.dataclass(frozen=True)
 class _ContentUnmarshaler(msh.Unmarshaler):
-    et: msh.Unmarshaler
+    bt: msh.Unmarshaler
 
     def unmarshal(self, ctx: msh.UnmarshalContext, v: msh.Value) -> ta.Any:
         if isinstance(v, str):
@@ -70,7 +77,7 @@ class _ContentUnmarshaler(msh.Unmarshaler):
         elif isinstance(v, ta.Sequence):
             return [self.unmarshal(ctx, e) for e in v]
         elif isinstance(v, collections.abc.Mapping):
-            return self.et.unmarshal(ctx, v)  # noqa
+            return self.bt.unmarshal(ctx, v)  # noqa
         else:
             raise TypeError(v)
 
@@ -79,53 +86,117 @@ class _ContentUnmarshalerFactory(msh.UnmarshalerFactory):
     def make_unmarshaler(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:  # noqa
         if not (rty is MarshalContent or rty == _MARSHAL_CONTENT_UNION_RTY):
             return None
-        return lambda: _ContentUnmarshaler(ctx.make_unmarshaler(ExtendedContent))
+        return lambda: _ContentUnmarshaler(ctx.make_unmarshaler(BaseContent))
 
 
 ##
 
 
-class MarshalCanContent(lang.NotInstantiable, lang.Final):
+class MarshalSingleRawContent(lang.NotInstantiable, lang.Final):
     pass
 
 
-MarshalCanContentUnion: ta.TypeAlias = ta.Union[  # noqa
-    ta.Iterable[MarshalCanContent],
-    _InnerCanContent,
+_SINGLE_RAW_CONTENT_UNION_RTY = rfl.type_(SingleRawContent)
+
+
+@dc.dataclass(frozen=True)
+class _SingleRawContentMarshaler(msh.Marshaler):
+    nst: msh.Marshaler
+
+    def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
+        if isinstance(o, str):
+            return o
+        elif isinstance(o, NON_STR_SINGLE_RAW_CONTENT_TYPES):
+            return self.nst.marshal(ctx, o)
+        else:
+            raise TypeError(o)
+
+
+class _SingleRawContentMarshalerFactory(msh.MarshalerFactory):
+    def make_marshaler(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if not (rty is MarshalSingleRawContent or rty == _SINGLE_RAW_CONTENT_UNION_RTY):
+            return None
+        return lambda: _SingleRawContentMarshaler(ctx.make_marshaler(NonStrSingleRawContent))
+
+
+@dc.dataclass(frozen=True)
+class _SingleRawContentUnmarshaler(msh.Unmarshaler):
+    nst: msh.Unmarshaler
+
+    def unmarshal(self, ctx: msh.UnmarshalContext, v: msh.Value) -> ta.Any:
+        if isinstance(v, str):
+            return v
+        elif isinstance(v, collections.abc.Mapping):
+            return self.nst.unmarshal(ctx, v)  # noqa
+        else:
+            raise TypeError(v)
+
+
+class _SingleRawContentUnmarshalerFactory(msh.UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:  # noqa
+        if not (rty is MarshalSingleRawContent or rty == _SINGLE_RAW_CONTENT_UNION_RTY):
+            return None
+        return lambda: _SingleRawContentUnmarshaler(ctx.make_unmarshaler(NonStrSingleRawContent))
+
+
+##
+
+
+class MarshalRawContent(lang.NotInstantiable, lang.Final):
+    pass
+
+
+MarshalRawContentUnion: ta.TypeAlias = ta.Union[  # noqa
+    SingleRawContent,
+    ta.Sequence[MarshalRawContent],
 ]
 
 
-_MARSHAL_CAN_CONTENT_UNION_RTY = rfl.type_(MarshalCanContentUnion)
+_MARSHAL_RAW_CONTENT_UNION_RTY = rfl.type_(MarshalRawContentUnion)
 
 
 @dc.dataclass(frozen=True)
-class _CanContentMarshaler(msh.Marshaler):
-    c: msh.Marshaler
+class _RawContentMarshaler(msh.Marshaler):
+    nst: msh.Marshaler
 
     def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
-        return self.c.marshal(ctx, check.isinstance(o, CONTENT_RUNTIME_TYPES))
+        if isinstance(o, str):
+            return o
+        elif isinstance(o, ta.Sequence):
+            return [self.marshal(ctx, e) for e in o]
+        elif isinstance(o, NON_STR_SINGLE_RAW_CONTENT_TYPES):
+            return self.nst.marshal(ctx, o)
+        else:
+            raise TypeError(o)
 
 
-class _CanContentMarshalerFactory(msh.MarshalerFactory):
+class _RawContentMarshalerFactory(msh.MarshalerFactory):
     def make_marshaler(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
-        if not (rty is MarshalCanContent or rty == _MARSHAL_CAN_CONTENT_UNION_RTY):
+        if not (rty is MarshalRawContent or rty == _MARSHAL_RAW_CONTENT_UNION_RTY):
             return None
-        return lambda: _CanContentMarshaler(ctx.make_marshaler(Content))
+        return lambda: _RawContentMarshaler(ctx.make_marshaler(NonStrSingleRawContent))
 
 
 @dc.dataclass(frozen=True)
-class _CanContentUnmarshaler(msh.Unmarshaler):
-    c: msh.Unmarshaler
+class _RawContentUnmarshaler(msh.Unmarshaler):
+    nst: msh.Unmarshaler
 
     def unmarshal(self, ctx: msh.UnmarshalContext, v: msh.Value) -> ta.Any:
-        return self.c.unmarshal(ctx, v)
+        if isinstance(v, str):
+            return v
+        elif isinstance(v, ta.Sequence):
+            return [self.unmarshal(ctx, e) for e in v]
+        elif isinstance(v, collections.abc.Mapping):
+            return self.nst.unmarshal(ctx, v)  # noqa
+        else:
+            raise TypeError(v)
 
 
-class _CanContentUnmarshalerFactory(msh.UnmarshalerFactory):
+class _RawContentUnmarshalerFactory(msh.UnmarshalerFactory):
     def make_unmarshaler(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:  # noqa
-        if not (rty is MarshalCanContent or rty == _MARSHAL_CAN_CONTENT_UNION_RTY):
+        if not (rty is MarshalRawContent or rty == _MARSHAL_RAW_CONTENT_UNION_RTY):
             return None
-        return lambda: _CanContentUnmarshaler(ctx.make_unmarshaler(Content))
+        return lambda: _RawContentUnmarshaler(ctx.make_unmarshaler(NonStrSingleRawContent))
 
 
 ##
@@ -159,36 +230,43 @@ class _JsonContentUnmarshaler(msh.Unmarshaler):
 
 @lang.static_init
 def _install_standard_marshaling() -> None:
-    extended_content_poly = msh.Polymorphism(
-        ExtendedContent,
+    base_content_poly = msh.Polymorphism(
+        BaseContent,
         [
-            msh.Impl(BlockContent, 'block'),
+
+            msh.Impl(CodeContent, 'code'),
+
             msh.Impl(ImageContent, 'image'),
-            msh.Impl(InlineContent, 'inline'),
+
             msh.Impl(JsonContent, 'json'),
+
+            msh.Impl(QuoteContent, 'quote'),
+
+            msh.Impl(SectionContent, 'section'),
+
+            msh.Impl(BlockContent, 'block'),
+            msh.Impl(InlineContent, 'inline'),
+            msh.Impl(ItemListContent, 'item_list'),
+
             msh.Impl(TagContent, 'tag'),
+
             msh.Impl(TextContent, 'text'),
+
         ],
     )
 
     msh.install_standard_factories(
-        msh.PolymorphismMarshalerFactory(extended_content_poly),
-        msh.TypeMapMarshalerFactory({
-            ImageContent: _ImageContentMarshaler(),
-            JsonContent: _JsonContentMarshaler(),
-        }),
-        _ContentMarshalerFactory(),
-        _CanContentMarshalerFactory(),
+        *msh.standard_polymorphism_factories(
+            base_content_poly,
+            unions='partial',
+        ),
     )
 
+    #
+
     msh.install_standard_factories(
-        msh.PolymorphismUnmarshalerFactory(extended_content_poly),
-        msh.TypeMapUnmarshalerFactory({
-            ImageContent: _ImageContentUnmarshaler(),
-            JsonContent: _JsonContentUnmarshaler(),
-        }),
+        _ContentMarshalerFactory(),
         _ContentUnmarshalerFactory(),
-        _CanContentUnmarshalerFactory(),
     )
 
     msh.register_global_config(
@@ -197,8 +275,41 @@ def _install_standard_marshaling() -> None:
         identity=True,
     )
 
+    #
+
+    msh.install_standard_factories(
+        _SingleRawContentMarshalerFactory(),
+        _SingleRawContentUnmarshalerFactory(),
+    )
+
+    msh.register_global_config(
+        SingleRawContent,
+        msh.ReflectOverride(MarshalSingleRawContent),
+        identity=True,
+    )
+
+    #
+
+    msh.install_standard_factories(
+        _RawContentMarshalerFactory(),
+        _RawContentUnmarshalerFactory(),
+    )
+
     msh.register_global_config(
-        CanContent,
-        msh.ReflectOverride(MarshalCanContent),
+        RawContent,
+        msh.ReflectOverride(MarshalRawContent),
         identity=True,
     )
+
+    #
+
+    msh.install_standard_factories(
+        msh.TypeMapMarshalerFactory({
+            ImageContent: _ImageContentMarshaler(),
+            JsonContent: _JsonContentMarshaler(),
+        }),
+        msh.TypeMapUnmarshalerFactory({
+            ImageContent: _ImageContentUnmarshaler(),
+            JsonContent: _JsonContentUnmarshaler(),
+        }),
+    )

ommlds/minichain/content/code.py

@@ -0,0 +1,17 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .standard import StandardContent
+from .types import LeafContent
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class CodeContent(StandardContent, LeafContent, lang.Final):
+    s: str
+
+    _: dc.KW_ONLY
+
+    lang: str | None = None

ommlds/minichain/content/dynamic.py

@@ -0,0 +1,12 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .standard import StandardContent
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DynamicContent(StandardContent, lang.Abstract):
+    pass

ommlds/minichain/content/images.py

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

ommlds/minichain/content/json.py

@@ -2,12 +2,13 @@ from omlish import dataclasses as dc
 from omlish import lang
 
 from ..json import JsonValue
-from .simple import SimpleSingleExtendedContent
+from .standard import StandardContent
+from .types import LeafContent
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class JsonContent(SimpleSingleExtendedContent, lang.Final):
+class JsonContent(StandardContent, LeafContent, lang.Final):
     v: JsonValue

ommlds/minichain/content/namespaces.py

@@ -1,8 +1,17 @@
+from omlish import dataclasses as dc
 from omlish import lang
 
+from .dynamic import DynamicContent
+from .types import LeafContent
+
 
 ##
 
 
 class ContentNamespace(lang.Namespace, lang.Abstract):
     pass
+
+
+@dc.dataclass(frozen=True)
+class NamespaceContent(DynamicContent, LeafContent, lang.Final):
+    ns: type[ContentNamespace]

ommlds/minichain/content/placeholders.py

@@ -1,20 +1,22 @@
+import typing as ta
+
 from omlish import dataclasses as dc
 from omlish import lang
 
+from .dynamic import DynamicContent
+from .types import LeafContent
+
 
 ##
 
 
-@dc.dataclass(frozen=True, eq=False)
-@dc.extra_class_params(repr_id=True)
-class ContentPlaceholder(lang.Final):
-    # kw_only to prevent misuse - the string passed to this class is not the Content itself, just the name of the
-    # placeholder
-    name: str | None = dc.field(default=None, kw_only=True, metadata=dc.extra_field_params(repr_fn=lang.opt_repr))
+class ContentPlaceholder(lang.Marker, lang.Abstract):
+    pass
 
 
-content_placeholder = ContentPlaceholder
+PlaceholderContentKey: ta.TypeAlias = str | type[ContentPlaceholder]
 
 
-class ContentPlaceholderMarker(lang.Marker):
-    pass
+@dc.dataclass(frozen=True)
+class PlaceholderContent(DynamicContent, LeafContent, lang.Final):
+    k: PlaceholderContentKey

ommlds/minichain/content/quote.py

@@ -0,0 +1,17 @@
+"""
+TODO:
+ - attribution
+"""
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .standard import StandardContent
+from .types import Content
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class QuoteContent(StandardContent, lang.Final):
+    body: Content