ommlds 0.0.0.dev466__py3-none-any.whl → 0.0.0.dev512__py3-none-any.whl

ommlds/minichain/content/resources.py

@@ -0,0 +1,22 @@
+from omlish import check
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .recursive import RecursiveContent
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ResourceContent(RecursiveContent, lang.Final):
+    package: str
+    file: str
+
+
+def resource_content(*parts: str) -> ResourceContent:
+    *package_parts, file = parts
+    for p in check.not_empty(package_parts):
+        check.non_empty_str(p)
+        check.arg(not (p.startswith('.') or p.endswith('.')))
+    return ResourceContent('.'.join(package_parts), file)

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 VisitorContentTransform
+
+
+##
+
+
+class JsonContentRenderer(VisitorContentTransform[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 transform(self, ):

ommlds/minichain/content/transform/materialize.py

@@ -0,0 +1,59 @@
+import abc
+
+from omlish import lang
+from omlish.text import templating as tpl
+
+from ..content import Content
+from .namespaces import NamespaceContentMaterializer
+from .placeholders import PlaceholderContentMaterializer
+from .placeholders import PlaceholderContents
+from .recursive import RecursiveContentMaterializer
+from .resources import ResourceContentMaterializer
+from .templates import TemplateContentMaterializer
+
+
+##
+
+
+class ContentMaterializer(lang.Abstract):
+    @abc.abstractmethod
+    def materialize(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._recursive_materializer = RecursiveContentMaterializer(
+            NamespaceContentMaterializer(),
+            PlaceholderContentMaterializer(placeholder_contents),
+            ResourceContentMaterializer(),
+        )
+
+        self._template_materializer = TemplateContentMaterializer(templater_context)
+
+    def materialize(self, c: Content) -> Content:
+        c = self._recursive_materializer.transform(c, None)
+        c = self._template_materializer.transform(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,
+    ).materialize(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 VisitorContentTransform
+
+
+##
+
+
+class OriginalMetadataStrippingContentTransform(VisitorContentTransform[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().transform(c, None)

ommlds/minichain/content/transform/namespaces.py

@@ -0,0 +1,20 @@
+from omlish import check
+
+from ..content import Content
+from ..namespaces import ContentNamespace
+from ..namespaces import NamespaceContent
+from .visitors import VisitorContentTransform
+
+
+##
+
+
+class NamespaceContentMaterializer(VisitorContentTransform[None]):
+    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.transform(e, ctx))
+        return out

ommlds/minichain/content/transform/placeholders.py

@@ -0,0 +1,60 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+
+from ..content import Content
+from ..placeholders import PlaceholderContent
+from ..placeholders import PlaceholderContentKey
+from .visitors import VisitorContentTransform
+
+
+##
+
+
+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 PlaceholderContentMaterializer(VisitorContentTransform[None]):
+    def __init__(
+            self,
+            placeholder_contents: PlaceholderContents | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._placeholder_content_fn = _make_placeholder_content_fn(placeholder_contents)
+
+    def visit_placeholder_content(self, c: PlaceholderContent, ctx: None) -> Content:
+        return self._placeholder_content_fn(c.k)

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,54 @@
+import typing as ta
+
+from ..content import Content
+from .types import ContentTransform
+
+
+C = ta.TypeVar('C')
+
+
+##
+
+
+class RecursiveContentDepthExceededError(Exception):
+    pass
+
+
+class RecursiveContentMaterializer(ContentTransform[C]):
+    DEFAULT_MAX_ITERATIONS: int = 8
+
+    def __init__(
+            self,
+            *children: ContentTransform[C],
+            max_iterations: int = DEFAULT_MAX_ITERATIONS,
+            debug: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._children = children
+        self._max_iterations = max_iterations
+        self._debug = debug
+
+    def transform(self, content: Content, ctx: C) -> Content:
+        n = 0
+
+        history: list[Content] | None = None
+        if self._debug:
+            history = []
+
+        while True:
+            if history is not None:
+                history.append(content)
+
+            if n >= self._max_iterations:
+                raise RecursiveContentDepthExceededError
+
+            out = content
+            for child in self._children:
+                out = child.transform(out, ctx)
+
+            if out is content:
+                return content
+
+            content = out
+            n += 1

ommlds/minichain/content/transform/resources.py

@@ -0,0 +1,58 @@
+from omlish import lang
+
+from ..content import Content
+from ..metadata import ContentOriginal
+from ..resources import ResourceContent
+from ..standard import StandardContent
+from ..text import TextContent
+from .visitors import VisitorContentTransform
+
+
+##
+
+
+class ResourceContentCache:
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._cache: dict[tuple[str, str], StandardContent] = {}
+
+    def get(self, rc: ResourceContent) -> StandardContent:
+        key = (rc.package, rc.file)
+
+        try:
+            return self._cache[key]
+        except KeyError:
+            pass
+
+        nc = self.load(rc)
+        self._cache[key] = nc
+        return nc
+
+    def load(self, rc: ResourceContent) -> StandardContent:
+        pr = lang.get_package_resources(rc.package)
+        rf = pr[rc.file]
+        txt = rf.read_text()
+        return TextContent(txt)
+
+
+RESOURCE_CONTENT_CACHE = ResourceContentCache()
+
+
+##
+
+
+class ResourceContentMaterializer(VisitorContentTransform[None]):
+    def __init__(
+            self,
+            content_cache: ResourceContentCache | None = None,
+    ) -> None:
+        super().__init__()
+
+        if content_cache is None:
+            content_cache = RESOURCE_CONTENT_CACHE
+        self._content_cache = content_cache
+
+    def visit_resource_content(self, c: ResourceContent, ctx: None) -> Content:
+        nc = self._content_cache.get(c)
+        return nc.with_metadata(ContentOriginal(c))

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 VisitorContentTransform
+
+
+##
+
+
+class LiftToStandardContentTransform(VisitorContentTransform[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