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
« prev ^ index » next coverage.py v7.16.2, created at 2026-11-16 16:55 +0000
1"""Present engine results through the control contract.
3Only the fields an operator or agent needs cross this boundary. Broker identities,
4configuration fingerprints and raw payload evidence stay inside the engine.
5"""
7from decimal import Decimal
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
40CENT = Decimal("0.01")
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )
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 )