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

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

@@ -8,30 +8,24 @@ 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.io.buffers import DelimitingBuffer
+from omlish.http import sse
 
 from .....backends.google.protocol import types as pt
-from ....chat.choices.types import ChatChoicesOutputs
-from ....chat.messages import AiMessage
-from ....chat.messages import Message
-from ....chat.messages import SystemMessage
-from ....chat.messages import ToolUseMessage
-from ....chat.messages import ToolUseResultMessage
-from ....chat.messages import UserMessage
-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 ....chat.stream.types import ToolUseAiChoiceDelta
+from ....chat.choices.stream.services import ChatChoicesStreamRequest
+from ....chat.choices.stream.services import ChatChoicesStreamResponse
+from ....chat.choices.stream.services import static_check_is_chat_choices_stream_service
+from ....chat.choices.stream.types import AiChoiceDeltas
+from ....chat.choices.stream.types import AiChoicesDeltas
+from ....chat.stream.types import ContentAiDelta
+from ....chat.stream.types import ToolUseAiDelta
 from ....chat.tools.types import Tool
+from ....http.stream import BytesHttpStreamResponseBuilder
+from ....http.stream import SimpleSseLinesHttpStreamResponseHandler
 from ....models.configs import ModelName
-from ....resources import UseResources
 from ....standard import ApiKey
-from ....stream.services import StreamResponseSink
-from ....stream.services import new_stream_response
 from .names import MODEL_NAMES
+from .protocol import make_msg_content
+from .protocol import pop_system_instructions
 from .tools import build_tool_spec_schema
 
 
@@ -46,80 +40,53 @@ from .tools import build_tool_spec_schema
 class GoogleChatChoicesStreamService:
     DEFAULT_MODEL_NAME: ta.ClassVar[ModelName] = ModelName(check.not_none(MODEL_NAMES.default))
 
-    def __init__(self, *configs: ApiKey | ModelName) -> None:
+    def __init__(
+            self,
+            *configs: ApiKey | ModelName,
+            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='GEMINI_API_KEY')
 
-    def _make_str_content(
-            self,
-            s: str | None,
-            *,
-            role: pt.ContentRole | None = None,
-    ) -> pt.Content | None:
-        if s is None:
-            return None
-
-        return pt.Content(
-            parts=[pt.Part(
-                text=check.not_none(s),
-            )],
-            role=role,
-        )
-
-    def _make_msg_content(self, m: Message) -> pt.Content:
-        if isinstance(m, (AiMessage, SystemMessage, UserMessage)):
-            return check.not_none(self._make_str_content(
-                check.isinstance(m.c, str),
-                role=self.ROLES_MAP[type(m)],
-            ))
-
-        elif isinstance(m, ToolUseResultMessage):
-            tr_resp_val: pt.Value
-            if m.tur.c is None:
-                tr_resp_val = pt.NullValue()  # type: ignore[unreachable]
-            elif isinstance(m.tur.c, str):
-                tr_resp_val = pt.StringValue(m.tur.c)
-            else:
-                raise TypeError(m.tur.c)
-            return pt.Content(
-                parts=[pt.Part(
-                    function_response=pt.FunctionResponse(
-                        id=m.tur.id,
-                        name=m.tur.name,
-                        response={
-                            'value': tr_resp_val,
-                        },
-                    ),
-                )],
-            )
-
-        elif isinstance(m, ToolUseMessage):
-            return pt.Content(
-                parts=[pt.Part(
-                    function_call=pt.FunctionCall(
-                        id=m.tu.id,
-                        name=m.tu.name,
-                        args=m.tu.args,
-                    ),
-                )],
-                role='model',
-            )
-
-        else:
-            raise TypeError(m)
-
     BASE_URL: ta.ClassVar[str] = 'https://generativelanguage.googleapis.com/v1beta/models'
 
-    ROLES_MAP: ta.ClassVar[ta.Mapping[type[Message], pt.ContentRole | None]] = {  # noqa
-        SystemMessage: None,
-        UserMessage: 'user',
-        AiMessage: 'model',
-    }
+    def _process_sse(self, so: sse.SseDecoderOutput) -> ta.Iterable[AiChoicesDeltas | None]:
+        if not (isinstance(so, sse.SseEvent) and so.type == b'message'):
+            return
+
+        gcr = msh.unmarshal(json.loads(so.data.decode('utf-8')), pt.GenerateContentResponse)  # noqa
+        cnd = check.single(check.not_none(gcr.candidates))
+
+        for p in check.not_none(cnd.content).parts or []:
+            if (txt := p.text) is not None:
+                check.none(p.function_call)
+                yield AiChoicesDeltas([
+                    AiChoiceDeltas([
+                        ContentAiDelta(check.not_none(txt)),
+                    ]),
+                ])
+
+            elif (fc := p.function_call) is not None:
+                check.none(p.text)
+                yield AiChoicesDeltas([
+                    AiChoiceDeltas([
+                        ToolUseAiDelta(
+                            id=fc.id,
+                            name=fc.name,
+                            args=fc.args,
+                        ),
+                    ]),
+                ])
+
+            else:
+                raise ValueError(p)
 
-    READ_CHUNK_SIZE = 64 * 1024
+    READ_CHUNK_SIZE: ta.ClassVar[int] = -1
 
     async def invoke(
             self,
@@ -127,13 +94,6 @@ class GoogleChatChoicesStreamService:
     ) -> ChatChoicesStreamResponse:
         key = check.not_none(self._api_key).reveal()
 
-        msgs = list(request.v)
-
-        system_inst: pt.Content | None = None
-        if msgs and isinstance(m0 := msgs[0], SystemMessage):
-            system_inst = self._make_msg_content(m0)
-            msgs.pop(0)
-
         g_tools: list[pt.Tool] = []
         with tv.TypedValues(*request.options).consume() as oc:
             t: Tool
@@ -142,11 +102,15 @@ class GoogleChatChoicesStreamService:
                     function_declarations=[build_tool_spec_schema(t.spec)],
                 ))
 
+        msgs = list(request.v)
+
+        system_inst = pop_system_instructions(msgs)
+
         g_req = pt.GenerateContentRequest(
             contents=[
-                self._make_msg_content(m)
+                make_msg_content(m)
                 for m in msgs
-            ],
+            ] or None,
             tools=g_tools or None,
             system_instruction=system_inst,
         )
@@ -162,53 +126,11 @@ class GoogleChatChoicesStreamService:
             method='POST',
         )
 
-        async with UseResources.or_new(request.options) as rs:
-            http_client = rs.enter_context(http.client())
-            http_response = rs.enter_context(http_client.stream_request(http_request))
-
-            async def inner(sink: StreamResponseSink[AiChoicesDeltas]) -> ta.Sequence[ChatChoicesOutputs] | None:
-                db = DelimitingBuffer([b'\r', b'\n', b'\r\n'])
-                while True:
-                    # FIXME: read1 not on response stream protocol
-                    b = http_response.stream.read1(self.READ_CHUNK_SIZE)  # type: ignore[attr-defined]
-                    for bl in db.feed(b):
-                        if isinstance(bl, DelimitingBuffer.Incomplete):
-                            # FIXME: handle
-                            return []
-
-                        l = bl.decode('utf-8')
-                        if not l:
-                            continue
-
-                        if l.startswith('data: '):
-                            gcr = msh.unmarshal(json.loads(l[6:]), pt.GenerateContentResponse)  # noqa
-                            cnd = check.single(check.not_none(gcr.candidates))
-
-                            for p in check.not_none(cnd.content).parts or []:
-                                if (txt := p.text) is not None:
-                                    check.none(p.function_call)
-                                    await sink.emit(AiChoicesDeltas([
-                                        AiChoiceDeltas([
-                                            ContentAiChoiceDelta(check.not_none(txt)),
-                                        ]),
-                                    ]))
-
-                                elif (fc := p.function_call) is not None:
-                                    check.none(p.text)
-                                    await sink.emit(AiChoicesDeltas([
-                                        AiChoiceDeltas([
-                                            ToolUseAiChoiceDelta(
-                                                id=fc.id,
-                                                name=fc.name,
-                                                args=fc.args,
-                                            ),
-                                        ]),
-                                    ]))
-
-                                else:
-                                    raise ValueError(p)
-
-                    if not b:
-                        return []
-
-            return await new_stream_response(rs, inner)
+        return await BytesHttpStreamResponseBuilder(
+            self._http_client,
+            lambda http_response: SimpleSseLinesHttpStreamResponseHandler(self._process_sse).as_lines().as_bytes(),
+            read_chunk_size=self.READ_CHUNK_SIZE,
+        ).new_stream_response(
+            http_request,
+            request.options,
+        )

ommlds/minichain/backends/impls/google/tools.py

@@ -7,8 +7,8 @@ from omlish import check
 from omlish import dataclasses as dc
 
 from .....backends.google.protocol import types as pt
-from ....content.prepare import ContentStrPreparer
-from ....content.prepare import default_content_str_preparer
+from ....content.transform.prepare import ContentStrPreparer
+from ....content.transform.prepare import default_content_str_preparer
 from ....tools.types import EnumToolDtype
 from ....tools.types import MappingToolDtype
 from ....tools.types import NullableToolDtype

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

@@ -0,0 +1,77 @@
+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 .....backends.groq.clients import REQUIRED_HTTP_HEADERS
+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.tools.types import Tool
+from ....models.configs import ModelName
+from ....standard import ApiKey
+from ....standard import DefaultOptions
+from .names import MODEL_NAMES
+from .protocol import build_gq_request_messages
+from .protocol import build_gq_request_tool
+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:
+        tools: list[pt.ChatCompletionRequest.Tool] = []
+        with tv.TypedValues(*request.options).consume() as oc:
+            t: Tool
+            for t in oc.pop(Tool, []):
+                tools.append(build_gq_request_tool(t))
+
+        gq_request = pt.ChatCompletionRequest(
+            messages=build_gq_request_messages(request.v),
+            model=MODEL_NAMES.resolve(self._model_name.v),
+            tools=tools or None,
+        )
+
+        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()),
+                **REQUIRED_HTTP_HEADERS,
+            },
+            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,48 @@
+"""
+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"
+
+"compound-beta",
+"compound-beta-mini",
+"gemma2-9b-it",
+"llama-3.1-8b-instant",
+"llama-3.3-70b-versatile",
+"meta-llama/llama-4-maverick-17b-128e-instruct",
+"meta-llama/llama-4-scout-17b-16e-instruct",
+"meta-llama/llama-guard-4-12b",
+"moonshotai/kimi-k2-instruct",
+"openai/gpt-oss-120b",
+"openai/gpt-oss-20b",
+"qwen/qwen3-32b",
+"""
+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,143 @@
+import itertools
+
+from omlish import check
+from omlish.formats import json
+
+from .....backends.groq import protocol as pt
+from ....chat.choices.services import ChatChoicesResponse
+from ....chat.choices.stream.types import AiChoiceDeltas
+from ....chat.choices.types import AiChoice
+from ....chat.messages import AiMessage
+from ....chat.messages import AnyAiMessage
+from ....chat.messages import Chat
+from ....chat.messages import SystemMessage
+from ....chat.messages import ToolUseMessage
+from ....chat.messages import ToolUseResultMessage
+from ....chat.messages import UserMessage
+from ....chat.stream.types import AiDelta
+from ....chat.stream.types import ContentAiDelta
+from ....chat.stream.types import ToolUseAiDelta
+from ....chat.tools.types import Tool
+from ....content.transform.prepare import prepare_content_str
+from ....tools.jsonschema import build_tool_spec_params_json_schema
+from ....tools.types import ToolUse
+
+
+##
+
+
+def build_gq_request_messages(chat: Chat) -> list[pt.ChatCompletionRequest.Message]:
+    gq_msgs: list[pt.ChatCompletionRequest.Message] = []
+
+    for _, g in itertools.groupby(chat, lambda mc_m: isinstance(mc_m, AnyAiMessage)):
+        mc_msgs = list(g)
+
+        if isinstance(mc_msgs[0], AnyAiMessage):
+            tups: list[tuple[AiMessage | None, list[ToolUseMessage]]] = []
+            for mc_msg in mc_msgs:
+                if isinstance(mc_msg, AiMessage):
+                    tups.append((mc_msg, []))
+
+                elif isinstance(mc_msg, ToolUseMessage):
+                    if not tups:
+                        tups.append((None, []))
+                    tups[-1][1].append(mc_msg)
+
+                else:
+                    raise TypeError(mc_msg)
+
+            for mc_ai_msg, mc_tu_msgs in tups:
+                gq_msgs.append(pt.ChatCompletionRequest.AssistantMessage(
+                    content=check.isinstance(mc_ai_msg.c, str) if mc_ai_msg is not None else None,
+                    tool_calls=[
+                        pt.ChatCompletionRequest.AssistantMessage.ToolCall(
+                            function=pt.ChatCompletionRequest.AssistantMessage.ToolCall.Function(
+                                name=mc_tu_msg.tu.name,
+                                arguments=check.not_none(mc_tu_msg.tu.raw_args),
+                            ),
+                            id=check.not_none(mc_tu_msg.tu.id),
+                        )
+                        for mc_tu_msg in mc_tu_msgs
+                    ] if mc_tu_msgs else None,
+                ))
+
+        else:
+            for mc_msg in mc_msgs:
+                if isinstance(mc_msg, SystemMessage):
+                    gq_msgs.append(pt.ChatCompletionRequest.SystemMessage(
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, UserMessage):
+                    gq_msgs.append(pt.ChatCompletionRequest.UserMessage(
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, ToolUseResultMessage):
+                    gq_msgs.append(pt.ChatCompletionRequest.ToolMessage(
+                        tool_call_id=check.not_none(mc_msg.tur.id),
+                        content=check.isinstance(mc_msg.tur.c, str),
+                    ))
+
+                else:
+                    raise TypeError(mc_msg)
+
+    return gq_msgs
+
+
+def build_gq_request_tool(t: Tool) -> pt.ChatCompletionRequest.Tool:
+    return pt.ChatCompletionRequest.Tool(
+        function=pt.ChatCompletionRequest.Tool.Function(
+            name=check.not_none(t.spec.name),
+            description=prepare_content_str(t.spec.desc) if t.spec.desc is not None else None,
+            parameters=build_tool_spec_params_json_schema(t.spec),
+        ),
+    )
+
+
+def build_mc_choices_response(gq_resp: pt.ChatCompletionResponse) -> ChatChoicesResponse:
+    def build_choice(gq_choice: pt.ChatCompletionResponse.Choice) -> AiChoice:
+        gq_msg = gq_choice.message
+
+        lst: list[AnyAiMessage] = []
+
+        if gq_msg.content is not None:
+            lst.append(AiMessage(
+                check.isinstance(gq_msg.content, str),
+            ))
+
+        for gq_tc in gq_msg.tool_calls or []:
+            lst.append(ToolUseMessage(ToolUse(
+                id=gq_tc.id,
+                name=gq_tc.function.name,
+                args=json.loads(gq_tc.function.arguments or '{}'),
+                raw_args=gq_tc.function.arguments,
+            )))
+
+        return AiChoice(lst)
+
+    return ChatChoicesResponse(list(map(build_choice, gq_resp.choices)))
+
+
+def build_mc_ai_choice_deltas(delta: pt.ChatCompletionChunk.Choice.Delta) -> AiChoiceDeltas:
+    if delta.role in (None, 'assistant'):
+        lst: list[AiDelta] = []
+
+        if delta.content is not None:
+            lst.append(ContentAiDelta(delta.content))
+
+        for tc in delta.tool_calls or []:
+            tc_fn = check.not_none(tc.function)
+            lst.append(ToolUseAiDelta(
+                id=tc.id,
+                name=check.not_none(tc_fn.name),
+                args=json.loads(tc_fn.arguments or '{}'),
+            ))
+
+        return AiChoiceDeltas(lst)
+
+    elif delta.channel in ('analysis', 'commentary'):
+        return AiChoiceDeltas([])
+
+    else:
+        raise ValueError(delta)

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

@@ -0,0 +1,114 @@
+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 .....backends.groq import protocol as pt
+from .....backends.groq.clients import REQUIRED_HTTP_HEADERS
+from ....chat.choices.stream.services import ChatChoicesStreamRequest
+from ....chat.choices.stream.services import ChatChoicesStreamResponse
+from ....chat.choices.stream.services import static_check_is_chat_choices_stream_service
+from ....chat.choices.stream.types import AiChoicesDeltas
+from ....chat.tools.types import Tool
+from ....configs import Config
+from ....http.stream import BytesHttpStreamResponseBuilder
+from ....http.stream import SimpleSseLinesHttpStreamResponseHandler
+from ....standard import ApiKey
+from .chat import GroqChatChoicesService
+from .names import MODEL_NAMES
+from .protocol import build_gq_request_messages
+from .protocol import build_gq_request_tool
+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')
+
+    URL: ta.ClassVar[str] = 'https://api.groq.com/openai/v1/chat/completions'
+
+    def _process_sse(self, so: sse.SseDecoderOutput) -> ta.Sequence[AiChoicesDeltas | None]:
+        if not (isinstance(so, sse.SseEvent) and so.type == b'message'):
+            return []
+
+        ss = so.data.decode('utf-8')
+        if ss == '[DONE]':
+            return [None]
+
+        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:
+            return []
+
+        if any(choice.finish_reason for choice in ccc.choices):
+            check.state(all(choice.finish_reason for choice in ccc.choices))
+            return [None]
+
+        return [AiChoicesDeltas([
+            build_mc_ai_choice_deltas(choice.delta)
+            for choice in ccc.choices
+        ])]
+
+    READ_CHUNK_SIZE: ta.ClassVar[int] = -1
+
+    async def invoke(self, request: ChatChoicesStreamRequest) -> ChatChoicesStreamResponse:
+        tools: list[pt.ChatCompletionRequest.Tool] = []
+        with tv.TypedValues(*request.options).consume() as oc:
+            t: Tool
+            for t in oc.pop(Tool, []):
+                tools.append(build_gq_request_tool(t))
+
+        gq_request = pt.ChatCompletionRequest(
+            messages=build_gq_request_messages(request.v),
+            model=MODEL_NAMES.resolve(self._model_name.v),
+            tools=tools or None,
+            stream=True,
+        )
+
+        raw_request = msh.marshal(gq_request)
+
+        http_request = http.HttpRequest(
+            self.URL,
+            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()),
+                **REQUIRED_HTTP_HEADERS,
+            },
+            data=json.dumps(raw_request).encode('utf-8'),
+        )
+
+        return await BytesHttpStreamResponseBuilder(
+            self._http_client,
+            lambda http_response: SimpleSseLinesHttpStreamResponseHandler(self._process_sse).as_lines().as_bytes(),
+            read_chunk_size=self.READ_CHUNK_SIZE,
+        ).new_stream_response(
+            http_request,
+            request.options,
+        )

ommlds/minichain/backends/impls/huggingface/repos.py

@@ -3,8 +3,6 @@ TODO:
  - local-only check first
   - cat ~/.cache/.../models/.../refs/main -> c5bfd839cd4cda0e5a39a97e00218d9c56e468af
 """
-import typing as ta
-
 from omlish import lang
 
 from ....models.configs import ModelRepo
@@ -12,10 +10,8 @@ from ....models.repos.resolving import ModelRepoResolver
 from ....models.repos.resolving import ResolvedModelRepo
 
 
-if ta.TYPE_CHECKING:
+with lang.auto_proxy_import(globals()):
     import huggingface_hub as hf
-else:
-    hf = lang.proxy_import('huggingface_hub')
 
 
 ##