Coverage for src/copytrading_engine/host/pipe/handlers/accounts.py: 59%

88 statements  

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

1"""Accounts, activity, history, and the owner's account controls.""" 

2 

3from copytrading_engine.host.pipe.requests import ( 

4 AttachAccountReadersRequest, 

5 ControlAccountRequest, 

6 DeleteAccountRecordRequest, 

7 DetachAccountReadersRequest, 

8 GetAccountFeedRequest, 

9 GetAccountsRequest, 

10 GetBarsRequest, 

11 GetDailyBarsRequest, 

12 GetEquityHistoryRequest, 

13 GetGuruActivityRequest, 

14 GetGuruDayStatsRequest, 

15 GetGuruPerformanceRequest, 

16 GetQuoteRequest, 

17 GetSourceActivityRequest, 

18 PipeRequest, 

19 RequestHandler, 

20 ResolveOwnershipRequest, 

21) 

22from copytrading_engine.host.pipe.responses import reply 

23from copytrading_engine.host.pipe.services import TradingServices 

24from copytrading_engine.trading.application.paused_reader import ReadKeys 

25 

26 

27class AccountHandlers: 

28 """Answer account, activity, and history reads, and apply the owner's account controls.""" 

29 

30 def __init__(self, *, trading: TradingServices | None) -> None: 

31 self._trading = trading 

32 

33 def handlers(self) -> dict[type[PipeRequest], RequestHandler]: 

34 return { 

35 ControlAccountRequest: self._on_control_account, 

36 ResolveOwnershipRequest: self._on_resolve_ownership, 

37 GetAccountsRequest: self._on_get_accounts, 

38 GetSourceActivityRequest: self._on_get_source_activity, 

39 GetGuruActivityRequest: self._on_get_guru_activity, 

40 GetGuruDayStatsRequest: self._on_get_guru_day_stats, 

41 GetAccountFeedRequest: self._on_get_account_feed, 

42 GetEquityHistoryRequest: self._on_get_equity_history, 

43 GetQuoteRequest: self._on_get_quote, 

44 GetBarsRequest: self._on_get_bars, 

45 GetDailyBarsRequest: self._on_get_daily_bars, 

46 GetGuruPerformanceRequest: self._on_get_guru_performance, 

47 AttachAccountReadersRequest: self._on_attach_account_readers, 

48 DetachAccountReadersRequest: self._on_detach_account_readers, 

49 DeleteAccountRecordRequest: self._on_delete_account_record, 

50 } 

51 

52 async def _on_get_quote(self, request: GetQuoteRequest) -> bytes: 

53 """A quote is read-only market data; an account with no read keys here is not found.""" 

54 if self._trading is None: 54 ↛ 55line 54 didn't jump to line 55 because the condition on line 54 was never true

55 return reply(request.version, request.request_id, error="unavailable") 

56 quote = await self._trading.operator.quote(request.account_id, request.symbol) 

57 return reply( 

58 request.version, 

59 request.request_id, 

60 ok={ 

61 "type": "quote", 

62 "account_id": request.account_id, 

63 "symbol": request.symbol, 

64 "quote": None if quote is None else quote.model_dump(mode="json"), 

65 }, 

66 ) 

67 

68 async def _on_get_bars(self, request: GetBarsRequest) -> bytes: 

69 """Bars are read-only market data, asked through the account's read keys.""" 

70 if self._trading is None: 70 ↛ 71line 70 didn't jump to line 71 because the condition on line 70 was never true

71 return reply(request.version, request.request_id, error="unavailable") 

72 bars = await self._trading.operator.bars(request.account_id, request.symbols) 

73 return reply( 

74 request.version, 

75 request.request_id, 

76 ok={ 

77 "type": "bars", 

78 "account_id": request.account_id, 

79 "bars": { 

80 symbol: [bar.model_dump(mode="json") for bar in series] 

81 for symbol, series in bars.items() 

82 }, 

83 }, 

84 ) 

85 

86 async def _on_get_daily_bars(self, request: GetDailyBarsRequest) -> bytes: 

87 """Daily bars are read-only market data, asked through the account's read keys.""" 

88 if self._trading is None: 88 ↛ 89line 88 didn't jump to line 89 because the condition on line 88 was never true

89 return reply(request.version, request.request_id, error="unavailable") 

90 bars = await self._trading.operator.daily_bars( 

91 request.account_id, request.symbol, request.range 

92 ) 

93 return reply( 

94 request.version, 

95 request.request_id, 

96 ok={ 

97 "type": "daily_bars", 

98 "account_id": request.account_id, 

99 "symbol": request.symbol, 

100 "range": request.range, 

101 "bars": [bar.model_dump(mode="json") for bar in bars], 

102 }, 

103 ) 

104 

105 async def _on_get_guru_performance(self, request: GetGuruPerformanceRequest) -> bytes: 

106 if self._trading is None: 106 ↛ 107line 106 didn't jump to line 107 because the condition on line 106 was never true

107 return reply(request.version, request.request_id, error="unavailable") 

108 performance = await self._trading.operator.guru_performance( 

109 request.account_id, request.guru_id 

110 ) 

111 return reply( 

112 request.version, 

113 request.request_id, 

114 ok={"type": "guru_performance", "performance": performance.model_dump(mode="json")}, 

115 ) 

116 

117 async def _on_attach_account_readers(self, request: AttachAccountReadersRequest) -> bytes: 

118 if self._trading is None: 

119 return reply(request.version, request.request_id, error="unavailable") 

120 self._trading.operator.attach_readers( 

121 tuple( 

122 ReadKeys( 

123 account_id=item.account_id, 

124 environment=item.environment, 

125 key=item.key, 

126 secret=item.secret, 

127 ) 

128 for item in request.accounts 

129 ) 

130 ) 

131 return reply(request.version, request.request_id, ok={"type": "account_readers"}) 

132 

133 async def _on_detach_account_readers(self, request: DetachAccountReadersRequest) -> bytes: 

134 if self._trading is None: 

135 return reply(request.version, request.request_id, error="unavailable") 

136 self._trading.operator.detach_readers() 

137 return reply(request.version, request.request_id, ok={"type": "account_readers"}) 

138 

139 async def _on_delete_account_record(self, request: DeleteAccountRecordRequest) -> bytes: 

140 if self._trading is None: 

141 return reply(request.version, request.request_id, error="unavailable") 

142 refusal = await self._trading.manual.delete_account_record(request.account_id) 

143 if refusal == "not_found": 

144 return reply(request.version, request.request_id, error="not_found") 

145 if refusal is not None: 

146 return reply( 

147 request.version, request.request_id, error="invalid_request", reason=refusal 

148 ) 

149 return reply( 

150 request.version, 

151 request.request_id, 

152 ok={"type": "account_record_deleted", "account_id": request.account_id}, 

153 ) 

154 

155 async def _on_control_account(self, request: ControlAccountRequest) -> bytes: 

156 if self._trading is None: 156 ↛ 157line 156 didn't jump to line 157 because the condition on line 156 was never true

157 return reply(request.version, request.request_id, error="unavailable") 

158 result = await self._trading.manual.control_account(request.command) 

159 return reply( 

160 request.version, 

161 request.request_id, 

162 ok={"type": "account_control", "control": result.model_dump(mode="json")}, 

163 ) 

164 

165 async def _on_resolve_ownership(self, request: ResolveOwnershipRequest) -> bytes: 

166 if self._trading is None: 166 ↛ 167line 166 didn't jump to line 167 because the condition on line 166 was never true

167 return reply(request.version, request.request_id, error="unavailable") 

168 result = await self._trading.manual.resolve_ownership( 

169 request.account_id, request.resolution 

170 ) 

171 return reply( 

172 request.version, 

173 request.request_id, 

174 ok={ 

175 "type": "ownership_resolution", 

176 "resolution": result.model_dump(mode="json"), 

177 }, 

178 ) 

179 

180 async def _on_get_accounts(self, request: GetAccountsRequest) -> bytes: 

181 if self._trading is None: 181 ↛ 182line 181 didn't jump to line 182 because the condition on line 181 was never true

182 return reply(request.version, request.request_id, error="unavailable") 

183 accounts = await self._trading.operator.account_overviews( 

184 request.before_account_id, request.limit 

185 ) 

186 return reply( 

187 request.version, 

188 request.request_id, 

189 ok={ 

190 "type": "accounts", 

191 "accounts": accounts.model_dump(mode="json"), 

192 }, 

193 ) 

194 

195 async def _on_get_source_activity(self, request: GetSourceActivityRequest) -> bytes: 

196 if self._trading is None: 196 ↛ 197line 196 didn't jump to line 197 because the condition on line 196 was never true

197 return reply(request.version, request.request_id, error="unavailable") 

198 page = await self._trading.operator.source_activity(request.before_seq, request.limit) 

199 return reply( 

200 request.version, 

201 request.request_id, 

202 ok={"type": "source_activity", "activity": page.model_dump(mode="json")}, 

203 ) 

204 

205 async def _on_get_guru_activity(self, request: GetGuruActivityRequest) -> bytes: 

206 if self._trading is None: 206 ↛ 207line 206 didn't jump to line 207 because the condition on line 206 was never true

207 return reply(request.version, request.request_id, error="unavailable") 

208 page = await self._trading.operator.guru_activity( 

209 request.guru_id, request.before_seq, request.limit 

210 ) 

211 return reply( 

212 request.version, 

213 request.request_id, 

214 ok={"type": "source_activity", "activity": page.model_dump(mode="json")}, 

215 ) 

216 

217 async def _on_get_guru_day_stats(self, request: GetGuruDayStatsRequest) -> bytes: 

218 if self._trading is None: 218 ↛ 219line 218 didn't jump to line 219 because the condition on line 218 was never true

219 return reply(request.version, request.request_id, error="unavailable") 

220 page = await self._trading.operator.guru_day_stats(request.day_start, request.day_end) 

221 return reply( 

222 request.version, 

223 request.request_id, 

224 ok={"type": "guru_day_stats", "stats": page.model_dump(mode="json")}, 

225 ) 

226 

227 async def _on_get_account_feed(self, request: GetAccountFeedRequest) -> bytes: 

228 if self._trading is None: 228 ↛ 229line 228 didn't jump to line 229 because the condition on line 228 was never true

229 return reply(request.version, request.request_id, error="unavailable") 

230 page = await self._trading.operator.account_feed( 

231 request.account_id, request.before_seq, request.limit 

232 ) 

233 return reply( 

234 request.version, 

235 request.request_id, 

236 ok={"type": "account_feed", "feed": page.model_dump(mode="json")}, 

237 ) 

238 

239 async def _on_get_equity_history(self, request: GetEquityHistoryRequest) -> bytes: 

240 if self._trading is None: 240 ↛ 241line 240 didn't jump to line 241 because the condition on line 240 was never true

241 return reply(request.version, request.request_id, error="unavailable") 

242 history = await self._trading.operator.equity_history(request.account_id, request.window) 

243 return reply( 

244 request.version, 

245 request.request_id, 

246 ok={ 

247 "type": "equity_history", 

248 "account_id": request.account_id, 

249 "history": None if history is None else history.model_dump(mode="json"), 

250 }, 

251 )