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
« 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."""
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
27class AccountHandlers:
28 """Answer account, activity, and history reads, and apply the owner's account controls."""
30 def __init__(self, *, trading: TradingServices | None) -> None:
31 self._trading = trading
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 }
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 )
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 )
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 )
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 )
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"})
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"})
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )