Coverage for src/copytrading_engine/parsing/providers/deepseek.py: 95%

36 statements  

« prev     ^ index     » next       coverage.py v7.16.2, created at 2026-11-16 16:55 +0000

1"""DeepSeek's OpenAI-compatible endpoint and prompted-JSON output mode.""" 

2 

3import logging 

4 

5import httpx2 as httpx 

6from openai import APIConnectionError, AsyncOpenAI 

7from pydantic_ai import Agent, PromptedOutput 

8from pydantic_ai.models.openai import OpenAIChatModel 

9from pydantic_ai.providers.deepseek import DeepSeekProvider 

10from pydantic_ai.settings import ModelSettings 

11 

12from copytrading_engine.parsing.learning import LEARN_INSTRUCTIONS, PlaybookProposal 

13from copytrading_engine.shared.cleanup import close_logged 

14from copytrading_engine.shared.model_providers import ProviderConfig 

15from copytrading_engine.shared.payload_capture import PayloadCapture 

16 

17from .pydantic_ai import PydanticAIDecoder, reading_agent 

18from .registry import ManagedDecoder 

19from .transport import DiagnosticHTTPTransport 

20 

21log = logging.getLogger(__name__) 

22 

23ENDPOINT = "https://api.deepseek.com" 

24 

25 

26def client(config: ProviderConfig, http_client: httpx.AsyncClient | None = None) -> AsyncOpenAI: 

27 return AsyncOpenAI( 

28 api_key=config.api_key.get_secret_value(), 

29 base_url=ENDPOINT, 

30 max_retries=0, 

31 timeout=config.timeout, 

32 http_client=http_client, 

33 ) 

34 

35 

36def chat_model(config: ProviderConfig, client: AsyncOpenAI) -> OpenAIChatModel: 

37 """The model the decoder reads with, which the assistant also chats with.""" 

38 return OpenAIChatModel(config.model, provider=DeepSeekProvider(openai_client=client)) 

39 

40 

41_READING: ModelSettings = { 

42 "temperature": 0, 

43 "max_tokens": 3000, 

44 "extra_body": {"thinking": {"type": "disabled"}}, 

45} 

46 

47 

48def build_decoder(config: ProviderConfig, client: AsyncOpenAI) -> PydanticAIDecoder: 

49 model = chat_model(config, client) 

50 agent = reading_agent(model, _READING) 

51 learner = Agent( 

52 model, 

53 output_type=PromptedOutput(PlaybookProposal), 

54 name="playbook_learner", 

55 instructions=LEARN_INSTRUCTIONS, 

56 retries=1, 

57 model_settings={ 

58 # A long free-form draft can loop at temperature 0 until it is cut off mid-JSON; 

59 # a little temperature and a repetition penalty keep it moving. 

60 "temperature": 0.2, 

61 "frequency_penalty": 0.5, 

62 "max_tokens": 8000, 

63 "extra_body": {"thinking": {"type": "disabled"}}, 

64 }, 

65 ) 

66 return PydanticAIDecoder( 

67 agent, learner, client, config.timeout, connection_errors=(APIConnectionError,) 

68 ) 

69 

70 

71async def create_decoder( 

72 config: ProviderConfig, 

73 *, 

74 diagnostics: PayloadCapture | None = None, 

75) -> ManagedDecoder: 

76 http_client = None 

77 if diagnostics is not None: 77 ↛ 78line 77 didn't jump to line 78 because the condition on line 77 was never true

78 http_client = httpx.AsyncClient( 

79 transport=DiagnosticHTTPTransport( 

80 httpx.AsyncHTTPTransport(retries=0), diagnostics, provider="deepseek" 

81 ), 

82 timeout=config.timeout, 

83 follow_redirects=False, 

84 ) 

85 opened = client(config, http_client) 

86 try: 

87 return build_decoder(config, opened) 

88 except BaseException: 

89 await close_logged(opened.close, resource="provider_client", log=log) 

90 raise