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

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

@@ -0,0 +1,14 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .standard import StandardContent
+from .types import Content
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class SectionContent(StandardContent, lang.Final):
+    header: str
+    body: Content

ommlds/minichain/content/sequence.py

@@ -8,16 +8,16 @@ import typing as ta
 from omlish import dataclasses as dc
 from omlish import lang
 
-from .cancontent import CanContent
-from .simple import SimpleExtendedContent
+from .standard import StandardContent
+from .types import Content
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class SequenceContent(SimpleExtendedContent, lang.Abstract):
-    l: ta.Sequence[CanContent]
+class SequenceContent(StandardContent, lang.Abstract):
+    l: ta.Sequence[Content]
 
 
 @dc.dataclass(frozen=True)
@@ -28,3 +28,8 @@ class InlineContent(SequenceContent, lang.Final):
 @dc.dataclass(frozen=True)
 class BlockContent(SequenceContent, lang.Final):
     pass
+
+
+@dc.dataclass(frozen=True)
+class ItemListContent(SequenceContent, lang.Final):
+    pass

ommlds/minichain/content/{simple.py → standard.py}

@@ -8,17 +8,16 @@ from omlish import typedvalues as tv
 from .._typedvalues import _tv_field_metadata
 from ..metadata import MetadataContainer
 from .metadata import ContentMetadatas
-from .types import ExtendedContent
-from .types import SingleExtendedContent
+from .types import BaseContent
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class SimpleExtendedContent(  # noqa
+class StandardContent(  # noqa
     MetadataContainer[ContentMetadatas],
-    ExtendedContent,
+    BaseContent,
     lang.Abstract,
 ):
     _metadata: ta.Sequence[ContentMetadatas] = dc.field(
@@ -36,12 +35,3 @@ class SimpleExtendedContent(  # noqa
 
     def with_metadata(self, *mds: ContentMetadatas, override: bool = False) -> ta.Self:
         return dc.replace(self, _metadata=tv.TypedValues(*self._metadata, *mds, override=override))
-
-
-@dc.dataclass(frozen=True)
-class SimpleSingleExtendedContent(
-    SimpleExtendedContent,
-    SingleExtendedContent,
-    lang.Abstract,
-):
-    pass

ommlds/minichain/content/tag.py

@@ -6,14 +6,14 @@ TODO:
 from omlish import dataclasses as dc
 from omlish import lang
 
-from .cancontent import CanContent
-from .simple import SimpleExtendedContent
+from .standard import StandardContent
+from .types import Content
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class TagContent(SimpleExtendedContent, lang.Final):
+class TagContent(StandardContent, lang.Final):
     tag: str
-    body: CanContent
+    body: Content

ommlds/minichain/content/templates.py

@@ -0,0 +1,14 @@
+from omlish import dataclasses as dc
+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):
+    t: tpl.Templater

ommlds/minichain/content/text.py

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

ommlds/minichain/content/transform/base.py

@@ -0,0 +1,63 @@
+import collections.abc
+
+from omlish import dataclasses as dc
+from omlish import dispatch
+from omlish import lang
+
+from ..quote import QuoteContent
+from ..section import SectionContent
+from ..sequence import SequenceContent
+from ..tag import TagContent
+from ..text import TextContent
+from ..types import Content
+from ..types import LeafContent
+
+
+##
+
+
+class ContentTransform(lang.Abstract):
+    @dispatch.method()
+    def apply(self, o: Content) -> Content:
+        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) -> collections.abc.Sequence:
+        # FIXME: this should be `Sequence[Content] -> Sequence[Content]` but omlish.reflect can't handle recursive
+        #   ForwardRef's yet
+        r = [self.apply(e) for e in l]
+        if len(r) == len(l) and all(le is re for le, re in zip(l, r)):
+            return l
+        return r
+
+    #
+
+    @apply.register
+    def apply_leaf_content(self, c: LeafContent) -> LeafContent:
+        return c
+
+    @apply.register
+    def apply_quote_content(self, c: QuoteContent) -> QuoteContent:
+        return dc.replace_is_not(c, l=self.apply(c.body))
+
+    @apply.register
+    def apply_section_content(self, c: SectionContent) -> SectionContent:
+        return dc.replace_is_not(c, l=self.apply(c.body))
+
+    @apply.register
+    def apply_sequence_content(self, c: SequenceContent) -> SequenceContent:
+        return dc.replace_is_not(c, l=self.apply(c.l))
+
+    @apply.register
+    def apply_tag_content(self, c: TagContent) -> TagContent:
+        return dc.replace_is_not(c, c=self.apply(c.body))
+
+    @apply.register
+    def apply_text_content(self, c: TextContent) -> TextContent:
+        return dc.replace_is_not(c, s=self.apply(c.s))

ommlds/minichain/content/transform/interleave.py

@@ -0,0 +1,68 @@
+from ..types import Content
+from .base import ContentTransform
+
+
+##
+
+
+class ContentInterleaver(ContentTransform):
+    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[Content], 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: Content) -> 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: BaseContent) -> 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,
+    ).apply(c)

ommlds/minichain/content/transform/materialize.py

@@ -0,0 +1,110 @@
+import typing as ta
+
+from omlish import check
+from omlish import dataclasses as dc
+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
+
+
+##
+
+
+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 ContentDepthExceededError(Exception):
+    pass
+
+
+class ContentMaterializer(ContentTransform):
+    DEFAULT_MAX_DEPTH: int = 8
+
+    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._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 materialize_content(
+        o: Content,
+        *,
+        placeholder_contents: PlaceholderContents | None = None,
+        templater_context: tpl.Templater.Context | None = None,
+) -> Content:
+    return ContentMaterializer(
+        placeholder_contents=placeholder_contents,
+        templater_context=templater_context,
+    ).apply(o)

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

@@ -8,12 +8,11 @@ import typing as ta
 from omlish import dataclasses as dc
 from omlish import lang
 
-from .cancontent import CanContent
+from ..types import Content
+from .interleave import interleave_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 .squeeze import squeeze_content
+from .stringify import stringify_content
 
 
 ##
@@ -21,13 +20,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,7 +43,7 @@ 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)
@@ -55,7 +54,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 +69,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/squeeze.py

@@ -0,0 +1,59 @@
+import typing as ta
+
+from ..types import Content
+from .base import ContentTransform
+
+
+##
+
+
+class ContentSqueezer(ContentTransform):
+    def __init__(
+            self,
+            *,
+            strip_strings: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._strip_strings = strip_strings
+
+    @ContentTransform.apply.register
+    def squeeze_str(self, c: str) -> ta.Iterable[Content]:
+        if self._strip_strings:
+            c = c.strip()
+        return c
+
+    # @squeeze.register
+    # def squeeze_sequence(self, c: ta.Sequence) -> ta.Iterable[Content]:
+    #     for e in c:
+    #         yield from self.squeeze(e)
+
+    # #
+
+    # # @squeeze.register
+    # # def squeeze_single_content(self, c: Content) -> ta.Iterable[Content]:
+    # #     return [c]
+
+    # @squeeze.register
+    # def squeeze_text_content(self, c: TextContent) -> ta.Iterable[Content]:
+    #     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[Content]:
+    #     for e in c.l:
+    #         yield from self.squeeze(e)
+
+
+def squeeze_content(
+        c: Content,
+        *,
+        strip_strings: bool = False,
+) -> Content:
+    return ContentSqueezer(
+        strip_strings=strip_strings,
+    ).apply(c)

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

@@ -3,7 +3,6 @@ import typing as ta
 
 from omlish import dispatch
 
-from ..sequence import SequenceContent
 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/types.py

@@ -6,11 +6,11 @@ from omlish import lang
 ##
 
 
-class ExtendedContent(lang.Abstract, lang.PackageSealed):
+class BaseContent(lang.Abstract, lang.PackageSealed):
     pass
 
 
-class SingleExtendedContent(ExtendedContent, lang.Abstract):
+class LeafContent(BaseContent, lang.Abstract):
     pass
 
 
@@ -19,25 +19,13 @@ class SingleExtendedContent(ExtendedContent, lang.Abstract):
 
 Content: ta.TypeAlias = ta.Union[  # noqa
     str,
-    ExtendedContent,
+    BaseContent,
     ta.Sequence['Content'],
 ]
 
 
-CONTENT_RUNTIME_TYPES: tuple[type, ...] = (
+CONTENT_TYPES: tuple[type, ...] = (
     str,
+    BaseContent,
     ta.Sequence,
-    ExtendedContent,
-)
-
-#
-
-SingleContent: ta.TypeAlias = ta.Union[  # noqa
-    str,
-    SingleExtendedContent,
-]
-
-SINGLE_CONTENT_RUNTIME_TYPES: tuple[type, ...] = (
-    str,
-    SingleExtendedContent,
 )

ommlds/minichain/lib/todo/tools/write.py

@@ -8,6 +8,7 @@ from omlish import lang
 from omlish import marshal as msh
 
 from ....content.namespaces import ContentNamespace
+from ....content.namespaces import NamespaceContent
 from ....tools.execution.catalog import ToolCatalogEntry
 from ....tools.execution.reflect import reflect_tool_catalog_entry
 from ....tools.reflect import tool_spec_override
@@ -311,7 +312,7 @@ class TodoWriteDescriptionChunks(ContentNamespace):
 
 
 @tool_spec_override(
-    desc=TodoWriteDescriptionChunks,
+    desc=NamespaceContent(TodoWriteDescriptionChunks),
 )
 def execute_todo_write_tool(todo_items: ta.Sequence[TodoItem]) -> ta.Sequence[TodoItem]:
     if todo_items:

ommlds/minichain/tools/execution/errorhandling.py

@@ -1,6 +1,6 @@
 import typing as ta
 
-from ...content.materialize import ContentMaterializer
+from ...content.transform.materialize import ContentMaterializer
 from ...content.types import Content
 from .context import ToolContext
 from .errors import ToolExecutionError
@@ -32,4 +32,4 @@ class ErrorHandlingToolExecutor(ToolExecutor):
             return await self._wrapped.execute_tool(ctx, name, args)
 
         except ToolExecutionError as txe:
-            return self._content_materializer.materialize(txe.content)
+            return self._content_materializer.apply(txe.content)

ommlds/minichain/tools/execution/errors.py

@@ -2,7 +2,7 @@ import abc
 
 from omlish import lang
 
-from ...content.cancontent import CanContent
+from ...content.types import Content
 
 
 ##
@@ -11,5 +11,5 @@ from ...content.cancontent import CanContent
 class ToolExecutionError(Exception, lang.Abstract):
     @property
     @abc.abstractmethod
-    def content(self) -> CanContent:
+    def content(self) -> Content:
         raise NotImplementedError

ommlds/minichain/tools/jsonschema.py

@@ -4,8 +4,8 @@ TODO:
 """
 from omlish import check
 
-from ..content.prepare import ContentStrPreparer
-from ..content.prepare import default_content_str_preparer
+from ..content.transform.prepare import ContentStrPreparer
+from ..content.transform.prepare import default_content_str_preparer
 from .types import EnumToolDtype
 from .types import MappingToolDtype
 from .types import NullableToolDtype