Coverage for src/copytrading_engine/trading/application/profile_review.py: 100%

45 statements  

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

1"""Read-only profile work: learn a playbook and evaluate history.""" 

2 

3import asyncio 

4import logging 

5from collections.abc import Callable, Collection 

6from pathlib import Path 

7 

8from pydantic import SecretStr 

9 

10from copytrading_engine.execution.domain.sizing import RouteConnection 

11from copytrading_engine.parsing.extraction import DecodeError 

12from copytrading_engine.parsing.providers.registry import NamedDecoderFactory 

13from copytrading_engine.shared.cleanup import close_logged 

14from copytrading_engine.shared.owner_facing import OwnerFacingError 

15from copytrading_engine.trading.application.ports import ChannelHistory, OperatorEvidence 

16from copytrading_engine.trading.domain.config import ProviderConfiguration 

17from copytrading_engine.trading.domain.profiles import ( 

18 LearnedPlaybook, 

19 ProfileEvaluation, 

20 ProfileEvaluationService, 

21 ProfileRevision, 

22) 

23 

24# Enough posts to see a guru's habits; few enough to stay one bounded model call. 

25LEARNING_POST_LIMIT = 80 

26# Writing a whole playbook takes far longer than reading one post. 

27LEARNING_TIMEOUT_SECONDS = 150 

28 

29log = logging.getLogger(__name__) 

30 

31 

32class ProfileReviewService: 

33 """Interpret with a temporary decoder; never open execution owners or order outboxes.""" 

34 

35 def __init__( 

36 self, 

37 data_dir: Path, 

38 decoder: NamedDecoderFactory, 

39 register_secrets: Callable[[Collection[str]], None], 

40 evidence: OperatorEvidence, 

41 history: ChannelHistory, 

42 ) -> None: 

43 self._data_dir = data_dir 

44 self._evidence = evidence 

45 self._history = history 

46 self._decoder = decoder 

47 self._register_secrets = register_secrets 

48 

49 async def evaluate_historical_profile( 

50 self, 

51 source_id: str, 

52 profile: ProfileRevision, 

53 provider: ProviderConfiguration, 

54 provider_api_key: SecretStr, 

55 destinations: list[RouteConnection], 

56 ) -> ProfileEvaluation: 

57 """Evaluate one captured historical message without opening execution owners.""" 

58 self._register_secrets((provider_api_key.get_secret_value(),)) 

59 source = await asyncio.to_thread( 

60 self._evidence.historical_source_message, self._data_dir / "application.db", source_id 

61 ) 

62 decoder = await self._decoder( 

63 provider.name, 

64 provider.reader(provider_api_key, timeout=20), 

65 ) 

66 try: 

67 service = ProfileEvaluationService( 

68 decoder, provider=provider.name, model=provider.model 

69 ) 

70 return await service.evaluate(source, profile, destinations=tuple(destinations)) 

71 finally: 

72 await close_logged(decoder.close, resource="provider", log=log) 

73 

74 async def learn_playbook( 

75 self, 

76 channel_id: str, 

77 author_id: str | None, 

78 discord_token: SecretStr, 

79 provider: ProviderConfiguration, 

80 provider_api_key: SecretStr, 

81 ) -> LearnedPlaybook: 

82 """Read the channel's recent posts and draft a playbook; nothing is saved.""" 

83 self._register_secrets( 

84 (discord_token.get_secret_value(), provider_api_key.get_secret_value()) 

85 ) 

86 posts = await self._history.recent_posts( 

87 discord_token.get_secret_value(), channel_id, author_id, LEARNING_POST_LIMIT 

88 ) 

89 if not posts: 

90 raise OwnerFacingError("This channel has no text posts to learn from yet.") 

91 decoder = await self._decoder( 

92 provider.name, 

93 provider.reader(provider_api_key, timeout=LEARNING_TIMEOUT_SECONDS), 

94 ) 

95 try: 

96 proposal = await decoder.learn(posts) 

97 except DecodeError as exc: 

98 raise OwnerFacingError(_LEARNING_FAILURES.get(exc.reason, _LEARNING_FAILED)) from None 

99 finally: 

100 await close_logged(decoder.close, resource="provider", log=log) 

101 return LearnedPlaybook( 

102 posts_read=len(posts), 

103 playbook=proposal.playbook.strip(), 

104 summary=proposal.summary.strip(), 

105 provider=provider.name, 

106 model=provider.model, 

107 ) 

108 

109 

110_LEARNING_FAILED = "The model could not draft a playbook. Try again." 

111_LEARNING_FAILURES = { 

112 "provider_rejected": "The model provider rejected the request. Check the API key and model.", 

113 "provider_key_rejected": "The model provider did not accept the API key. Check Connections.", 

114 "provider_model_not_found": "The model provider has no model by that name. Check Connections.", 

115 "provider_unavailable": "The model provider is unavailable right now. Try again shortly.", 

116 "provider_timeout": "The model took too long to answer. Try again.", 

117}