ommlds 0.0.0.dev514__py3-none-any.whl → 0.0.0.dev516__py3-none-any.whl

ommlds/__about__.py

@@ -22,7 +22,7 @@ class Project(ProjectBase):
             'llama-cpp-python ~= 0.3',
 
             'mlx ~= 0.30; sys_platform == "darwin"',
-            'mlx-lm ~= 0.29; sys_platform == "darwin"',
+            'mlx-lm ~= 0.30; sys_platform == "darwin"',
 
             'sentencepiece ~= 0.2',
 
@@ -35,12 +35,12 @@ class Project(ProjectBase):
 
             'torch ~= 2.10',
 
-            'transformers ~= 4.57',
+            'transformers ~= 5.0',
             'sentence-transformers ~= 5.2',
         ],
 
         'huggingface': [
-            'huggingface-hub ~= 0.36',
+            'huggingface-hub ~= 1.3',
             'datasets ~= 4.5',
         ],
 

ommlds/backends/mlx/generation.py

@@ -238,7 +238,7 @@ class GenerationOutput:
 def stream_generate(
         model: 'mlx_nn.Module',
         tokenization: Tokenization,
-        prompt: ta.Union[str, 'mx.array'],
+        prompt: ta.Union[str, ta.Sequence[int], 'mx.array'],
         params: GenerationParams = GenerationParams(),
 ) -> ta.Generator[GenerationOutput]:
     if not isinstance(prompt, mx.array):
@@ -312,7 +312,7 @@ def stream_generate(
 def generate(
         model: 'mlx_nn.Module',
         tokenization: Tokenization,
-        prompt: ta.Union[str, 'mx.array'],
+        prompt: ta.Union[str, ta.Sequence[int], 'mx.array'],
         params: GenerationParams = GenerationParams(),
         *,
         verbose: bool = False,

ommlds/backends/mlx/tokenization/detokenization/naive.py

@@ -1,3 +1,5 @@
+from omlish import check
+
 from ..types import Tokenizer
 from .base import BaseStreamingDetokenizer
 
@@ -36,14 +38,14 @@ class NaiveStreamingDetokenizer(BaseStreamingDetokenizer):
         self._tokens.append(token)
 
     def finalize(self) -> None:
-        self._text += self._tokenizer.decode(self._current_tokens)
+        self._text += check.isinstance(self._tokenizer.decode(self._current_tokens), str)
         self._current_tokens = []
         self._current_text = ''
 
     @property
     def text(self) -> str:
         if self._current_tokens:
-            self._current_text = self._tokenizer.decode(self._current_tokens)
+            self._current_text = check.isinstance(self._tokenizer.decode(self._current_tokens), str)
             if self._current_text.endswith('\ufffd') or (
                     self._tokenizer.clean_up_tokenization_spaces and
                     self._current_text and

ommlds/backends/mlx/tokenization/tokenization.py

@@ -44,7 +44,7 @@ class Tokenization:
         try:
             token_id = int(token)
         except ValueError:
-            token_id = self._tokenizer.convert_tokens_to_ids(token)
+            token_id = check.isinstance(self._tokenizer.convert_tokens_to_ids(check.isinstance(token, str)), int)
 
         if token_id is None:
             raise ValueError(f"'{token}' is not a token for this tokenizer")

ommlds/backends/transformers/streamers.py

@@ -12,19 +12,24 @@ P = ta.ParamSpec('P')
 
 
 class CancellableTextStreamer(tfm.TextStreamer):
+    class Tokenizer(ta.Protocol):
+        """Transformers base class still hard deps an AutoTokenizer despite only needing this one method."""
+
+        def decode(self, tokens: ta.Sequence[int], **kwargs: ta.Any) -> str: ...
+
     class Callback(ta.Protocol):
         def __call__(self, text: str, *, stream_end: bool) -> None: ...
 
     def __init__(
             self,
-            tokenizer: tfm.AutoTokenizer,
+            tokenizer: Tokenizer,
             callback: Callback,
             *,
             skip_prompt: bool = False,
             **decode_kwargs: ta.Any,
     ) -> None:
         super().__init__(
-            tokenizer,
+            ta.cast(tfm.AutoTokenizer, tokenizer),  # noqa
             skip_prompt=skip_prompt,
             **decode_kwargs,
         )

ommlds/cli/_dataclasses.py

@@ -1450,6 +1450,153 @@ def _process_dataclass__d65d18393f357ae0fb02bb80268c6f1473462613():
     return _process_dataclass
 
 
+@_register(
+    plan_repr=(
+        "Plans(tup=(CopyPlan(fields=('profile', 'args')), EqPlan(fields=('profile', 'args')), FrozenPlan(fields=('profi"
+        "le', 'args'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('profile', 'args'), cache=Fals"
+        "e), InitPlan(fields=(InitPlan.Field(name='profile', annotation=OpRef(name='init.fields.0.annotation'), default"
+        "=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=N"
+        "one, check_type=None), InitPlan.Field(name='args', annotation=OpRef(name='init.fields.1.annotation'), default="
+        "None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=No"
+        "ne, check_type=None)), self_param='self', std_params=('profile', 'args'), kw_only_params=(), frozen=True, slot"
+        "s=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='profile',"
+        " kw_only=False, fn=None), ReprPlan.Field(name='args', kw_only=False, fn=None)), id=False, terse=False, default"
+        "_fn=None)))"
+    ),
+    plan_repr_sha1='3ca2bdd121559ad92e95a0e4bdf8210452f20e5d',
+    op_ref_idents=(
+        '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__1__annotation',
+    ),
+    cls_names=(
+        ('ommlds.cli.main', 'ProfileAspect.ConfigureContext'),
+    ),
+)
+def _process_dataclass__3ca2bdd121559ad92e95a0e4bdf8210452f20e5d():
+    def _process_dataclass(
+        *,
+        __dataclass__cls,
+        __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__1__annotation,
+        __dataclass__FieldFnValidationError,  # noqa
+        __dataclass__FieldTypeValidationError,  # noqa
+        __dataclass__FnValidationError,  # noqa
+        __dataclass__FrozenInstanceError=dataclasses.FrozenInstanceError,  # noqa
+        __dataclass__FunctionType=types.FunctionType,  # noqa
+        __dataclass__HAS_DEFAULT_FACTORY=dataclasses._HAS_DEFAULT_FACTORY,  # noqa
+        __dataclass__MISSING=dataclasses.MISSING,  # noqa
+        __dataclass__None=None,  # noqa
+        __dataclass__TypeError=TypeError,  # noqa
+        __dataclass___recursive_repr=reprlib.recursive_repr,  # noqa
+        __dataclass__isinstance=isinstance,  # noqa
+        __dataclass__object_setattr=object.__setattr__,  # noqa
+        __dataclass__property=property,  # noqa
+    ):
+        def __copy__(self):
+            if self.__class__ is not __dataclass__cls:
+                raise TypeError(self)
+            return __dataclass__cls(  # noqa
+                profile=self.profile,
+                args=self.args,
+            )
+
+        __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
+        if '__copy__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __copy__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__copy__', __copy__)
+
+        def __eq__(self, other):
+            if self is other:
+                return True
+            if self.__class__ is not other.__class__:
+                return NotImplemented
+            return (
+                self.profile == other.profile and
+                self.args == other.args
+            )
+
+        __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
+        if '__eq__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__eq__', __eq__)
+
+        __dataclass___setattr_frozen_fields = {
+            'profile',
+            'args',
+        }
+
+        def __setattr__(self, name, value):
+            if (
+                type(self) is __dataclass__cls
+                or name in __dataclass___setattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
+            super(__dataclass__cls, self).__setattr__(name, value)
+
+        __setattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__setattr__"
+        if '__setattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__setattr__', __setattr__)
+
+        __dataclass___delattr_frozen_fields = {
+            'profile',
+            'args',
+        }
+
+        def __delattr__(self, name):
+            if (
+                type(self) is __dataclass__cls
+                or name in __dataclass___delattr_frozen_fields
+            ):
+                raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
+            super(__dataclass__cls, self).__delattr__(name)
+
+        __delattr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__delattr__"
+        if '__delattr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __delattr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__delattr__', __delattr__)
+
+        def __hash__(self):
+            return hash((
+                self.profile,
+                self.args,
+            ))
+
+        __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
+        setattr(__dataclass__cls, '__hash__', __hash__)
+
+        def __init__(
+            self,
+            profile: __dataclass__init__fields__0__annotation,
+            args: __dataclass__init__fields__1__annotation,
+        ) -> __dataclass__None:
+            __dataclass__object_setattr(self, 'profile', profile)
+            __dataclass__object_setattr(self, 'args', args)
+
+        __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
+        if '__init__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __init__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__init__', __init__)
+
+        @__dataclass___recursive_repr()
+        def __repr__(self):
+            parts = []
+            parts.append(f"profile={self.profile!r}")
+            parts.append(f"args={self.args!r}")
+            return (
+                f"{self.__class__.__qualname__}("
+                f"{', '.join(parts)}"
+                f")"
+            )
+
+        __repr__.__qualname__ = f"{__dataclass__cls.__qualname__}.__repr__"
+        if '__repr__' in __dataclass__cls.__dict__:
+            raise __dataclass__TypeError(f"Cannot overwrite attribute __repr__ in class {__dataclass__cls.__name__}")
+        setattr(__dataclass__cls, '__repr__', __repr__)
+
+    return _process_dataclass
+
+
 @_register(
     plan_repr=(
         "Plans(tup=(CopyPlan(fields=('markdown',)), EqPlan(fields=('markdown',)), FrozenPlan(fields=('markdown',), allo"

ommlds/cli/inject.py

@@ -17,6 +17,7 @@ with lang.auto_proxy_import(globals()):
 def bind_main(
         *,
         session_cfg: SessionConfig,
+        profile_name: str | None = None,
 ) -> inj.Elements:
     els: list[inj.Elemental] = []
 
@@ -30,7 +31,10 @@ def bind_main(
     #
 
     els.extend([
-        _sessions.bind_sessions(session_cfg),
+        _sessions.bind_sessions(
+            session_cfg,
+            profile_name=profile_name,
+        ),
 
         _state.bind_state(),
     ])

ommlds/cli/main.py

@@ -2,30 +2,20 @@
 TODO:
  - bootstrap lol
 """
-import abc
 import functools
-import sys
 import typing as ta
 
 import anyio
 
-from omlish import check
-from omlish import dataclasses as dc
 from omlish import inject as inj
-from omlish import lang
 from omlish.argparse import all as ap
 from omlish.logs import all as logs
 
 from .inject import bind_main
+from .profiles import PROFILE_TYPES
 from .secrets import install_env_secrets
 from .sessions.base import Session
-from .sessions.chat.configs import ChatConfig
-from .sessions.chat.interfaces.bare.configs import BareInterfaceConfig
-from .sessions.chat.interfaces.configs import InterfaceConfig
-from .sessions.chat.interfaces.textual.configs import TextualInterfaceConfig
-from .sessions.completion.configs import CompletionConfig
 from .sessions.configs import SessionConfig
-from .sessions.embedding.configs import EmbeddingConfig
 
 
 ##
@@ -48,337 +38,14 @@ def _process_main_extra_args(args: ap.Namespace) -> None:
 ##
 
 
-class Profile(lang.Abstract):
-    @abc.abstractmethod
-    def configure(self, argv: ta.Sequence[str]) -> SessionConfig:
-        raise NotImplementedError
-
-
-##
-
-
-# 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: ...
-
-
-class ChatProfile(Profile):
-    _args: ap.Namespace
-
-    #
-
-    BACKEND_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
-        ap.arg('-b', '--backend', group='backend'),
-    ]
-
-    def configure_backend(self, cfg: ChatConfig) -> ChatConfig:
-        return dc.replace(
-            cfg,
-            driver=dc.replace(
-                cfg.driver,
-                backend=dc.replace(
-                    cfg.driver.backend,
-                    backend=self._args.backend,
-                ),
-            ),
-        )
-
-    #
-
-    INTERFACE_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
-        ap.arg('-i', '--interactive', action='store_true', group='interface'),
-        ap.arg('-T', '--textual', action='store_true', group='interface'),
-        ap.arg('-e', '--editor', action='store_true', group='interface'),
-    ]
-
-    def configure_interface(self, cfg: ChatConfig) -> ChatConfig:
-        if self._args.editor:
-            check.arg(not self._args.interactive)
-            check.arg(not self._args.message)
-            raise NotImplementedError
-
-        if self._args.textual:
-            check.isinstance(cfg.interface, BareInterfaceConfig)
-            cfg = dc.replace(
-                cfg,
-                interface=TextualInterfaceConfig(**{
-                    f.name: getattr(cfg.interface, f.name)
-                    for f in dc.fields(InterfaceConfig)
-                }),
-            )
-
-        else:
-            cfg = dc.replace(
-                cfg,
-                driver=dc.replace(
-                    cfg.driver,
-                    ai=dc.replace(
-                        cfg.driver.ai,
-                        verbose=True,
-                    ),
-                ),
-                interface=dc.replace(
-                    check.isinstance(cfg.interface, BareInterfaceConfig),
-                    interactive=self._args.interactive,
-                ),
-            )
-
-        return cfg
-
-    #
-
-    INPUT_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
-        ap.arg('message', nargs='*', group='input'),
-    ]
-
-    def configure_input(self, cfg: ChatConfig) -> ChatConfig:
-        if self._args.interactive or self._args.textual:
-            check.arg(not self._args.message)
-
-        elif self._args.message:
-            ps: list[str] = []
-
-            for a in self._args.message:
-                if a == '-':
-                    ps.append(sys.stdin.read())
-
-                elif a.startswith('@'):
-                    with open(a[1:]) as f:
-                        ps.append(f.read())
-
-                else:
-                    ps.append(a)
-
-            c = ' '.join(ps)
-
-            cfg = dc.replace(
-                cfg,
-                driver=dc.replace(
-                    cfg.driver,
-                    user=dc.replace(
-                        cfg.driver.user,
-                        initial_user_content=c,
-                    ),
-                ),
-            )
-
-        else:
-            raise ValueError('Must specify input')
-
-        return cfg
-
-    #
-
-    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,
-            driver=dc.replace(
-                cfg.driver,
-                state=dc.replace(
-                    cfg.driver.state,
-                    state='ephemeral' if self._args.ephemeral else 'new' if self._args.new else 'continue',
-                ),
-            ),
-        )
-
-    #
-
-    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,
-            driver=dc.replace(
-                cfg.driver,
-                ai=dc.replace(
-                    cfg.driver.ai,
-                    stream=bool(self._args.stream),
-                ),
-            ),
-            rendering=dc.replace(
-                cfg.rendering,
-                markdown=bool(self._args.markdown),
-            ),
-        )
-
-    #
-
-    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:
-        if not (
-                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
-        ):
-            return cfg
-
-        return dc.replace(
-            cfg,
-            driver=dc.replace(
-                cfg.driver,
-                ai=dc.replace(
-                    cfg.driver.ai,
-                    enable_tools=True,
-                ),
-                tools=dc.replace(
-                    cfg.driver.tools,
-                    enabled_tools={  # noqa
-                        *(cfg.driver.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 []),
-                    },
-                ),
-            ),
-            interface=dc.replace(
-                cfg.interface,
-                enable_tools=True,
-            ),
-        )
-
-    #
-
-    CODE_CONFIG: ta.ClassVar[ta.Sequence[ap.Arg]] = [
-        ap.arg('-c', '--code', action='store_true', group='code'),
-    ]
-
-    def configure_code(self, cfg: ChatConfig) -> ChatConfig:
-        if not self._args.code:
-            return cfg
-
-        cfg = dc.replace(
-            cfg,
-            driver=dc.replace(
-                cfg.driver,
-                ai=dc.replace(
-                    cfg.driver.ai,
-                    enable_tools=True,
-                ),
-            ),
-        )
-
-        if self._args.new or self._args.ephemeral:
-            from ..minichain.lib.code.prompts import CODE_AGENT_SYSTEM_PROMPT
-            system_content = CODE_AGENT_SYSTEM_PROMPT
-
-            cfg = dc.replace(
-                cfg,
-                driver=dc.replace(
-                    cfg.driver,
-                    user=dc.replace(
-                        cfg.driver.user,
-                        initial_system_content=system_content,
-                    ),
-                ),
-            )
-
-        return cfg
-
-    #
-
-    def configure(self, argv: ta.Sequence[str]) -> SessionConfig:
-        parser = ap.ArgumentParser()
-
-        for grp_name, grp_args in [
-            ('backend', self.BACKEND_ARGS),
-            ('interface', self.INTERFACE_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_interface(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)
-
-        return cfg
-
-
-##
-
-
-class CompletionProfile(Profile):
-    def configure(self, argv: ta.Sequence[str]) -> SessionConfig:
-        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(
-            content=check.non_empty_str(content),
-            backend=args.backend,
-        )
-
-        return cfg
-
-
-##
-
-
-class EmbedProfile(Profile):
-    def configure(self, argv: ta.Sequence[str]) -> SessionConfig:
-        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(
-            content=check.non_empty_str(content),
-            backend=args.backend,
-        )
-
-        return cfg
-
-
-##
-
-
-PROFILE_TYPES: ta.Mapping[str, type[Profile]] = {
-    'chat': ChatProfile,
-    'complete': CompletionProfile,
-    'embed': EmbedProfile,
-}
-
-
-##
-
-
-async def _run_session_cfg(session_cfg: SessionConfig) -> None:
+async def _run_session_cfg(
+        session_cfg: SessionConfig,
+        *,
+        profile_name: str | None = None,
+) -> None:
     async with inj.create_async_managed_injector(bind_main(
             session_cfg=session_cfg,
+            profile_name=profile_name,
     )) as injector:
         await (await injector[Session]).run()
 
@@ -388,12 +55,13 @@ async def _run_session_cfg(session_cfg: SessionConfig) -> None:
 
 MAIN_PROFILE_ARGS: ta.Sequence[ap.Arg] = [
     ap.arg('-p', '--profile', default='chat'),
+    ap.arg('-h', '--help', action='store_true'),
     ap.arg('args', nargs=ap.REMAINDER),
 ]
 
 
 async def _a_main(argv: ta.Any = None) -> None:
-    parser = ap.ArgumentParser()
+    parser = ap.ArgumentParser(add_help=False)
 
     for a in [*MAIN_PROFILE_ARGS, *MAIN_EXTRA_ARGS]:
         parser.add_argument(*a.args, **a.kwargs)
@@ -407,9 +75,16 @@ async def _a_main(argv: ta.Any = None) -> None:
     profile_cls = PROFILE_TYPES[args.profile]
     profile = profile_cls()
 
-    session_cfg = profile.configure([*unk_args, *args.args])
+    session_cfg = profile.configure([
+        *unk_args,
+        *(['--help'] if args.help else []),
+        *args.args,
+    ])
 
-    await _run_session_cfg(session_cfg)
+    await _run_session_cfg(
+        session_cfg,
+        profile_name=args.profile,
+    )
 
 
 def _main(args: ta.Any = None) -> None: