Coverage for src/copytrading_engine/parsing/providers/registry.py: 100%
40 statements
« prev ^ index » next coverage.py v7.16.2, created at 2026-11-16 16:55 +0000
« prev ^ index » next coverage.py v7.16.2, created at 2026-11-16 16:55 +0000
1"""The fixed registry and shared contracts for parser provider adapters."""
3from collections.abc import Awaitable, Callable, Mapping
4from types import MappingProxyType
5from typing import Protocol
7from pydantic_ai.models import Model
9from copytrading_engine.parsing.extraction import Decoder
10from copytrading_engine.parsing.learning import Learner
11from copytrading_engine.shared.model_providers import ModelProvider, ProviderConfig
12from copytrading_engine.shared.payload_capture import PayloadCapture
15class ManagedDecoder(Decoder, Learner, Protocol):
16 async def model_names(self) -> tuple[str, ...]:
17 """The model names the provider lists for this key."""
18 ...
20 async def close(self) -> None: ...
23DecoderFactory = Callable[..., Awaitable[ManagedDecoder]]
24type NamedDecoderFactory = Callable[[str, ProviderConfig], Awaitable[ManagedDecoder]]
25"""Create the named provider's decoder; the caller must close it."""
28class ProviderRegistry:
29 def __init__(self, factories: Mapping[str, DecoderFactory]) -> None:
30 self._factories: Mapping[str, DecoderFactory] = MappingProxyType(dict(factories))
32 def names(self) -> tuple[str, ...]:
33 return tuple(sorted(self._factories))
35 async def create(
36 self,
37 name: str,
38 config: ProviderConfig,
39 *,
40 diagnostics: PayloadCapture | None = None,
41 ) -> ManagedDecoder:
42 try:
43 factory = self._factories[name]
44 except KeyError:
45 raise ValueError(f"Unknown LLM provider: {name}") from None
46 return await (
47 factory(config) if diagnostics is None else factory(config, diagnostics=diagnostics)
48 )
51def builtin_registry() -> ProviderRegistry:
52 from .anthropic import create_decoder as create_anthropic_decoder
53 from .deepseek import create_decoder as create_deepseek_decoder
54 from .openai_compatible import factories as openai_compatible_factories
56 return ProviderRegistry(
57 {
58 "anthropic": create_anthropic_decoder,
59 "deepseek": create_deepseek_decoder,
60 **openai_compatible_factories(),
61 }
62 )
65async def open_chat_model(
66 name: ModelProvider, config: ProviderConfig
67) -> tuple[Model, Callable[[], Awaitable[None]]]:
68 """The interpreter as a plain chat model, for the assistant; the caller closes it."""
69 from . import anthropic, deepseek, openai_compatible
71 if name == "anthropic":
72 client = anthropic.client(config)
73 return anthropic.chat_model(config, client), client.close
74 if name == "deepseek":
75 client = deepseek.client(config)
76 return deepseek.chat_model(config, client), client.close
77 service = openai_compatible.SERVICES[name]
78 client = openai_compatible.client(service, config)
79 return openai_compatible.chat_model(service, config, client), client.close