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

ommlds/minichain/content/quote.py

@@ -0,0 +1,17 @@
+"""
+TODO:
+ - attribution
+"""
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .standard import StandardContent
+from .types import Content
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class QuoteContent(StandardContent, lang.Final):
+    body: Content

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,7 +8,7 @@ import typing as ta
 from omlish import dataclasses as dc
 from omlish import lang
 
-from .simple import SimpleExtendedContent
+from .standard import StandardContent
 from .types import Content
 
 
@@ -16,7 +16,7 @@ from .types import Content
 
 
 @dc.dataclass(frozen=True)
-class SequenceContent(SimpleExtendedContent, lang.Abstract):
+class SequenceContent(StandardContent, lang.Abstract):
     l: ta.Sequence[Content]
 
 
@@ -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

@@ -0,0 +1,19 @@
+"""
+TODO:
+ - track BlockContent nesting depth?
+ - section names? dedicated 'section' content with header and body?
+"""
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .standard import StandardContent
+from .types import Content
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class TagContent(StandardContent, lang.Final):
+    tag: str
+    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}

@@ -1,19 +1,18 @@
 """
 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 ..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/fs/tools/read.py

@@ -27,7 +27,7 @@ MAX_LINE_LENGTH = 2_000
 
 @tool_spec_override(
     desc=f"""
-         Reads a file from the local filesystem. You can access any file directly by using this tool.
+        Reads a file from the local filesystem. You can access any file directly by using this tool.
 
         Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that
         path is valid. It is okay to read a file that does not exist; an error will be returned.

ommlds/minichain/lib/fs/tools/recursivels/rendering.py

@@ -5,10 +5,10 @@ TODO:
   - any directory with unlisted children will be suffixed inline with '...'
   - absence of '...' indicates an empty directory
 """
-import dataclasses as dc
 import typing as ta
 
 from omlish import check
+from omlish import dataclasses as dc
 from omlish import lang
 
 from .running import DirLsItem

ommlds/minichain/lib/fs/tools/recursivels/running.py

@@ -1,8 +1,8 @@
-import dataclasses as dc
 import os.path
 import typing as ta
 
 from omlish import check
+from omlish import dataclasses as dc
 from omlish import lang
 
 

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: