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

ommlds/cli/sessions/embedding/inject.py

@@ -2,11 +2,15 @@ from omlish import dataclasses as dc
 from omlish import inject as inj
 from omlish import lang
 
+from ...backends.configs import BackendConfig
+from ...backends.types import DefaultBackendName
 from ..base import Session
+from .configs import DEFAULT_BACKEND
 from .configs import EmbeddingConfig
 
 
 with lang.auto_proxy_import(globals()):
+    from ...backends import inject as _backends
     from . import session as _session
 
 
@@ -25,4 +29,14 @@ def bind_embedding(cfg: EmbeddingConfig) -> inj.Elements:
 
     #
 
+    els.extend([
+        _backends.bind_backends(BackendConfig(
+            backend=cfg.backend,
+        )),
+
+        inj.bind(DefaultBackendName, to_const=DEFAULT_BACKEND),
+    ])
+
+    #
+
     return inj.as_elements(*els)

ommlds/cli/sessions/embedding/session.py

@@ -1,11 +1,9 @@
-import dataclasses as dc
-
-from omlish import lang
+from omlish import dataclasses as dc
 from omlish.formats import json
 
 from .... import minichain as mc
+from ...backends.types import EmbeddingServiceBackendProvider
 from ..base import Session
-from .configs import DEFAULT_EMBEDDING_MODEL_BACKEND
 from .configs import EmbeddingConfig
 
 
@@ -21,17 +19,15 @@ class EmbeddingSession(Session['EmbeddingSession.Config']):
             self,
             config: Config,
             *,
-            backend_catalog: mc.BackendCatalog,
+            service_provider: EmbeddingServiceBackendProvider,
     ) -> None:
         super().__init__(config)
 
-        self._backend_catalog = backend_catalog
+        self._service_provider = service_provider
 
     async def run(self) -> None:
         mdl: mc.EmbeddingService
-        async with lang.async_maybe_managing(self._backend_catalog.new_backend(
-            mc.EmbeddingService,
-            self._config.backend or DEFAULT_EMBEDDING_MODEL_BACKEND,
-        )) as mdl:
+        async with self._service_provider.provide_backend() as mdl:
             response = await mdl.invoke(mc.EmbeddingRequest(self._config.content))
-            print(json.dumps_compact(list(map(float, response.v))))
+
+        print(json.dumps_compact(list(map(float, response.v))))

ommlds/cli/state/storage.py

@@ -1,8 +1,8 @@
 import abc
-import dataclasses as dc
 import os.path
 import typing as ta
 
+from omlish import dataclasses as dc
 from omlish import lang
 from omlish import marshal as msh
 from omlish.formats import json

ommlds/minichain/backends/catalogs/strings.py

@@ -39,7 +39,7 @@ class BackendStringBackendCatalog(BackendCatalog):
 
         al: list = list(rs.args or [])
 
-        # FIXME: lol
+        # FIXME: lol - move *into* local model classes as an injected dep?
         if al and isinstance(al[0], ModelRepo):
             [mr] = al
             mrr = check.not_none(self._model_repo_resolver)

ommlds/minichain/backends/impls/dummy/chat.py

@@ -0,0 +1,69 @@
+# ruff: noqa: PERF402
+import typing as ta
+
+from omlish.text.lorem import LOREM
+
+from ....chat.choices.services import ChatChoicesRequest
+from ....chat.choices.services import ChatChoicesResponse
+from ....chat.choices.services import static_check_is_chat_choices_service
+from ....chat.choices.types import AiChoice
+from ....chat.choices.types import ChatChoicesOutputs
+from ....chat.messages import AiMessage
+from ....chat.stream.services import ChatChoicesStreamRequest
+from ....chat.stream.services import ChatChoicesStreamResponse
+from ....chat.stream.services import static_check_is_chat_choices_stream_service
+from ....chat.stream.types import AiChoiceDeltas
+from ....chat.stream.types import AiChoicesDeltas
+from ....chat.stream.types import ContentAiChoiceDelta
+from ....resources import UseResources
+from ....stream.services import StreamResponseSink
+from ....stream.services import new_stream_response
+
+
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='dummy',
+#     type='ChatChoicesService',
+# )
+@static_check_is_chat_choices_service
+class DummyChatChoicesService:
+    async def invoke(self, request: ChatChoicesRequest) -> ChatChoicesResponse:
+        return ChatChoicesResponse([AiChoice([AiMessage(LOREM)])])
+
+
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='dummy',
+#     type='ChatChoicesStreamService',
+# )
+@static_check_is_chat_choices_stream_service
+class DummyChatChoicesStreamService:
+    async def invoke(self, request: ChatChoicesStreamRequest) -> ChatChoicesStreamResponse:
+        async with UseResources.or_new(request.options) as rs:
+            async def inner(sink: StreamResponseSink[AiChoicesDeltas]) -> ta.Sequence[ChatChoicesOutputs]:
+                for s in LOREM:
+                    await sink.emit(AiChoicesDeltas([
+                        AiChoiceDeltas([
+                            ContentAiChoiceDelta(s),
+                        ]),
+                    ]))
+
+                return []
+
+            return await new_stream_response(rs, inner)
+
+
+##
+
+
+# @omlish-manifest $.minichain.backends.strings.manifests.BackendStringsManifest(
+#     [
+#         'ChatChoicesService',
+#         'ChatChoicesStreamService',
+#     ],
+#     'dummy',
+# )

ommlds/minichain/backends/impls/groq/chat.py

@@ -0,0 +1,69 @@
+import typing as ta
+
+from omlish import check
+from omlish import marshal as msh
+from omlish import typedvalues as tv
+from omlish.formats import json
+from omlish.http import all as http
+
+from .....backends.groq import protocol as pt
+from ....chat.choices.services import ChatChoicesRequest
+from ....chat.choices.services import ChatChoicesResponse
+from ....chat.choices.services import static_check_is_chat_choices_service
+from ....models.configs import ModelName
+from ....standard import ApiKey
+from ....standard import DefaultOptions
+from .names import MODEL_NAMES
+from .protocol import build_gq_request_message
+from .protocol import build_mc_choices_response
+
+
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='groq',
+#     type='ChatChoicesService',
+# )
+@static_check_is_chat_choices_service
+class GroqChatChoicesService:
+    DEFAULT_MODEL_NAME: ta.ClassVar[ModelName] = ModelName(check.not_none(MODEL_NAMES.default))
+
+    def __init__(
+            self,
+            *configs: ApiKey | ModelName | DefaultOptions,
+            http_client: http.AsyncHttpClient | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._http_client = http_client
+
+        with tv.consume(*configs) as cc:
+            self._model_name = cc.pop(self.DEFAULT_MODEL_NAME)
+            self._api_key = ApiKey.pop_secret(cc, env='GROQ_API_KEY')
+            self._default_options: tv.TypedValues = DefaultOptions.pop(cc)
+
+    async def invoke(self, request: ChatChoicesRequest) -> ChatChoicesResponse:
+        gq_request = pt.ChatCompletionRequest(
+            messages=[
+                build_gq_request_message(m)
+                for m in request.v
+            ],
+            model=MODEL_NAMES.resolve(self._model_name.v),
+        )
+
+        raw_request = msh.marshal(gq_request)
+
+        http_response = await http.async_request(
+            'https://api.groq.com/openai/v1/chat/completions',
+            headers={
+                http.consts.HEADER_CONTENT_TYPE: http.consts.CONTENT_TYPE_JSON,
+                http.consts.HEADER_AUTH: http.consts.format_bearer_auth_header(check.not_none(self._api_key).reveal()),
+            },
+            data=json.dumps(raw_request).encode('utf-8'),
+            client=self._http_client,
+        )
+
+        raw_response = json.loads(check.not_none(http_response.data).decode('utf-8'))
+
+        return build_mc_choices_response(msh.unmarshal(raw_response, pt.ChatCompletionResponse))

ommlds/minichain/backends/impls/groq/names.py

@@ -0,0 +1,35 @@
+"""
+https://console.groq.com/docs/models
+
+curl -X GET "https://api.groq.com/openai/v1/models" \
+     -H "Authorization: Bearer $GROQ_API_KEY" \
+     -H "Content-Type: application/json"
+"""
+from ....models.names import ModelNameCollection
+from ...strings.manifests import BackendStringsManifest
+
+
+##
+
+
+MODEL_NAMES = ModelNameCollection(
+    default='gpt-oss-120b',
+    aliases={
+        'gpt-oss-120b': 'openai/gpt-oss-120b',
+        'openai/gpt-oss-120b': None,
+
+        'gpt-oss-20b': 'openai/gpt-oss-20b',
+        'openai/gpt-oss-20b': None,
+    },
+)
+
+
+# @omlish-manifest
+_BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
+    [
+        'ChatChoicesService',
+        'ChatChoicesStreamService',
+    ],
+    'groq',
+    model_names=MODEL_NAMES,
+)

ommlds/minichain/backends/impls/groq/protocol.py

@@ -0,0 +1,46 @@
+from omlish import check
+
+from .....backends.groq import protocol as pt
+from ....chat.choices.services import ChatChoicesResponse
+from ....chat.choices.types import AiChoice
+from ....chat.messages import AiMessage
+from ....chat.messages import Message
+from ....chat.messages import SystemMessage
+from ....chat.messages import UserMessage
+from ....chat.stream.types import AiChoiceDeltas
+from ....chat.stream.types import ContentAiChoiceDelta
+
+
+##
+
+
+def build_gq_request_message(mc_msg: Message) -> pt.ChatCompletionRequest.Message:
+    if isinstance(mc_msg, SystemMessage):
+        return pt.ChatCompletionRequest.SystemMessage(
+            content=check.isinstance(mc_msg.c, str),
+        )
+
+    elif isinstance(mc_msg, UserMessage):
+        return pt.ChatCompletionRequest.UserMessage(
+            content=check.isinstance(mc_msg.c, str),
+        )
+
+    else:
+        raise TypeError(mc_msg)
+
+
+def build_mc_choices_response(gq_resp: pt.ChatCompletionResponse) -> ChatChoicesResponse:
+    return ChatChoicesResponse([
+        AiChoice([AiMessage(
+            check.isinstance(gq_choice.message.content, str),
+        )])
+        for gq_choice in gq_resp.choices
+    ])
+
+
+def build_mc_ai_choice_deltas(delta: pt.ChatCompletionChunk.Choice.Delta) -> AiChoiceDeltas:
+    if delta.role in (None, 'assistant') and delta.content is not None:
+        return AiChoiceDeltas([ContentAiChoiceDelta(delta.content)])
+
+    else:
+        return AiChoiceDeltas([])

ommlds/minichain/backends/impls/groq/stream.py

@@ -0,0 +1,121 @@
+import typing as ta
+
+from omlish import check
+from omlish import marshal as msh
+from omlish import typedvalues as tv
+from omlish.formats import json
+from omlish.http import all as http
+from omlish.http import sse
+from omlish.io.buffers import DelimitingBuffer
+
+from .....backends.groq import protocol as pt
+from ....chat.choices.services import ChatChoicesOutputs
+from ....chat.stream.services import ChatChoicesStreamRequest
+from ....chat.stream.services import ChatChoicesStreamResponse
+from ....chat.stream.services import static_check_is_chat_choices_stream_service
+from ....chat.stream.types import AiChoicesDeltas
+from ....configs import Config
+from ....resources import UseResources
+from ....standard import ApiKey
+from ....stream.services import StreamResponseSink
+from ....stream.services import new_stream_response
+from .chat import GroqChatChoicesService
+from .names import MODEL_NAMES
+from .protocol import build_gq_request_message
+from .protocol import build_mc_ai_choice_deltas
+
+
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='groq',
+#     type='ChatChoicesStreamService',
+# )
+@static_check_is_chat_choices_stream_service
+class GroqChatChoicesStreamService:
+    def __init__(
+            self,
+            *configs: Config,
+            http_client: http.AsyncHttpClient | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._http_client = http_client
+
+        with tv.consume(*configs) as cc:
+            self._model_name = cc.pop(GroqChatChoicesService.DEFAULT_MODEL_NAME)
+            self._api_key = ApiKey.pop_secret(cc, env='GROQ_API_KEY')
+
+    READ_CHUNK_SIZE: ta.ClassVar[int] = -1
+
+    async def invoke(self, request: ChatChoicesStreamRequest) -> ChatChoicesStreamResponse:
+        # check.isinstance(request, ChatRequest)
+
+        gq_request = pt.ChatCompletionRequest(
+            messages=[
+                build_gq_request_message(m)
+                for m in request.v
+            ],
+            model=MODEL_NAMES.resolve(self._model_name.v),
+            stream=True,
+        )
+
+        raw_request = msh.marshal(gq_request)
+
+        http_request = http.HttpRequest(
+            'https://api.groq.com/openai/v1/chat/completions',
+            headers={
+                http.consts.HEADER_CONTENT_TYPE: http.consts.CONTENT_TYPE_JSON,
+                http.consts.HEADER_AUTH: http.consts.format_bearer_auth_header(check.not_none(self._api_key).reveal()),
+            },
+            data=json.dumps(raw_request).encode('utf-8'),
+        )
+
+        async with UseResources.or_new(request.options) as rs:
+            http_client = await rs.enter_async_context(http.manage_async_client(self._http_client))
+            http_response = await rs.enter_async_context(await http_client.stream_request(http_request))
+
+            async def inner(sink: StreamResponseSink[AiChoicesDeltas]) -> ta.Sequence[ChatChoicesOutputs]:
+                db = DelimitingBuffer([b'\r', b'\n', b'\r\n'])
+                sd = sse.SseDecoder()
+                while True:
+                    b = await http_response.stream.read1(self.READ_CHUNK_SIZE)
+                    for l in db.feed(b):
+                        if isinstance(l, DelimitingBuffer.Incomplete):
+                            # FIXME: handle
+                            return []
+
+                        # FIXME: https://platform.openai.com/docs/guides/function-calling?api-mode=responses#streaming
+                        for so in sd.process_line(l):
+                            if isinstance(so, sse.SseEvent) and so.type == b'message':
+                                ss = so.data.decode('utf-8')
+                                if ss == '[DONE]':
+                                    return []
+
+                                sj = json.loads(ss)  # ChatCompletionChunk
+
+                                check.state(sj['object'] == 'chat.completion.chunk')
+
+                                ccc = msh.unmarshal(sj, pt.ChatCompletionChunk)
+
+                                # FIXME: stop reason
+                                if not ccc.choices:
+                                    continue
+
+                                if any(choice.finish_reason for choice in ccc.choices):
+                                    check.state(all(choice.finish_reason for choice in ccc.choices))
+                                    break
+
+                                await sink.emit(AiChoicesDeltas([
+                                    build_mc_ai_choice_deltas(choice.delta)
+                                    for choice in ccc.choices
+                                ]))
+
+                    if not b:
+                        return []
+
+            # raw_response = json.loads(check.not_none(http_response.data).decode('utf-8'))
+            # return rh.build_response(raw_response)
+
+            return await new_stream_response(rs, inner)

ommlds/minichain/backends/impls/openai/chat.py

@@ -28,7 +28,7 @@ from ....standard import ApiKey
 from ....standard import DefaultOptions
 from .format import OpenaiChatRequestHandler
 from .format import build_mc_choices_response
-from .names import MODEL_NAMES
+from .names import CHAT_MODEL_NAMES
 
 
 ##
@@ -40,7 +40,7 @@ from .names import MODEL_NAMES
 # )
 @static_check_is_chat_choices_service
 class OpenaiChatChoicesService:
-    DEFAULT_MODEL_NAME: ta.ClassVar[ModelName] = ModelName(check.not_none(MODEL_NAMES.default))
+    DEFAULT_MODEL_NAME: ta.ClassVar[ModelName] = ModelName(check.not_none(CHAT_MODEL_NAMES.default))
 
     def __init__(
             self,
@@ -66,7 +66,7 @@ class OpenaiChatChoicesService:
                 *request.options,
                 override=True,
             ),
-            model=MODEL_NAMES.resolve(self._model_name.v),
+            model=CHAT_MODEL_NAMES.resolve(self._model_name.v),
             mandatory_kwargs=dict(
                 stream=False,
             ),

ommlds/minichain/backends/impls/openai/names.py

@@ -33,7 +33,7 @@ _GPT_MODEL_NAMES = [
 ]
 
 
-MODEL_NAMES = ModelNameCollection(
+CHAT_MODEL_NAMES = ModelNameCollection(
     default='gpt',
     aliases={
         **{
@@ -61,11 +61,35 @@ MODEL_NAMES = ModelNameCollection(
 
 
 # @omlish-manifest
-_BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
+_CHAT_BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
     [
         'ChatChoicesService',
         'ChatChoicesStreamService',
     ],
     'openai',
-    model_names=MODEL_NAMES,
+    model_names=CHAT_MODEL_NAMES,
+)
+
+
+##
+
+
+# @omlish-manifest
+_COMPLETION_BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
+    [
+        'CompletionService',
+    ],
+    'openai',
+)
+
+
+##
+
+
+# @omlish-manifest
+_EMBEDDING_BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
+    [
+        'EmbeddingService',
+    ],
+    'openai',
 )

ommlds/minichain/backends/impls/openai/stream.py

@@ -29,7 +29,7 @@ from ....stream.services import new_stream_response
 from .chat import OpenaiChatChoicesService
 from .format import OpenaiChatRequestHandler
 from .format import build_mc_ai_choice_delta
-from .names import MODEL_NAMES
+from .names import CHAT_MODEL_NAMES
 
 
 ##
@@ -66,7 +66,7 @@ class OpenaiChatChoicesStreamService:
                 for o in request.options
                 if not isinstance(o, (ChatChoicesStreamOption, StreamOption, ResourcesOption))
             ],
-            model=MODEL_NAMES.resolve(self._model_name.v),
+            model=CHAT_MODEL_NAMES.resolve(self._model_name.v),
             mandatory_kwargs=dict(
                 stream=True,
                 stream_options=pt.ChatCompletionRequest.StreamOptions(

ommlds/wiki/analyze.py

@@ -213,7 +213,7 @@ class FileAnalyzer:
         self.verbose and print()
         return True
 
-    @logs.error_logging(log)
+    @logs.exception_logging(log)
     def run(self, file_name: str) -> None:
         log.info(f'{self._ctx.deathpact=} {file_name}')  # noqa
 
@@ -268,7 +268,7 @@ class FileAnalyzer:
             self._flush_rows()
 
 
-@logs.error_logging(log)
+@logs.exception_logging(log)
 def analyze_file(
         file_name: str,
         db_url: str,

ommlds/wiki/utils/xml.py

@@ -24,7 +24,7 @@ else:
 
 T = ta.TypeVar('T')
 
-Element: ta.TypeAlias = ta.Union[ET.Element, 'lxml_etree.Element']
+Element: ta.TypeAlias = ta.Union[ET.Element, 'lxml_etree.Element']  # type: ignore[valid-type]
 
 
 ##
@@ -83,8 +83,8 @@ class ElementToKwargs:
                 raise KeyError(k)
             kw[k] = v
 
-        if el.attrib:
-            for k, v in el.attrib.items():
+        if el.attrib:  # type: ignore
+            for k, v in el.attrib.items():  # type: ignore
                 k = strip_ns(k)
 
                 if k in self.attrs:
@@ -99,7 +99,7 @@ class ElementToKwargs:
                 else:
                     raise KeyError(k)
 
-        for cel in el:
+        for cel in el:  # type: ignore
             k = strip_ns(cel.tag)
 
             if k in self.scalars:
@@ -123,7 +123,7 @@ class ElementToKwargs:
                 raise KeyError(k)
 
         if self.text is not None:
-            set_kw(self.text, el.text)
+            set_kw(self.text, el.text)  # type: ignore
 
         return kw
 

{ommlds-0.0.0.dev474.dist-info → ommlds-0.0.0.dev476.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommlds
-Version: 0.0.0.dev474
+Version: 0.0.0.dev476
 Summary: ommlds
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,8 +14,8 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omdev==0.0.0.dev474
-Requires-Dist: omlish==0.0.0.dev474
+Requires-Dist: omdev==0.0.0.dev476
+Requires-Dist: omlish==0.0.0.dev476
 Provides-Extra: all
 Requires-Dist: llama-cpp-python~=0.3; extra == "all"
 Requires-Dist: mlx~=0.29; extra == "all"
@@ -33,7 +33,7 @@ Requires-Dist: numpy>=1.26; extra == "all"
 Requires-Dist: pytesseract~=0.3; extra == "all"
 Requires-Dist: rapidocr-onnxruntime~=1.4; extra == "all"
 Requires-Dist: pillow~=12.0; extra == "all"
-Requires-Dist: ddgs~=9.7; extra == "all"
+Requires-Dist: ddgs~=9.9; extra == "all"
 Requires-Dist: mwparserfromhell~=0.7; extra == "all"
 Requires-Dist: wikitextparser~=0.56; extra == "all"
 Requires-Dist: lxml>=5.3; python_version < "3.13" and extra == "all"
@@ -60,7 +60,7 @@ Requires-Dist: rapidocr-onnxruntime~=1.4; extra == "ocr"
 Provides-Extra: pillow
 Requires-Dist: pillow~=12.0; extra == "pillow"
 Provides-Extra: search
-Requires-Dist: ddgs~=9.7; extra == "search"
+Requires-Dist: ddgs~=9.9; extra == "search"
 Provides-Extra: wiki
 Requires-Dist: mwparserfromhell~=0.7; extra == "wiki"
 Requires-Dist: wikitextparser~=0.56; extra == "wiki"