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

ommlds/minichain/content/_marshal.py

@@ -1,22 +1,34 @@
 import collections.abc
-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
 
-from .images import ImageContent  # noqa
-from .json import JsonContent  # noqa
-from .materialize import CanContent
-from .materialize import _InnerCanContent
-from .sequence import BlockContent  # noqa
-from .sequence import InlineContent  # noqa
-from .text import TextContent  # noqa
-from .types import CONTENT_RUNTIME_TYPES
-from .types import Content
-from .types import ExtendedContent
+from .code import BlockCodeContent
+from .code import InlineCodeContent
+from .content import BaseContent
+from .content import Content
+from .emphasis import BoldContent
+from .emphasis import BoldItalicContent
+from .emphasis import ItalicContent
+from .images import ImageContent
+from .json import JsonContent
+from .link import LinkContent
+from .markdown import MarkdownContent
+from .quote import QuoteContent
+from .raw import NON_STR_SINGLE_RAW_CONTENT_TYPES
+from .raw import NonStrSingleRawContent
+from .raw import RawContent
+from .raw import SingleRawContent
+from .section import SectionContent
+from .sequence import BlockContent
+from .sequence import InlineContent
+from .sequence import ItemListContent
+from .tag import TagContent
+from .text import TextContent
 
 
 ##
@@ -29,7 +41,7 @@ class MarshalContent(lang.NotInstantiable, lang.Final):
 
 MarshalContentUnion: ta.TypeAlias = ta.Union[  # noqa
     str,
-    ExtendedContent,
+    BaseContent,
     ta.Sequence[MarshalContent],
 ]
 
@@ -39,15 +51,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)
 
@@ -56,12 +68,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):
@@ -69,7 +81,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)
 
@@ -78,53 +90,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))
 
 
 ##
@@ -158,35 +234,52 @@ 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(InlineContent, 'inline'),
-            msh.Impl(BlockContent, 'block'),
+
+            msh.Impl(InlineCodeContent, 'inline_code'),
+            msh.Impl(BlockCodeContent, 'block_code'),
+
+            msh.Impl(BoldContent, 'bold'),
+            msh.Impl(ItalicContent, 'italic'),
+            msh.Impl(BoldItalicContent, 'bold_italic'),
+
             msh.Impl(ImageContent, 'image'),
+
             msh.Impl(JsonContent, 'json'),
+
+            msh.Impl(LinkContent, 'link'),
+
+            msh.Impl(MarkdownContent, 'markdown'),
+
+            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(
@@ -195,8 +288,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,26 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .standard import StandardContent
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class CodeContent(StandardContent, lang.Abstract):
+    s: str
+
+    _: dc.KW_ONLY
+
+    lang: str | None = None
+
+
+@dc.dataclass(frozen=True)
+class InlineCodeContent(CodeContent, lang.Final):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class BlockCodeContent(CodeContent, lang.Final):
+    pass

ommlds/minichain/content/composite.py

@@ -0,0 +1,28 @@
+import abc
+import typing as ta
+
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .content import Content
+from .standard import StandardContent
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class CompositeContent(StandardContent, lang.Abstract):
+    @abc.abstractmethod
+    def child_content(self) -> ta.Sequence[Content]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def _replace_child_content(self, new_child_content: ta.Sequence[Content]) -> ta.Self:
+        raise NotImplementedError
+
+    def replace_child_content(self, new_child_content: ta.Sequence[Content]) -> ta.Self:
+        if lang.seqs_identical(new_child_content, self.child_content()):
+            return self
+
+        return self._replace_child_content(new_child_content)

ommlds/minichain/content/content.py

@@ -0,0 +1,27 @@
+import typing as ta
+
+from omlish import lang
+
+
+##
+
+
+class BaseContent(lang.Abstract, lang.PackageSealed):
+    pass
+
+
+##
+
+
+Content: ta.TypeAlias = ta.Union[  # noqa
+    str,
+    BaseContent,
+    ta.Sequence['Content'],
+]
+
+
+CONTENT_TYPES: tuple[type, ...] = (
+    str,
+    BaseContent,
+    ta.Sequence,
+)

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/emphasis.py

@@ -0,0 +1,27 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .standard import StandardContent
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class EmphasisContent(StandardContent, lang.Abstract):
+    s: str
+
+
+@dc.dataclass(frozen=True)
+class BoldContent(EmphasisContent, lang.Final):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class ItalicContent(EmphasisContent, lang.Final):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class BoldItalicContent(EmphasisContent, lang.Final):
+    pass

ommlds/minichain/content/images.py

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

ommlds/minichain/content/json.py

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

ommlds/minichain/content/link.py

@@ -0,0 +1,13 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .standard import StandardContent
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class LinkContent(StandardContent, lang.Final):
+    url: str
+    title: str | None = None

ommlds/minichain/content/markdown.py

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

ommlds/minichain/content/metadata.py

@@ -1,9 +1,11 @@
 import typing as ta
 
+from omlish import dataclasses as dc
 from omlish import lang
 
 from ..metadata import CommonMetadata
 from ..metadata import Metadata
+from .content import Content
 
 
 ##
@@ -14,3 +16,11 @@ class ContentMetadata(Metadata, lang.Abstract):
 
 
 ContentMetadatas: ta.TypeAlias = ContentMetadata | CommonMetadata
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ContentOriginal(ContentMetadata, lang.Final):
+    c: Content

ommlds/minichain/content/namespaces.py

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

ommlds/minichain/content/placeholders.py

@@ -1,20 +1,21 @@
+import typing as ta
+
 from omlish import dataclasses as dc
 from omlish import lang
 
+from .recursive import RecursiveContent
+
 
 ##
 
 
-@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(RecursiveContent, lang.Final):
+    k: PlaceholderContentKey

ommlds/minichain/content/quote.py

@@ -0,0 +1,26 @@
+"""
+TODO:
+ - attribution
+"""
+import typing as ta
+
+from omlish import check
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .composite import CompositeContent
+from .content import Content
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class QuoteContent(CompositeContent, lang.Final):
+    body: Content
+
+    def child_content(self) -> ta.Sequence[Content]:
+        return [self.body]
+
+    def _replace_child_content(self, new_child_content: ta.Sequence[Content]) -> ta.Self:
+        return self.replace(body=check.single(new_child_content))

ommlds/minichain/content/raw.py

@@ -0,0 +1,49 @@
+import typing as ta
+
+from .images import ImageContent
+from .text import TextContent
+
+
+##
+
+
+NonStrSingleRawContent: ta.TypeAlias = ta.Union[  # noqa
+    TextContent,
+    ImageContent,
+]
+
+
+NON_STR_SINGLE_RAW_CONTENT_TYPES: tuple[type, ...] = (
+    TextContent,
+    ImageContent,
+)
+
+
+#
+
+
+SingleRawContent: ta.TypeAlias = ta.Union[  # noqa
+    str,
+    NonStrSingleRawContent,
+]
+
+
+SINGLE_RAW_CONTENT_TYPES: tuple[type, ...] = (
+    str,
+    *NON_STR_SINGLE_RAW_CONTENT_TYPES,
+)
+
+
+#
+
+
+RawContent: ta.TypeAlias = ta.Union[  # noqa
+    SingleRawContent,
+    ta.Sequence[SingleRawContent],
+]
+
+
+RAW_CONTENT_TYPES: tuple[type, ...] = (
+    *SINGLE_RAW_CONTENT_TYPES,
+    ta.Sequence,
+)

ommlds/minichain/content/recursive.py

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