ommlds 0.0.0.dev474__py3-none-any.whl → 0.0.0.dev476__py3-none-any.whl

ommlds/cli/{sessions/chat/content → content}/strings.py

@@ -4,7 +4,7 @@ import typing as ta
 from omlish import lang
 from omlish.formats import json
 
-from ..... import minichain as mc
+from ... import minichain as mc
 
 
 ##

ommlds/cli/inject.py

@@ -5,7 +5,7 @@ from omlish import lang
 
 
 with lang.auto_proxy_import(globals()):
-    from .backends import inject as _backends
+    from . import asyncs
     from .sessions import inject as _sessions
     from .state import inject as _state
 
@@ -16,17 +16,12 @@ with lang.auto_proxy_import(globals()):
 def bind_main(
         *,
         session_cfg: ta.Any,
-        enable_backend_strings: bool = False,
 ) -> inj.Elements:
     els: list[inj.Elemental] = []
 
     #
 
     els.extend([
-        _backends.bind_backends(
-            enable_backend_strings=enable_backend_strings,
-        ),
-
         _sessions.bind_sessions(session_cfg),
 
         _state.bind_state(),
@@ -34,4 +29,10 @@ def bind_main(
 
     #
 
+    els.extend([
+        inj.bind(asyncs.AsyncThreadRunner, to_ctor=asyncs.AnyioAsyncThreadRunner),
+    ])
+
+    #
+
     return inj.as_elements(*els)

ommlds/cli/inputs/asyncs.py

@@ -0,0 +1,32 @@
+import typing as ta
+
+from .. import asyncs
+from .sync import SyncStringInput
+
+
+##
+
+
+class AsyncStringInput(ta.Protocol):
+    def __call__(self) -> ta.Awaitable[str]: ...
+
+
+class ThreadAsyncStringInput:
+    def __init__(self, child: SyncStringInput, runner: asyncs.AsyncThreadRunner) -> None:
+        super().__init__()
+
+        self._child = child
+        self._runner = runner
+
+    async def __call__(self) -> str:
+        return await self._runner.run_in_thread(self._child)
+
+
+class SyncAsyncStringInput:
+    def __init__(self, child: SyncStringInput) -> None:
+        super().__init__()
+
+        self._child = child
+
+    async def __call__(self) -> str:
+        return self._child()

ommlds/cli/inputs/sync.py

@@ -0,0 +1,75 @@
+import sys
+import typing as ta
+
+from omlish import check
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    from omlish.subprocesses import editor
+    from omlish.subprocesses import sync as sync_subprocesses
+
+
+##
+
+
+class SyncStringInput(ta.Protocol):
+    def __call__(self) -> str: ...
+
+
+class InputSyncStringInput:
+    DEFAULT_PROMPT: ta.ClassVar[str] = '> '
+
+    def __init__(
+            self,
+            prompt: str | None = None,
+            *,
+            use_readline: bool | ta.Literal['auto'] = False,
+    ) -> None:
+        super().__init__()
+
+        if prompt is None:
+            prompt = self.DEFAULT_PROMPT
+        self._prompt = prompt
+        self._use_readline = use_readline
+
+        self._handled_readline = False
+
+    def _handle_readline(self) -> None:
+        if self._handled_readline:
+            return
+        self._handled_readline = True
+
+        if not self._use_readline:
+            return
+
+        if self._use_readline == 'auto':
+            if not sys.stdin.isatty():
+                return
+
+        try:
+            import readline  # noqa
+        except ImportError:
+            pass
+
+    def __call__(self) -> str:
+        self._handle_readline()
+        return input(self._prompt)
+
+
+class FileSyncStringInput(InputSyncStringInput):
+    def __init__(self, path: str) -> None:
+        super().__init__()
+
+        self._path = check.non_empty_str(path)
+
+    def __call__(self) -> str:
+        with open(self._path) as f:
+            return f.read()
+
+
+class UserEditorSyncStringInput(InputSyncStringInput):
+    def __call__(self) -> str:
+        if (ec := editor.edit_text_with_user_editor('', sync_subprocesses.subprocesses)) is None:
+            raise EOFError
+        return ec

ommlds/cli/main.py

@@ -1,188 +1,331 @@
 """
-See:
- - https://github.com/simonw/llm
- - https://github.com/TheR1D/shell_gpt
- - https://github.com/paul-gauthier/aider
+TODO:
+ - bootstrap lol
 """
-import argparse
+import abc
 import functools
-import os.path
-import sys
 import typing as ta
 
 import anyio
 
-from omdev.home.secrets import load_secrets
 from omlish import check
+from omlish import dataclasses as dc
 from omlish import inject as inj
 from omlish import lang
-from omlish.diag import pycharm
+from omlish.argparse import all as ap
 from omlish.logs import all as logs
-from omlish.subprocesses.editor import edit_text_with_user_editor
-from omlish.subprocesses.sync import subprocesses
 
-from .. import minichain as mc
 from .inject import bind_main
+from .secrets import install_secrets
 from .sessions.base import Session
 from .sessions.chat.configs import ChatConfig
 from .sessions.completion.configs import CompletionConfig
 from .sessions.embedding.configs import EmbeddingConfig
 
 
-if ta.TYPE_CHECKING:
-    import PIL.Image as pimg  # noqa
-else:
-    pimg = lang.proxy_import('PIL.Image')
-
-
 ##
 
 
-async def _a_main(args: ta.Any = None) -> None:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('prompt', nargs='*')
+MAIN_EXTRA_ARGS: ta.Sequence[ap.Arg] = [
+    ap.arg('-v', '--verbose', action='store_true'),
+]
 
-    parser.add_argument('-b', '--backend', default='openai')
 
-    parser.add_argument('-m', '--model-name')
+def _process_main_extra_args(args: ap.Namespace) -> None:
+    if args.verbose:
+        logs.configure_standard_logging('DEBUG')
+    else:
+        logs.configure_standard_logging('INFO')
+        logs.silence_noisy_loggers()
 
-    parser.add_argument('-C', '--completion', action='store_true')
 
-    parser.add_argument('-n', '--new', action='store_true')
-    parser.add_argument('--ephemeral', action='store_true')
+##
 
-    parser.add_argument('-e', '--editor', action='store_true')
-    parser.add_argument('-i', '--interactive', action='store_true')
-    parser.add_argument('-c', '--code', action='store_true')
-    parser.add_argument('-s', '--stream', action='store_true')
-    parser.add_argument('-M', '--markdown', action='store_true')
 
-    parser.add_argument('-E', '--embed', action='store_true')
-    parser.add_argument('-j', '--image', action='store_true')
+class Profile(lang.Abstract):
+    @abc.abstractmethod
+    def run(self, argv: ta.Sequence[str]) -> ta.Awaitable[None]:
+        raise NotImplementedError
 
-    parser.add_argument('-v', '--verbose', action='store_true')
 
-    parser.add_argument('--enable-fs-tools', action='store_true')
-    parser.add_argument('--enable-todo-tools', action='store_true')
-    parser.add_argument('--enable-unsafe-tools-do-not-use-lol', action='store_true')
-    parser.add_argument('--enable-test-weather-tool', action='store_true')
-    parser.add_argument('--dangerous-no-tool-confirmation', action='store_true')
+##
 
-    args = parser.parse_args(args)
 
-    #
+# class ChatAspect(lang.Abstract):
+#     def get_parser_args(self) -> ta.Sequence[ap.Arg]: ...
+#     def set_args(self, args: ap.Namespace) -> None: ...
+#     def configure(self, cfg: ChatConfig) -> ChatConfig: ...
 
-    if args.verbose:
-        logs.configure_standard_logging('DEBUG')
-    else:
-        logs.configure_standard_logging('INFO')
-        logs.silence_noisy_loggers()
+
+class ChatProfile(Profile):
+    _args: ap.Namespace
 
     #
 
-    content: mc.Content | None
+    BACKEND_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('-b', '--backend', group='backend'),
+    ]
 
-    if args.image:
-        content = mc.ImageContent(pimg.open(check.non_empty_str(check.single(args.prompt))))
+    def configure_backend(self, cfg: ChatConfig) -> ChatConfig:
+        return dc.replace(
+            cfg,
+            backend=dc.replace(
+                cfg.backend,
+                backend=self._args.backend,
+            ),
+        )
 
-    elif args.editor:
-        check.arg(not args.prompt)
-        if (ec := edit_text_with_user_editor('', subprocesses)) is None:
-            return
-        content = ec
+    #
 
-    elif args.interactive:
-        if args.prompt:
-            raise ValueError('Must not provide prompt')
-        content = None
+    INPUT_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('message', nargs='*', group='input'),
+        ap.arg('-i', '--interactive', action='store_true', group='input'),
+        ap.arg('-e', '--editor', action='store_true', group='input'),
+    ]
+
+    def configure_input(self, cfg: ChatConfig) -> ChatConfig:
+        if self._args.editor:
+            check.arg(not self._args.interactive)
+            check.arg(not self._args.message)
+            raise NotImplementedError
+
+        elif self._args.interactive:
+            check.arg(not self._args.message)
+            return dc.replace(
+                cfg,
+                user=dc.replace(
+                    cfg.user,
+                    interactive=True,
+                ),
+            )
+
+        elif self._args.message:
+            # TODO: '-' -> stdin
+            return dc.replace(
+                cfg,
+                user=dc.replace(
+                    cfg.user,
+                    initial_user_content=' '.join(self._args.message),
+                ),
+            )
 
-    elif args.code:
-        if args.prompt:
-            content = ' '.join(args.prompt)
         else:
-            content = None
+            raise ValueError('Must specify input')
 
-    elif not args.prompt:
-        raise ValueError('Must provide prompt')
+    #
 
-    else:
-        prompt = ' '.join(args.prompt)
+    STATE_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('-n', '--new', action='store_true', group='state'),
+        ap.arg('--ephemeral', action='store_true', group='state'),
+    ]
+
+    def configure_state(self, cfg: ChatConfig) -> ChatConfig:
+        return dc.replace(
+            cfg,
+            state=dc.replace(
+                cfg.state,
+                state='ephemeral' if self._args.ephemeral else 'new' if self._args.new else 'continue',
+            ),
+        )
 
-        # FIXME: ptk / maysync
-        if not sys.stdin.isatty() and not pycharm.is_pycharm_hosted():
-            stdin_data = sys.stdin.read()
-            prompt = '\n'.join([prompt, stdin_data])
+    #
 
-        content = prompt
+    OUTPUT_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('-s', '--stream', action='store_true', group='output'),
+        ap.arg('-M', '--markdown', action='store_true', group='output'),
+    ]
+
+    def configure_output(self, cfg: ChatConfig) -> ChatConfig:
+        return dc.replace(
+            cfg,
+            ai=dc.replace(
+                cfg.ai,
+                stream=bool(self._args.stream),
+            ),
+            rendering=dc.replace(
+                cfg.rendering,
+                markdown=bool(self._args.markdown),
+            ),
+        )
 
     #
 
-    # FIXME: lol garbage
-    for key in [
-        'OPENAI_API_KEY',
-        'HUGGINGFACE_TOKEN',
-        'TAVILY_API_KEY',
-        'ANTHROPIC_API_KEY',
-        'MISTRAL_API_KEY',
-        'GEMINI_API_KEY',
-    ]:
-        if (sec := load_secrets().try_get(key.lower())) is not None:
-            os.environ[key] = sec.reveal()
+    TOOLS_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('--enable-fs-tools', action='store_true', group='tools'),
+        ap.arg('--enable-todo-tools', action='store_true', group='tools'),
+        # ap.arg('--enable-unsafe-tools-do-not-use-lol', action='store_true', group='tools'),
+        ap.arg('--enable-test-weather-tool', action='store_true', group='tools'),
+    ]
+
+    def configure_tools(self, cfg: ChatConfig) -> ChatConfig:
+        return dc.replace(
+            cfg,
+            ai=dc.replace(
+                cfg.ai,
+                enable_tools=(
+                    self._args.enable_fs_tools or
+                    self._args.enable_todo_tools or
+                    # self._args.enable_unsafe_tools_do_not_use_lol or
+                    self._args.enable_test_weather_tool or
+                    self._args.code
+                ),
+            ),
+            tools=dc.replace(
+                cfg.tools,
+                enabled_tools={  # noqa
+                    *(cfg.tools.enabled_tools or []),
+                    *(['fs'] if self._args.enable_fs_tools else []),
+                    *(['todo'] if self._args.enable_todo_tools else []),
+                    *(['weather'] if self._args.enable_test_weather_tool else []),
+                },
+            ),
+        )
 
     #
 
-    session_cfg: ta.Any
+    CODE_CONFIG: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('-c', '--code', action='store_true', group='code'),
+    ]
 
-    if args.embed:
-        session_cfg = EmbeddingConfig(
-            check.not_none(content),  # noqa
-            backend=args.backend,
-        )
+    def configure_code(self, cfg: ChatConfig) -> ChatConfig:
+        if not self._args.code:
+            return cfg
 
-    elif args.completion:
-        session_cfg = CompletionConfig(
-            check.not_none(content),  # noqa
-            backend=args.backend,
+        cfg = dc.replace(
+            cfg,
+            ai=dc.replace(
+                cfg.ai,
+                enable_tools=True,
+            ),
         )
 
-    else:
-        system_content: mc.Content | None = None
-        if (args.new or args.ephemeral) and args.code:
+        if self._args.new or self._args.ephemeral:
             from ..minichain.lib.code.prompts import CODE_AGENT_SYSTEM_PROMPT
             system_content = CODE_AGENT_SYSTEM_PROMPT
 
-        session_cfg = ChatConfig(
+            cfg = dc.replace(
+                cfg,
+                user=dc.replace(
+                    cfg.user,
+                    initial_system_content=system_content,
+                ),
+            )
+
+        return cfg
+
+    #
+
+    async def run(self, argv: ta.Sequence[str]) -> None:
+        parser = ap.ArgumentParser()
+
+        for grp_name, grp_args in [
+            ('backend', self.BACKEND_ARGS),
+            ('input', self.INPUT_ARGS),
+            ('state', self.STATE_ARGS),
+            ('output', self.OUTPUT_ARGS),
+            ('tools', self.TOOLS_ARGS),
+            ('code', self.CODE_CONFIG),
+        ]:
+            grp = parser.add_argument_group(grp_name)
+            for a in grp_args:
+                grp.add_argument(*a.args, **a.kwargs)
+
+        self._args = parser.parse_args(argv)
+
+        cfg = ChatConfig()
+        cfg = self.configure_backend(cfg)
+        cfg = self.configure_input(cfg)
+        cfg = self.configure_state(cfg)
+        cfg = self.configure_output(cfg)
+        cfg = self.configure_tools(cfg)
+        cfg = self.configure_code(cfg)
+
+        with inj.create_managed_injector(bind_main(
+                session_cfg=cfg,
+        )) as injector:
+            await injector[Session].run()
+
+
+##
+
+
+class CompletionProfile(Profile):
+    async def run(self, argv: ta.Sequence[str]) -> None:
+        parser = ap.ArgumentParser()
+        parser.add_argument('prompt', nargs='*')
+        parser.add_argument('-b', '--backend', default='openai')
+        args = parser.parse_args(argv)
+
+        content = ' '.join(args.prompt)
+
+        cfg = CompletionConfig(
+            check.non_empty_str(content),
             backend=args.backend,
-            model_name=args.model_name,
-            state='ephemeral' if args.ephemeral else 'new' if args.new else 'continue',
-            initial_system_content=system_content,
-            initial_user_content=content,  # noqa
-            interactive=bool(args.interactive),
-            markdown=bool(args.markdown),
-            stream=bool(args.stream),
-            enable_tools=(
-                args.enable_fs_tools or
-                args.enable_todo_tools or
-                args.enable_unsafe_tools_do_not_use_lol or
-                args.enable_test_weather_tool or
-                args.code
-            ),
-            enabled_tools={  # noqa
-                *(['fs'] if args.enable_fs_tools else []),
-                *(['todo'] if args.enable_todo_tools else []),
-                *(['weather'] if args.enable_test_weather_tool else []),
-                # FIXME: enable_unsafe_tools_do_not_use_lol
-            },
-            dangerous_no_tool_confirmation=bool(args.dangerous_no_tool_confirmation),
         )
 
-    #
+        with inj.create_managed_injector(bind_main(
+                session_cfg=cfg,
+        )) as injector:
+            await injector[Session].run()
+
+
+##
+
+
+class EmbedProfile(Profile):
+    async def run(self, argv: ta.Sequence[str]) -> None:
+        parser = ap.ArgumentParser()
+        parser.add_argument('prompt', nargs='*')
+        parser.add_argument('-b', '--backend', default='openai')
+        args = parser.parse_args(argv)
+
+        content = ' '.join(args.prompt)
+
+        cfg = EmbeddingConfig(
+            check.non_empty_str(content),
+            backend=args.backend,
+        )
+
+        with inj.create_managed_injector(bind_main(
+                session_cfg=cfg,
+        )) as injector:
+            await injector[Session].run()
+
+
+##
+
+
+PROFILE_TYPES: ta.Mapping[str, type[Profile]] = {
+    'chat': ChatProfile,
+    'complete': CompletionProfile,
+    'embed': EmbedProfile,
+}
+
+
+##
+
+
+MAIN_PROFILE_ARGS: ta.Sequence[ap.Arg] = [
+    ap.arg('-p', '--profile', default='chat'),
+    ap.arg('args', nargs=ap.REMAINDER),
+]
+
+
+async def _a_main(argv: ta.Any = None) -> None:
+    parser = ap.ArgumentParser()
+
+    for a in [*MAIN_PROFILE_ARGS, *MAIN_EXTRA_ARGS]:
+        parser.add_argument(*a.args, **a.kwargs)
+
+    args, unk_args = parser.parse_known_args(argv)
+
+    _process_main_extra_args(args)
+
+    install_secrets()
 
-    with inj.create_managed_injector(bind_main(
-            session_cfg=session_cfg,
-            enable_backend_strings=isinstance(session_cfg, ChatConfig),
-    )) as injector:
-        await injector[Session].run()
+    profile_cls = PROFILE_TYPES[args.profile]
+    profile = profile_cls()
+    await profile.run([*unk_args, *args.args])
 
 
 def _main(args: ta.Any = None) -> None:
@@ -191,7 +334,6 @@ def _main(args: ta.Any = None) -> None:
             _a_main,
             args,
         ),
-        # backend='trio',
     )  # noqa
 
 

ommlds/cli/rendering/configs.py

@@ -0,0 +1,9 @@
+from omlish import dataclasses as dc
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class RenderingConfig:
+    markdown: bool = False

ommlds/cli/{sessions/chat/rendering → rendering}/inject.py

@@ -1,6 +1,8 @@
 from omlish import inject as inj
 from omlish import lang
 
+from .configs import RenderingConfig
+
 
 with lang.auto_proxy_import(globals()):
     from . import markdown as _markdown
@@ -11,13 +13,10 @@ with lang.auto_proxy_import(globals()):
 ##
 
 
-def bind_rendering(
-        *,
-        markdown: bool = False,
-) -> inj.Elements:
+def bind_rendering(cfg: RenderingConfig = RenderingConfig()) -> inj.Elements:
     els: list[inj.Elemental] = []
 
-    if markdown:
+    if cfg.markdown:
         els.extend([
             inj.bind(_types.ContentRendering, to_ctor=_markdown.MarkdownContentRendering, singleton=True),
             inj.bind(_types.StreamContentRendering, to_ctor=_markdown.MarkdownStreamContentRendering, singleton=True),

ommlds/cli/{sessions/chat/rendering → rendering}/markdown.py

@@ -3,7 +3,7 @@ import typing as ta
 from omdev.tui import rich
 from omlish import lang
 
-from ..... import minichain as mc
+from ... import minichain as mc
 from ..content.strings import ContentStringifier
 from ..content.strings import HasContentStringifier
 from .types import ContentRendering

ommlds/cli/{sessions/chat/rendering → rendering}/raw.py

@@ -2,7 +2,7 @@ import typing as ta
 
 from omlish import lang
 
-from ..... import minichain as mc
+from ... import minichain as mc
 from ..content.strings import ContentStringifier
 from ..content.strings import HasContentStringifier
 from .types import ContentRendering

ommlds/cli/{sessions/chat/rendering → rendering}/types.py

@@ -3,7 +3,7 @@ import typing as ta
 
 from omlish import lang
 
-from ..... import minichain as mc
+from ... import minichain as mc
 
 
 ##