ommlds 0.0.0.dev496__py3-none-any.whl → 0.0.0.dev498__py3-none-any.whl

ommlds/minichain/content/standard.py

@@ -1,14 +1,12 @@
 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 ..metadata import MetadataContainerDataclass
+from .content import BaseContent
 from .metadata import ContentMetadatas
-from .types import BaseContent
+from .metadata import ContentOriginal
 
 
 ##
@@ -16,22 +14,19 @@ from .types import BaseContent
 
 @dc.dataclass(frozen=True)
 class StandardContent(  # noqa
-    MetadataContainer[ContentMetadatas],
+    MetadataContainerDataclass[ContentMetadatas],
     BaseContent,
     lang.Abstract,
 ):
     _metadata: ta.Sequence[ContentMetadatas] = dc.field(
         default=(),
         kw_only=True,
-        metadata=_tv_field_metadata(
-            ContentMetadatas,
-            marshal_name='metadata',
-        ),
+        repr=False,
     )
 
-    @property
-    def metadata(self) -> tv.TypedValues[ContentMetadatas]:
-        return check.isinstance(self._metadata, tv.TypedValues)
+    MetadataContainerDataclass._configure_metadata_field(_metadata, ContentMetadatas)  # noqa
 
-    def with_metadata(self, *mds: ContentMetadatas, override: bool = False) -> ta.Self:
-        return dc.replace(self, _metadata=tv.TypedValues(*self._metadata, *mds, override=override))
+    def replace(self, **kwargs: ta.Any) -> ta.Self:
+        if (n := dc.replace_is_not(self, **kwargs)) is self:
+            return self
+        return n.update_metadata(ContentOriginal(self), discard=[ContentOriginal], override=True)

ommlds/minichain/content/tag.py

@@ -3,17 +3,26 @@ TODO:
  - track BlockContent nesting depth?
  - section names? dedicated 'section' content with header and body?
 """
+import typing as ta
+
+from omlish import check
 from omlish import dataclasses as dc
 from omlish import lang
 
-from .standard import StandardContent
-from .types import Content
+from .composite import CompositeContent
+from .content import Content
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class TagContent(StandardContent, lang.Final):
+class TagContent(CompositeContent, lang.Final):
     tag: str
     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/templates.py

@@ -3,12 +3,11 @@ from omlish import lang
 from omlish.text import templating as tpl
 
 from .dynamic import DynamicContent
-from .types import LeafContent
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class TemplateContent(DynamicContent, LeafContent, lang.Final):
+class TemplateContent(DynamicContent, lang.Final):
     t: tpl.Templater

ommlds/minichain/content/text.py

@@ -2,12 +2,11 @@ from omlish import dataclasses as dc
 from omlish import lang
 
 from .standard import StandardContent
-from .types import LeafContent
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class TextContent(StandardContent, LeafContent, lang.Final):
+class TextContent(StandardContent, lang.Final):
     s: str

ommlds/minichain/content/transform/json.py

@@ -0,0 +1,55 @@
+import typing as ta
+
+from omlish.formats import json
+
+from ..code import BlockCodeContent
+from ..code import InlineCodeContent
+from ..json import JsonContent
+from ..metadata import ContentOriginal
+from ..standard import StandardContent
+from ..text import TextContent
+from ..visitors import ContentTransform
+
+
+##
+
+
+class JsonContentRenderer(ContentTransform[None]):
+    def __init__(
+            self,
+            *,
+            backend: json.Backend | None = None,
+            mode: ta.Literal['pretty', 'compact', 'normal'] = 'pretty',
+            code: ta.Literal['inline', 'block', None] = None,
+    ) -> None:
+        super().__init__()
+
+        if backend is None:
+            backend = json.default_backend()
+        self._backend = backend
+        self._mode = mode
+        self._code = code
+
+    def visit_json_content(self, c: JsonContent, ctx: None) -> StandardContent:
+        match self._mode:
+            case 'pretty':
+                s = self._backend.dumps_pretty(c.v)
+            case 'compact':
+                s = self._backend.dumps_compact(c.v)
+            case 'normal':
+                s = self._backend.dumps(c.v)
+            case _:
+                raise ValueError(self._mode)
+
+        nc: StandardContent
+        match self._code:
+            case 'inline':
+                nc = InlineCodeContent(s, lang='json')
+            case 'block':
+                nc = BlockCodeContent(s, lang='json')
+            case None:
+                nc = TextContent(s)
+            case _:
+                raise ValueError(self._code)
+
+        return nc.update_metadata(ContentOriginal(c))

ommlds/minichain/content/transform/markdown.py

@@ -0,0 +1,8 @@
+# from .base import ContentTransform
+#
+#
+# ##
+#
+#
+# class MarkdownContentTransform(ContentTransform):
+#     def apply(self, ):

ommlds/minichain/content/transform/materialize.py

@@ -1,110 +1,51 @@
-import typing as ta
+import abc
 
-from omlish import check
-from omlish import dataclasses as dc
+from omlish import lang
 from omlish.text import templating as tpl
 
-from ..namespaces import ContentNamespace
-from ..namespaces import NamespaceContent
-from ..placeholders import PlaceholderContent
-from ..placeholders import PlaceholderContentKey
-from ..types import Content
-from .base import ContentTransform
+from ..content import Content
+from .recursive import PlaceholderContents
+from .recursive import RecursiveContentMaterializer
+from .templates import TemplateContentMaterializer
 
 
 ##
 
 
-PlaceholderContentMap: ta.TypeAlias = ta.Mapping[PlaceholderContentKey, Content]
-PlaceholderContentFn: ta.TypeAlias = ta.Callable[[PlaceholderContentKey], Content]
-PlaceholderContents: ta.TypeAlias = PlaceholderContentMap | PlaceholderContentFn
-
-
-@dc.dataclass()
-class PlaceholderContentMissingError(Exception):
-    key: PlaceholderContentKey
-
-
-def _make_placeholder_content_fn(cps: PlaceholderContents | None = None) -> PlaceholderContentFn:
-    if cps is None:
-        def none_fn(cpk: PlaceholderContentKey) -> Content:
-            raise PlaceholderContentMissingError(cpk)
-
-        return none_fn
-
-    elif isinstance(cps, ta.Mapping):
-        def mapping_fn(cpk: PlaceholderContentKey) -> Content:
-            try:
-                return cps[cpk]
-            except KeyError:
-                raise PlaceholderContentMissingError(cpk) from None
-
-        return mapping_fn
-
-    elif callable(cps):
-        return cps
-
-    else:
-        raise TypeError(cps)
+class ContentMaterializer(lang.Abstract):
+    @abc.abstractmethod
+    def apply(self, c: Content) -> Content:
+        raise NotImplementedError
 
 
 ##
 
 
-class ContentDepthExceededError(Exception):
-    pass
-
-
-class ContentMaterializer(ContentTransform):
-    DEFAULT_MAX_DEPTH: int = 8
-
+class DefaultContentMaterializer(ContentMaterializer):
     def __init__(
             self,
             *,
             placeholder_contents: PlaceholderContents | None = None,
             templater_context: tpl.Templater.Context | None = None,
-            max_depth: int = DEFAULT_MAX_DEPTH,
     ) -> None:
         super().__init__()
 
+        self._placeholder_contents = placeholder_contents
         self._templater_context = templater_context
-        self._placeholder_content_fn = _make_placeholder_content_fn(placeholder_contents)
-        self._max_depth = max_depth
-
-        self._cur_depth = 0
-
-    def recurse(self, o: Content) -> Content:
-        if self._cur_depth >= self._max_depth:
-            raise ContentDepthExceededError
-
-        self._cur_depth += 1
-        try:
-            return self.apply(o)
-        finally:
-            self._cur_depth -= 1
-
-    @ContentTransform.apply.register
-    def apply_namespace_content(self, c: NamespaceContent) -> Content:
-        check.issubclass(c.ns, ContentNamespace)
-        out: list[Content] = []
-        for n, e in c.ns:
-            if n.startswith('_'):
-                continue
-            out.append(self.recurse(e))
-        return out
 
-    @ContentTransform.apply.register
-    def apply_placeholder_content(self, c: PlaceholderContent) -> Content:
-        return self.recurse(self._placeholder_content_fn(c.k))
+    def apply(self, c: Content) -> Content:
+        c = RecursiveContentMaterializer(self._placeholder_contents).visit(c, None)
+        c = TemplateContentMaterializer(self._templater_context).visit(c, None)
+        return c
 
 
 def materialize_content(
-        o: Content,
+        c: Content,
         *,
         placeholder_contents: PlaceholderContents | None = None,
         templater_context: tpl.Templater.Context | None = None,
 ) -> Content:
-    return ContentMaterializer(
+    return DefaultContentMaterializer(
         placeholder_contents=placeholder_contents,
         templater_context=templater_context,
-    ).apply(o)
+    ).apply(c)

ommlds/minichain/content/transform/metadata.py

@@ -0,0 +1,16 @@
+from ..content import Content
+from ..metadata import ContentOriginal
+from ..standard import StandardContent
+from ..visitors import ContentTransform
+
+
+##
+
+
+class OriginalMetadataStrippingContentTransform(ContentTransform[None]):
+    def visit_standard_content(self, c: StandardContent, ctx: None) -> StandardContent:
+        return c.discard_metadata(ContentOriginal)
+
+
+def strip_content_original_metadata(c: Content) -> Content:
+    return OriginalMetadataStrippingContentTransform().visit(c, None)

ommlds/minichain/content/transform/prepare.py

@@ -8,10 +8,8 @@ import typing as ta
 from omlish import dataclasses as dc
 from omlish import lang
 
-from ..types import Content
-from .interleave import interleave_content
+from ..content import Content
 from .materialize import materialize_content
-from .squeeze import squeeze_content
 from .stringify import stringify_content
 
 
@@ -45,8 +43,6 @@ class DefaultContentPreparer(ContentPreparer):
 
     def prepare(self, c: Content) -> Content:
         c = materialize_content(c)
-        c = squeeze_content(c, strip_strings=self.strip_strings)
-        c = interleave_content(c, block_separator=self.block_separator)
         return c
 
 

ommlds/minichain/content/transform/recursive.py

@@ -0,0 +1,97 @@
+import typing as ta
+
+from omlish import check
+from omlish import dataclasses as dc
+
+from ..content import Content
+from ..namespaces import ContentNamespace
+from ..namespaces import NamespaceContent
+from ..placeholders import PlaceholderContent
+from ..placeholders import PlaceholderContentKey
+from ..recursive import RecursiveContent
+from ..visitors import ContentTransform
+
+
+##
+
+
+PlaceholderContentMap: ta.TypeAlias = ta.Mapping[PlaceholderContentKey, Content]
+PlaceholderContentFn: ta.TypeAlias = ta.Callable[[PlaceholderContentKey], Content]
+PlaceholderContents: ta.TypeAlias = PlaceholderContentMap | PlaceholderContentFn
+
+
+@dc.dataclass()
+class PlaceholderContentMissingError(Exception):
+    key: PlaceholderContentKey
+
+
+def _make_placeholder_content_fn(cps: PlaceholderContents | None = None) -> PlaceholderContentFn:
+    if cps is None:
+        def none_fn(cpk: PlaceholderContentKey) -> Content:
+            raise PlaceholderContentMissingError(cpk)
+
+        return none_fn
+
+    elif isinstance(cps, ta.Mapping):
+        def mapping_fn(cpk: PlaceholderContentKey) -> Content:
+            try:
+                return cps[cpk]
+            except KeyError:
+                raise PlaceholderContentMissingError(cpk) from None
+
+        return mapping_fn
+
+    elif callable(cps):
+        return cps
+
+    else:
+        raise TypeError(cps)
+
+
+##
+
+
+class RecursiveContentDepthExceededError(Exception):
+    pass
+
+
+class RecursiveContentMaterializer(ContentTransform[None]):
+    DEFAULT_MAX_DEPTH: int = 8
+
+    def __init__(
+            self,
+            placeholder_contents: PlaceholderContents | None = None,
+            *,
+            max_depth: int = DEFAULT_MAX_DEPTH,
+    ) -> None:
+        super().__init__()
+
+        self._placeholder_content_fn = _make_placeholder_content_fn(placeholder_contents)
+        self._max_depth = max_depth
+
+        self._cur_depth = 0
+
+    def recurse(self, o: Content, ctx: None) -> Content:
+        if self._cur_depth >= self._max_depth:
+            raise RecursiveContentDepthExceededError
+
+        self._cur_depth += 1
+        try:
+            return self.visit(o, ctx)
+        finally:
+            self._cur_depth -= 1
+
+    def visit_recursive_content(self, c: RecursiveContent, ctx: None) -> Content:
+        raise TypeError(c)
+
+    def visit_namespace_content(self, c: NamespaceContent, ctx: None) -> Content:
+        check.issubclass(c.ns, ContentNamespace)
+        out: list[Content] = []
+        for n, e in c.ns:
+            if n.startswith('_'):
+                continue
+            out.append(self.recurse(e, ctx))
+        return out
+
+    def visit_placeholder_content(self, c: PlaceholderContent, ctx: None) -> Content:
+        return self.recurse(self._placeholder_content_fn(c.k), ctx)

ommlds/minichain/content/transform/standard.py

@@ -0,0 +1,43 @@
+import collections.abc
+import typing as ta
+
+from omlish import check
+
+from ..content import Content
+from ..metadata import ContentOriginal
+from ..sequence import BlockContent
+from ..sequence import InlineContent
+from ..sequence import SequenceContent
+from ..text import TextContent
+from ..visitors import ContentTransform
+
+
+##
+
+
+class LiftToStandardContentTransform(ContentTransform[None]):
+    def __init__(
+            self,
+            *,
+            sequence_mode: ta.Literal['block', 'inline'] = 'block',
+    ) -> None:
+        super().__init__()
+
+        self._sequence_mode = sequence_mode
+
+    def visit_str(self, s: str, ctx: None) -> Content:
+        return TextContent(s).update_metadata(ContentOriginal(s))
+
+    def visit_sequence(self, c: ta.Sequence[Content], ctx: None) -> Content:
+        cc = check.isinstance(super().visit_sequence(c, ctx), collections.abc.Sequence)
+
+        nc: SequenceContent
+        match self._sequence_mode:
+            case 'block':
+                nc = BlockContent(cc)
+            case 'inline':
+                nc = InlineContent(cc)
+            case _:
+                raise ValueError(self._sequence_mode)
+
+        return nc.update_metadata(ContentOriginal(c))

ommlds/minichain/content/transform/stringify.py

@@ -3,8 +3,8 @@ import typing as ta
 
 from omlish import dispatch
 
+from ..content import Content
 from ..text import TextContent
-from ..types import Content
 
 
 ##

ommlds/minichain/content/transform/strings.py

@@ -2,7 +2,11 @@ import typing as ta
 
 from omlish import dataclasses as dc
 
-from .base import ContentTransform
+from ..content import Content
+from ..emphasis import EmphasisContent
+from ..metadata import ContentOriginal
+from ..text import TextContent
+from ..visitors import ContentTransform
 
 
 T = ta.TypeVar('T')
@@ -12,13 +16,18 @@ T = ta.TypeVar('T')
 
 
 @dc.dataclass(frozen=True)
-class StringFnContentTransform(ContentTransform):
+class StringFnContentTransform(ContentTransform[None]):
     fn: ta.Callable[[str], str]
 
-    @ContentTransform.apply.register  # noqa
-    def apply_str(self, s: str) -> str:
-        return self.fn(s)
+    def visit_str(self, c: str, ctx: None) -> TextContent:
+        return TextContent(self.fn(c)).update_metadata(ContentOriginal(c))
 
+    def visit_text_content(self, c: TextContent, ctx: None) -> TextContent:
+        return c.replace(s=self.fn(c.s))
 
-def transform_content_strings(fn: ta.Callable[[str], str], o: T) -> T:
-    return StringFnContentTransform(fn).apply(o)
+    def visit_emphasis_content(self, c: EmphasisContent, ctx: None) -> EmphasisContent:
+        return c.replace(s=self.fn(c.s))
+
+
+def transform_content_strings(fn: ta.Callable[[str], str], o: Content) -> Content:
+    return StringFnContentTransform(fn).visit(o, None)

ommlds/minichain/content/transform/templates.py

@@ -0,0 +1,25 @@
+from omlish import check
+from omlish.text import templating as tpl
+
+from ..content import Content
+from ..metadata import ContentOriginal
+from ..templates import TemplateContent
+from ..text import TextContent
+from ..visitors import ContentTransform
+
+
+##
+
+
+class TemplateContentMaterializer(ContentTransform[None]):
+    def __init__(
+            self,
+            templater_context: tpl.Templater.Context | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._templater_context = templater_context
+
+    def visit_template_content(self, c: TemplateContent, ctx: None) -> Content:
+        s = c.t.render(check.not_none(self._templater_context))
+        return TextContent(s).update_metadata(ContentOriginal(c))