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

1"""The fixed registry and shared contracts for parser provider adapters.""" 

2 

3from collections.abc import Awaitable, Callable, Mapping 

4from types import MappingProxyType 

5from typing import Protocol 

6 

7from pydantic_ai.models import Model 

8 

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 

13 

14 

15class ManagedDecoder(Decoder, Learner, Protocol): 

16 async def model_names(self) -> tuple[str, ...]: 

17 """The model names the provider lists for this key.""" 

18 ... 

19 

20 async def close(self) -> None: ... 

21 

22 

23DecoderFactory = Callable[..., Awaitable[ManagedDecoder]] 

24type NamedDecoderFactory = Callable[[str, ProviderConfig], Awaitable[ManagedDecoder]] 

25"""Create the named provider's decoder; the caller must close it.""" 

26 

27 

28class ProviderRegistry: 

29 def __init__(self, factories: Mapping[str, DecoderFactory]) -> None: 

30 self._factories: Mapping[str, DecoderFactory] = MappingProxyType(dict(factories)) 

31 

32 def names(self) -> tuple[str, ...]: 

33 return tuple(sorted(self._factories)) 

34 

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 ) 

49 

50 

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 

55 

56 return ProviderRegistry( 

57 { 

58 "anthropic": create_anthropic_decoder, 

59 "deepseek": create_deepseek_decoder, 

60 **openai_compatible_factories(), 

61 } 

62 ) 

63 

64 

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 

70 

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