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

ommlds/minichain/content/materialize.py

@@ -1,196 +0,0 @@
-"""
-TODO:
- - ExtendedCanContent
-"""
-import dataclasses as dc
-import typing as ta
-
-from omlish import check
-from omlish import dispatch
-from omlish.text import templating as tpl
-
-from .namespaces import ContentNamespace
-from .placeholders import ContentPlaceholder
-from .placeholders import ContentPlaceholderMarker
-from .types import Content
-from .types import ExtendedContent
-
-
-##
-
-
-_InnerCanContent: ta.TypeAlias = ta.Union[  # noqa
-    str,
-    ExtendedContent,
-
-    ContentPlaceholder,
-    type[ContentPlaceholderMarker],
-
-    type[ContentNamespace],
-
-    tpl.Templater,
-]
-
-CanContent: ta.TypeAlias = ta.Union[  # noqa
-    ta.Iterable['CanContent'],
-
-    None,
-
-    _InnerCanContent,
-]
-
-
-##
-
-
-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/simple.py

@@ -1,47 +0,0 @@
-import typing as ta
-
-from omlish import check
-from omlish import dataclasses as dc
-from omlish import lang
-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
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class SimpleExtendedContent(  # noqa
-    MetadataContainer[ContentMetadatas],
-    ExtendedContent,
-    lang.Abstract,
-):
-    _metadata: ta.Sequence[ContentMetadatas] = dc.field(
-        default=(),
-        kw_only=True,
-        metadata=_tv_field_metadata(
-            ContentMetadatas,
-            marshal_name='metadata',
-        ),
-    )
-
-    @property
-    def metadata(self) -> tv.TypedValues[ContentMetadatas]:
-        return check.isinstance(self._metadata, tv.TypedValues)
-
-    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/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,70 +0,0 @@
-import typing as ta
-
-from omlish import dataclasses as dc
-from omlish import dispatch
-from omlish import lang
-
-from ..sequence import BlockContent
-from ..sequence import InlineContent
-from ..types import Content
-
-
-##
-
-
-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[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:
-        return 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_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))

ommlds/minichain/content/transforms/strings.py

@@ -1,24 +0,0 @@
-import typing as ta
-
-from omlish import dataclasses as dc
-
-from .base import ContentTransform
-
-
-T = ta.TypeVar('T')
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class StringFnContentTransform(ContentTransform):
-    fn: ta.Callable[[str], str]
-
-    @ContentTransform.apply.register  # noqa
-    def apply_str(self, s: str) -> str:
-        return self.fn(s)
-
-
-def transform_content_strings(fn: ta.Callable[[str], str], o: T) -> T:
-    return StringFnContentTransform(fn).apply(o)

ommlds/minichain/content/types.py

@@ -1,43 +0,0 @@
-import typing as ta
-
-from omlish import lang
-
-
-##
-
-
-class ExtendedContent(lang.Abstract, lang.PackageSealed):
-    pass
-
-
-class SingleExtendedContent(ExtendedContent, lang.Abstract):
-    pass
-
-
-##
-
-
-Content: ta.TypeAlias = ta.Union[  # noqa
-    str,
-    ExtendedContent,
-    ta.Sequence['Content'],
-]
-
-
-CONTENT_RUNTIME_TYPES: tuple[type, ...] = (
-    str,
-    ta.Sequence,
-    ExtendedContent,
-)
-
-#
-
-SingleContent: ta.TypeAlias = ta.Union[  # noqa
-    str,
-    SingleExtendedContent,
-]
-
-SINGLE_CONTENT_RUNTIME_TYPES: tuple[type, ...] = (
-    str,
-    SingleExtendedContent,
-)

ommlds/minichain/stream/wrap.py

@@ -1,62 +0,0 @@
-# ruff: noqa: UP028
-import typing as ta
-
-from ..resources import UseResources
-from ..services import Request
-from ..services import Service
-from ..types import Output
-from .services import StreamResponse
-from .services import StreamResponseSink
-from .services import new_stream_response
-
-
-StreamRequestT = ta.TypeVar('StreamRequestT', bound=Request)
-V = ta.TypeVar('V')
-OutputT = ta.TypeVar('OutputT', bound=Output)
-StreamOutputT = ta.TypeVar('StreamOutputT', bound=Output)
-
-
-##
-
-
-class WrappedStreamService(ta.Generic[StreamRequestT, V, OutputT, StreamOutputT]):
-    """Only handles simple, non-type-modifying usecases."""
-
-    def __init__(self, inner: Service[StreamRequestT, StreamResponse[V, OutputT, StreamOutputT]]) -> None:
-        super().__init__()
-
-        self._inner = inner
-
-    #
-
-    async def _process_request(self, request: StreamRequestT) -> StreamRequestT:
-        return request
-
-    async def _process_stream_outputs(self, outputs: ta.Sequence[StreamOutputT]) -> ta.Sequence[StreamOutputT]:
-        return outputs
-
-    async def _process_value(self, v: V) -> ta.Iterable[V]:
-        return [v]
-
-    async def _process_outputs(self, outputs: ta.Sequence[OutputT]) -> ta.Sequence[OutputT]:
-        return outputs
-
-    #
-
-    async def invoke(self, request: StreamRequestT) -> StreamResponse[V, OutputT, StreamOutputT]:
-        async with UseResources.or_new(request.options) as rs:  # noqa
-            in_resp = await self._inner.invoke(await self._process_request(request))
-            in_vs = await rs.enter_async_context(in_resp.v)
-
-            async def inner(sink: StreamResponseSink[V]) -> ta.Sequence[OutputT] | None:
-                async for in_v in in_vs:
-                    for out_v in (await self._process_value(in_v)):
-                        await sink.emit(out_v)
-
-                return await self._process_outputs(in_vs.outputs)
-
-            return await new_stream_response(
-                rs,
-                inner,
-                await self._process_stream_outputs(in_resp.outputs),
-            )