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

ommlds/minichain/content/section.py

@@ -0,0 +1,26 @@
+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 SectionContent(CompositeContent, lang.Final):
+    body: Content
+
+    _: dc.KW_ONLY
+
+    header: str | None
+
+    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/sequence.py

@@ -1,5 +1,6 @@
 """
 TODO:
+ - ... does inline have *any* separator? generic whitespace when content is stripped?
  - track BlockContent nesting depth?
  - section names? dedicated 'section' content with header and body?
 """
@@ -8,17 +9,23 @@ import typing as ta
 from omlish import dataclasses as dc
 from omlish import lang
 
-from .simple import SimpleExtendedContent
-from .types import Content
+from .composite import CompositeContent
+from .content import Content
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class SequenceContent(SimpleExtendedContent, lang.Abstract):
+class SequenceContent(CompositeContent, lang.Abstract):
     l: ta.Sequence[Content]
 
+    def child_content(self) -> ta.Sequence[Content]:
+        return self.l
+
+    def _replace_child_content(self, new_child_content: ta.Sequence[Content]) -> ta.Self:
+        return self.replace(l=new_child_content)
+
 
 @dc.dataclass(frozen=True)
 class InlineContent(SequenceContent, lang.Final):
@@ -28,3 +35,10 @@ class InlineContent(SequenceContent, lang.Final):
 @dc.dataclass(frozen=True)
 class BlockContent(SequenceContent, lang.Final):
     pass
+
+
+@dc.dataclass(frozen=True)
+class ItemListContent(SequenceContent, lang.Final):
+    _: dc.KW_ONLY
+
+    style: ta.Literal['-', '#'] = '-'

ommlds/minichain/content/standard.py

@@ -0,0 +1,32 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+from omlish import lang
+
+from ..metadata import MetadataContainerDataclass
+from .content import BaseContent
+from .metadata import ContentMetadatas
+from .metadata import ContentOriginal
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class StandardContent(  # noqa
+    MetadataContainerDataclass[ContentMetadatas],
+    BaseContent,
+    lang.Abstract,
+):
+    _metadata: ta.Sequence[ContentMetadatas] = dc.field(
+        default=(),
+        kw_only=True,
+        repr=False,
+    )
+
+    MetadataContainerDataclass._configure_metadata_field(_metadata, ContentMetadatas)  # noqa
+
+    def replace(self, **kwargs: ta.Any) -> ta.Self:
+        if (n := dc.replace_is_not(self, **kwargs)) is self:
+            return self
+        return n.with_metadata(ContentOriginal(self), discard=[ContentOriginal], override=True)

ommlds/minichain/content/tag.py

@@ -0,0 +1,28 @@
+"""
+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 .composite import CompositeContent
+from .content import Content
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+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

@@ -0,0 +1,13 @@
+from omlish import dataclasses as dc
+from omlish import lang
+from omlish.text import templating as tpl
+
+from .dynamic import DynamicContent
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class TemplateContent(DynamicContent, lang.Final):
+    t: tpl.Templater

ommlds/minichain/content/text.py

@@ -1,12 +1,12 @@
 from omlish import dataclasses as dc
 from omlish import lang
 
-from .simple import SimpleSingleExtendedContent
+from .standard import StandardContent
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class TextContent(SimpleSingleExtendedContent, 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.with_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

@@ -0,0 +1,51 @@
+import abc
+
+from omlish import lang
+from omlish.text import templating as tpl
+
+from ..content import Content
+from .recursive import PlaceholderContents
+from .recursive import RecursiveContentMaterializer
+from .templates import TemplateContentMaterializer
+
+
+##
+
+
+class ContentMaterializer(lang.Abstract):
+    @abc.abstractmethod
+    def apply(self, c: Content) -> Content:
+        raise NotImplementedError
+
+
+##
+
+
+class DefaultContentMaterializer(ContentMaterializer):
+    def __init__(
+            self,
+            *,
+            placeholder_contents: PlaceholderContents | None = None,
+            templater_context: tpl.Templater.Context | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._placeholder_contents = placeholder_contents
+        self._templater_context = templater_context
+
+    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(
+        c: Content,
+        *,
+        placeholder_contents: PlaceholderContents | None = None,
+        templater_context: tpl.Templater.Context | None = None,
+) -> Content:
+    return DefaultContentMaterializer(
+        placeholder_contents=placeholder_contents,
+        templater_context=templater_context,
+    ).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.with_metadata(discard=[ContentOriginal])
+
+
+def strip_content_original_metadata(c: Content) -> Content:
+    return OriginalMetadataStrippingContentTransform().visit(c, None)

ommlds/minichain/content/{prepare.py → transform/prepare.py}

@@ -1,19 +1,16 @@
 """
 TODO:
- - re-softwrap
+ - re-docwrap
 """
 import abc
-import dataclasses as dc
 import typing as ta
 
+from omlish import dataclasses as dc
 from omlish import lang
 
-from .materialize import CanContent
+from ..content import Content
 from .materialize import materialize_content
-from .transforms.interleave import interleave_content
-from .transforms.squeeze import squeeze_content
-from .transforms.stringify import stringify_content
-from .types import Content
+from .stringify import stringify_content
 
 
 ##
@@ -21,13 +18,13 @@ from .types import Content
 
 class ContentPreparer(lang.Abstract):
     @abc.abstractmethod
-    def prepare(self, c: CanContent) -> Content:
+    def prepare(self, c: Content) -> Content:
         raise NotImplementedError
 
 
 class ContentStrPreparer(lang.Abstract):
     @abc.abstractmethod
-    def prepare_str(self, c: CanContent) -> str:
+    def prepare_str(self, c: Content) -> str:
         raise NotImplementedError
 
 
@@ -44,10 +41,8 @@ class DefaultContentPreparer(ContentPreparer):
     strip_strings: bool = True
     block_separator: Content = DEFAULT_BLOCK_SEPARATOR
 
-    def prepare(self, c: CanContent) -> Content:
+    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
 
 
@@ -55,7 +50,7 @@ class DefaultContentPreparer(ContentPreparer):
 class DefaultContentStrPreparer(ContentStrPreparer):
     content_preparer: ContentPreparer
 
-    def prepare_str(self, c: CanContent) -> str:
+    def prepare_str(self, c: Content) -> str:
         return stringify_content(self.content_preparer.prepare(c))
 
 
@@ -70,9 +65,9 @@ def default_content_str_preparer(**kwargs: ta.Any) -> ContentStrPreparer:
     return DefaultContentStrPreparer(DefaultContentPreparer(**kwargs))
 
 
-def prepare_content(c: CanContent, **kwargs: ta.Any) -> Content:
+def prepare_content(c: Content, **kwargs: ta.Any) -> Content:
     return default_content_preparer(**kwargs).prepare(c)
 
 
-def prepare_content_str(c: CanContent, **kwargs: ta.Any) -> str:
+def prepare_content_str(c: Content, **kwargs: ta.Any) -> str:
     return default_content_str_preparer(**kwargs).prepare_str(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).with_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.with_metadata(ContentOriginal(c))

ommlds/minichain/content/{transforms → transform}/stringify.py

@@ -3,9 +3,8 @@ import typing as ta
 
 from omlish import dispatch
 
-from ..sequence import SequenceContent
+from ..content import Content
 from ..text import TextContent
-from ..types import Content
 
 
 ##
@@ -45,11 +44,6 @@ class ContentStringWriter:
     def write_text_content(self, c: TextContent) -> None:
         self._out.write(c.s)
 
-    @write.register
-    def write_sequence_content(self, c: SequenceContent) -> None:
-        for e in c.l:
-            self.write(e)
-
     #
 
     @classmethod

ommlds/minichain/content/transform/strings.py

@@ -0,0 +1,33 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+
+from ..content import Content
+from ..emphasis import EmphasisContent
+from ..metadata import ContentOriginal
+from ..text import TextContent
+from ..visitors import ContentTransform
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class StringFnContentTransform(ContentTransform[None]):
+    fn: ta.Callable[[str], str]
+
+    def visit_str(self, c: str, ctx: None) -> TextContent:
+        return TextContent(self.fn(c)).with_metadata(ContentOriginal(c))
+
+    def visit_text_content(self, c: TextContent, ctx: None) -> TextContent:
+        return c.replace(s=self.fn(c.s))
+
+    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).with_metadata(ContentOriginal(c))