ommlds 0.0.0.dev480__py3-none-any.whl → 0.0.0.dev503__py3-none-any.whl

ommlds/cli/sessions/chat/chat/user/inject.py

@@ -1,62 +0,0 @@
-from omlish import inject as inj
-from omlish import lang
-
-from ...... import minichain as mc
-from ...phases.injection import phase_callbacks
-from ...phases.types import ChatPhase
-from ...phases.types import ChatPhaseCallback
-from .configs import UserConfig
-
-
-with lang.auto_proxy_import(globals()):
-    from .....inputs import asyncs as _inputs_asyncs
-    from .....inputs import sync as _inputs_sync
-    from ..state import types as _state
-    from . import interactive as _interactive
-    from . import oneshot as _oneshot
-    from . import types as _types
-
-
-##
-
-
-def bind_user(cfg: UserConfig = UserConfig()) -> inj.Elements:
-    els: list[inj.Elemental] = []
-
-    # FIXME: barf
-    if cfg.initial_system_content is not None:
-        async def add_initial_system_content(cm: '_state.ChatStateManager') -> None:
-            await cm.extend_chat([mc.SystemMessage(cfg.initial_system_content)])
-
-        els.append(phase_callbacks().bind_item(to_fn=lang.typed_lambda(cm=_state.ChatStateManager)(
-            lambda cm: ChatPhaseCallback(ChatPhase.STARTED, lambda: add_initial_system_content(cm)),
-        )))
-
-    if cfg.interactive:
-        if cfg.initial_user_content is not None:
-            async def add_initial_user_content(cm: '_state.ChatStateManager') -> None:
-                await cm.extend_chat([mc.UserMessage(cfg.initial_user_content)])
-
-            els.append(phase_callbacks().bind_item(to_fn=lang.typed_lambda(cm=_state.ChatStateManager)(
-                lambda cm: ChatPhaseCallback(ChatPhase.STARTED, lambda: add_initial_user_content(cm)),
-            )))
-
-            raise NotImplementedError
-
-        els.append(inj.bind(_types.UserChatInput, to_ctor=_interactive.InteractiveUserChatInput, singleton=True))
-
-        els.extend([
-            inj.bind(_inputs_sync.SyncStringInput, to_const=_inputs_sync.InputSyncStringInput(use_readline=cfg.use_readline)),  # noqa
-            inj.bind(_inputs_asyncs.AsyncStringInput, to_ctor=_inputs_asyncs.ThreadAsyncStringInput, singleton=True),
-        ])
-
-    else:
-        if cfg.initial_user_content is None:
-            raise ValueError('Initial user content is required for non-interactive chat')
-
-        els.extend([
-            inj.bind(_oneshot.OneshotUserChatInputInitialChat, to_const=[mc.UserMessage(cfg.initial_user_content)]),
-            inj.bind(_types.UserChatInput, to_ctor=_oneshot.OneshotUserChatInput, singleton=True),
-        ])
-
-    return inj.as_elements(*els)

ommlds/cli/sessions/chat/chat/user/interactive.py

@@ -1,31 +0,0 @@
-import typing as ta
-
-from ...... import minichain as mc
-from .....inputs.asyncs import AsyncStringInput
-from .....inputs.asyncs import SyncAsyncStringInput
-from .....inputs.sync import InputSyncStringInput
-from .types import UserChatInput
-
-
-##
-
-
-class InteractiveUserChatInput(UserChatInput):
-    DEFAULT_STRING_INPUT: ta.ClassVar[AsyncStringInput] = SyncAsyncStringInput(InputSyncStringInput())
-
-    def __init__(
-            self,
-            string_input: AsyncStringInput | None = None,
-    ) -> None:
-        super().__init__()
-
-        if string_input is None:
-            string_input = self.DEFAULT_STRING_INPUT
-        self._string_input = string_input
-
-    async def get_next_user_messages(self) -> 'mc.UserChat':
-        try:
-            s = await self._string_input()
-        except EOFError:
-            return []
-        return [mc.UserMessage(s)]

ommlds/cli/sessions/chat/chat/user/oneshot.py

@@ -1,25 +0,0 @@
-import typing as ta
-
-from ...... import minichain as mc
-from .types import UserChatInput
-
-
-##
-
-
-OneshotUserChatInputInitialChat = ta.NewType('OneshotUserChatInputInitialChat', mc.UserChat)
-
-
-class OneshotUserChatInput(UserChatInput):
-    def __init__(
-            self,
-            initial_chat: OneshotUserChatInputInitialChat,
-    ) -> None:
-        super().__init__()
-
-        self._pending_chat: mc.UserChat | None = initial_chat
-
-    async def get_next_user_messages(self) -> 'mc.UserChat':
-        ret = self._pending_chat
-        self._pending_chat = None
-        return ret or []

ommlds/cli/sessions/chat/chat/user/types.py

@@ -1,15 +0,0 @@
-import abc
-import typing as ta
-
-from omlish import lang
-
-from ...... import minichain as mc
-
-
-##
-
-
-class UserChatInput(lang.Abstract):
-    @abc.abstractmethod
-    def get_next_user_messages(self) -> ta.Awaitable['mc.UserChat']:
-        raise NotImplementedError

ommlds/cli/sessions/chat/driver.py

@@ -1,43 +0,0 @@
-from .chat.ai.types import AiChatGenerator
-from .chat.state.types import ChatStateManager
-from .chat.user.types import UserChatInput
-from .phases.manager import ChatPhaseManager
-from .phases.types import ChatPhase
-
-
-##
-
-
-class ChatDriver:
-    def __init__(
-            self,
-            *,
-            phases: ChatPhaseManager,
-            ai_chat_generator: AiChatGenerator,
-            user_chat_input: UserChatInput,
-            chat_state_manager: ChatStateManager,
-    ):
-        super().__init__()
-
-        self._phases = phases
-        self._ai_chat_generator = ai_chat_generator
-        self._user_chat_input = user_chat_input
-        self._chat_state_manager = chat_state_manager
-
-    async def run(self) -> None:
-        await self._phases.set_phase(ChatPhase.STARTING)
-        await self._phases.set_phase(ChatPhase.STARTED)
-
-        while True:
-            next_user_chat = await self._user_chat_input.get_next_user_messages()
-            if not next_user_chat:
-                break
-
-            prev_user_chat = (await self._chat_state_manager.get_state()).chat
-
-            next_ai_chat = await self._ai_chat_generator.get_next_ai_messages([*prev_user_chat, *next_user_chat])
-
-            await self._chat_state_manager.extend_chat([*next_user_chat, *next_ai_chat])
-
-        await self._phases.set_phase(ChatPhase.STOPPING)
-        await self._phases.set_phase(ChatPhase.STOPPED)

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,
-)