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

ommlds/minichain/content/materialize.py

@@ -1,173 +0,0 @@
-"""
-TODO:
- - ExtendedCanContent
-"""
-import typing as ta
-
-from omlish import check
-from omlish import dataclasses as dc
-from omlish import dispatch
-from omlish.text import templating as tpl
-
-from .cancontent import CanContent
-from .namespaces import ContentNamespace
-from .placeholders import ContentPlaceholder
-from .placeholders import ContentPlaceholderMarker
-from .types import Content
-from .types import ExtendedContent
-
-
-##
-
-
-ContentPlaceholderKey: ta.TypeAlias = ContentPlaceholder | type[ContentPlaceholderMarker]
-ContentPlaceholderMap: ta.TypeAlias = ta.Mapping[ContentPlaceholderKey, CanContent]
-ContentPlaceholderFn: ta.TypeAlias = ta.Callable[[ContentPlaceholderKey], CanContent]
-ContentPlaceholders: ta.TypeAlias = ContentPlaceholderMap | ContentPlaceholderFn
-
-
-@dc.dataclass()
-class ContentPlaceholderMissingError(Exception):
-    key: ContentPlaceholderKey
-
-
-def _make_content_placeholder_fn(cps: ContentPlaceholders | None = None) -> ContentPlaceholderFn:
-    if cps is None:
-        def none_fn(cpk: ContentPlaceholderKey) -> CanContent:
-            raise ContentPlaceholderMissingError(cpk)
-
-        return none_fn
-
-    elif isinstance(cps, ta.Mapping):
-        def mapping_fn(cpk: ContentPlaceholderKey) -> CanContent:
-            try:
-                return cps[cpk]
-            except KeyError:
-                raise ContentPlaceholderMissingError(cpk) from None
-
-        return mapping_fn
-
-    elif callable(cps):
-        return cps
-
-    else:
-        raise TypeError(cps)
-
-
-##
-
-
-class ContentDepthExceededError(Exception):
-    pass
-
-
-class ContentMaterializer:
-    DEFAULT_MAX_DEPTH: int = 100
-
-    def __init__(
-            self,
-            *,
-            content_placeholders: ContentPlaceholders | None = None,
-            templater_context: tpl.Templater.Context | None = None,
-            max_depth: int = DEFAULT_MAX_DEPTH,
-    ) -> None:
-        super().__init__()
-
-        self._templater_context = templater_context
-        self._content_placeholders_fn = _make_content_placeholder_fn(content_placeholders)
-        self._max_depth = max_depth
-
-        self._cur_depth = 0
-
-    def materialize(self, o: CanContent) -> Content:
-        if self._cur_depth >= self._max_depth:
-            raise ContentDepthExceededError
-
-        self._cur_depth += 1
-        try:
-            return self._materialize(o)
-        finally:
-            self._cur_depth -= 1
-
-    @dispatch.method()
-    def _materialize(self, o: CanContent) -> Content:
-        raise TypeError(o)
-
-    #
-
-    @_materialize.register
-    def _materialize_str(self, o: str) -> Content:
-        return o
-
-    @_materialize.register
-    def _materialize_extended_content(self, o: ExtendedContent) -> Content:
-        return o
-
-    #
-
-    @_materialize.register
-    def _materialize_iterable(self, o: ta.Iterable) -> Content:
-        # `collections.abc.Iterable` appears as a virtual base in the dispatch c3.mro for ContentNamespace before `type`
-        # does (due to NamespaceMeta having `__iter__`), so handle that here too.
-        if isinstance(o, type) and issubclass(o, ContentNamespace):
-            return self._materialize_namespace_type(o)
-
-        else:
-            return [self.materialize(e) for e in o]
-
-    @_materialize.register
-    def _materialize_none(self, o: None) -> Content:
-        return []
-
-    #
-
-    @_materialize.register
-    def _materialize_placeholder(self, o: ContentPlaceholder) -> Content:
-        return self.materialize(self._content_placeholders_fn(o))
-
-    def _materialize_placeholder_marker_type(self, o: type[ContentPlaceholderMarker]) -> Content:
-        check.issubclass(o, ContentPlaceholderMarker)
-        return self.materialize(self._content_placeholders_fn(o))
-
-    #
-
-    def _materialize_namespace_type(self, o: type[ContentNamespace]) -> Content:
-        check.issubclass(o, ContentNamespace)
-
-        out: list[Content] = []
-        for n, e in o:
-            if n.startswith('_'):
-                continue
-            out.append(self.materialize(e))
-        return out
-
-    #
-
-    @_materialize.register
-    def _materialize_type(self, o: type) -> Content:
-        if issubclass(o, ContentPlaceholderMarker):
-            return self._materialize_placeholder_marker_type(o)
-
-        elif issubclass(o, ContentNamespace):
-            return self._materialize_namespace_type(o)
-
-        else:
-            raise TypeError(o)
-
-    #
-
-    @_materialize.register
-    def _materialize_templater(self, o: tpl.Templater) -> Content:
-        return o.render(check.not_none(self._templater_context))
-
-
-def materialize_content(
-        o: CanContent,
-        *,
-        content_placeholders: ContentPlaceholders | None = None,
-        templater_context: tpl.Templater.Context | None = None,
-) -> Content:
-    return ContentMaterializer(
-        content_placeholders=content_placeholders,
-        templater_context=templater_context,
-    ).materialize(o)

ommlds/minichain/content/transforms/base.py

@@ -1,46 +0,0 @@
-import collections.abc
-import typing as ta
-
-from omlish import dataclasses as dc
-from omlish import dispatch
-from omlish import lang
-
-from ..images import ImageContent
-from ..sequence import SequenceContent
-from ..text import TextContent
-
-
-T = ta.TypeVar('T')
-
-
-##
-
-
-class ContentTransform(lang.Abstract):
-    @dispatch.method(installable=True)
-    def apply(self, o: T) -> T:
-        raise TypeError(o)
-
-    #
-
-    @apply.register  # noqa
-    def apply_str(self, s: str) -> str:
-        return s
-
-    @apply.register  # noqa
-    def apply_sequence(self, l: collections.abc.Sequence[T]) -> collections.abc.Sequence[T]:
-        return [self.apply(e) for e in l]
-
-    #
-
-    @apply.register
-    def apply_image_content(self, c: ImageContent) -> ImageContent:
-        return c
-
-    @apply.register
-    def apply_sequence_content(self, c: SequenceContent) -> SequenceContent:
-        return dc.replace(c, l=self.apply(c.l))
-
-    @apply.register
-    def apply_text_content(self, c: TextContent) -> TextContent:
-        return dc.replace(c, s=self.apply(c.s))

ommlds/minichain/content/transforms/interleave.py

@@ -1,77 +0,0 @@
-import typing as ta
-
-from omlish import dataclasses as dc
-from omlish import dispatch
-from omlish import lang
-
-from ..cancontent import CanContent
-from ..sequence import BlockContent
-from ..sequence import InlineContent
-from ..types import Content
-from ..types import ExtendedContent
-
-
-##
-
-
-class ContentInterleaver:
-    def __init__(
-            self,
-            *,
-            separator: Content | None = None,
-            sequence_separator: Content | None = None,
-            inline_separator: Content | None = None,
-            block_separator: Content | None = None,
-    ) -> None:
-        super().__init__()
-
-        self._sequence_separator = sequence_separator if sequence_separator is not None else separator
-        self._inline_separator = inline_separator if inline_separator is not None else separator
-        self._block_separator = block_separator if block_separator is not None else separator
-
-    def _interleave(self, l: ta.Iterable[CanContent], separator: Content | None) -> ta.Sequence[Content]:
-        cs: ta.Iterable[Content] = map(self.interleave, l)
-        if separator is not None:
-            cs = lang.interleave(cs, separator)
-        return list(cs)
-
-    @dispatch.method()
-    def interleave(self, c: CanContent) -> Content:
-        raise TypeError(c)
-
-    @interleave.register
-    def interleave_str(self, c: str) -> Content:
-        return c
-
-    @interleave.register
-    def interleave_sequence(self, c: ta.Sequence) -> Content:
-        return self._interleave(c, self._sequence_separator)
-
-    @interleave.register
-    def interleave_extended_content(self, c: ExtendedContent) -> Content:
-        # FIXME:
-        return c
-
-    @interleave.register
-    def interleave_inline_content(self, c: InlineContent) -> Content:
-        return dc.replace(c, l=self._interleave(c.l, self._inline_separator))
-
-    @interleave.register
-    def interleave_block_content(self, c: BlockContent) -> Content:
-        return dc.replace(c, l=self._interleave(c.l, self._block_separator))
-
-
-def interleave_content(
-        c: Content,
-        *,
-        separator: Content | None = None,
-        sequence_separator: Content | None = None,
-        inline_separator: Content | None = None,
-        block_separator: Content | None = None,
-) -> Content:
-    return ContentInterleaver(
-        separator=separator,
-        sequence_separator=sequence_separator,
-        inline_separator=inline_separator,
-        block_separator=block_separator,
-    ).interleave(c)

ommlds/minichain/content/transforms/squeeze.py

@@ -1,72 +0,0 @@
-import typing as ta
-
-from omlish import dataclasses as dc
-from omlish import dispatch
-
-from ..sequence import SequenceContent
-from ..text import TextContent
-from ..types import Content
-from ..types import SingleContent
-
-
-##
-
-
-class ContentSqueezer:
-    def __init__(
-            self,
-            *,
-            strip_strings: bool = False,
-    ) -> None:
-        super().__init__()
-
-        self._strip_strings = strip_strings
-
-    @dispatch.method()
-    def squeeze(self, c: Content) -> ta.Iterable[SingleContent]:
-        raise TypeError(c)
-
-    #
-
-    @squeeze.register
-    def squeeze_str(self, c: str) -> ta.Iterable[SingleContent]:
-        if self._strip_strings:
-            c = c.strip()
-
-        if c:
-            yield c
-
-    @squeeze.register
-    def squeeze_sequence(self, c: ta.Sequence) -> ta.Iterable[SingleContent]:
-        for e in c:
-            yield from self.squeeze(e)
-
-    #
-
-    @squeeze.register
-    def squeeze_single_content(self, c: SingleContent) -> ta.Iterable[SingleContent]:
-        return [c]
-
-    @squeeze.register
-    def squeeze_text_content(self, c: TextContent) -> ta.Iterable[SingleContent]:
-        if self._strip_strings:
-            if (ss := c.s.strip()) != c.s:
-                c = dc.replace(c, s=ss)
-
-        if c.s:
-            yield c.s
-
-    @squeeze.register
-    def squeeze_sequence_content(self, c: SequenceContent) -> ta.Iterable[SingleContent]:
-        for e in c.l:
-            yield from self.squeeze(e)
-
-
-def squeeze_content(
-        c: Content,
-        *,
-        strip_strings: bool = False,
-) -> ta.Sequence[SingleContent]:
-    return list(ContentSqueezer(
-        strip_strings=strip_strings,
-    ).squeeze(c))