Coverage for src/copytrading_engine/control/views.py: 94%

69 statements  

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

1"""Present engine results through the control contract. 

2 

3Only the fields an operator or agent needs cross this boundary. Broker identities, 

4configuration fingerprints and raw payload evidence stay inside the engine. 

5""" 

6 

7from decimal import Decimal 

8 

9from copytrading_engine.control import copying, wire 

10from copytrading_engine.control.proposals import ( 

11 ApplySetup, 

12 Closed, 

13 ConfirmManualOrder, 

14 Finished, 

15 Pending, 

16 Proposal, 

17 ResumeAccount, 

18 Running, 

19 SetAccountLimits, 

20 SetRecovery, 

21 StartProcessing, 

22) 

23from copytrading_engine.execution.domain.lifecycle import AccountControlResult 

24from copytrading_engine.execution.domain.manual_commands import ( 

25 ManualCommandPage, 

26 ManualCommandResult, 

27 ManualOrderPreview, 

28) 

29from copytrading_engine.execution.presentation.operator_views import ( 

30 AccountEventPage, 

31 AccountOverview, 

32 AccountOverviewPage, 

33 AccountUnavailable, 

34 DestinationView, 

35 PositionView, 

36) 

37from copytrading_engine.trading.domain.status import AccountStatus, TradingStatus 

38from copytrading_engine.trading.presentation.operator_models import SourceActivityPage 

39 

40CENT = Decimal("0.01") 

41 

42 

43def processing(status: TradingStatus) -> wire.ProcessingView: 

44 words = copying.overall(status.state, status.error_code) 

45 return wire.ProcessingView( 

46 state=status.state, 

47 copying=words.word, 

48 copying_detail=words.detail, 

49 source_connected=status.source_connected, 

50 model_ready=status.model_ready, 

51 pending_source=status.pending_source, 

52 pending_signals=status.pending_signals, 

53 processed_signals=status.processed_signals, 

54 error_code=status.error_code, 

55 ) 

56 

57 

58def _account_state(trading: TradingStatus, account: AccountStatus) -> wire.AccountStateView: 

59 words = copying.account( 

60 processing_state=trading.state, 

61 active_configuration=True, 

62 entry_permission=account.entry_permission, 

63 readiness=account.readiness, 

64 error_code=account.error_code, 

65 run_state=account.state, 

66 ) 

67 return wire.AccountStateView( 

68 account_id=account.id, 

69 copying=words.word, 

70 copying_detail=words.detail, 

71 run_state=account.state, 

72 entry_permission=account.entry_permission, 

73 recovery_preference=account.recovery_preference, 

74 readiness=account.readiness, 

75 risk_status=account.account_risk_status, 

76 activity_status=account.account_activity_status, 

77 error_code=account.error_code, 

78 ) 

79 

80 

81def status(engine_state: str, trading: TradingStatus) -> wire.StatusView: 

82 return wire.StatusView( 

83 engine_state=engine_state, 

84 processing=processing(trading), 

85 accounts=tuple(_account_state(trading, account) for account in trading.accounts), 

86 ) 

87 

88 

89def _unavailable(items: tuple[AccountUnavailable, ...]) -> tuple[wire.UnavailableAccountView, ...]: 

90 return tuple( 

91 wire.UnavailableAccountView(account_id=item.account_id, reason=item.reason) 

92 for item in items 

93 ) 

94 

95 

96def _sold_out(position: PositionView) -> bool: 

97 """A stock the account no longer holds any of, kept in the ledger only as history.""" 

98 return ( 

99 not position.lots 

100 and not position.owned_qty 

101 and not position.external_qty 

102 and (position.broker_qty is None or not Decimal(position.broker_qty)) 

103 ) 

104 

105 

106def _account(item: AccountOverview) -> wire.AccountView: 

107 words = copying.account( 

108 processing_state=None, 

109 active_configuration=item.active_configuration, 

110 entry_permission=item.entry_permission, 

111 readiness=item.readiness, 

112 ) 

113 return wire.AccountView( 

114 account_id=item.account_id, 

115 environment=item.environment, 

116 copying=words.word, 

117 copying_detail=words.detail, 

118 entry_permission=item.entry_permission, 

119 recovery_preference=item.recovery_preference, 

120 readiness=item.readiness, 

121 risk_status=item.account_risk_status, 

122 risk_reason=item.account_risk_reason, 

123 activity_status=item.account_activity_status, 

124 activity_reason=item.account_activity_reason, 

125 total_exposure_usd=None 

126 if item.total_exposure_usd is None 

127 else item.total_exposure_usd.quantize(CENT), 

128 positions=tuple( 

129 wire.PositionView( 

130 symbol=position.symbol, 

131 owned_qty=position.owned_qty, 

132 external_qty=position.external_qty, 

133 lots=tuple( 

134 wire.LotView( 

135 lot_id=lot.lot_id, 

136 source_id=lot.source_id, 

137 guru_id=lot.guru_id, 

138 posted_at=lot.posted_at, 

139 untrusted_source_text=lot.excerpt, 

140 bought_at=lot.bought_at, 

141 original_qty=lot.original_qty, 

142 remaining_qty=lot.remaining_qty, 

143 average_price=lot.average_price, 

144 ) 

145 for lot in position.lots 

146 ), 

147 ) 

148 for position in item.positions 

149 if not _sold_out(position) 

150 ), 

151 ownership_incidents=len(item.ownership_incidents), 

152 pending_orders=item.pending_orders, 

153 balance=None 

154 if item.balance is None 

155 else wire.BalanceView( 

156 equity=item.balance.equity, 

157 day_change_usd=item.balance.day_change_usd, 

158 cash=item.balance.cash, 

159 buying_power=item.balance.buying_power, 

160 observed_at=item.balance.observed_at, 

161 ), 

162 ) 

163 

164 

165def accounts(page: AccountOverviewPage) -> wire.AccountsPage: 

166 return wire.AccountsPage( 

167 items=tuple(_account(item) for item in page.items), 

168 next_before_account_id=page.next_before_account_id, 

169 unavailable=_unavailable(page.unavailable_accounts), 

170 ) 

171 

172 

173def _destination(item: DestinationView) -> wire.DestinationView: 

174 return wire.DestinationView( 

175 account_id=item.account_id, 

176 environment=item.environment, 

177 status=item.status, 

178 instruction_outcomes=item.instruction_outcomes, 

179 orders=tuple( 

180 wire.OrderView( 

181 client_id=order.client_id, 

182 symbol=order.symbol, 

183 side=order.side, 

184 status=order.status, 

185 quantity=order.quantity, 

186 filled_quantity=order.filled_quantity, 

187 average_fill_price=order.average_fill_price, 

188 ) 

189 for order in item.orders 

190 ), 

191 ) 

192 

193 

194def activity(page: SourceActivityPage) -> wire.ActivityPage: 

195 return wire.ActivityPage( 

196 items=tuple( 

197 wire.ActivityItem( 

198 sequence=item.sequence, 

199 source_id=item.source_id, 

200 source_at=item.source_at, 

201 captured_at=item.captured_at, 

202 parse_status=item.parse_status, 

203 delivery_status=item.delivery_status, 

204 decision=item.decision, 

205 parser_reason=item.parser_reason, 

206 guru_id=item.guru_id, 

207 untrusted_source_text=item.text, 

208 understood_as=tuple( 

209 wire.InstructionItem( 

210 action=instruction.action, 

211 symbol=instruction.symbol, 

212 price=instruction.price, 

213 fraction=instruction.fraction, 

214 usd_amount=instruction.usd_amount, 

215 ) 

216 for instruction in item.instructions 

217 ), 

218 destinations=tuple(_destination(target) for target in item.destinations), 

219 ) 

220 for item in page.items 

221 ), 

222 rejected=tuple( 

223 wire.RejectedActivityItem( 

224 source_id=item.source_id, rejected_at=item.rejected_at, reason=item.reason 

225 ) 

226 for item in page.rejected_items 

227 ), 

228 next_before_seq=page.next_before_seq, 

229 unavailable=_unavailable(page.unavailable_accounts), 

230 ) 

231 

232 

233def account_events(page: AccountEventPage) -> wire.AccountEventsPage: 

234 return wire.AccountEventsPage( 

235 account_id=page.account_id, 

236 items=tuple( 

237 wire.AccountEventView( 

238 sequence=item.sequence, 

239 at=item.at, 

240 kind=item.kind, 

241 message_id=item.message_id, 

242 order_id=item.order_id, 

243 reason=item.reason, 

244 status=item.status, 

245 ) 

246 for item in page.items 

247 ), 

248 next_before_seq=page.next_before_seq, 

249 ) 

250 

251 

252def manual_command(result: ManualCommandResult) -> wire.ManualCommandView: 

253 record = result.command 

254 return wire.ManualCommandView( 

255 command_id=record.request.command_id, 

256 account_id=record.request.account_id, 

257 source_id=record.source_id, 

258 correction_id=record.correction_id, 

259 instruction_index=record.instruction_index, 

260 actor=record.request.actor, 

261 confirmed_at=record.confirmed_at, 

262 status=result.status, 

263 reason=result.reason, 

264 client_id=result.client_id, 

265 ) 

266 

267 

268def manual_commands(page: ManualCommandPage) -> wire.ManualCommandsPage: 

269 return wire.ManualCommandsPage( 

270 account_id=page.account_id, 

271 source_id=page.source_id, 

272 items=tuple(manual_command(item) for item in page.items), 

273 next_before_command_id=page.next_before_command_id, 

274 ) 

275 

276 

277def manual_preview(preview: ManualOrderPreview) -> wire.ManualPreview: 

278 instruction = preview.instruction 

279 plan = preview.plan 

280 return wire.ManualPreview( 

281 preview_id=preview.request.preview_id, 

282 account_id=preview.request.account_id, 

283 environment=preview.environment, 

284 source_age_seconds=preview.source_age_seconds, 

285 created_at=preview.created_at, 

286 expires_at=preview.expires_at, 

287 instruction=wire.InstructionView( 

288 action=instruction.action, 

289 symbol=instruction.symbol, 

290 price=instruction.price, 

291 entry_price=instruction.entry_price, 

292 fraction=instruction.fraction, 

293 ), 

294 fresh_price=preview.fresh_price, 

295 plan=None 

296 if plan is None 

297 else wire.OrderPlanView( 

298 side=plan.side, 

299 type=plan.type, 

300 quantity=plan.qty, 

301 limit_price=plan.limit_price, 

302 session=plan.session.value, 

303 ), 

304 checks=tuple( 

305 wire.CheckView(name=check.name, status=check.status, reason=check.reason) 

306 for check in preview.checks 

307 ), 

308 reasons=preview.reasons, 

309 ) 

310 

311 

312def account_control(result: AccountControlResult) -> wire.AccountControlView: 

313 return wire.AccountControlView( 

314 account_id=result.command.account_id, 

315 entry_permission=result.entry_permission, 

316 recovery_preference=result.recovery_preference, 

317 applied_at=result.applied_at, 

318 ) 

319 

320 

321def proposal(item: Proposal) -> wire.ProposalView: 

322 subject: ( 

323 wire.ResumeAccountSubject 

324 | wire.RecoverySubject 

325 | wire.ManualOrderSubject 

326 | wire.LimitsSubject 

327 | wire.StartProcessingSubject 

328 | wire.ApplySetupSubject 

329 ) 

330 match item.subject: 

331 case ResumeAccount(account_id=account_id): 

332 subject = wire.ResumeAccountSubject(account_id=account_id) 

333 case SetRecovery(account_id=account_id, preference=preference): 

334 subject = wire.RecoverySubject(account_id=account_id, preference=preference) 

335 case SetAccountLimits(account_id=account_id, changes=changes): 

336 subject = wire.LimitsSubject( 

337 account_id=account_id, 

338 changes=tuple(wire.LimitChange(field=f, value=v) for f, v in changes), # ty: ignore[invalid-argument-type] 

339 ) 

340 case StartProcessing(): 

341 subject = wire.StartProcessingSubject() 

342 case ApplySetup() as setup: 

343 subject = wire.ApplySetupSubject( 

344 made_live=setup.made_live, 

345 new_live_keys=setup.new_live_keys, 

346 changed_live=setup.changed_live, 

347 starts_live=setup.starts_live, 

348 ) 

349 case ConfirmManualOrder() as order: 349 ↛ 360line 349 didn't jump to line 360 because the pattern on line 349 always matched

350 subject = wire.ManualOrderSubject( 

351 account_id=order.account_id, 

352 preview_id=order.preview_id, 

353 environment=order.environment, 

354 symbol=order.symbol, 

355 side=order.side, 

356 order_type=order.order_type, 

357 quantity=order.quantity, 

358 limit_price=order.limit_price, 

359 ) 

360 outcome = None 

361 match item.state: 

362 case Pending(): 

363 state = "pending" 

364 case Running(): 

365 state = "running" 

366 case Finished(result=result, code=code): 

367 state = result 

368 outcome = wire.ProposalOutcome(status=result, code=code, command_id=item.command_id) 

369 case Closed(reason=reason): 369 ↛ 371line 369 didn't jump to line 371 because the pattern on line 369 always matched

370 state = reason 

371 return wire.ProposalView( 

372 proposal_id=item.proposal_id, 

373 state=state, 

374 subject=subject, 

375 digest=item.digest, 

376 command_id=item.command_id, 

377 created_at=item.created_at, 

378 expires_at=item.expires_at, 

379 requested_by=wire.CallerView(pid=item.caller.pid, path=item.caller.path), 

380 outcome=outcome, 

381 )