1use std::{
17 any::Any,
18 cell::{RefCell, UnsafeCell},
19 collections::HashMap,
20 fmt::Debug,
21 num::NonZeroUsize,
22 ops::{Deref, DerefMut},
23 rc::Rc,
24};
25
26use indexmap::IndexMap;
27use jiff::Timestamp;
28use nautilus_core::{
29 from_pydict,
30 nanos::UnixNanos,
31 python::{to_pyruntime_err, to_pytype_err, to_pyvalue_err, upgrade_py_weakref},
32};
33#[cfg(feature = "defi")]
34use nautilus_model::defi::{
35 Block, Blockchain, Pool, PoolFeeCollect, PoolFlash, PoolLiquidityUpdate, PoolSwap,
36};
37use nautilus_model::{
38 data::{
39 Bar, BarType, CustomData, DataType, FundingRateUpdate, IndexPriceUpdate, InstrumentStatus,
40 MarkPriceUpdate, OrderBookDelta, OrderBookDeltas, OrderBookDepth, QuoteTick, TradeTick,
41 close::InstrumentClose,
42 option_chain::{OptionChainSlice, OptionGreeks},
43 },
44 enums::BookType,
45 identifiers::{
46 ActorId, ClientId, ExecAlgorithmId, InstrumentId, OptionSeriesId, TraderId, Venue,
47 },
48 instruments::{InstrumentAny, SyntheticInstrument},
49 orderbook::OrderBook,
50 orders::{OrderAny, OrderList},
51 python::{
52 data::option_chain::PyStrikeRange, instruments::instrument_any_to_pyobject,
53 orders::order_any_to_pyobject,
54 },
55};
56use pyo3::{
57 IntoPyObjectExt,
58 prelude::*,
59 types::{PyBytes, PyDict, PyList, PySet, PyWeakrefReference},
60};
61use ustr::Ustr;
62
63use crate::{
64 actor::{
65 Actor, DataActor, DataActorNative,
66 data_actor::{DataActorConfig, DataActorCore, ImportableActorConfig},
67 registry::{try_get_actor_unchecked, with_actor_registry},
68 },
69 cache::Cache,
70 clock::Clock,
71 component::{Component, ComponentAccessError, with_component_registry},
72 enums::ComponentState,
73 logging::{CMD, RECV},
74 messages::{
75 data::{
76 DataResponseEnvelope, IntoBarTypes, IntoInstrumentIds, ensure_routable_bar_types,
77 ensure_routable_instrument_ids, ensure_subscription_routes, quote_routing,
78 },
79 execution::TradingCommand,
80 system::{QueueStateChanged, SocketStateChanged},
81 },
82 msgbus::{self, ShareableMessageHandler, TypedHandler},
83 python::{
84 cache::PyCache,
85 clock::PyClock,
86 indicators::{registered_python_indicators, wrap_python_indicator},
87 logging::{PyLogger, format_exception},
88 response::PyDataResponse,
89 wrappers::{get_python_message_bus, retain_python_wrapper},
90 },
91 runner::SystemChannel,
92 signal::Signal,
93 timer::{TimeEvent, TimeEventCallback},
94};
95
96#[pyo3::pymethods]
97#[pyo3_stub_gen::derive::gen_stub_pymethods]
98impl DataActorConfig {
99 #[new]
101 #[pyo3(signature = (actor_id=None, log_events=true, log_commands=true, **_kwargs))]
102 fn py_new(
103 actor_id: Option<ActorId>,
104 log_events: bool,
105 log_commands: bool,
106 _kwargs: Option<&Bound<'_, PyDict>>,
107 ) -> Self {
108 Self {
109 actor_id,
110 log_events,
111 log_commands,
112 }
113 }
114
115 #[getter]
116 fn actor_id(&self) -> Option<ActorId> {
117 self.actor_id
118 }
119
120 #[setter]
121 fn set_actor_id(&mut self, actor_id: Option<ActorId>) {
122 self.actor_id = actor_id;
123 }
124
125 #[getter]
126 fn log_events(&self) -> bool {
127 self.log_events
128 }
129
130 #[setter]
131 fn set_log_events(&mut self, log_events: bool) {
132 self.log_events = log_events;
133 }
134
135 #[getter]
136 fn log_commands(&self) -> bool {
137 self.log_commands
138 }
139
140 #[setter]
141 fn set_log_commands(&mut self, log_commands: bool) {
142 self.log_commands = log_commands;
143 }
144}
145
146#[pyo3::pymethods]
147#[pyo3_stub_gen::derive::gen_stub_pymethods]
148impl ImportableActorConfig {
149 #[new]
151 #[expect(clippy::needless_pass_by_value)]
152 fn py_new(actor_path: String, config_path: String, config: Py<PyDict>) -> PyResult<Self> {
153 let json_config = Python::attach(|py| -> PyResult<HashMap<String, serde_json::Value>> {
154 let kwargs = PyDict::new(py);
155 kwargs.set_item("default", py.eval(pyo3::ffi::c_str!("str"), None, None)?)?;
156 let json_str: String = PyModule::import(py, "json")?
157 .call_method("dumps", (config.bind(py),), Some(&kwargs))?
158 .extract()?;
159
160 let json_value: serde_json::Value =
161 serde_json::from_str(&json_str).map_err(to_pyvalue_err)?;
162
163 if let serde_json::Value::Object(map) = json_value {
164 Ok(map.into_iter().collect())
165 } else {
166 Err(to_pyvalue_err("Config must be a dictionary"))
167 }
168 })?;
169
170 Ok(Self {
171 actor_path,
172 config_path,
173 config: json_config,
174 })
175 }
176
177 #[getter]
178 fn actor_path(&self) -> &String {
179 &self.actor_path
180 }
181
182 #[getter]
183 fn config_path(&self) -> &String {
184 &self.config_path
185 }
186
187 #[getter]
188 fn config(&self, py: Python<'_>) -> PyResult<Py<PyDict>> {
189 let py_dict = PyDict::new(py);
191
192 for (key, value) in &self.config {
193 let json_str = serde_json::to_string(value).map_err(to_pyvalue_err)?;
195 let py_value = PyModule::import(py, "json")?.call_method("loads", (json_str,), None)?;
196 py_dict.set_item(key, py_value)?;
197 }
198 Ok(py_dict.unbind())
199 }
200}
201
202pub struct PyDataActorInner {
208 core: DataActorCore,
209 py_self: Option<Py<PyWeakrefReference>>,
210 config: Option<Py<PyAny>>,
211 clock: PyClock,
212 logger: PyLogger,
213}
214
215impl Debug for PyDataActorInner {
216 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
217 f.debug_struct(stringify!(PyDataActorInner))
218 .field("core", &self.core)
219 .field(
220 "py_self",
221 &self.py_self.as_ref().map(|_| "<Py<PyWeakrefReference>>"),
222 )
223 .field("config", &self.config.as_ref().map(|_| "<Py<PyAny>>"))
224 .field("clock", &self.clock)
225 .field("logger", &self.logger)
226 .finish()
227 }
228}
229
230impl Deref for PyDataActorInner {
231 type Target = DataActorCore;
232
233 fn deref(&self) -> &Self::Target {
234 &self.core
235 }
236}
237
238impl DerefMut for PyDataActorInner {
239 fn deref_mut(&mut self) -> &mut Self::Target {
240 &mut self.core
241 }
242}
243
244impl DataActorNative for PyDataActorInner {
245 fn core(&self) -> &DataActorCore {
246 &self.core
247 }
248
249 fn core_mut(&mut self) -> &mut DataActorCore {
250 &mut self.core
251 }
252}
253
254#[expect(clippy::needless_pass_by_ref_mut)]
255impl PyDataActorInner {
256 fn execute_exec_algorithm_command(&mut self, command: &TradingCommand) -> anyhow::Result<()> {
257 if self.core.config.log_commands {
258 let id = self.core.actor_id;
259 log::info!("{id} {RECV}{CMD} {command}");
260 }
261
262 if self.core.state() != ComponentState::Running {
263 return Ok(());
264 }
265
266 match command {
267 TradingCommand::SubmitOrder(cmd) => {
268 let order = DataActor::cache(self).try_order(&cmd.client_order_id)?;
269 self.dispatch_on_order(order).map_err(|e| {
270 anyhow::anyhow!("Python on_order failed:\n{}", format_exception(&e))
271 })
272 }
273 TradingCommand::SubmitOrderList(cmd) => {
274 let orders = self.orders_for_list(&cmd.order_list)?;
275 self.dispatch_on_order_list(cmd.order_list.clone(), orders)
276 .map_err(|e| {
277 anyhow::anyhow!("Python on_order_list failed:\n{}", format_exception(&e))
278 })
279 }
280 _ => {
281 log::warn!("Unhandled command type: {command}");
282 Ok(())
283 }
284 }
285 }
286
287 fn orders_for_list(&self, order_list: &OrderList) -> anyhow::Result<Vec<OrderAny>> {
288 let cache = DataActor::cache(self);
289 let mut orders = Vec::with_capacity(order_list.client_order_ids.len());
290
291 for client_order_id in &order_list.client_order_ids {
292 orders.push(cache.try_order(client_order_id)?);
293 }
294
295 Ok(orders)
296 }
297
298 fn dispatch_on_order(&mut self, order: OrderAny) -> PyResult<()> {
299 if let Some(py_self) = self.python_instance()? {
300 Python::attach(|py| -> PyResult<()> {
301 let py_order = order_any_to_pyobject(py, order)?;
302 py_self.call_method1(py, "on_order", (py_order,))?;
303 Ok(())
304 })?;
305 }
306 Ok(())
307 }
308
309 fn dispatch_on_order_list(
310 &mut self,
311 order_list: OrderList,
312 orders: Vec<OrderAny>,
313 ) -> PyResult<()> {
314 if let Some(py_self) = self.python_instance()? {
315 Python::attach(|py| -> PyResult<()> {
316 if py_self.bind(py).hasattr("on_order_list")? {
317 let py_order_list = order_list.into_py_any(py)?;
318 let py_orders = orders
319 .into_iter()
320 .map(|order| order_any_to_pyobject(py, order))
321 .collect::<PyResult<Vec<_>>>()?;
322 let py_orders = PyList::new(py, py_orders)?;
323
324 py_self.call_method1(py, "on_order_list", (py_order_list, py_orders))?;
325 } else {
326 for order in orders {
327 let py_order = order_any_to_pyobject(py, order)?;
328 py_self.call_method1(py, "on_order", (py_order,))?;
329 }
330 }
331 Ok(())
332 })?;
333 }
334 Ok(())
335 }
336
337 fn dispatch_on_start(&self) -> PyResult<()> {
338 if let Some(py_self) = self.python_instance()? {
339 Python::attach(|py| py_self.call_method0(py, "on_start"))?;
340 }
341 Ok(())
342 }
343
344 fn dispatch_on_stop(&mut self) -> PyResult<()> {
345 if let Some(py_self) = self.python_instance()? {
346 Python::attach(|py| py_self.call_method0(py, "on_stop"))?;
347 }
348 Ok(())
349 }
350
351 fn dispatch_on_resume(&mut self) -> PyResult<()> {
352 if let Some(py_self) = self.python_instance()? {
353 Python::attach(|py| py_self.call_method0(py, "on_resume"))?;
354 }
355 Ok(())
356 }
357
358 fn dispatch_on_reset(&mut self) -> PyResult<()> {
359 if let Some(py_self) = self.python_instance()? {
360 Python::attach(|py| py_self.call_method0(py, "on_reset"))?;
361 }
362 Ok(())
363 }
364
365 fn dispatch_on_dispose(&mut self) -> PyResult<()> {
366 if let Some(py_self) = self.python_instance()? {
367 Python::attach(|py| py_self.call_method0(py, "on_dispose"))?;
368 }
369 Ok(())
370 }
371
372 fn dispatch_on_degrade(&mut self) -> PyResult<()> {
373 if let Some(py_self) = self.python_instance()? {
374 Python::attach(|py| py_self.call_method0(py, "on_degrade"))?;
375 }
376 Ok(())
377 }
378
379 fn dispatch_on_fault(&mut self) -> PyResult<()> {
380 if let Some(py_self) = self.python_instance()? {
381 Python::attach(|py| py_self.call_method0(py, "on_fault"))?;
382 }
383 Ok(())
384 }
385
386 fn dispatch_on_save(&self) -> PyResult<IndexMap<String, Vec<u8>>> {
387 if let Some(py_self) = self.python_instance()? {
388 Python::attach(|py| {
389 let py_state = py_self.call_method0(py, "on_save")?;
390 let py_state: &Bound<'_, PyDict> = py_state.cast_bound::<PyDict>(py)?;
391 pydict_to_state(py_state)
392 })
393 } else {
394 Ok(IndexMap::new())
395 }
396 }
397
398 fn dispatch_on_load(&mut self, state: &IndexMap<String, Vec<u8>>) -> PyResult<()> {
399 if let Some(py_self) = self.python_instance()? {
400 Python::attach(|py| -> PyResult<()> {
401 let py_state = state_to_pydict(py, state)?;
402 py_self.call_method1(py, "on_load", (py_state,))?;
403 Ok(())
404 })?;
405 }
406 Ok(())
407 }
408
409 fn dispatch_on_time_event(&mut self, event: TimeEvent) -> PyResult<()> {
410 if let Some(py_self) = self.python_instance()? {
411 Python::attach(|py| {
412 py_self.call_method1(py, "on_time_event", (event.into_py_any(py)?,))
413 })?;
414 }
415 Ok(())
416 }
417
418 fn dispatch_on_data(&mut self, data: Py<PyAny>) -> PyResult<()> {
419 if let Some(py_self) = self.python_instance()? {
420 Python::attach(|py| py_self.call_method1(py, "on_data", (data,)))?;
421 }
422 Ok(())
423 }
424
425 fn dispatch_on_signal(&mut self, signal: &Signal) -> PyResult<()> {
426 if let Some(py_self) = self.python_instance()? {
427 Python::attach(|py| {
428 py_self.call_method1(py, "on_signal", (signal.clone().into_py_any(py)?,))
429 })?;
430 }
431 Ok(())
432 }
433
434 fn dispatch_on_queue_state(&mut self, event: &QueueStateChanged) -> PyResult<()> {
435 if let Some(py_self) = self.python_instance()? {
436 Python::attach(|py| {
437 py_self.call_method1(py, "on_queue_state", (event.clone().into_py_any(py)?,))
438 })?;
439 }
440 Ok(())
441 }
442
443 fn dispatch_on_socket_state(&mut self, event: &SocketStateChanged) -> PyResult<()> {
444 if let Some(py_self) = self.python_instance()? {
445 Python::attach(|py| {
446 py_self.call_method1(py, "on_socket_state", (event.clone().into_py_any(py)?,))
447 })?;
448 }
449 Ok(())
450 }
451
452 fn dispatch_on_instrument(&mut self, instrument: Py<PyAny>) -> PyResult<()> {
453 if let Some(py_self) = self.python_instance()? {
454 Python::attach(|py| py_self.call_method1(py, "on_instrument", (instrument,)))?;
455 }
456 Ok(())
457 }
458
459 fn dispatch_on_quote(&mut self, quote: QuoteTick) -> PyResult<()> {
460 if let Some(py_self) = self.python_instance()? {
461 Python::attach(|py| py_self.call_method1(py, "on_quote", (quote.into_py_any(py)?,)))?;
462 }
463 Ok(())
464 }
465
466 fn dispatch_on_trade(&mut self, trade: TradeTick) -> PyResult<()> {
467 if let Some(py_self) = self.python_instance()? {
468 Python::attach(|py| py_self.call_method1(py, "on_trade", (trade.into_py_any(py)?,)))?;
469 }
470 Ok(())
471 }
472
473 fn dispatch_on_bar(&mut self, bar: Bar) -> PyResult<()> {
474 if let Some(py_self) = self.python_instance()? {
475 Python::attach(|py| py_self.call_method1(py, "on_bar", (bar.into_py_any(py)?,)))?;
476 }
477 Ok(())
478 }
479
480 fn dispatch_on_book_deltas(&mut self, deltas: OrderBookDeltas) -> PyResult<()> {
481 if let Some(py_self) = self.python_instance()? {
482 Python::attach(|py| {
483 py_self.call_method1(py, "on_book_deltas", (deltas.into_py_any(py)?,))
484 })?;
485 }
486 Ok(())
487 }
488
489 fn dispatch_on_book_depth(&mut self, depth: &OrderBookDepth) -> PyResult<()> {
490 if let Some(py_self) = self.python_instance()? {
491 Python::attach(|py| {
492 py_self.call_method1(py, "on_book_depth", (depth.clone().into_py_any(py)?,))
493 })?;
494 }
495 Ok(())
496 }
497
498 fn dispatch_on_book(&mut self, book: &OrderBook) -> PyResult<()> {
499 if let Some(py_self) = self.python_instance()? {
500 Python::attach(|py| {
501 py_self.call_method1(py, "on_book", (book.clone().into_py_any(py)?,))
502 })?;
503 }
504 Ok(())
505 }
506
507 fn dispatch_on_mark_price(&mut self, mark_price: MarkPriceUpdate) -> PyResult<()> {
508 if let Some(py_self) = self.python_instance()? {
509 Python::attach(|py| {
510 py_self.call_method1(py, "on_mark_price", (mark_price.into_py_any(py)?,))
511 })?;
512 }
513 Ok(())
514 }
515
516 fn dispatch_on_index_price(&mut self, index_price: IndexPriceUpdate) -> PyResult<()> {
517 if let Some(py_self) = self.python_instance()? {
518 Python::attach(|py| {
519 py_self.call_method1(py, "on_index_price", (index_price.into_py_any(py)?,))
520 })?;
521 }
522 Ok(())
523 }
524
525 fn dispatch_on_funding_rate(&mut self, funding_rate: FundingRateUpdate) -> PyResult<()> {
526 if let Some(py_self) = self.python_instance()? {
527 Python::attach(|py| {
528 py_self.call_method1(py, "on_funding_rate", (funding_rate.into_py_any(py)?,))
529 })?;
530 }
531 Ok(())
532 }
533
534 fn dispatch_on_instrument_status(&mut self, data: InstrumentStatus) -> PyResult<()> {
535 if let Some(py_self) = self.python_instance()? {
536 Python::attach(|py| {
537 py_self.call_method1(py, "on_instrument_status", (data.into_py_any(py)?,))
538 })?;
539 }
540 Ok(())
541 }
542
543 fn dispatch_on_instrument_close(&mut self, update: InstrumentClose) -> PyResult<()> {
544 if let Some(py_self) = self.python_instance()? {
545 Python::attach(|py| {
546 py_self.call_method1(py, "on_instrument_close", (update.into_py_any(py)?,))
547 })?;
548 }
549 Ok(())
550 }
551
552 fn dispatch_on_option_greeks(&mut self, greeks: OptionGreeks) -> PyResult<()> {
553 if let Some(py_self) = self.python_instance()? {
554 Python::attach(|py| {
555 py_self.call_method1(py, "on_option_greeks", (greeks.into_py_any(py)?,))
556 })?;
557 }
558 Ok(())
559 }
560
561 fn dispatch_on_option_chain(&mut self, slice: OptionChainSlice) -> PyResult<()> {
562 if let Some(py_self) = self.python_instance()? {
563 Python::attach(|py| {
564 py_self.call_method1(py, "on_option_chain", (slice.into_py_any(py)?,))
565 })?;
566 }
567 Ok(())
568 }
569
570 fn dispatch_on_historical_data(&mut self, data: Py<PyAny>) -> PyResult<()> {
571 if let Some(py_self) = self.python_instance()? {
572 Python::attach(|py| py_self.call_method1(py, "on_historical_data", (data,)))?;
573 }
574 Ok(())
575 }
576
577 fn dispatch_on_historical_book_deltas(&mut self, deltas: Vec<OrderBookDelta>) -> PyResult<()> {
578 if let Some(py_self) = self.python_instance()? {
579 Python::attach(|py| {
580 let py_deltas = deltas
581 .into_iter()
582 .map(|delta| delta.into_py_any(py))
583 .collect::<PyResult<Vec<_>>>()?;
584 py_self.call_method1(py, "on_historical_book_deltas", (py_deltas,))
585 })?;
586 }
587 Ok(())
588 }
589
590 fn dispatch_on_historical_book_depth(&mut self, depths: Vec<OrderBookDepth>) -> PyResult<()> {
591 if let Some(py_self) = self.python_instance()? {
592 Python::attach(|py| {
593 let py_depths = depths
594 .into_iter()
595 .map(|depth| depth.into_py_any(py))
596 .collect::<PyResult<Vec<_>>>()?;
597 py_self.call_method1(py, "on_historical_book_depth", (py_depths,))
598 })?;
599 }
600 Ok(())
601 }
602
603 fn dispatch_on_historical_quotes(&mut self, quotes: Vec<QuoteTick>) -> PyResult<()> {
604 if let Some(py_self) = self.python_instance()? {
605 Python::attach(|py| {
606 let py_quotes = quotes
607 .into_iter()
608 .map(|q| q.into_py_any(py))
609 .collect::<PyResult<Vec<_>>>()?;
610 py_self.call_method1(py, "on_historical_quotes", (py_quotes,))
611 })?;
612 }
613 Ok(())
614 }
615
616 fn dispatch_on_historical_trades(&mut self, trades: Vec<TradeTick>) -> PyResult<()> {
617 if let Some(py_self) = self.python_instance()? {
618 Python::attach(|py| {
619 let py_trades = trades
620 .into_iter()
621 .map(|t| t.into_py_any(py))
622 .collect::<PyResult<Vec<_>>>()?;
623 py_self.call_method1(py, "on_historical_trades", (py_trades,))
624 })?;
625 }
626 Ok(())
627 }
628
629 fn dispatch_on_historical_funding_rates(
630 &mut self,
631 funding_rates: Vec<FundingRateUpdate>,
632 ) -> PyResult<()> {
633 if let Some(py_self) = self.python_instance()? {
634 Python::attach(|py| {
635 let py_rates = funding_rates
636 .into_iter()
637 .map(|r| r.into_py_any(py))
638 .collect::<PyResult<Vec<_>>>()?;
639 py_self.call_method1(py, "on_historical_funding_rates", (py_rates,))
640 })?;
641 }
642 Ok(())
643 }
644
645 fn dispatch_on_historical_bars(&mut self, bars: Vec<Bar>) -> PyResult<()> {
646 if let Some(py_self) = self.python_instance()? {
647 Python::attach(|py| {
648 let py_bars = bars
649 .into_iter()
650 .map(|b| b.into_py_any(py))
651 .collect::<PyResult<Vec<_>>>()?;
652 py_self.call_method1(py, "on_historical_bars", (py_bars,))
653 })?;
654 }
655 Ok(())
656 }
657
658 fn dispatch_on_historical_mark_prices(
659 &mut self,
660 mark_prices: Vec<MarkPriceUpdate>,
661 ) -> PyResult<()> {
662 if let Some(py_self) = self.python_instance()? {
663 Python::attach(|py| {
664 let py_prices = mark_prices
665 .into_iter()
666 .map(|p| p.into_py_any(py))
667 .collect::<PyResult<Vec<_>>>()?;
668 py_self.call_method1(py, "on_historical_mark_prices", (py_prices,))
669 })?;
670 }
671 Ok(())
672 }
673
674 fn dispatch_on_historical_index_prices(
675 &mut self,
676 index_prices: Vec<IndexPriceUpdate>,
677 ) -> PyResult<()> {
678 if let Some(py_self) = self.python_instance()? {
679 Python::attach(|py| {
680 let py_prices = index_prices
681 .into_iter()
682 .map(|p| p.into_py_any(py))
683 .collect::<PyResult<Vec<_>>>()?;
684 py_self.call_method1(py, "on_historical_index_prices", (py_prices,))
685 })?;
686 }
687 Ok(())
688 }
689
690 #[cfg(feature = "defi")]
691 fn dispatch_on_block(&mut self, block: Block) -> PyResult<()> {
692 if let Some(py_self) = self.python_instance()? {
693 Python::attach(|py| py_self.call_method1(py, "on_block", (block.into_py_any(py)?,)))?;
694 }
695 Ok(())
696 }
697
698 #[cfg(feature = "defi")]
699 fn dispatch_on_pool(&mut self, pool: Pool) -> PyResult<()> {
700 if let Some(py_self) = self.python_instance()? {
701 Python::attach(|py| py_self.call_method1(py, "on_pool", (pool.into_py_any(py)?,)))?;
702 }
703 Ok(())
704 }
705
706 #[cfg(feature = "defi")]
707 fn dispatch_on_pool_swap(&mut self, swap: PoolSwap) -> PyResult<()> {
708 if let Some(py_self) = self.python_instance()? {
709 Python::attach(|py| {
710 py_self.call_method1(py, "on_pool_swap", (swap.into_py_any(py)?,))
711 })?;
712 }
713 Ok(())
714 }
715
716 #[cfg(feature = "defi")]
717 fn dispatch_on_pool_liquidity_update(&mut self, update: PoolLiquidityUpdate) -> PyResult<()> {
718 if let Some(py_self) = self.python_instance()? {
719 Python::attach(|py| {
720 py_self.call_method1(py, "on_pool_liquidity_update", (update.into_py_any(py)?,))
721 })?;
722 }
723 Ok(())
724 }
725
726 #[cfg(feature = "defi")]
727 fn dispatch_on_pool_fee_collect(&mut self, collect: PoolFeeCollect) -> PyResult<()> {
728 if let Some(py_self) = self.python_instance()? {
729 Python::attach(|py| {
730 py_self.call_method1(py, "on_pool_fee_collect", (collect.into_py_any(py)?,))
731 })?;
732 }
733 Ok(())
734 }
735
736 #[cfg(feature = "defi")]
737 fn dispatch_on_pool_flash(&mut self, flash: PoolFlash) -> PyResult<()> {
738 if let Some(py_self) = self.python_instance()? {
739 Python::attach(|py| {
740 py_self.call_method1(py, "on_pool_flash", (flash.into_py_any(py)?,))
741 })?;
742 }
743 Ok(())
744 }
745
746 fn python_instance(&self) -> PyResult<Option<Py<PyAny>>> {
749 upgrade_py_weakref(self.py_self.as_ref(), &self.core.actor_id)
750 }
751}
752
753fn dict_to_params(
754 py: Python<'_>,
755 params: Option<Py<PyDict>>,
756) -> PyResult<Option<nautilus_core::Params>> {
757 match params {
758 Some(dict) => from_pydict(py, &dict),
759 None => Ok(None),
760 }
761}
762
763fn state_to_pydict(py: Python<'_>, state: &IndexMap<String, Vec<u8>>) -> PyResult<Py<PyDict>> {
764 let py_state = PyDict::new(py);
765 for (key, value) in state {
766 py_state.set_item(key, PyBytes::new(py, value))?;
767 }
768 Ok(py_state.unbind())
769}
770
771fn pydict_to_state(state: &Bound<'_, PyDict>) -> PyResult<IndexMap<String, Vec<u8>>> {
772 let mut rust_state = IndexMap::with_capacity(state.len());
773 for (key, value) in state.iter() {
774 rust_state.insert(key.extract()?, value.extract()?);
775 }
776 Ok(rust_state)
777}
778
779#[allow(non_camel_case_types)]
785#[pyo3::pyclass(
786 module = "nautilus_trader.common",
787 name = "DataActor",
788 unsendable,
789 subclass,
790 weakref
791)]
792#[pyo3_stub_gen::derive::gen_stub_pyclass(module = "nautilus_trader.common")]
793pub struct PyDataActor {
794 inner: Rc<UnsafeCell<PyDataActorInner>>,
795}
796
797impl Debug for PyDataActor {
798 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
799 f.debug_struct(stringify!(PyDataActor))
800 .field("inner", &self.inner())
801 .finish()
802 }
803}
804
805impl PyDataActor {
806 #[inline]
813 #[allow(unsafe_code)]
814 pub(crate) fn inner(&self) -> &PyDataActorInner {
815 unsafe { &*self.inner.get() }
816 }
817
818 #[inline]
825 #[allow(unsafe_code, clippy::mut_from_ref)]
826 pub(crate) fn inner_mut(&self) -> &mut PyDataActorInner {
827 unsafe { &mut *self.inner.get() }
828 }
829}
830
831impl Deref for PyDataActor {
832 type Target = DataActorCore;
833
834 fn deref(&self) -> &Self::Target {
835 &self.inner().core
836 }
837}
838
839impl DerefMut for PyDataActor {
840 fn deref_mut(&mut self) -> &mut Self::Target {
841 &mut self.inner_mut().core
842 }
843}
844
845impl PyDataActor {
846 pub fn new(config: Option<DataActorConfig>) -> Self {
848 let config = config.unwrap_or_default();
849 let core = DataActorCore::new(config);
850 let clock = PyClock::new_test(); let logger = PyLogger::new(core.actor_id().as_str());
852
853 let inner = PyDataActorInner {
854 core,
855 py_self: None,
856 config: None,
857 clock,
858 logger,
859 };
860
861 Self {
862 inner: Rc::new(UnsafeCell::new(inner)),
863 }
864 }
865
866 #[must_use]
872 pub fn from_py_config(config: Option<Py<PyAny>>) -> Self {
873 let actor_config = config
874 .as_ref()
875 .and_then(|obj| Python::attach(|py| obj.extract::<DataActorConfig>(py).ok()));
876 let mut actor = Self::new(actor_config);
877 actor.set_config(config);
878 actor
879 }
880
881 pub fn set_python_instance(&mut self, py_obj: &Bound<'_, PyAny>) -> PyResult<()> {
895 self.inner_mut().py_self = Some(PyWeakrefReference::new(py_obj)?.unbind());
896 Ok(())
897 }
898
899 pub fn set_config(&mut self, config: Option<Py<PyAny>>) {
904 self.inner_mut().config = config;
905 }
906
907 pub fn set_actor_id(&mut self, actor_id: ActorId) {
914 let inner = self.inner_mut();
915 inner.core.config.actor_id = Some(actor_id);
916 inner.core.actor_id = actor_id;
917 inner.logger = PyLogger::new(actor_id.as_str());
918 }
919
920 pub fn set_log_events(&mut self, log_events: bool) {
922 self.inner_mut().core.config.log_events = log_events;
923 }
924
925 pub fn set_log_commands(&mut self, log_commands: bool) {
927 self.inner_mut().core.config.log_commands = log_commands;
928 }
929
930 pub fn mem_address(&self) -> String {
932 self.inner().core.mem_address()
933 }
934
935 pub fn is_registered(&self) -> bool {
937 self.inner().core.is_registered()
938 }
939
940 pub fn register(
946 &mut self,
947 trader_id: TraderId,
948 clock: Rc<RefCell<dyn Clock>>,
949 cache: Rc<RefCell<Cache>>,
950 ) -> anyhow::Result<()> {
951 let inner = self.inner_mut();
952 inner.core.register(trader_id, clock, cache)?;
953
954 inner.clock = PyClock::from_rc(inner.core.clock_rc());
955
956 let actor_id = inner.actor_id().inner();
958 let callback = TimeEventCallback::from(move |event: TimeEvent| {
959 if let Some(mut actor) = try_get_actor_unchecked::<PyDataActorInner>(&actor_id) {
960 if let Err(e) = actor.on_time_event(&event) {
961 log::error!("Python time event handler failed for actor {actor_id}: {e}");
962 }
963 } else {
964 log::error!("Actor {actor_id} not found for time event handling");
965 }
966 });
967
968 inner.clock.inner_mut().register_default_handler(callback);
969
970 inner.initialize()
971 }
972
973 pub fn register_in_global_registries(&self) -> PyResult<()> {
985 let inner = self.inner();
986 let component_id = inner.component_id();
987 let actor_id = Actor::id(inner);
988
989 let Some(wrapper) = inner.python_instance()? else {
990 return Err(to_pyruntime_err(format!(
991 "Cannot register actor {actor_id} without a Python wrapper, call `set_python_instance` first"
992 )));
993 };
994
995 let inner_ref: Rc<UnsafeCell<PyDataActorInner>> = self.inner.clone();
996
997 let component_trait_ref: Rc<UnsafeCell<dyn Component>> = inner_ref.clone();
998 with_component_registry(|registry| {
999 registry.insert(component_id.inner(), component_trait_ref);
1000 });
1001
1002 let actor_trait_ref: Rc<UnsafeCell<dyn Actor>> = inner_ref;
1003 with_actor_registry(|registry| registry.insert(actor_id, actor_trait_ref));
1004
1005 retain_python_wrapper(component_id, wrapper, inner.core.message_bus());
1006
1007 Ok(())
1008 }
1009}
1010
1011pub fn register_python_exec_algorithm_endpoint(exec_algorithm_id: ExecAlgorithmId) {
1012 let actor_id = exec_algorithm_id.inner();
1013 let endpoint: Ustr = format!("{exec_algorithm_id}.execute").into();
1014 let handler = ShareableMessageHandler::from_typed(move |command: &TradingCommand| {
1015 if let Some(mut algo) = try_get_actor_unchecked::<PyDataActorInner>(&actor_id) {
1016 if let Err(e) = algo.execute_exec_algorithm_command(command) {
1017 log::error!("Error executing command on Python algorithm {actor_id}: {e}");
1018 }
1019 } else {
1020 log::error!("Python execution algorithm {actor_id} not found in registry");
1021 }
1022 });
1023 msgbus::register_any(endpoint.into(), handler);
1024}
1025
1026impl DataActor for PyDataActorInner {
1027 fn response_handler(&self) -> TypedHandler<DataResponseEnvelope> {
1028 crate::python::response::response_handler(
1029 self.core().actor_id().inner(),
1030 Self::python_instance,
1031 None,
1032 )
1033 }
1034
1035 fn on_start(&mut self) -> anyhow::Result<()> {
1036 self.dispatch_on_start()
1037 .map_err(|e| anyhow::anyhow!("Python on_start failed:\n{}", format_exception(&e)))
1038 }
1039
1040 fn on_stop(&mut self) -> anyhow::Result<()> {
1041 self.dispatch_on_stop()
1042 .map_err(|e| anyhow::anyhow!("Python on_stop failed:\n{}", format_exception(&e)))
1043 }
1044
1045 fn on_resume(&mut self) -> anyhow::Result<()> {
1046 self.dispatch_on_resume()
1047 .map_err(|e| anyhow::anyhow!("Python on_resume failed:\n{}", format_exception(&e)))
1048 }
1049
1050 fn on_reset(&mut self) -> anyhow::Result<()> {
1051 self.dispatch_on_reset()
1052 .map_err(|e| anyhow::anyhow!("Python on_reset failed:\n{}", format_exception(&e)))
1053 }
1054
1055 fn on_dispose(&mut self) -> anyhow::Result<()> {
1056 self.dispatch_on_dispose()
1057 .map_err(|e| anyhow::anyhow!("Python on_dispose failed:\n{}", format_exception(&e)))
1058 }
1059
1060 fn on_degrade(&mut self) -> anyhow::Result<()> {
1061 self.dispatch_on_degrade()
1062 .map_err(|e| anyhow::anyhow!("Python on_degrade failed:\n{}", format_exception(&e)))
1063 }
1064
1065 fn on_fault(&mut self) -> anyhow::Result<()> {
1066 self.dispatch_on_fault()
1067 .map_err(|e| anyhow::anyhow!("Python on_fault failed:\n{}", format_exception(&e)))
1068 }
1069
1070 fn on_save(&self) -> anyhow::Result<IndexMap<String, Vec<u8>>> {
1071 self.dispatch_on_save()
1072 .map_err(|e| anyhow::anyhow!("Python on_save failed:\n{}", format_exception(&e)))
1073 }
1074
1075 fn on_load(&mut self, state: IndexMap<String, Vec<u8>>) -> anyhow::Result<()> {
1076 self.dispatch_on_load(&state)
1077 .map_err(|e| anyhow::anyhow!("Python on_load failed:\n{}", format_exception(&e)))
1078 }
1079
1080 fn on_time_event(&mut self, event: &TimeEvent) -> anyhow::Result<()> {
1081 self.dispatch_on_time_event(event.clone())
1082 .map_err(|e| anyhow::anyhow!("Python on_time_event failed:\n{}", format_exception(&e)))
1083 }
1084
1085 #[allow(unused_variables)]
1086 fn on_data(&mut self, data: &CustomData) -> anyhow::Result<()> {
1087 Python::attach(|py| {
1088 let py_data: Py<PyAny> = Py::new(py, data.clone())?.into_any();
1089 self.dispatch_on_data(py_data)
1090 .map_err(|e| anyhow::anyhow!("Python on_data failed:\n{}", format_exception(&e)))
1091 })
1092 }
1093
1094 fn on_signal(&mut self, signal: &Signal) -> anyhow::Result<()> {
1095 self.dispatch_on_signal(signal)
1096 .map_err(|e| anyhow::anyhow!("Python on_signal failed:\n{}", format_exception(&e)))
1097 }
1098
1099 fn on_queue_state(&mut self, event: &QueueStateChanged) -> anyhow::Result<()> {
1100 self.dispatch_on_queue_state(event)
1101 .map_err(|e| anyhow::anyhow!("Python on_queue_state failed:\n{}", format_exception(&e)))
1102 }
1103
1104 fn on_socket_state(&mut self, event: &SocketStateChanged) -> anyhow::Result<()> {
1105 self.dispatch_on_socket_state(event).map_err(|e| {
1106 anyhow::anyhow!("Python on_socket_state failed:\n{}", format_exception(&e))
1107 })
1108 }
1109
1110 fn on_instrument(&mut self, instrument: &InstrumentAny) -> anyhow::Result<()> {
1111 Python::attach(|py| {
1112 let py_instrument = instrument_any_to_pyobject(py, instrument.clone())
1113 .map_err(|e| anyhow::anyhow!("Failed to convert InstrumentAny to Python: {e}"))?;
1114 self.dispatch_on_instrument(py_instrument).map_err(|e| {
1115 anyhow::anyhow!("Python on_instrument failed:\n{}", format_exception(&e))
1116 })
1117 })
1118 }
1119
1120 fn on_quote(&mut self, quote: &QuoteTick) -> anyhow::Result<()> {
1121 self.dispatch_on_quote(*quote)
1122 .map_err(|e| anyhow::anyhow!("Python on_quote failed:\n{}", format_exception(&e)))
1123 }
1124
1125 fn on_trade(&mut self, tick: &TradeTick) -> anyhow::Result<()> {
1126 self.dispatch_on_trade(*tick)
1127 .map_err(|e| anyhow::anyhow!("Python on_trade failed:\n{}", format_exception(&e)))
1128 }
1129
1130 fn on_bar(&mut self, bar: &Bar) -> anyhow::Result<()> {
1131 self.dispatch_on_bar(*bar)
1132 .map_err(|e| anyhow::anyhow!("Python on_bar failed:\n{}", format_exception(&e)))
1133 }
1134
1135 fn on_book_deltas(&mut self, deltas: &OrderBookDeltas) -> anyhow::Result<()> {
1136 self.dispatch_on_book_deltas(deltas.clone())
1137 .map_err(|e| anyhow::anyhow!("Python on_book_deltas failed:\n{}", format_exception(&e)))
1138 }
1139
1140 fn on_book_depth(&mut self, depth: &OrderBookDepth) -> anyhow::Result<()> {
1141 self.dispatch_on_book_depth(depth)
1142 .map_err(|e| anyhow::anyhow!("Python on_book_depth failed:\n{}", format_exception(&e)))
1143 }
1144
1145 fn on_book(&mut self, order_book: &OrderBook) -> anyhow::Result<()> {
1146 self.dispatch_on_book(order_book)
1147 .map_err(|e| anyhow::anyhow!("Python on_book failed:\n{}", format_exception(&e)))
1148 }
1149
1150 fn on_mark_price(&mut self, mark_price: &MarkPriceUpdate) -> anyhow::Result<()> {
1151 self.dispatch_on_mark_price(*mark_price)
1152 .map_err(|e| anyhow::anyhow!("Python on_mark_price failed:\n{}", format_exception(&e)))
1153 }
1154
1155 fn on_index_price(&mut self, index_price: &IndexPriceUpdate) -> anyhow::Result<()> {
1156 self.dispatch_on_index_price(*index_price)
1157 .map_err(|e| anyhow::anyhow!("Python on_index_price failed:\n{}", format_exception(&e)))
1158 }
1159
1160 fn on_funding_rate(&mut self, funding_rate: &FundingRateUpdate) -> anyhow::Result<()> {
1161 self.dispatch_on_funding_rate(*funding_rate).map_err(|e| {
1162 anyhow::anyhow!("Python on_funding_rate failed:\n{}", format_exception(&e))
1163 })
1164 }
1165
1166 fn on_instrument_status(&mut self, data: &InstrumentStatus) -> anyhow::Result<()> {
1167 self.dispatch_on_instrument_status(*data).map_err(|e| {
1168 anyhow::anyhow!(
1169 "Python on_instrument_status failed:\n{}",
1170 format_exception(&e)
1171 )
1172 })
1173 }
1174
1175 fn on_instrument_close(&mut self, update: &InstrumentClose) -> anyhow::Result<()> {
1176 self.dispatch_on_instrument_close(*update).map_err(|e| {
1177 anyhow::anyhow!(
1178 "Python on_instrument_close failed:\n{}",
1179 format_exception(&e)
1180 )
1181 })
1182 }
1183
1184 fn on_option_greeks(&mut self, greeks: &OptionGreeks) -> anyhow::Result<()> {
1185 self.dispatch_on_option_greeks(*greeks).map_err(|e| {
1186 anyhow::anyhow!("Python on_option_greeks failed:\n{}", format_exception(&e))
1187 })
1188 }
1189
1190 fn on_option_chain(&mut self, slice: &OptionChainSlice) -> anyhow::Result<()> {
1191 self.dispatch_on_option_chain(slice.clone()).map_err(|e| {
1192 anyhow::anyhow!("Python on_option_chain failed:\n{}", format_exception(&e))
1193 })
1194 }
1195
1196 #[cfg(feature = "defi")]
1197 fn on_block(&mut self, block: &Block) -> anyhow::Result<()> {
1198 self.dispatch_on_block(block.clone())
1199 .map_err(|e| anyhow::anyhow!("Python on_block failed:\n{}", format_exception(&e)))
1200 }
1201
1202 #[cfg(feature = "defi")]
1203 fn on_pool(&mut self, pool: &Pool) -> anyhow::Result<()> {
1204 self.dispatch_on_pool(pool.clone())
1205 .map_err(|e| anyhow::anyhow!("Python on_pool failed:\n{}", format_exception(&e)))
1206 }
1207
1208 #[cfg(feature = "defi")]
1209 fn on_pool_swap(&mut self, swap: &PoolSwap) -> anyhow::Result<()> {
1210 self.dispatch_on_pool_swap(swap.clone())
1211 .map_err(|e| anyhow::anyhow!("Python on_pool_swap failed:\n{}", format_exception(&e)))
1212 }
1213
1214 #[cfg(feature = "defi")]
1215 fn on_pool_liquidity_update(&mut self, update: &PoolLiquidityUpdate) -> anyhow::Result<()> {
1216 self.dispatch_on_pool_liquidity_update(update.clone())
1217 .map_err(|e| {
1218 anyhow::anyhow!(
1219 "Python on_pool_liquidity_update failed:\n{}",
1220 format_exception(&e)
1221 )
1222 })
1223 }
1224
1225 #[cfg(feature = "defi")]
1226 fn on_pool_fee_collect(&mut self, collect: &PoolFeeCollect) -> anyhow::Result<()> {
1227 self.dispatch_on_pool_fee_collect(collect.clone())
1228 .map_err(|e| {
1229 anyhow::anyhow!(
1230 "Python on_pool_fee_collect failed:\n{}",
1231 format_exception(&e)
1232 )
1233 })
1234 }
1235
1236 #[cfg(feature = "defi")]
1237 fn on_pool_flash(&mut self, flash: &PoolFlash) -> anyhow::Result<()> {
1238 self.dispatch_on_pool_flash(flash.clone())
1239 .map_err(|e| anyhow::anyhow!("Python on_pool_flash failed:\n{}", format_exception(&e)))
1240 }
1241
1242 fn on_historical_data(&mut self, data: &dyn Any) -> anyhow::Result<()> {
1243 Python::attach(|py| {
1244 let py_data: Py<PyAny> = if let Some(custom_data) = data.downcast_ref::<CustomData>() {
1245 Py::new(py, custom_data.clone())?.into_any()
1246 } else if let Some(custom_data) = data.downcast_ref::<Vec<CustomData>>() {
1247 custom_data.clone().into_py_any(py)?
1248 } else {
1249 anyhow::bail!("Failed to convert historical data to Python: unsupported type");
1250 };
1251
1252 self.dispatch_on_historical_data(py_data).map_err(|e| {
1253 anyhow::anyhow!(
1254 "Python on_historical_data failed:\n{}",
1255 format_exception(&e)
1256 )
1257 })
1258 })
1259 }
1260
1261 fn on_historical_book_deltas(&mut self, deltas: &[OrderBookDelta]) -> anyhow::Result<()> {
1262 self.dispatch_on_historical_book_deltas(deltas.to_vec())
1263 .map_err(|e| {
1264 anyhow::anyhow!(
1265 "Python on_historical_book_deltas failed:\n{}",
1266 format_exception(&e)
1267 )
1268 })
1269 }
1270
1271 fn on_historical_book_depth(&mut self, depths: &[OrderBookDepth]) -> anyhow::Result<()> {
1272 self.dispatch_on_historical_book_depth(depths.to_vec())
1273 .map_err(|e| {
1274 anyhow::anyhow!(
1275 "Python on_historical_book_depth failed:\n{}",
1276 format_exception(&e)
1277 )
1278 })
1279 }
1280
1281 fn on_historical_quotes(&mut self, quotes: &[QuoteTick]) -> anyhow::Result<()> {
1282 self.dispatch_on_historical_quotes(quotes.to_vec())
1283 .map_err(|e| {
1284 anyhow::anyhow!(
1285 "Python on_historical_quotes failed:\n{}",
1286 format_exception(&e)
1287 )
1288 })
1289 }
1290
1291 fn on_historical_trades(&mut self, trades: &[TradeTick]) -> anyhow::Result<()> {
1292 self.dispatch_on_historical_trades(trades.to_vec())
1293 .map_err(|e| {
1294 anyhow::anyhow!(
1295 "Python on_historical_trades failed:\n{}",
1296 format_exception(&e)
1297 )
1298 })
1299 }
1300
1301 fn on_historical_funding_rates(
1302 &mut self,
1303 funding_rates: &[FundingRateUpdate],
1304 ) -> anyhow::Result<()> {
1305 self.dispatch_on_historical_funding_rates(funding_rates.to_vec())
1306 .map_err(|e| {
1307 anyhow::anyhow!(
1308 "Python on_historical_funding_rates failed:\n{}",
1309 format_exception(&e)
1310 )
1311 })
1312 }
1313
1314 fn on_historical_bars(&mut self, bars: &[Bar]) -> anyhow::Result<()> {
1315 self.dispatch_on_historical_bars(bars.to_vec())
1316 .map_err(|e| {
1317 anyhow::anyhow!(
1318 "Python on_historical_bars failed:\n{}",
1319 format_exception(&e)
1320 )
1321 })
1322 }
1323
1324 fn on_historical_mark_prices(&mut self, mark_prices: &[MarkPriceUpdate]) -> anyhow::Result<()> {
1325 self.dispatch_on_historical_mark_prices(mark_prices.to_vec())
1326 .map_err(|e| {
1327 anyhow::anyhow!(
1328 "Python on_historical_mark_prices failed:\n{}",
1329 format_exception(&e)
1330 )
1331 })
1332 }
1333
1334 fn on_historical_index_prices(
1335 &mut self,
1336 index_prices: &[IndexPriceUpdate],
1337 ) -> anyhow::Result<()> {
1338 self.dispatch_on_historical_index_prices(index_prices.to_vec())
1339 .map_err(|e| {
1340 anyhow::anyhow!(
1341 "Python on_historical_index_prices failed:\n{}",
1342 format_exception(&e)
1343 )
1344 })
1345 }
1346}
1347
1348#[pymethods]
1349#[pyo3_stub_gen::derive::gen_stub_pymethods]
1350impl PyDataActor {
1351 #[new]
1363 #[pyo3(signature = (config=None))]
1364 fn py_new(config: Option<Py<PyAny>>) -> Self {
1365 Self::from_py_config(config)
1366 }
1367
1368 #[pyo3(signature = (config=None))]
1369 fn __init__(slf: &Bound<'_, Self>, config: Option<Py<PyAny>>) -> PyResult<()> {
1370 {
1371 let mut borrowed = slf.borrow_mut();
1372 borrowed.set_python_instance(slf.as_any())?;
1373 if config.is_some() {
1375 borrowed.set_config(config);
1376 }
1377 }
1378
1379 if !has_configured_actor_id(slf) {
1380 let py_type = slf.get_type();
1381 let type_name = py_type.name()?;
1382 let actor_id = ActorId::new_checked(type_name.to_str()?).map_err(to_pyvalue_err)?;
1383 slf.borrow_mut().set_actor_id(actor_id);
1384 }
1385
1386 Ok(())
1387 }
1388
1389 #[getter]
1390 #[pyo3(name = "clock")]
1391 fn py_clock(&self) -> PyResult<PyClock> {
1392 let inner = self.inner();
1393 if inner.core.is_registered() {
1394 Ok(inner.clock.clone())
1395 } else {
1396 Err(to_pyruntime_err(
1397 "Actor must be registered with a trader before accessing clock",
1398 ))
1399 }
1400 }
1401
1402 #[getter]
1403 #[pyo3(name = "cache")]
1404 fn py_cache(&self) -> PyResult<PyCache> {
1405 let inner = self.inner();
1406 if inner.core.is_registered() {
1407 Ok(PyCache::from_rc(inner.core.cache_rc()))
1408 } else {
1409 Err(to_pyruntime_err(
1410 "Actor must be registered with a trader before accessing cache",
1411 ))
1412 }
1413 }
1414
1415 #[getter]
1416 #[pyo3(name = "log")]
1417 fn py_log(&self) -> PyLogger {
1418 self.inner().logger.clone()
1419 }
1420
1421 #[getter]
1422 #[pyo3(name = "actor_id")]
1423 fn py_actor_id(&self) -> ActorId {
1424 self.inner().core.actor_id
1425 }
1426
1427 #[getter]
1428 #[pyo3(name = "config")]
1429 fn py_config(&self, py: Python<'_>) -> Option<Py<PyAny>> {
1430 self.inner()
1431 .config
1432 .as_ref()
1433 .map(|config| config.clone_ref(py))
1434 }
1435
1436 #[getter]
1437 #[pyo3(name = "trader_id")]
1438 fn py_trader_id(&self) -> Option<TraderId> {
1439 self.inner().core.trader_id()
1440 }
1441
1442 #[pyo3(name = "state")]
1443 fn py_state(&self) -> ComponentState {
1444 Component::state(self.inner())
1445 }
1446
1447 #[pyo3(name = "is_ready")]
1448 fn py_is_ready(&self) -> bool {
1449 Component::is_ready(self.inner())
1450 }
1451
1452 #[pyo3(name = "is_running")]
1453 fn py_is_running(&self) -> bool {
1454 Component::is_running(self.inner())
1455 }
1456
1457 #[pyo3(name = "is_stopped")]
1458 fn py_is_stopped(&self) -> bool {
1459 Component::is_stopped(self.inner())
1460 }
1461
1462 #[pyo3(name = "is_degraded")]
1463 fn py_is_degraded(&self) -> bool {
1464 Component::is_degraded(self.inner())
1465 }
1466
1467 #[pyo3(name = "is_faulted")]
1468 fn py_is_faulted(&self) -> bool {
1469 Component::is_faulted(self.inner())
1470 }
1471
1472 #[pyo3(name = "is_disposed")]
1473 fn py_is_disposed(&self) -> bool {
1474 Component::is_disposed(self.inner())
1475 }
1476
1477 #[pyo3(name = "start")]
1478 fn py_start(&mut self) -> PyResult<()> {
1479 Component::start(self.inner_mut()).map_err(to_pyruntime_err)
1480 }
1481
1482 #[pyo3(name = "stop")]
1483 fn py_stop(&mut self) -> PyResult<()> {
1484 Component::stop(self.inner_mut()).map_err(to_pyruntime_err)
1485 }
1486
1487 #[pyo3(name = "save")]
1488 fn py_save(&self, py: Python<'_>) -> PyResult<Py<PyDict>> {
1489 let state = DataActor::on_save(self.inner()).map_err(to_pyruntime_err)?;
1490 state_to_pydict(py, &state)
1491 }
1492
1493 #[pyo3(name = "load")]
1494 fn py_load(&mut self, state: &Bound<'_, PyDict>) -> PyResult<()> {
1495 let state = pydict_to_state(state)?;
1496 DataActor::on_load(self.inner_mut(), state).map_err(to_pyruntime_err)
1497 }
1498
1499 #[pyo3(name = "resume")]
1500 fn py_resume(&mut self) -> PyResult<()> {
1501 Component::resume(self.inner_mut()).map_err(to_pyruntime_err)
1502 }
1503
1504 #[pyo3(name = "reset")]
1505 fn py_reset(&mut self) -> PyResult<()> {
1506 Component::reset(self.inner_mut()).map_err(to_pyruntime_err)
1507 }
1508
1509 #[pyo3(name = "dispose")]
1510 fn py_dispose(&mut self) -> PyResult<()> {
1511 Component::dispose(self.inner_mut()).map_err(to_pyruntime_err)
1512 }
1513
1514 #[pyo3(name = "degrade")]
1515 fn py_degrade(&mut self) -> PyResult<()> {
1516 Component::degrade(self.inner_mut()).map_err(to_pyruntime_err)
1517 }
1518
1519 #[pyo3(name = "fault")]
1520 fn py_fault(&mut self) -> PyResult<()> {
1521 Component::fault(self.inner_mut()).map_err(to_pyruntime_err)
1522 }
1523
1524 #[pyo3(name = "shutdown_system")]
1525 #[pyo3(signature = (reason=None))]
1526 fn py_shutdown_system(&self, reason: Option<String>) -> PyResult<()> {
1527 if !self.inner().core.is_registered() {
1528 return Err(to_pyruntime_err(
1529 "Actor must be registered with a trader before shutting down the system",
1530 ));
1531 }
1532
1533 self.inner().shutdown_system(reason);
1534 Ok(())
1535 }
1536
1537 #[pyo3(name = "publish_data")]
1538 fn py_publish_data(&self, data_type: &DataType, data: &CustomData) -> PyResult<()> {
1539 self.ensure_registered_for_data()?;
1540 self.inner().publish_data(data_type, data);
1541 Ok(())
1542 }
1543
1544 #[pyo3(name = "publish_signal")]
1545 #[pyo3(signature = (name, value, ts_event=0))]
1546 #[expect(
1547 clippy::needless_pass_by_value,
1548 reason = "PyO3 accepts an owned PyAny handle for Python signal values"
1549 )]
1550 fn py_publish_signal(
1551 &self,
1552 py: Python<'_>,
1553 name: &str,
1554 value: Py<PyAny>,
1555 ts_event: u64,
1556 ) -> PyResult<()> {
1557 self.ensure_registered_for_data()?;
1558 let value_str: String = value.bind(py).str()?.extract()?;
1559 self.inner()
1560 .publish_signal(name, value_str, UnixNanos::from(ts_event));
1561 Ok(())
1562 }
1563
1564 #[pyo3(name = "add_synthetic")]
1565 fn py_add_synthetic(&self, synthetic: SyntheticInstrument) -> PyResult<()> {
1566 self.ensure_registered_for_data()?;
1567 self.inner()
1568 .add_synthetic(synthetic)
1569 .map_err(to_pyvalue_err)
1570 }
1571
1572 #[pyo3(name = "update_synthetic")]
1573 fn py_update_synthetic(&self, synthetic: SyntheticInstrument) -> PyResult<()> {
1574 self.ensure_registered_for_data()?;
1575 self.inner()
1576 .update_synthetic(synthetic)
1577 .map_err(to_pyvalue_err)
1578 }
1579
1580 #[getter]
1581 #[pyo3(name = "registered_indicators")]
1582 fn py_registered_indicators(&self, py: Python<'_>) -> PyResult<Py<PyList>> {
1583 registered_python_indicators(py, self.inner().core.registered_indicators())
1584 }
1585
1586 #[pyo3(name = "indicators_initialized")]
1587 fn py_indicators_initialized(&self, _py: Python<'_>) -> PyResult<bool> {
1588 self.inner()
1589 .core
1590 .indicators_initialized()
1591 .map_err(to_pyruntime_err)
1592 }
1593
1594 #[pyo3(name = "register_indicator_for_quote_ticks")]
1595 fn py_register_indicator_for_quote_ticks(
1596 &mut self,
1597 py: Python<'_>,
1598 instrument_id: InstrumentId,
1599 indicator: Py<PyAny>,
1600 ) {
1601 let indicator = wrap_python_indicator(py, indicator);
1602 self.inner_mut()
1603 .core
1604 .register_indicator_for_quote_ticks(instrument_id, indicator);
1605 }
1606
1607 #[pyo3(name = "register_indicator_for_trade_ticks")]
1608 fn py_register_indicator_for_trade_ticks(
1609 &mut self,
1610 py: Python<'_>,
1611 instrument_id: InstrumentId,
1612 indicator: Py<PyAny>,
1613 ) {
1614 let indicator = wrap_python_indicator(py, indicator);
1615 self.inner_mut()
1616 .core
1617 .register_indicator_for_trade_ticks(instrument_id, indicator);
1618 }
1619
1620 #[pyo3(name = "register_indicator_for_bars")]
1621 fn py_register_indicator_for_bars(
1622 &mut self,
1623 py: Python<'_>,
1624 bar_type: BarType,
1625 indicator: Py<PyAny>,
1626 ) {
1627 let indicator = wrap_python_indicator(py, indicator);
1628 self.inner_mut()
1629 .core
1630 .register_indicator_for_bars(bar_type, indicator);
1631 }
1632
1633 #[pyo3(name = "on_start")]
1634 fn py_on_start(_slf: &Bound<'_, Self>) {}
1635
1636 #[pyo3(name = "on_stop")]
1637 fn py_on_stop(_slf: &Bound<'_, Self>) {}
1638
1639 #[pyo3(name = "on_resume")]
1640 fn py_on_resume(_slf: &Bound<'_, Self>) {}
1641
1642 #[pyo3(name = "on_reset")]
1643 fn py_on_reset(_slf: &Bound<'_, Self>) {}
1644
1645 #[pyo3(name = "on_dispose")]
1646 fn py_on_dispose(_slf: &Bound<'_, Self>) {}
1647
1648 #[pyo3(name = "on_degrade")]
1649 fn py_on_degrade(_slf: &Bound<'_, Self>) {}
1650
1651 #[pyo3(name = "on_fault")]
1652 fn py_on_fault(_slf: &Bound<'_, Self>) {}
1653
1654 #[pyo3(name = "on_save")]
1655 fn py_on_save(_slf: &Bound<'_, Self>, py: Python<'_>) -> Py<PyDict> {
1656 PyDict::new(py).unbind()
1657 }
1658
1659 #[allow(unused_variables)]
1660 #[pyo3(name = "on_load")]
1661 fn py_on_load(_slf: &Bound<'_, Self>, state: &Bound<'_, PyDict>) {}
1662
1663 #[allow(unused_variables, clippy::needless_pass_by_value)]
1664 #[pyo3(name = "on_time_event")]
1665 fn py_on_time_event(_slf: &Bound<'_, Self>, event: TimeEvent) {}
1666
1667 #[allow(unused_variables, clippy::needless_pass_by_value)]
1668 #[pyo3(name = "on_data")]
1669 fn py_on_data(_slf: &Bound<'_, Self>, data: Py<PyAny>) {}
1670
1671 #[allow(unused_variables)]
1672 #[pyo3(name = "on_signal")]
1673 fn py_on_signal(_slf: &Bound<'_, Self>, signal: &Signal) {}
1674
1675 #[allow(unused_variables, clippy::needless_pass_by_value)]
1676 #[pyo3(name = "on_queue_state")]
1677 fn py_on_queue_state(_slf: &Bound<'_, Self>, event: QueueStateChanged) {}
1678
1679 #[allow(unused_variables, clippy::needless_pass_by_value)]
1680 #[pyo3(name = "on_socket_state")]
1681 fn py_on_socket_state(_slf: &Bound<'_, Self>, event: SocketStateChanged) {}
1682
1683 #[allow(unused_variables, clippy::needless_pass_by_value)]
1684 #[pyo3(name = "on_instrument")]
1685 fn py_on_instrument(_slf: &Bound<'_, Self>, instrument: Py<PyAny>) {}
1686
1687 #[allow(unused_variables)]
1688 #[pyo3(name = "on_quote")]
1689 fn py_on_quote(_slf: &Bound<'_, Self>, quote: QuoteTick) {}
1690
1691 #[allow(unused_variables)]
1692 #[pyo3(name = "on_trade")]
1693 fn py_on_trade(_slf: &Bound<'_, Self>, trade: TradeTick) {}
1694
1695 #[allow(unused_variables)]
1696 #[pyo3(name = "on_bar")]
1697 fn py_on_bar(_slf: &Bound<'_, Self>, bar: Bar) {}
1698
1699 #[allow(unused_variables, clippy::needless_pass_by_value)]
1700 #[pyo3(name = "on_book_deltas")]
1701 fn py_on_book_deltas(_slf: &Bound<'_, Self>, deltas: OrderBookDeltas) {}
1702
1703 #[allow(unused_variables)]
1704 #[pyo3(name = "on_book_depth")]
1705 fn py_on_book_depth(_slf: &Bound<'_, Self>, depth: &OrderBookDepth) {}
1706
1707 #[allow(unused_variables)]
1708 #[pyo3(name = "on_book")]
1709 fn py_on_book(_slf: &Bound<'_, Self>, book: &OrderBook) {}
1710
1711 #[allow(unused_variables)]
1712 #[pyo3(name = "on_mark_price")]
1713 fn py_on_mark_price(_slf: &Bound<'_, Self>, mark_price: MarkPriceUpdate) {}
1714
1715 #[allow(unused_variables)]
1716 #[pyo3(name = "on_index_price")]
1717 fn py_on_index_price(_slf: &Bound<'_, Self>, index_price: IndexPriceUpdate) {}
1718
1719 #[allow(unused_variables)]
1720 #[pyo3(name = "on_funding_rate")]
1721 fn py_on_funding_rate(_slf: &Bound<'_, Self>, funding_rate: FundingRateUpdate) {}
1722
1723 #[allow(unused_variables)]
1724 #[pyo3(name = "on_instrument_status")]
1725 fn py_on_instrument_status(_slf: &Bound<'_, Self>, status: InstrumentStatus) {}
1726
1727 #[allow(unused_variables)]
1728 #[pyo3(name = "on_instrument_close")]
1729 fn py_on_instrument_close(_slf: &Bound<'_, Self>, close: InstrumentClose) {}
1730
1731 #[allow(unused_variables)]
1732 #[pyo3(name = "on_option_greeks")]
1733 fn py_on_option_greeks(_slf: &Bound<'_, Self>, greeks: OptionGreeks) {}
1734
1735 #[allow(unused_variables, clippy::needless_pass_by_value)]
1736 #[pyo3(name = "on_option_chain")]
1737 fn py_on_option_chain(_slf: &Bound<'_, Self>, slice: OptionChainSlice) {}
1738
1739 #[pyo3(name = "subscribe_data")]
1740 #[pyo3(signature = (data_type, client_id=None, params=None))]
1741 fn py_subscribe_data(
1742 &mut self,
1743 py: Python<'_>,
1744 data_type: DataType,
1745 client_id: Option<ClientId>,
1746 params: Option<Py<PyDict>>,
1747 ) -> PyResult<()> {
1748 self.ensure_registered()?;
1749 let params = dict_to_params(py, params)?;
1750 DataActor::subscribe_data(self.inner_mut(), data_type, client_id, params);
1751 Ok(())
1752 }
1753
1754 #[pyo3(name = "subscribe_signal")]
1755 #[pyo3(signature = (name="", priority=None))]
1756 fn py_subscribe_signal(
1757 slf: &Bound<'_, Self>,
1758 name: &str,
1759 priority: Option<u32>,
1760 ) -> PyResult<()> {
1761 let actor = borrow_actor_mut(slf, "subscribe_signal")?;
1762 actor.ensure_registered()?;
1763 DataActor::subscribe_signal(actor.inner_mut(), name, priority);
1764 Ok(())
1765 }
1766
1767 #[pyo3(name = "subscribe_queue_state")]
1768 #[pyo3(signature = (channel=None, priority=None))]
1769 fn py_subscribe_queue_state(
1770 &mut self,
1771 channel: Option<SystemChannel>,
1772 priority: Option<u32>,
1773 ) -> PyResult<()> {
1774 self.ensure_registered()?;
1775 DataActor::subscribe_queue_state(self.inner_mut(), channel, priority);
1776 Ok(())
1777 }
1778
1779 #[pyo3(name = "subscribe_socket_state")]
1780 #[pyo3(signature = (client_id=None, endpoint=None, priority=None))]
1781 fn py_subscribe_socket_state(
1782 &mut self,
1783 client_id: Option<ClientId>,
1784 endpoint: Option<&str>,
1785 priority: Option<u32>,
1786 ) -> PyResult<()> {
1787 self.ensure_registered()?;
1788 DataActor::subscribe_socket_state(self.inner_mut(), client_id, endpoint, priority);
1789 Ok(())
1790 }
1791
1792 #[pyo3(name = "subscribe_instruments")]
1793 #[pyo3(signature = (venue, client_id=None, params=None))]
1794 fn py_subscribe_instruments(
1795 &mut self,
1796 py: Python<'_>,
1797 venue: Venue,
1798 client_id: Option<ClientId>,
1799 params: Option<Py<PyDict>>,
1800 ) -> PyResult<()> {
1801 self.ensure_registered()?;
1802 let params = dict_to_params(py, params)?;
1803 DataActor::subscribe_instruments(self.inner_mut(), venue, client_id, params);
1804 Ok(())
1805 }
1806
1807 #[pyo3(name = "subscribe_instrument")]
1808 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
1809 fn py_subscribe_instrument(
1810 &mut self,
1811 py: Python<'_>,
1812 #[gen_stub(override_type(
1813 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
1814 ))]
1815 instrument_id: &Bound<'_, PyAny>,
1816 client_id: Option<ClientId>,
1817 params: Option<Py<PyDict>>,
1818 ) -> PyResult<()> {
1819 self.ensure_registered()?;
1820 let instrument_id = extract_instrument_ids(instrument_id)?;
1821 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
1822 .map_err(to_pyvalue_err)?;
1823 ensure_subscription_routes(
1824 &instrument_id,
1825 client_id.as_ref(),
1826 &DataActorNative::cache_ref(self.inner()),
1827 )
1828 .map_err(to_pyvalue_err)?;
1829 let params = dict_to_params(py, params)?;
1830 DataActor::subscribe_instrument(self.inner_mut(), instrument_id, client_id, params);
1831 Ok(())
1832 }
1833
1834 #[pyo3(name = "subscribe_book_deltas")]
1835 #[pyo3(signature = (instrument_id, book_type, depth=None, client_id=None, managed=false, params=None))]
1836 #[expect(clippy::too_many_arguments)]
1837 fn py_subscribe_book_deltas(
1838 &mut self,
1839 py: Python<'_>,
1840 #[gen_stub(override_type(
1841 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
1842 ))]
1843 instrument_id: &Bound<'_, PyAny>,
1844 book_type: BookType,
1845 depth: Option<usize>,
1846 client_id: Option<ClientId>,
1847 managed: bool,
1848 params: Option<Py<PyDict>>,
1849 ) -> PyResult<()> {
1850 self.ensure_registered()?;
1851 let instrument_id = extract_instrument_ids(instrument_id)?;
1852 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
1853 .map_err(to_pyvalue_err)?;
1854 ensure_subscription_routes(
1855 &instrument_id,
1856 client_id.as_ref(),
1857 &DataActorNative::cache_ref(self.inner()),
1858 )
1859 .map_err(to_pyvalue_err)?;
1860 let params = dict_to_params(py, params)?;
1861 let depth = depth.and_then(NonZeroUsize::new);
1862 DataActor::subscribe_book_deltas(
1863 self.inner_mut(),
1864 instrument_id,
1865 book_type,
1866 depth,
1867 client_id,
1868 managed,
1869 params,
1870 );
1871 Ok(())
1872 }
1873
1874 #[expect(clippy::too_many_arguments)]
1875 #[pyo3(name = "subscribe_book_depth")]
1876 #[pyo3(signature = (instrument_id, book_type, depth=None, client_id=None, managed=false, params=None))]
1877 fn py_subscribe_book_depth(
1878 &mut self,
1879 py: Python<'_>,
1880 #[gen_stub(override_type(
1881 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
1882 ))]
1883 instrument_id: &Bound<'_, PyAny>,
1884 book_type: BookType,
1885 depth: Option<usize>,
1886 client_id: Option<ClientId>,
1887 managed: bool,
1888 params: Option<Py<PyDict>>,
1889 ) -> PyResult<()> {
1890 self.ensure_registered()?;
1891 let instrument_id = extract_instrument_ids(instrument_id)?;
1892 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
1893 .map_err(to_pyvalue_err)?;
1894 ensure_subscription_routes(
1895 &instrument_id,
1896 client_id.as_ref(),
1897 &DataActorNative::cache_ref(self.inner()),
1898 )
1899 .map_err(to_pyvalue_err)?;
1900
1901 let depth = depth
1902 .map(|value| {
1903 NonZeroUsize::new(value).ok_or_else(|| to_pyvalue_err("depth must be positive"))
1904 })
1905 .transpose()?;
1906
1907 let params = dict_to_params(py, params)?;
1908 DataActor::subscribe_book_depth(
1909 self.inner_mut(),
1910 instrument_id,
1911 book_type,
1912 depth,
1913 client_id,
1914 managed,
1915 params,
1916 );
1917 Ok(())
1918 }
1919
1920 #[pyo3(name = "subscribe_book_at_interval")]
1921 #[pyo3(signature = (instrument_id, book_type, interval_ms, depth=None, client_id=None, params=None))]
1922 #[expect(clippy::too_many_arguments)]
1923 fn py_subscribe_book_at_interval(
1924 &mut self,
1925 py: Python<'_>,
1926 #[gen_stub(override_type(
1927 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
1928 ))]
1929 instrument_id: &Bound<'_, PyAny>,
1930 book_type: BookType,
1931 interval_ms: usize,
1932 depth: Option<usize>,
1933 client_id: Option<ClientId>,
1934 params: Option<Py<PyDict>>,
1935 ) -> PyResult<()> {
1936 let interval_ms = NonZeroUsize::new(interval_ms)
1937 .ok_or_else(|| to_pyvalue_err("interval_ms must be > 0"))?;
1938
1939 self.ensure_registered()?;
1940 let instrument_id = extract_instrument_ids(instrument_id)?;
1941 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
1942 .map_err(to_pyvalue_err)?;
1943 ensure_subscription_routes(
1944 &instrument_id,
1945 client_id.as_ref(),
1946 &DataActorNative::cache_ref(self.inner()),
1947 )
1948 .map_err(to_pyvalue_err)?;
1949 let params = dict_to_params(py, params)?;
1950 let depth = depth.and_then(NonZeroUsize::new);
1951 DataActor::subscribe_book_at_interval(
1952 self.inner_mut(),
1953 instrument_id,
1954 book_type,
1955 depth,
1956 interval_ms,
1957 client_id,
1958 params,
1959 );
1960 Ok(())
1961 }
1962
1963 #[pyo3(name = "subscribe_quotes")]
1964 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
1965 fn py_subscribe_quotes(
1966 &mut self,
1967 py: Python<'_>,
1968 #[gen_stub(override_type(
1969 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
1970 ))]
1971 instrument_id: &Bound<'_, PyAny>,
1972 client_id: Option<ClientId>,
1973 params: Option<Py<PyDict>>,
1974 ) -> PyResult<()> {
1975 self.ensure_registered()?;
1976 let instrument_ids = extract_instrument_ids(instrument_id)?;
1977 ensure_routable_instrument_ids(&instrument_ids, client_id.is_some())
1978 .map_err(to_pyvalue_err)?;
1979 let params = dict_to_params(py, params)?;
1980 quote_routing(
1981 &instrument_ids,
1982 client_id.as_ref(),
1983 params.as_ref(),
1984 &DataActorNative::cache_ref(self.inner()),
1985 )
1986 .map_err(to_pyvalue_err)?;
1987 DataActor::subscribe_quotes(self.inner_mut(), instrument_ids, client_id, params);
1988 Ok(())
1989 }
1990
1991 #[pyo3(name = "subscribe_trades")]
1992 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
1993 fn py_subscribe_trades(
1994 &mut self,
1995 py: Python<'_>,
1996 #[gen_stub(override_type(
1997 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
1998 ))]
1999 instrument_id: &Bound<'_, PyAny>,
2000 client_id: Option<ClientId>,
2001 params: Option<Py<PyDict>>,
2002 ) -> PyResult<()> {
2003 self.ensure_registered()?;
2004 let instrument_ids = extract_instrument_ids(instrument_id)?;
2005 ensure_routable_instrument_ids(&instrument_ids, client_id.is_some())
2006 .map_err(to_pyvalue_err)?;
2007 let params = dict_to_params(py, params)?;
2008 DataActor::subscribe_trades(self.inner_mut(), instrument_ids, client_id, params);
2009 Ok(())
2010 }
2011
2012 #[pyo3(name = "subscribe_bars")]
2013 #[pyo3(signature = (bar_type, client_id=None, params=None))]
2014 fn py_subscribe_bars(
2015 &mut self,
2016 py: Python<'_>,
2017 #[gen_stub(override_type(type_repr = "model.BarType | typing.Sequence[model.BarType]"))]
2018 bar_type: &Bound<'_, PyAny>,
2019 client_id: Option<ClientId>,
2020 params: Option<Py<PyDict>>,
2021 ) -> PyResult<()> {
2022 self.ensure_registered()?;
2023 let bar_types = extract_bar_types(bar_type)?;
2024 ensure_routable_bar_types(&bar_types, client_id.is_some()).map_err(to_pyvalue_err)?;
2025 let params = dict_to_params(py, params)?;
2026 DataActor::subscribe_bars(self.inner_mut(), bar_types, client_id, params);
2027 Ok(())
2028 }
2029
2030 #[pyo3(name = "subscribe_mark_prices")]
2031 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
2032 fn py_subscribe_mark_prices(
2033 &mut self,
2034 py: Python<'_>,
2035 #[gen_stub(override_type(
2036 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2037 ))]
2038 instrument_id: &Bound<'_, PyAny>,
2039 client_id: Option<ClientId>,
2040 params: Option<Py<PyDict>>,
2041 ) -> PyResult<()> {
2042 self.ensure_registered()?;
2043 let instrument_id = extract_instrument_ids(instrument_id)?;
2044 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
2045 .map_err(to_pyvalue_err)?;
2046 let params = dict_to_params(py, params)?;
2047 DataActor::subscribe_mark_prices(self.inner_mut(), instrument_id, client_id, params);
2048 Ok(())
2049 }
2050
2051 #[pyo3(name = "subscribe_index_prices")]
2052 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
2053 fn py_subscribe_index_prices(
2054 &mut self,
2055 py: Python<'_>,
2056 #[gen_stub(override_type(
2057 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2058 ))]
2059 instrument_id: &Bound<'_, PyAny>,
2060 client_id: Option<ClientId>,
2061 params: Option<Py<PyDict>>,
2062 ) -> PyResult<()> {
2063 self.ensure_registered()?;
2064 let instrument_id = extract_instrument_ids(instrument_id)?;
2065 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
2066 .map_err(to_pyvalue_err)?;
2067 let params = dict_to_params(py, params)?;
2068 DataActor::subscribe_index_prices(self.inner_mut(), instrument_id, client_id, params);
2069 Ok(())
2070 }
2071
2072 #[pyo3(name = "subscribe_funding_rates")]
2073 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
2074 fn py_subscribe_funding_rates(
2075 &mut self,
2076 py: Python<'_>,
2077 #[gen_stub(override_type(
2078 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2079 ))]
2080 instrument_id: &Bound<'_, PyAny>,
2081 client_id: Option<ClientId>,
2082 params: Option<Py<PyDict>>,
2083 ) -> PyResult<()> {
2084 self.ensure_registered()?;
2085 let instrument_id = extract_instrument_ids(instrument_id)?;
2086 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
2087 .map_err(to_pyvalue_err)?;
2088 let params = dict_to_params(py, params)?;
2089 DataActor::subscribe_funding_rates(self.inner_mut(), instrument_id, client_id, params);
2090 Ok(())
2091 }
2092
2093 #[pyo3(name = "subscribe_option_greeks")]
2094 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
2095 fn py_subscribe_option_greeks(
2096 &mut self,
2097 py: Python<'_>,
2098 #[gen_stub(override_type(
2099 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2100 ))]
2101 instrument_id: &Bound<'_, PyAny>,
2102 client_id: Option<ClientId>,
2103 params: Option<Py<PyDict>>,
2104 ) -> PyResult<()> {
2105 self.ensure_registered()?;
2106 let instrument_id = extract_instrument_ids(instrument_id)?;
2107 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
2108 .map_err(to_pyvalue_err)?;
2109 ensure_subscription_routes(
2110 &instrument_id,
2111 client_id.as_ref(),
2112 &DataActorNative::cache_ref(self.inner()),
2113 )
2114 .map_err(to_pyvalue_err)?;
2115 let params = dict_to_params(py, params)?;
2116 DataActor::subscribe_option_greeks(self.inner_mut(), instrument_id, client_id, params);
2117 Ok(())
2118 }
2119
2120 #[pyo3(name = "subscribe_instrument_status")]
2121 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
2122 fn py_subscribe_instrument_status(
2123 &mut self,
2124 py: Python<'_>,
2125 #[gen_stub(override_type(
2126 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2127 ))]
2128 instrument_id: &Bound<'_, PyAny>,
2129 client_id: Option<ClientId>,
2130 params: Option<Py<PyDict>>,
2131 ) -> PyResult<()> {
2132 self.ensure_registered()?;
2133 let instrument_id = extract_instrument_ids(instrument_id)?;
2134 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
2135 .map_err(to_pyvalue_err)?;
2136 ensure_subscription_routes(
2137 &instrument_id,
2138 client_id.as_ref(),
2139 &DataActorNative::cache_ref(self.inner()),
2140 )
2141 .map_err(to_pyvalue_err)?;
2142 let params = dict_to_params(py, params)?;
2143 DataActor::subscribe_instrument_status(self.inner_mut(), instrument_id, client_id, params);
2144 Ok(())
2145 }
2146
2147 #[pyo3(name = "subscribe_instrument_close")]
2148 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
2149 fn py_subscribe_instrument_close(
2150 &mut self,
2151 py: Python<'_>,
2152 #[gen_stub(override_type(
2153 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2154 ))]
2155 instrument_id: &Bound<'_, PyAny>,
2156 client_id: Option<ClientId>,
2157 params: Option<Py<PyDict>>,
2158 ) -> PyResult<()> {
2159 self.ensure_registered()?;
2160 let instrument_id = extract_instrument_ids(instrument_id)?;
2161 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
2162 .map_err(to_pyvalue_err)?;
2163 ensure_subscription_routes(
2164 &instrument_id,
2165 client_id.as_ref(),
2166 &DataActorNative::cache_ref(self.inner()),
2167 )
2168 .map_err(to_pyvalue_err)?;
2169 let params = dict_to_params(py, params)?;
2170 DataActor::subscribe_instrument_close(self.inner_mut(), instrument_id, client_id, params);
2171 Ok(())
2172 }
2173
2174 #[pyo3(name = "subscribe_option_chain")]
2175 #[pyo3(signature = (series_id, strike_range, snapshot_interval_ms=None, client_id=None, params=None))]
2176 fn py_subscribe_option_chain(
2177 &mut self,
2178 py: Python<'_>,
2179 series_id: OptionSeriesId,
2180 strike_range: PyStrikeRange,
2181 snapshot_interval_ms: Option<u64>,
2182 client_id: Option<ClientId>,
2183 params: Option<Py<PyDict>>,
2184 ) -> PyResult<()> {
2185 self.ensure_registered()?;
2186 let params = dict_to_params(py, params)?;
2187 DataActor::subscribe_option_chain(
2188 self.inner_mut(),
2189 series_id,
2190 strike_range.inner,
2191 snapshot_interval_ms,
2192 client_id,
2193 params,
2194 )
2195 .map_err(to_pyvalue_err)?;
2196 Ok(())
2197 }
2198
2199 #[pyo3(name = "unsubscribe_data")]
2200 #[pyo3(signature = (data_type, client_id=None, params=None))]
2201 fn py_unsubscribe_data(
2202 &mut self,
2203 py: Python<'_>,
2204 data_type: DataType,
2205 client_id: Option<ClientId>,
2206 params: Option<Py<PyDict>>,
2207 ) -> PyResult<()> {
2208 self.ensure_registered()?;
2209 let params = dict_to_params(py, params)?;
2210 DataActor::unsubscribe_data(self.inner_mut(), data_type, client_id, params);
2211 Ok(())
2212 }
2213
2214 #[pyo3(name = "unsubscribe_signal")]
2215 #[pyo3(signature = (name=""))]
2216 fn py_unsubscribe_signal(slf: &Bound<'_, Self>, name: &str) -> PyResult<()> {
2217 let actor = borrow_actor_mut(slf, "unsubscribe_signal")?;
2218 actor.ensure_registered()?;
2219 DataActor::unsubscribe_signal(actor.inner_mut(), name);
2220 Ok(())
2221 }
2222
2223 #[pyo3(name = "unsubscribe_queue_state")]
2224 #[pyo3(signature = (channel=None))]
2225 fn py_unsubscribe_queue_state(&mut self, channel: Option<SystemChannel>) -> PyResult<()> {
2226 self.ensure_registered()?;
2227 DataActor::unsubscribe_queue_state(self.inner_mut(), channel);
2228 Ok(())
2229 }
2230
2231 #[pyo3(name = "unsubscribe_socket_state")]
2232 #[pyo3(signature = (client_id=None, endpoint=None))]
2233 fn py_unsubscribe_socket_state(
2234 &mut self,
2235 client_id: Option<ClientId>,
2236 endpoint: Option<&str>,
2237 ) -> PyResult<()> {
2238 self.ensure_registered()?;
2239 DataActor::unsubscribe_socket_state(self.inner_mut(), client_id, endpoint);
2240 Ok(())
2241 }
2242
2243 #[pyo3(name = "unsubscribe_instruments")]
2244 #[pyo3(signature = (venue, client_id=None, params=None))]
2245 fn py_unsubscribe_instruments(
2246 &mut self,
2247 py: Python<'_>,
2248 venue: Venue,
2249 client_id: Option<ClientId>,
2250 params: Option<Py<PyDict>>,
2251 ) -> PyResult<()> {
2252 self.ensure_registered()?;
2253 let params = dict_to_params(py, params)?;
2254 DataActor::unsubscribe_instruments(self.inner_mut(), venue, client_id, params);
2255 Ok(())
2256 }
2257
2258 #[pyo3(name = "unsubscribe_instrument")]
2259 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
2260 fn py_unsubscribe_instrument(
2261 &mut self,
2262 py: Python<'_>,
2263 #[gen_stub(override_type(
2264 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2265 ))]
2266 instrument_id: &Bound<'_, PyAny>,
2267 client_id: Option<ClientId>,
2268 params: Option<Py<PyDict>>,
2269 ) -> PyResult<()> {
2270 self.ensure_registered()?;
2271 let instrument_id = extract_instrument_ids(instrument_id)?;
2272 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
2273 .map_err(to_pyvalue_err)?;
2274 let params = dict_to_params(py, params)?;
2275 DataActor::unsubscribe_instrument(self.inner_mut(), instrument_id, client_id, params);
2276 Ok(())
2277 }
2278
2279 #[pyo3(name = "unsubscribe_book_deltas")]
2280 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
2281 fn py_unsubscribe_book_deltas(
2282 &mut self,
2283 py: Python<'_>,
2284 #[gen_stub(override_type(
2285 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2286 ))]
2287 instrument_id: &Bound<'_, PyAny>,
2288 client_id: Option<ClientId>,
2289 params: Option<Py<PyDict>>,
2290 ) -> PyResult<()> {
2291 self.ensure_registered()?;
2292 let instrument_id = extract_instrument_ids(instrument_id)?;
2293 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
2294 .map_err(to_pyvalue_err)?;
2295 let params = dict_to_params(py, params)?;
2296 DataActor::unsubscribe_book_deltas(self.inner_mut(), instrument_id, client_id, params);
2297 Ok(())
2298 }
2299
2300 #[pyo3(name = "unsubscribe_book_depth")]
2301 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
2302 fn py_unsubscribe_book_depth(
2303 &mut self,
2304 py: Python<'_>,
2305 #[gen_stub(override_type(
2306 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2307 ))]
2308 instrument_id: &Bound<'_, PyAny>,
2309 client_id: Option<ClientId>,
2310 params: Option<Py<PyDict>>,
2311 ) -> PyResult<()> {
2312 self.ensure_registered()?;
2313 let instrument_id = extract_instrument_ids(instrument_id)?;
2314 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
2315 .map_err(to_pyvalue_err)?;
2316 let params = dict_to_params(py, params)?;
2317 DataActor::unsubscribe_book_depth(self.inner_mut(), instrument_id, client_id, params);
2318 Ok(())
2319 }
2320
2321 #[pyo3(name = "unsubscribe_book_at_interval")]
2322 #[pyo3(signature = (instrument_id, interval_ms, client_id=None, params=None))]
2323 fn py_unsubscribe_book_at_interval(
2324 &mut self,
2325 py: Python<'_>,
2326 #[gen_stub(override_type(
2327 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2328 ))]
2329 instrument_id: &Bound<'_, PyAny>,
2330 interval_ms: usize,
2331 client_id: Option<ClientId>,
2332 params: Option<Py<PyDict>>,
2333 ) -> PyResult<()> {
2334 let interval_ms = NonZeroUsize::new(interval_ms)
2335 .ok_or_else(|| to_pyvalue_err("interval_ms must be > 0"))?;
2336
2337 self.ensure_registered()?;
2338 let instrument_id = extract_instrument_ids(instrument_id)?;
2339 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
2340 .map_err(to_pyvalue_err)?;
2341 let params = dict_to_params(py, params)?;
2342 DataActor::unsubscribe_book_at_interval(
2343 self.inner_mut(),
2344 instrument_id,
2345 interval_ms,
2346 client_id,
2347 params,
2348 );
2349 Ok(())
2350 }
2351
2352 #[pyo3(name = "unsubscribe_quotes")]
2353 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
2354 fn py_unsubscribe_quotes(
2355 &mut self,
2356 py: Python<'_>,
2357 #[gen_stub(override_type(
2358 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2359 ))]
2360 instrument_id: &Bound<'_, PyAny>,
2361 client_id: Option<ClientId>,
2362 params: Option<Py<PyDict>>,
2363 ) -> PyResult<()> {
2364 self.ensure_registered()?;
2365 let instrument_ids = extract_instrument_ids(instrument_id)?;
2366 ensure_routable_instrument_ids(&instrument_ids, client_id.is_some())
2367 .map_err(to_pyvalue_err)?;
2368 let params = dict_to_params(py, params)?;
2369 DataActor::unsubscribe_quotes(self.inner_mut(), instrument_ids, client_id, params);
2370 Ok(())
2371 }
2372
2373 #[pyo3(name = "unsubscribe_trades")]
2374 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
2375 fn py_unsubscribe_trades(
2376 &mut self,
2377 py: Python<'_>,
2378 #[gen_stub(override_type(
2379 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2380 ))]
2381 instrument_id: &Bound<'_, PyAny>,
2382 client_id: Option<ClientId>,
2383 params: Option<Py<PyDict>>,
2384 ) -> PyResult<()> {
2385 self.ensure_registered()?;
2386 let instrument_ids = extract_instrument_ids(instrument_id)?;
2387 ensure_routable_instrument_ids(&instrument_ids, client_id.is_some())
2388 .map_err(to_pyvalue_err)?;
2389 let params = dict_to_params(py, params)?;
2390 DataActor::unsubscribe_trades(self.inner_mut(), instrument_ids, client_id, params);
2391 Ok(())
2392 }
2393
2394 #[pyo3(name = "unsubscribe_bars")]
2395 #[pyo3(signature = (bar_type, client_id=None, params=None))]
2396 fn py_unsubscribe_bars(
2397 &mut self,
2398 py: Python<'_>,
2399 #[gen_stub(override_type(type_repr = "model.BarType | typing.Sequence[model.BarType]"))]
2400 bar_type: &Bound<'_, PyAny>,
2401 client_id: Option<ClientId>,
2402 params: Option<Py<PyDict>>,
2403 ) -> PyResult<()> {
2404 self.ensure_registered()?;
2405 let bar_types = extract_bar_types(bar_type)?;
2406 ensure_routable_bar_types(&bar_types, client_id.is_some()).map_err(to_pyvalue_err)?;
2407 let params = dict_to_params(py, params)?;
2408 DataActor::unsubscribe_bars(self.inner_mut(), bar_types, client_id, params);
2409 Ok(())
2410 }
2411
2412 #[pyo3(name = "unsubscribe_mark_prices")]
2413 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
2414 fn py_unsubscribe_mark_prices(
2415 &mut self,
2416 py: Python<'_>,
2417 #[gen_stub(override_type(
2418 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2419 ))]
2420 instrument_id: &Bound<'_, PyAny>,
2421 client_id: Option<ClientId>,
2422 params: Option<Py<PyDict>>,
2423 ) -> PyResult<()> {
2424 self.ensure_registered()?;
2425 let instrument_id = extract_instrument_ids(instrument_id)?;
2426 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
2427 .map_err(to_pyvalue_err)?;
2428 let params = dict_to_params(py, params)?;
2429 DataActor::unsubscribe_mark_prices(self.inner_mut(), instrument_id, client_id, params);
2430 Ok(())
2431 }
2432
2433 #[pyo3(name = "unsubscribe_index_prices")]
2434 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
2435 fn py_unsubscribe_index_prices(
2436 &mut self,
2437 py: Python<'_>,
2438 #[gen_stub(override_type(
2439 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2440 ))]
2441 instrument_id: &Bound<'_, PyAny>,
2442 client_id: Option<ClientId>,
2443 params: Option<Py<PyDict>>,
2444 ) -> PyResult<()> {
2445 self.ensure_registered()?;
2446 let instrument_id = extract_instrument_ids(instrument_id)?;
2447 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
2448 .map_err(to_pyvalue_err)?;
2449 let params = dict_to_params(py, params)?;
2450 DataActor::unsubscribe_index_prices(self.inner_mut(), instrument_id, client_id, params);
2451 Ok(())
2452 }
2453
2454 #[pyo3(name = "unsubscribe_funding_rates")]
2455 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
2456 fn py_unsubscribe_funding_rates(
2457 &mut self,
2458 py: Python<'_>,
2459 #[gen_stub(override_type(
2460 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2461 ))]
2462 instrument_id: &Bound<'_, PyAny>,
2463 client_id: Option<ClientId>,
2464 params: Option<Py<PyDict>>,
2465 ) -> PyResult<()> {
2466 self.ensure_registered()?;
2467 let instrument_id = extract_instrument_ids(instrument_id)?;
2468 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
2469 .map_err(to_pyvalue_err)?;
2470 let params = dict_to_params(py, params)?;
2471 DataActor::unsubscribe_funding_rates(self.inner_mut(), instrument_id, client_id, params);
2472 Ok(())
2473 }
2474
2475 #[pyo3(name = "unsubscribe_option_greeks")]
2476 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
2477 fn py_unsubscribe_option_greeks(
2478 &mut self,
2479 py: Python<'_>,
2480 #[gen_stub(override_type(
2481 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2482 ))]
2483 instrument_id: &Bound<'_, PyAny>,
2484 client_id: Option<ClientId>,
2485 params: Option<Py<PyDict>>,
2486 ) -> PyResult<()> {
2487 self.ensure_registered()?;
2488 let instrument_id = extract_instrument_ids(instrument_id)?;
2489 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
2490 .map_err(to_pyvalue_err)?;
2491 let params = dict_to_params(py, params)?;
2492 DataActor::unsubscribe_option_greeks(self.inner_mut(), instrument_id, client_id, params);
2493 Ok(())
2494 }
2495
2496 #[pyo3(name = "unsubscribe_instrument_status")]
2497 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
2498 fn py_unsubscribe_instrument_status(
2499 &mut self,
2500 py: Python<'_>,
2501 #[gen_stub(override_type(
2502 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2503 ))]
2504 instrument_id: &Bound<'_, PyAny>,
2505 client_id: Option<ClientId>,
2506 params: Option<Py<PyDict>>,
2507 ) -> PyResult<()> {
2508 self.ensure_registered()?;
2509 let instrument_id = extract_instrument_ids(instrument_id)?;
2510 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
2511 .map_err(to_pyvalue_err)?;
2512 let params = dict_to_params(py, params)?;
2513 DataActor::unsubscribe_instrument_status(
2514 self.inner_mut(),
2515 instrument_id,
2516 client_id,
2517 params,
2518 );
2519 Ok(())
2520 }
2521
2522 #[pyo3(name = "unsubscribe_instrument_close")]
2523 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
2524 fn py_unsubscribe_instrument_close(
2525 &mut self,
2526 py: Python<'_>,
2527 #[gen_stub(override_type(
2528 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2529 ))]
2530 instrument_id: &Bound<'_, PyAny>,
2531 client_id: Option<ClientId>,
2532 params: Option<Py<PyDict>>,
2533 ) -> PyResult<()> {
2534 self.ensure_registered()?;
2535 let instrument_id = extract_instrument_ids(instrument_id)?;
2536 ensure_routable_instrument_ids(&instrument_id, client_id.is_some())
2537 .map_err(to_pyvalue_err)?;
2538 let params = dict_to_params(py, params)?;
2539 DataActor::unsubscribe_instrument_close(self.inner_mut(), instrument_id, client_id, params);
2540 Ok(())
2541 }
2542
2543 #[pyo3(name = "unsubscribe_option_chain")]
2544 #[pyo3(signature = (series_id, client_id=None))]
2545 fn py_unsubscribe_option_chain(
2546 &mut self,
2547 series_id: OptionSeriesId,
2548 client_id: Option<ClientId>,
2549 ) -> PyResult<()> {
2550 self.ensure_registered()?;
2551 DataActor::unsubscribe_option_chain(self.inner_mut(), series_id, client_id);
2552 Ok(())
2553 }
2554
2555 #[pyo3(name = "request_data")]
2556 #[pyo3(signature = (data_type, client_id, start=None, end=None, limit=None, params=None, callback=None))]
2557 #[expect(clippy::too_many_arguments)]
2558 fn py_request_data(
2559 slf: &Bound<'_, Self>,
2560 py: Python<'_>,
2561 data_type: DataType,
2562 client_id: ClientId,
2563 start: Option<Timestamp>,
2564 end: Option<Timestamp>,
2565 limit: Option<usize>,
2566 params: Option<Py<PyDict>>,
2567 #[gen_stub(override_type(type_repr = "typing.Callable[[str], None] | None"))]
2568 callback: Option<Py<PyAny>>,
2569 ) -> PyResult<String> {
2570 let actor = Self {
2571 inner: Rc::clone(&slf.try_borrow()?.inner),
2572 };
2573
2574 actor.ensure_registered_for_data()?;
2575 let params = dict_to_params(py, params)?;
2576 let limit = limit.and_then(NonZeroUsize::new);
2577 let handler = crate::python::response::request_handler(
2578 py,
2579 actor.inner().core().actor_id().inner(),
2580 PyDataActorInner::python_instance,
2581 callback,
2582 )?;
2583 let request_id = DataActorCore::request_data(
2584 actor.inner().core(),
2585 data_type,
2586 client_id,
2587 start,
2588 end,
2589 limit,
2590 params,
2591 handler,
2592 )
2593 .map_err(to_pyvalue_err)?;
2594 Ok(request_id.to_string())
2595 }
2596
2597 #[pyo3(name = "request_instrument")]
2598 #[pyo3(signature = (instrument_id, start=None, end=None, client_id=None, params=None, callback=None))]
2599 #[expect(clippy::too_many_arguments)]
2600 fn py_request_instrument(
2601 slf: &Bound<'_, Self>,
2602 py: Python<'_>,
2603 #[gen_stub(override_type(
2604 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2605 ))]
2606 instrument_id: &Bound<'_, PyAny>,
2607 start: Option<Timestamp>,
2608 end: Option<Timestamp>,
2609 client_id: Option<ClientId>,
2610 params: Option<Py<PyDict>>,
2611 #[gen_stub(override_type(type_repr = "typing.Callable[[str], None] | None"))]
2612 callback: Option<Py<PyAny>>,
2613 ) -> PyResult<String> {
2614 let actor = Self {
2615 inner: Rc::clone(&slf.try_borrow()?.inner),
2616 };
2617
2618 let instrument_id = extract_instrument_ids(instrument_id)?;
2619 actor.ensure_registered_for_data()?;
2620 let params = dict_to_params(py, params)?;
2621 let handler = crate::python::response::request_handler(
2622 py,
2623 actor.inner().core().actor_id().inner(),
2624 PyDataActorInner::python_instance,
2625 callback,
2626 )?;
2627 let request_id = DataActorCore::request_instrument(
2628 actor.inner().core(),
2629 instrument_id,
2630 start,
2631 end,
2632 client_id,
2633 params,
2634 handler,
2635 )
2636 .map_err(to_pyvalue_err)?;
2637 Ok(request_id.to_string())
2638 }
2639
2640 #[pyo3(name = "request_instruments")]
2641 #[pyo3(signature = (venue=None, start=None, end=None, client_id=None, params=None, callback=None))]
2642 #[expect(clippy::too_many_arguments)]
2643 fn py_request_instruments(
2644 slf: &Bound<'_, Self>,
2645 py: Python<'_>,
2646 venue: Option<Venue>,
2647 start: Option<Timestamp>,
2648 end: Option<Timestamp>,
2649 client_id: Option<ClientId>,
2650 params: Option<Py<PyDict>>,
2651 #[gen_stub(override_type(type_repr = "typing.Callable[[str], None] | None"))]
2652 callback: Option<Py<PyAny>>,
2653 ) -> PyResult<String> {
2654 let actor = Self {
2655 inner: Rc::clone(&slf.try_borrow()?.inner),
2656 };
2657
2658 actor.ensure_registered_for_data()?;
2659 let params = dict_to_params(py, params)?;
2660 let handler = crate::python::response::request_handler(
2661 py,
2662 actor.inner().core().actor_id().inner(),
2663 PyDataActorInner::python_instance,
2664 callback,
2665 )?;
2666 let request_id = DataActorCore::request_instruments(
2667 actor.inner().core(),
2668 venue,
2669 start,
2670 end,
2671 client_id,
2672 params,
2673 handler,
2674 )
2675 .map_err(to_pyvalue_err)?;
2676 Ok(request_id.to_string())
2677 }
2678
2679 #[pyo3(name = "request_book_snapshot")]
2680 #[pyo3(signature = (instrument_id, depth=None, client_id=None, params=None, callback=None))]
2681 fn py_request_book_snapshot(
2682 slf: &Bound<'_, Self>,
2683 py: Python<'_>,
2684 #[gen_stub(override_type(
2685 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2686 ))]
2687 instrument_id: &Bound<'_, PyAny>,
2688 depth: Option<usize>,
2689 client_id: Option<ClientId>,
2690 params: Option<Py<PyDict>>,
2691 #[gen_stub(override_type(type_repr = "typing.Callable[[str], None] | None"))]
2692 callback: Option<Py<PyAny>>,
2693 ) -> PyResult<String> {
2694 let actor = Self {
2695 inner: Rc::clone(&slf.try_borrow()?.inner),
2696 };
2697
2698 let instrument_id = extract_instrument_ids(instrument_id)?;
2699 actor.ensure_registered_for_data()?;
2700 let params = dict_to_params(py, params)?;
2701 let depth = depth.and_then(NonZeroUsize::new);
2702
2703 let handler = crate::python::response::request_handler(
2704 py,
2705 actor.inner().core().actor_id().inner(),
2706 PyDataActorInner::python_instance,
2707 callback,
2708 )?;
2709 let request_id = DataActorCore::request_book_snapshot(
2710 actor.inner().core(),
2711 instrument_id,
2712 depth,
2713 client_id,
2714 params,
2715 handler,
2716 )
2717 .map_err(to_pyvalue_err)?;
2718 Ok(request_id.to_string())
2719 }
2720
2721 #[pyo3(name = "request_book_deltas")]
2722 #[pyo3(signature = (instrument_id, start=None, end=None, limit=None, client_id=None, params=None, callback=None))]
2723 #[expect(clippy::too_many_arguments)]
2724 fn py_request_book_deltas(
2725 slf: &Bound<'_, Self>,
2726 py: Python<'_>,
2727 #[gen_stub(override_type(
2728 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2729 ))]
2730 instrument_id: &Bound<'_, PyAny>,
2731 start: Option<Timestamp>,
2732 end: Option<Timestamp>,
2733 limit: Option<usize>,
2734 client_id: Option<ClientId>,
2735 params: Option<Py<PyDict>>,
2736 #[gen_stub(override_type(type_repr = "typing.Callable[[str], None] | None"))]
2737 callback: Option<Py<PyAny>>,
2738 ) -> PyResult<String> {
2739 let actor = Self {
2740 inner: Rc::clone(&slf.try_borrow()?.inner),
2741 };
2742
2743 let instrument_id = extract_instrument_ids(instrument_id)?;
2744 actor.ensure_registered_for_data()?;
2745 let params = dict_to_params(py, params)?;
2746 let limit = limit.and_then(NonZeroUsize::new);
2747 let handler = crate::python::response::request_handler(
2748 py,
2749 actor.inner().core().actor_id().inner(),
2750 PyDataActorInner::python_instance,
2751 callback,
2752 )?;
2753 let request_id = DataActorCore::request_book_deltas(
2754 actor.inner().core(),
2755 instrument_id,
2756 start,
2757 end,
2758 limit,
2759 client_id,
2760 params,
2761 handler,
2762 )
2763 .map_err(to_pyvalue_err)?;
2764 Ok(request_id.to_string())
2765 }
2766
2767 #[pyo3(name = "request_book_depth")]
2768 #[pyo3(signature = (instrument_id, start=None, end=None, limit=None, depth=None, client_id=None, params=None, callback=None))]
2769 #[expect(clippy::too_many_arguments)]
2770 fn py_request_book_depth(
2771 slf: &Bound<'_, Self>,
2772 py: Python<'_>,
2773 #[gen_stub(override_type(
2774 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2775 ))]
2776 instrument_id: &Bound<'_, PyAny>,
2777 start: Option<Timestamp>,
2778 end: Option<Timestamp>,
2779 limit: Option<usize>,
2780 depth: Option<usize>,
2781 client_id: Option<ClientId>,
2782 params: Option<Py<PyDict>>,
2783 #[gen_stub(override_type(type_repr = "typing.Callable[[str], None] | None"))]
2784 callback: Option<Py<PyAny>>,
2785 ) -> PyResult<String> {
2786 let actor = Self {
2787 inner: Rc::clone(&slf.try_borrow()?.inner),
2788 };
2789
2790 let instrument_id = extract_instrument_ids(instrument_id)?;
2791 actor.ensure_registered_for_data()?;
2792 let params = dict_to_params(py, params)?;
2793 let limit = limit.and_then(NonZeroUsize::new);
2794 let depth = depth.and_then(NonZeroUsize::new);
2795 let handler = crate::python::response::request_handler(
2796 py,
2797 actor.inner().core().actor_id().inner(),
2798 PyDataActorInner::python_instance,
2799 callback,
2800 )?;
2801 let request_id = DataActorCore::request_book_depth(
2802 actor.inner().core(),
2803 instrument_id,
2804 start,
2805 end,
2806 limit,
2807 depth,
2808 client_id,
2809 params,
2810 handler,
2811 )
2812 .map_err(to_pyvalue_err)?;
2813 Ok(request_id.to_string())
2814 }
2815
2816 #[pyo3(name = "request_quotes")]
2817 #[pyo3(signature = (instrument_id, start=None, end=None, limit=None, client_id=None, params=None, callback=None))]
2818 #[expect(clippy::too_many_arguments)]
2819 fn py_request_quotes(
2820 slf: &Bound<'_, Self>,
2821 py: Python<'_>,
2822 #[gen_stub(override_type(
2823 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2824 ))]
2825 instrument_id: &Bound<'_, PyAny>,
2826 start: Option<Timestamp>,
2827 end: Option<Timestamp>,
2828 limit: Option<usize>,
2829 client_id: Option<ClientId>,
2830 params: Option<Py<PyDict>>,
2831 #[gen_stub(override_type(type_repr = "typing.Callable[[str], None] | None"))]
2832 callback: Option<Py<PyAny>>,
2833 ) -> PyResult<String> {
2834 let actor = Self {
2835 inner: Rc::clone(&slf.try_borrow()?.inner),
2836 };
2837
2838 let instrument_id = extract_instrument_ids(instrument_id)?;
2839 actor.ensure_registered_for_data()?;
2840 let params = dict_to_params(py, params)?;
2841 let limit = limit.and_then(NonZeroUsize::new);
2842 let handler = crate::python::response::request_handler(
2843 py,
2844 actor.inner().core().actor_id().inner(),
2845 PyDataActorInner::python_instance,
2846 callback,
2847 )?;
2848 let request_id = DataActorCore::request_quotes(
2849 actor.inner().core(),
2850 instrument_id,
2851 start,
2852 end,
2853 limit,
2854 client_id,
2855 params,
2856 handler,
2857 )
2858 .map_err(to_pyvalue_err)?;
2859 Ok(request_id.to_string())
2860 }
2861
2862 #[pyo3(name = "request_trades")]
2863 #[pyo3(signature = (instrument_id, start=None, end=None, limit=None, client_id=None, params=None, callback=None))]
2864 #[expect(clippy::too_many_arguments)]
2865 fn py_request_trades(
2866 slf: &Bound<'_, Self>,
2867 py: Python<'_>,
2868 #[gen_stub(override_type(
2869 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2870 ))]
2871 instrument_id: &Bound<'_, PyAny>,
2872 start: Option<Timestamp>,
2873 end: Option<Timestamp>,
2874 limit: Option<usize>,
2875 client_id: Option<ClientId>,
2876 params: Option<Py<PyDict>>,
2877 #[gen_stub(override_type(type_repr = "typing.Callable[[str], None] | None"))]
2878 callback: Option<Py<PyAny>>,
2879 ) -> PyResult<String> {
2880 let actor = Self {
2881 inner: Rc::clone(&slf.try_borrow()?.inner),
2882 };
2883
2884 let instrument_id = extract_instrument_ids(instrument_id)?;
2885 actor.ensure_registered_for_data()?;
2886 let params = dict_to_params(py, params)?;
2887 let limit = limit.and_then(NonZeroUsize::new);
2888 let handler = crate::python::response::request_handler(
2889 py,
2890 actor.inner().core().actor_id().inner(),
2891 PyDataActorInner::python_instance,
2892 callback,
2893 )?;
2894 let request_id = DataActorCore::request_trades(
2895 actor.inner().core(),
2896 instrument_id,
2897 start,
2898 end,
2899 limit,
2900 client_id,
2901 params,
2902 handler,
2903 )
2904 .map_err(to_pyvalue_err)?;
2905 Ok(request_id.to_string())
2906 }
2907
2908 #[pyo3(name = "request_funding_rates")]
2909 #[pyo3(signature = (instrument_id, start=None, end=None, limit=None, client_id=None, params=None, callback=None))]
2910 #[expect(clippy::too_many_arguments)]
2911 fn py_request_funding_rates(
2912 slf: &Bound<'_, Self>,
2913 py: Python<'_>,
2914 #[gen_stub(override_type(
2915 type_repr = "model.InstrumentId | typing.Sequence[model.InstrumentId]"
2916 ))]
2917 instrument_id: &Bound<'_, PyAny>,
2918 start: Option<Timestamp>,
2919 end: Option<Timestamp>,
2920 limit: Option<usize>,
2921 client_id: Option<ClientId>,
2922 params: Option<Py<PyDict>>,
2923 #[gen_stub(override_type(type_repr = "typing.Callable[[str], None] | None"))]
2924 callback: Option<Py<PyAny>>,
2925 ) -> PyResult<String> {
2926 let actor = Self {
2927 inner: Rc::clone(&slf.try_borrow()?.inner),
2928 };
2929
2930 let instrument_id = extract_instrument_ids(instrument_id)?;
2931 actor.ensure_registered_for_data()?;
2932 let params = dict_to_params(py, params)?;
2933 let limit = limit.and_then(NonZeroUsize::new);
2934 let handler = crate::python::response::request_handler(
2935 py,
2936 actor.inner().core().actor_id().inner(),
2937 PyDataActorInner::python_instance,
2938 callback,
2939 )?;
2940 let request_id = DataActorCore::request_funding_rates(
2941 actor.inner().core(),
2942 instrument_id,
2943 start,
2944 end,
2945 limit,
2946 client_id,
2947 params,
2948 handler,
2949 )
2950 .map_err(to_pyvalue_err)?;
2951 Ok(request_id.to_string())
2952 }
2953
2954 #[pyo3(name = "request_bars")]
2955 #[pyo3(signature = (bar_type, start=None, end=None, limit=None, client_id=None, params=None, callback=None))]
2956 #[expect(clippy::too_many_arguments)]
2957 fn py_request_bars(
2958 slf: &Bound<'_, Self>,
2959 py: Python<'_>,
2960 #[gen_stub(override_type(type_repr = "model.BarType | typing.Sequence[model.BarType]"))]
2961 bar_type: &Bound<'_, PyAny>,
2962 start: Option<Timestamp>,
2963 end: Option<Timestamp>,
2964 limit: Option<usize>,
2965 client_id: Option<ClientId>,
2966 params: Option<Py<PyDict>>,
2967 #[gen_stub(override_type(type_repr = "typing.Callable[[str], None] | None"))]
2968 callback: Option<Py<PyAny>>,
2969 ) -> PyResult<String> {
2970 let actor = Self {
2971 inner: Rc::clone(&slf.try_borrow()?.inner),
2972 };
2973
2974 let bar_type = extract_bar_types(bar_type)?;
2975 actor.ensure_registered_for_data()?;
2976 let params = dict_to_params(py, params)?;
2977 let limit = limit.and_then(NonZeroUsize::new);
2978 let handler = crate::python::response::request_handler(
2979 py,
2980 actor.inner().core().actor_id().inner(),
2981 PyDataActorInner::python_instance,
2982 callback,
2983 )?;
2984 let request_id = DataActorCore::request_bars(
2985 actor.inner().core(),
2986 bar_type,
2987 start,
2988 end,
2989 limit,
2990 client_id,
2991 params,
2992 handler,
2993 )
2994 .map_err(to_pyvalue_err)?;
2995 Ok(request_id.to_string())
2996 }
2997
2998 #[pyo3(name = "request_join", signature = (request_ids, callback=None, request_id=None))]
2999 fn py_request_join(
3000 slf: &Bound<'_, Self>,
3001 py: Python<'_>,
3002 #[gen_stub(override_type(type_repr = "typing.Sequence[str | core.UUID4]", imports = ("typing", "nautilus_trader.core")))]
3003 request_ids: Vec<Bound<'_, PyAny>>,
3004 #[gen_stub(override_type(type_repr = "typing.Callable[[str], None] | None"))]
3005 callback: Option<Py<PyAny>>,
3006 #[gen_stub(override_type(type_repr = "str | core.UUID4 | None", imports = ("nautilus_trader.core",)))]
3007 request_id: Option<&Bound<'_, PyAny>>,
3008 ) -> PyResult<String> {
3009 let actor_id = {
3010 let actor = slf.try_borrow()?;
3011 actor.ensure_registered_for_data()?;
3012 actor.inner().core().actor_id().inner()
3013 };
3014
3015 let request_ids = request_ids
3016 .into_iter()
3017 .map(|id| crate::python::response::extract_request_id(&id))
3018 .collect::<PyResult<Vec<_>>>()?;
3019 let request_id = request_id
3020 .map(crate::python::response::extract_request_id)
3021 .transpose()?;
3022 crate::python::response::request_join::<PyDataActorInner>(
3023 py,
3024 actor_id,
3025 PyDataActorInner::python_instance,
3026 request_ids,
3027 request_id,
3028 callback,
3029 )
3030 }
3031
3032 #[pyo3(name = "is_pending_request")]
3033 fn py_is_pending_request(
3034 &self,
3035 #[gen_stub(override_type(type_repr = "str | core.UUID4", imports = ("nautilus_trader.core",)))]
3036 request_id: &Bound<'_, PyAny>,
3037 ) -> PyResult<bool> {
3038 let id = crate::python::response::extract_request_id(request_id)?;
3039 Ok(self.inner().core().is_pending_request(&id))
3040 }
3041
3042 #[pyo3(name = "has_pending_requests")]
3043 fn py_has_pending_requests(&self) -> bool {
3044 !self.inner().core().pending_requests().is_empty()
3045 }
3046
3047 #[pyo3(name = "pending_requests")]
3048 #[gen_stub(override_return_type(type_repr = "set[str]"))]
3049 fn py_pending_requests(&self, py: Python<'_>) -> PyResult<Py<PySet>> {
3050 let ids = self.inner().core().pending_requests();
3051 PySet::new(py, ids.iter().map(ToString::to_string)).map(Bound::unbind)
3052 }
3053
3054 #[pyo3(name = "reconnect_socket")]
3056 fn py_reconnect_socket(&self, client_id: ClientId, endpoint: &str) -> PyResult<()> {
3057 DataActor::reconnect_socket(self.inner(), client_id, endpoint).map_err(to_pyruntime_err)
3058 }
3059
3060 #[allow(unused_variables, clippy::needless_pass_by_value)]
3061 #[pyo3(name = "on_data_response")]
3062 fn py_on_data_response(_slf: &Bound<'_, Self>, response: Py<PyDataResponse>) {}
3063
3064 #[allow(unused_variables, clippy::needless_pass_by_value)]
3065 #[pyo3(name = "on_historical_data")]
3066 fn py_on_historical_data(_slf: &Bound<'_, Self>, data: Py<PyAny>) {
3067 }
3069
3070 #[allow(unused_variables, clippy::needless_pass_by_value)]
3071 #[pyo3(name = "on_historical_book_deltas")]
3072 fn py_on_historical_book_deltas(_slf: &Bound<'_, Self>, deltas: Vec<OrderBookDelta>) {}
3073
3074 #[allow(unused_variables, clippy::needless_pass_by_value)]
3075 #[pyo3(name = "on_historical_book_depth")]
3076 fn py_on_historical_book_depth(_slf: &Bound<'_, Self>, depths: Vec<OrderBookDepth>) {}
3077
3078 #[allow(unused_variables, clippy::needless_pass_by_value)]
3079 #[pyo3(name = "on_historical_quotes")]
3080 fn py_on_historical_quotes(_slf: &Bound<'_, Self>, quotes: Vec<QuoteTick>) {
3081 }
3083
3084 #[allow(unused_variables, clippy::needless_pass_by_value)]
3085 #[pyo3(name = "on_historical_trades")]
3086 fn py_on_historical_trades(_slf: &Bound<'_, Self>, trades: Vec<TradeTick>) {
3087 }
3089
3090 #[allow(unused_variables, clippy::needless_pass_by_value)]
3091 #[pyo3(name = "on_historical_funding_rates")]
3092 fn py_on_historical_funding_rates(
3093 _slf: &Bound<'_, Self>,
3094 funding_rates: Vec<FundingRateUpdate>,
3095 ) {
3096 }
3098
3099 #[allow(unused_variables, clippy::needless_pass_by_value)]
3100 #[pyo3(name = "on_historical_bars")]
3101 fn py_on_historical_bars(_slf: &Bound<'_, Self>, bars: Vec<Bar>) {
3102 }
3104
3105 #[allow(unused_variables, clippy::needless_pass_by_value)]
3106 #[pyo3(name = "on_historical_mark_prices")]
3107 fn py_on_historical_mark_prices(_slf: &Bound<'_, Self>, mark_prices: Vec<MarkPriceUpdate>) {
3108 }
3110
3111 #[allow(unused_variables, clippy::needless_pass_by_value)]
3112 #[pyo3(name = "on_historical_index_prices")]
3113 fn py_on_historical_index_prices(_slf: &Bound<'_, Self>, index_prices: Vec<IndexPriceUpdate>) {
3114 }
3116}
3117
3118#[pyo3_stub_gen::derive::gen_stub_pymethods]
3119#[pyo3::pymethods]
3120impl PyDataActor {
3121 #[pyo3(name = "publish_message", signature = (topic, message))]
3122 fn py_publish_message(
3123 slf: &Bound<'_, Self>,
3124 topic: &str,
3125 #[gen_stub(override_type(type_repr = "object"))] message: Py<PyAny>,
3126 ) -> PyResult<()> {
3127 let messages = get_python_message_bus(slf.as_any())?;
3128 messages.publish_message(topic, message)
3129 }
3130
3131 #[pyo3(name = "subscribe_topic")]
3132 #[pyo3(signature = (topic, handler, priority=0))]
3133 fn py_subscribe_topic(
3134 slf: &Bound<'_, Self>,
3135 topic: &str,
3136 #[gen_stub(override_type(type_repr = "collections.abc.Callable[[object], None]", imports = ("collections.abc",)))]
3137 handler: Py<PyAny>,
3138 priority: u32,
3139 ) -> PyResult<()> {
3140 let messages = get_python_message_bus(slf.as_any())?;
3141 messages.subscribe_topic(slf.py(), topic, handler, priority)
3142 }
3143
3144 #[pyo3(name = "unsubscribe_topic", signature = (topic, handler))]
3145 fn py_unsubscribe_topic(
3146 slf: &Bound<'_, Self>,
3147 topic: &str,
3148 #[gen_stub(override_type(type_repr = "collections.abc.Callable[[object], None]", imports = ("collections.abc",)))]
3149 handler: &Bound<'_, PyAny>,
3150 ) -> PyResult<()> {
3151 let messages = get_python_message_bus(slf.as_any())?;
3152 messages.unsubscribe_topic(topic, handler)
3153 }
3154}
3155
3156#[cfg(feature = "defi")]
3157#[pymethods]
3158#[pyo3_stub_gen::derive::gen_stub_pymethods]
3159impl PyDataActor {
3160 #[pyo3(name = "on_block")]
3161 #[allow(unused_variables, clippy::needless_pass_by_value)]
3162 fn py_on_block(_slf: &Bound<'_, Self>, block: Block) {}
3163
3164 #[pyo3(name = "on_pool")]
3165 #[allow(unused_variables, clippy::needless_pass_by_value)]
3166 fn py_on_pool(_slf: &Bound<'_, Self>, pool: Pool) {}
3167
3168 #[pyo3(name = "on_pool_swap")]
3169 #[allow(unused_variables, clippy::needless_pass_by_value)]
3170 fn py_on_pool_swap(_slf: &Bound<'_, Self>, swap: PoolSwap) {}
3171
3172 #[pyo3(name = "on_pool_liquidity_update")]
3173 #[allow(unused_variables, clippy::needless_pass_by_value)]
3174 fn py_on_pool_liquidity_update(_slf: &Bound<'_, Self>, update: PoolLiquidityUpdate) {}
3175
3176 #[pyo3(name = "on_pool_fee_collect")]
3177 #[allow(unused_variables, clippy::needless_pass_by_value)]
3178 fn py_on_pool_fee_collect(_slf: &Bound<'_, Self>, update: PoolFeeCollect) {}
3179
3180 #[pyo3(name = "on_pool_flash")]
3181 #[allow(unused_variables, clippy::needless_pass_by_value)]
3182 fn py_on_pool_flash(_slf: &Bound<'_, Self>, flash: PoolFlash) {}
3183
3184 #[pyo3(name = "subscribe_blocks")]
3185 #[pyo3(signature = (chain, client_id=None, params=None))]
3186 fn py_subscribe_blocks(
3187 &mut self,
3188 py: Python<'_>,
3189 chain: Blockchain,
3190 client_id: Option<ClientId>,
3191 params: Option<Py<PyDict>>,
3192 ) -> PyResult<()> {
3193 self.ensure_registered()?;
3194 let params = dict_to_params(py, params)?;
3195 DataActor::subscribe_blocks(self.inner_mut(), chain, client_id, params);
3196 Ok(())
3197 }
3198
3199 #[pyo3(name = "subscribe_pool")]
3200 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
3201 fn py_subscribe_pool(
3202 &mut self,
3203 py: Python<'_>,
3204 instrument_id: InstrumentId,
3205 client_id: Option<ClientId>,
3206 params: Option<Py<PyDict>>,
3207 ) -> PyResult<()> {
3208 self.ensure_registered()?;
3209 let params = dict_to_params(py, params)?;
3210 DataActor::subscribe_pool(self.inner_mut(), instrument_id, client_id, params);
3211 Ok(())
3212 }
3213
3214 #[pyo3(name = "subscribe_pool_swaps")]
3215 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
3216 fn py_subscribe_pool_swaps(
3217 &mut self,
3218 py: Python<'_>,
3219 instrument_id: InstrumentId,
3220 client_id: Option<ClientId>,
3221 params: Option<Py<PyDict>>,
3222 ) -> PyResult<()> {
3223 self.ensure_registered()?;
3224 let params = dict_to_params(py, params)?;
3225 DataActor::subscribe_pool_swaps(self.inner_mut(), instrument_id, client_id, params);
3226 Ok(())
3227 }
3228
3229 #[pyo3(name = "subscribe_pool_liquidity_updates")]
3230 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
3231 fn py_subscribe_pool_liquidity_updates(
3232 &mut self,
3233 py: Python<'_>,
3234 instrument_id: InstrumentId,
3235 client_id: Option<ClientId>,
3236 params: Option<Py<PyDict>>,
3237 ) -> PyResult<()> {
3238 self.ensure_registered()?;
3239 let params = dict_to_params(py, params)?;
3240 DataActor::subscribe_pool_liquidity_updates(
3241 self.inner_mut(),
3242 instrument_id,
3243 client_id,
3244 params,
3245 );
3246 Ok(())
3247 }
3248
3249 #[pyo3(name = "subscribe_pool_fee_collects")]
3250 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
3251 fn py_subscribe_pool_fee_collects(
3252 &mut self,
3253 py: Python<'_>,
3254 instrument_id: InstrumentId,
3255 client_id: Option<ClientId>,
3256 params: Option<Py<PyDict>>,
3257 ) -> PyResult<()> {
3258 self.ensure_registered()?;
3259 let params = dict_to_params(py, params)?;
3260 DataActor::subscribe_pool_fee_collects(self.inner_mut(), instrument_id, client_id, params);
3261 Ok(())
3262 }
3263
3264 #[pyo3(name = "subscribe_pool_flash_events")]
3265 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
3266 fn py_subscribe_pool_flash_events(
3267 &mut self,
3268 py: Python<'_>,
3269 instrument_id: InstrumentId,
3270 client_id: Option<ClientId>,
3271 params: Option<Py<PyDict>>,
3272 ) -> PyResult<()> {
3273 self.ensure_registered()?;
3274 let params = dict_to_params(py, params)?;
3275 DataActor::subscribe_pool_flash_events(self.inner_mut(), instrument_id, client_id, params);
3276 Ok(())
3277 }
3278
3279 #[pyo3(name = "unsubscribe_blocks")]
3280 #[pyo3(signature = (chain, client_id=None, params=None))]
3281 fn py_unsubscribe_blocks(
3282 &mut self,
3283 py: Python<'_>,
3284 chain: Blockchain,
3285 client_id: Option<ClientId>,
3286 params: Option<Py<PyDict>>,
3287 ) -> PyResult<()> {
3288 self.ensure_registered()?;
3289 let params = dict_to_params(py, params)?;
3290 DataActor::unsubscribe_blocks(self.inner_mut(), chain, client_id, params);
3291 Ok(())
3292 }
3293
3294 #[pyo3(name = "unsubscribe_pool")]
3295 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
3296 fn py_unsubscribe_pool(
3297 &mut self,
3298 py: Python<'_>,
3299 instrument_id: InstrumentId,
3300 client_id: Option<ClientId>,
3301 params: Option<Py<PyDict>>,
3302 ) -> PyResult<()> {
3303 self.ensure_registered()?;
3304 let params = dict_to_params(py, params)?;
3305 DataActor::unsubscribe_pool(self.inner_mut(), instrument_id, client_id, params);
3306 Ok(())
3307 }
3308
3309 #[pyo3(name = "unsubscribe_pool_swaps")]
3310 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
3311 fn py_unsubscribe_pool_swaps(
3312 &mut self,
3313 py: Python<'_>,
3314 instrument_id: InstrumentId,
3315 client_id: Option<ClientId>,
3316 params: Option<Py<PyDict>>,
3317 ) -> PyResult<()> {
3318 self.ensure_registered()?;
3319 let params = dict_to_params(py, params)?;
3320 DataActor::unsubscribe_pool_swaps(self.inner_mut(), instrument_id, client_id, params);
3321 Ok(())
3322 }
3323
3324 #[pyo3(name = "unsubscribe_pool_liquidity_updates")]
3325 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
3326 fn py_unsubscribe_pool_liquidity_updates(
3327 &mut self,
3328 py: Python<'_>,
3329 instrument_id: InstrumentId,
3330 client_id: Option<ClientId>,
3331 params: Option<Py<PyDict>>,
3332 ) -> PyResult<()> {
3333 self.ensure_registered()?;
3334 let params = dict_to_params(py, params)?;
3335 DataActor::unsubscribe_pool_liquidity_updates(
3336 self.inner_mut(),
3337 instrument_id,
3338 client_id,
3339 params,
3340 );
3341 Ok(())
3342 }
3343
3344 #[pyo3(name = "unsubscribe_pool_fee_collects")]
3345 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
3346 fn py_unsubscribe_pool_fee_collects(
3347 &mut self,
3348 py: Python<'_>,
3349 instrument_id: InstrumentId,
3350 client_id: Option<ClientId>,
3351 params: Option<Py<PyDict>>,
3352 ) -> PyResult<()> {
3353 self.ensure_registered()?;
3354 let params = dict_to_params(py, params)?;
3355 DataActor::unsubscribe_pool_fee_collects(
3356 self.inner_mut(),
3357 instrument_id,
3358 client_id,
3359 params,
3360 );
3361 Ok(())
3362 }
3363
3364 #[pyo3(name = "unsubscribe_pool_flash_events")]
3365 #[pyo3(signature = (instrument_id, client_id=None, params=None))]
3366 fn py_unsubscribe_pool_flash_events(
3367 &mut self,
3368 py: Python<'_>,
3369 instrument_id: InstrumentId,
3370 client_id: Option<ClientId>,
3371 params: Option<Py<PyDict>>,
3372 ) -> PyResult<()> {
3373 self.ensure_registered()?;
3374 let params = dict_to_params(py, params)?;
3375 DataActor::unsubscribe_pool_flash_events(
3376 self.inner_mut(),
3377 instrument_id,
3378 client_id,
3379 params,
3380 );
3381 Ok(())
3382 }
3383}
3384
3385impl PyDataActor {
3386 fn ensure_registered_for_data(&self) -> PyResult<()> {
3387 if self.inner().core.is_registered() {
3388 Ok(())
3389 } else {
3390 Err(to_pyruntime_err(
3391 "DataActor must be registered before publishing, managing synthetics, or requesting data",
3392 ))
3393 }
3394 }
3395
3396 fn ensure_registered(&self) -> PyResult<()> {
3397 if self.inner().core.is_registered() {
3398 Ok(())
3399 } else {
3400 Err(to_pyruntime_err(
3401 "DataActor must be registered before managing subscriptions",
3402 ))
3403 }
3404 }
3405}
3406
3407pub fn prepare_python_actor(
3421 actor_obj: &Bound<'_, PyAny>,
3422 config: Option<&Bound<'_, PyAny>>,
3423) -> anyhow::Result<ActorId> {
3424 let mut actor = actor_obj
3425 .extract::<PyRefMut<PyDataActor>>()
3426 .map_err(Into::<PyErr>::into)
3427 .map_err(|e| anyhow::anyhow!("Failed to extract PyDataActor: {e}"))?;
3428
3429 if let Some(config) = config {
3430 if let Some(actor_id) = config
3431 .getattr("actor_id")
3432 .ok()
3433 .filter(|actor_id| !actor_id.is_none())
3434 {
3435 let actor_id = if let Ok(actor_id) = actor_id.extract::<ActorId>() {
3436 actor_id
3437 } else if let Ok(actor_id) = actor_id.extract::<String>() {
3438 ActorId::new_checked(&actor_id)?
3439 } else {
3440 anyhow::bail!("Invalid `actor_id` type");
3441 };
3442 actor.set_actor_id(actor_id);
3443 }
3444
3445 if let Some(log_events) = extract_bool_config_attr(config, "log_events") {
3446 actor.set_log_events(log_events);
3447 }
3448
3449 if let Some(log_commands) = extract_bool_config_attr(config, "log_commands") {
3450 actor.set_log_commands(log_commands);
3451 }
3452 }
3453
3454 actor.set_python_instance(actor_obj)?;
3455 apply_class_derived_actor_id(&mut actor, actor_obj)?;
3456 Ok(actor.actor_id())
3457}
3458
3459fn apply_class_derived_actor_id(
3460 actor: &mut PyRefMut<'_, PyDataActor>,
3461 actor_obj: &Bound<'_, PyAny>,
3462) -> PyResult<()> {
3463 if actor.inner().core.config.actor_id.is_some() {
3464 return Ok(());
3465 }
3466
3467 let py_type = actor_obj.get_type();
3468 let type_name = py_type.name()?;
3469 let actor_id = ActorId::new_checked(type_name.to_str()?).map_err(to_pyvalue_err)?;
3470 actor.set_actor_id(actor_id);
3471
3472 Ok(())
3473}
3474
3475fn extract_bool_config_attr(config: &Bound<'_, PyAny>, attr: &str) -> Option<bool> {
3476 config
3477 .getattr(attr)
3478 .ok()
3479 .and_then(|value| value.extract::<bool>().ok())
3480}
3481
3482fn borrow_actor_mut<'py>(
3483 actor: &Bound<'py, PyDataActor>,
3484 operation: &'static str,
3485) -> PyResult<PyRefMut<'py, PyDataActor>> {
3486 actor.try_borrow_mut().map_err(|_| {
3487 to_pyruntime_err(ComponentAccessError::WriteConflict {
3488 resource: "Python actor",
3489 operation,
3490 })
3491 })
3492}
3493
3494fn has_configured_actor_id(slf: &Bound<'_, PyDataActor>) -> bool {
3500 let py = slf.py();
3501 let config = slf
3502 .borrow()
3503 .inner()
3504 .config
3505 .as_ref()
3506 .map(|config| config.clone_ref(py));
3507
3508 config.is_some_and(|config| {
3509 config
3510 .bind(py)
3511 .getattr("actor_id")
3512 .is_ok_and(|actor_id| !actor_id.is_none())
3513 })
3514}
3515
3516pub fn extract_instrument_ids(value: &Bound<'_, PyAny>) -> PyResult<Vec<InstrumentId>> {
3526 let instrument_ids = if let Ok(instrument_id) = value.extract::<InstrumentId>() {
3527 vec![instrument_id]
3528 } else {
3529 value.extract::<Vec<InstrumentId>>().map_err(|_| {
3530 to_pytype_err("expected InstrumentId or a sequence of InstrumentId values")
3531 })?
3532 };
3533
3534 instrument_ids.into_instrument_ids().map_err(to_pyvalue_err)
3535}
3536
3537pub fn extract_bar_types(value: &Bound<'_, PyAny>) -> PyResult<Vec<BarType>> {
3545 let bar_types = if let Ok(bar_type) = value.extract::<BarType>() {
3546 vec![bar_type]
3547 } else {
3548 value
3549 .extract::<Vec<BarType>>()
3550 .map_err(|_| to_pytype_err("expected BarType or a sequence of BarType values"))?
3551 };
3552
3553 bar_types.into_bar_types().map_err(to_pyvalue_err)
3554}
3555
3556#[cfg(test)]
3557mod tests {
3558 use std::{cell::RefCell, collections::HashMap, rc::Rc, str::FromStr, sync::Arc};
3559
3560 #[cfg(feature = "defi")]
3561 use alloy_primitives::{I256, U160, U256};
3562 use indexmap::IndexMap;
3563 use nautilus_core::{UUID4, UnixNanos, python::IntoPyObjectNautilusExt};
3564 #[cfg(feature = "defi")]
3565 use nautilus_model::defi::{
3566 AmmType, Block, Blockchain, Chain, Dex, DexType, Pool, PoolFeeCollect, PoolFlash,
3567 PoolIdentifier, PoolLiquidityUpdate, PoolLiquidityUpdateType, PoolSwap, Token,
3568 };
3569 use nautilus_model::{
3570 data::{
3571 Bar, BarType, CustomData, DataType, FundingRateUpdate, IndexPriceUpdate,
3572 InstrumentStatus, MarkPriceUpdate, OrderBookDelta, OrderBookDeltas, OrderBookDepth,
3573 QuoteTick, TradeTick,
3574 close::InstrumentClose,
3575 greeks::OptionGreekValues,
3576 option_chain::{OptionChainSlice, OptionGreeks},
3577 stubs::{stub_custom_data, stub_deltas, stub_depth10},
3578 },
3579 enums::{
3580 AggressorSide, BookType, GreeksConvention, InstrumentCloseType, MarketStatusAction,
3581 },
3582 identifiers::{
3583 ActorId, ClientId, ComponentId, InstrumentId, OptionSeriesId, TradeId, TraderId, Venue,
3584 },
3585 instruments::{CurrencyPair, InstrumentAny, stubs::audusd_sim},
3586 orderbook::OrderBook,
3587 types::{Price, Quantity},
3588 };
3589 use pyo3::{
3590 Bound, IntoPyObjectExt, Py, PyAny, PyRef, PyResult, Python,
3591 ffi::c_str,
3592 types::{
3593 PyAnyMethods, PyBytes, PyDict, PyList, PyModule, PyTuple, PyWeakrefMethods,
3594 PyWeakrefReference,
3595 },
3596 };
3597 use rstest::{fixture, rstest};
3598 use ustr::Ustr;
3599
3600 use super::{PyDataActor, prepare_python_actor};
3601 use crate::{
3602 actor::{DataActor, data_actor::DataActorConfig, registry::actor_exists},
3603 cache::Cache,
3604 clock::VirtualClock,
3605 component::{Component, get_component},
3606 enums::ComponentState,
3607 live::runner::replace_system_command_sender,
3608 messages::{
3609 SystemCommand,
3610 data::{
3611 BarsResponse, CustomDataResponse, DataCommand, QuotesResponse, RequestCommand,
3612 TradesResponse,
3613 },
3614 system::{
3615 QueueCondition, QueueState, QueueStateChanged, SocketState, SocketStateChanged,
3616 },
3617 },
3618 msgbus::{
3619 self, MessageBus, MessagingSwitchboard, get_message_bus,
3620 stubs::get_typed_into_message_saving_handler,
3621 switchboard::{get_quotes_topic, get_trades_topic},
3622 },
3623 python::wrappers::get_python_wrapper,
3624 runner::{SyncDataCommandSender, SystemChannel, set_data_cmd_sender},
3625 signal::Signal,
3626 timer::TimeEvent,
3627 };
3628
3629 #[fixture]
3630 fn clock() -> Rc<RefCell<VirtualClock>> {
3631 Rc::new(RefCell::new(VirtualClock::new()))
3632 }
3633
3634 #[fixture]
3635 fn cache() -> Rc<RefCell<Cache>> {
3636 Rc::new(RefCell::new(Cache::new(None, None)))
3637 }
3638
3639 #[fixture]
3640 fn trader_id() -> TraderId {
3641 TraderId::from("TRADER-001")
3642 }
3643
3644 #[fixture]
3645 fn client_id() -> ClientId {
3646 ClientId::new("TestClient")
3647 }
3648
3649 #[fixture]
3650 fn venue() -> Venue {
3651 Venue::from("SIM")
3652 }
3653
3654 #[fixture]
3655 fn data_type() -> DataType {
3656 DataType::new("TestData", None, None)
3657 }
3658
3659 #[fixture]
3660 fn bar_type(audusd_sim: CurrencyPair) -> BarType {
3661 BarType::from_str(&format!("{}-1-MINUTE-LAST-INTERNAL", audusd_sim.id)).unwrap()
3662 }
3663
3664 fn create_unregistered_actor() -> PyDataActor {
3665 PyDataActor::new(None)
3666 }
3667
3668 fn create_registered_actor(
3669 clock: Rc<RefCell<VirtualClock>>,
3670 cache: Rc<RefCell<Cache>>,
3671 trader_id: TraderId,
3672 ) -> PyDataActor {
3673 let sender = SyncDataCommandSender;
3675 set_data_cmd_sender(Arc::new(sender));
3676
3677 let mut actor = PyDataActor::new(None);
3678 actor.register(trader_id, clock, cache).unwrap();
3679 actor
3680 }
3681
3682 #[rstest]
3683 fn test_python_identifier_lists_require_registration_before_validation(
3684 #[values(
3685 "subscribe_quotes",
3686 "unsubscribe_quotes",
3687 "subscribe_trades",
3688 "unsubscribe_trades"
3689 )]
3690 method: &str,
3691 #[values("empty", "invalid", "mixed_venues")] input: &str,
3692 ) {
3693 Python::initialize();
3694 Python::attach(|py| {
3695 let actor = create_unregistered_actor();
3696 let actor = Py::new(py, actor).unwrap();
3697 let argument = match input {
3698 "empty" => PyList::empty(py).into_any(),
3699 "invalid" => PyList::new(py, [42]).unwrap().into_any(),
3700 "mixed_venues" => PyList::new(
3701 py,
3702 [
3703 InstrumentId::from("BTC/USD.SIM"),
3704 InstrumentId::from("ETH/USD.OTHER"),
3705 ],
3706 )
3707 .unwrap()
3708 .into_any(),
3709 _ => unreachable!(),
3710 };
3711
3712 let error = actor
3713 .bind(py)
3714 .call_method1(method, (&argument,))
3715 .unwrap_err();
3716
3717 assert!(error.is_instance_of::<pyo3::exceptions::PyRuntimeError>(py));
3718 assert_eq!(
3719 error.value(py).to_string(),
3720 "DataActor must be registered before managing subscriptions"
3721 );
3722 });
3723 }
3724
3725 #[rstest]
3726 fn test_python_identifier_list_subscriptions(
3727 #[values(
3728 "instrument",
3729 "book_deltas",
3730 "book_depth",
3731 "book_at_interval",
3732 "quotes",
3733 "trades",
3734 "mark_prices",
3735 "index_prices",
3736 "funding_rates",
3737 "instrument_status",
3738 "instrument_close",
3739 "option_greeks"
3740 )]
3741 family: &str,
3742 #[values("single", "list", "tuple")] input: &str,
3743 #[values(false, true)] keyword: bool,
3744 clock: Rc<RefCell<VirtualClock>>,
3745 cache: Rc<RefCell<Cache>>,
3746 trader_id: TraderId,
3747 ) {
3748 let expected_variant = match family {
3749 "instrument" => "Instrument",
3750 "book_deltas" => "BookDeltas",
3751 "book_depth" => "BookDepth",
3752 "book_at_interval" => "BookSnapshots",
3753 "quotes" => "Quotes",
3754 "trades" => "Trades",
3755 "mark_prices" => "MarkPrices",
3756 "index_prices" => "IndexPrices",
3757 "funding_rates" => "FundingRates",
3758 "instrument_status" => "InstrumentStatus",
3759 "instrument_close" => "InstrumentClose",
3760 "option_greeks" => "OptionGreeks",
3761 _ => unreachable!(),
3762 };
3763
3764 let first = InstrumentId::from("BTC/USD.SIM");
3765 let second = InstrumentId::from("ETH/USD.SIM");
3766
3767 Python::initialize();
3768 Python::attach(|py| {
3769 *get_message_bus().borrow_mut() = MessageBus::default();
3770 let actor = create_registered_actor(clock, cache, trader_id);
3771 let actor = Py::new(py, actor).unwrap();
3772 let (handler, saver) = get_typed_into_message_saving_handler::<DataCommand>(None);
3773 msgbus::register_data_command_endpoint(
3774 MessagingSwitchboard::data_engine_queue_execute(),
3775 handler,
3776 );
3777
3778 let (argument, expected_ids) = match input {
3779 "single" => (first.into_py_any(py).unwrap(), vec![first]),
3780 "list" => (
3781 PyList::new(py, [second, first, second])
3782 .unwrap()
3783 .into_any()
3784 .unbind(),
3785 vec![second, first],
3786 ),
3787 "tuple" => (
3788 PyTuple::new(py, [second, first, second])
3789 .unwrap()
3790 .into_any()
3791 .unbind(),
3792 vec![second, first],
3793 ),
3794 _ => unreachable!(),
3795 };
3796
3797 let args = PyTuple::new(py, (!keyword).then_some(argument.bind(py))).unwrap();
3798 for action in ["subscribe", "unsubscribe"] {
3799 let kwargs = instrument_subscription_keywords(py, family, action == "subscribe");
3800 if keyword {
3801 kwargs.set_item("instrument_id", argument.bind(py)).unwrap();
3802 }
3803
3804 let method = format!("{action}_{family}");
3805 actor
3806 .bind(py)
3807 .call_method(method.as_str(), &args, Some(&kwargs))
3808 .unwrap();
3809 }
3810
3811 let commands = saver.get_messages();
3812
3813 assert_eq!(commands.len(), 2);
3814
3815 for (index, command) in commands.iter().enumerate() {
3816 let (subscribe, actual_ids, serialized) = match command {
3817 DataCommand::Subscribe(command) => (
3818 true,
3819 command.instrument_ids().unwrap(),
3820 serde_json::to_value(command).unwrap(),
3821 ),
3822 DataCommand::Unsubscribe(command) => (
3823 false,
3824 command.instrument_ids().unwrap(),
3825 serde_json::to_value(command).unwrap(),
3826 ),
3827 _ => panic!("unexpected command"),
3828 };
3829
3830 assert_eq!(
3831 serialized.as_object().unwrap().keys().collect::<Vec<_>>(),
3832 vec![expected_variant]
3833 );
3834
3835 assert_eq!(subscribe, index == 0);
3836
3837 assert_eq!(actual_ids, expected_ids);
3838 }
3839 });
3840 }
3841
3842 #[rstest::rstest]
3843 fn test_python_subscription_lists_reject_invalid_routes_before_effects(
3844 #[values(
3845 "subscribe_quotes",
3846 "subscribe_instrument",
3847 "subscribe_book_deltas",
3848 "subscribe_book_depth",
3849 "subscribe_book_at_interval",
3850 "subscribe_option_greeks",
3851 "subscribe_instrument_status",
3852 "subscribe_instrument_close"
3853 )]
3854 method: &str,
3855 #[values(false, true)] external: bool,
3856 clock: Rc<RefCell<VirtualClock>>,
3857 cache: Rc<RefCell<Cache>>,
3858 trader_id: TraderId,
3859 ) {
3860 Python::initialize();
3861 Python::attach(|py| {
3862 let client_id = ClientId::from("ROUTED");
3863 if external {
3864 cache.borrow_mut().add_external_data_client(client_id);
3865 }
3866
3867 let actor = Py::new(py, create_registered_actor(clock, cache, trader_id)).unwrap();
3868 let (handler, saver) = get_typed_into_message_saving_handler::<DataCommand>(None);
3869 msgbus::register_data_command_endpoint(
3870 MessagingSwitchboard::data_engine_queue_execute(),
3871 handler,
3872 );
3873 let ids = PyList::new(
3874 py,
3875 [
3876 InstrumentId::from("AUD/USD.SIM"),
3877 InstrumentId::from("SYNTH.SYNTH"),
3878 ],
3879 )
3880 .unwrap();
3881 let kwargs = PyDict::new(py);
3882 kwargs.set_item("client_id", client_id).unwrap();
3883 if method.starts_with("subscribe_book") {
3884 kwargs.set_item("book_type", BookType::L2_MBP).unwrap();
3885 }
3886
3887 if method == "subscribe_book_at_interval" {
3888 kwargs.set_item("interval_ms", 13).unwrap();
3889 }
3890
3891 let result = actor.bind(py).call_method(method, (&ids,), Some(&kwargs));
3892 if external {
3893 result.unwrap();
3894 } else {
3895 let error = result.unwrap_err();
3896 assert!(error.is_instance_of::<pyo3::exceptions::PyValueError>(py));
3897
3898 let expected = if method == "subscribe_quotes" {
3899 "quote identifier lists cannot mix client, synthetic, and spread routes"
3900 } else {
3901 "Cannot subscribe synthetic instruments for this data type"
3902 };
3903
3904 assert_eq!(error.value(py).to_string(), expected);
3905 assert!(saver.get_messages().is_empty());
3906 }
3907
3908 if method.starts_with("subscribe_book") {
3909 kwargs.del_item("book_type").unwrap();
3910 }
3911
3912 let unsubscribe = method.replacen("subscribe", "unsubscribe", 1);
3913 actor
3914 .bind(py)
3915 .call_method(unsubscribe.as_str(), (&ids,), Some(&kwargs))
3916 .unwrap();
3917 assert_eq!(saver.get_messages().len(), if external { 2 } else { 0 });
3918 });
3919 }
3920
3921 #[rstest]
3922 fn test_python_identifier_lists_reject_mixed_venues_before_effects(
3923 #[values(
3924 "subscribe_quotes",
3925 "unsubscribe_quotes",
3926 "subscribe_trades",
3927 "unsubscribe_trades"
3928 )]
3929 method: &str,
3930 clock: Rc<RefCell<VirtualClock>>,
3931 cache: Rc<RefCell<Cache>>,
3932 trader_id: TraderId,
3933 ) {
3934 Python::initialize();
3935 Python::attach(|py| {
3936 *get_message_bus().borrow_mut() = MessageBus::default();
3937 let actor = create_registered_actor(clock, cache, trader_id);
3938 let actor = Py::new(py, actor).unwrap();
3939 let (handler, saver) = get_typed_into_message_saving_handler::<DataCommand>(None);
3940 msgbus::register_data_command_endpoint(
3941 MessagingSwitchboard::data_engine_queue_execute(),
3942 handler,
3943 );
3944 let first = InstrumentId::from("BTC/USD.SIM");
3945 let second = InstrumentId::from("ETH/USD.OTHER");
3946 let argument = PyList::new(py, [first, second]).unwrap();
3947 let quotes = method.ends_with("quotes");
3948 let subscribe = method.starts_with("subscribe_");
3949 if !subscribe {
3950 let kwargs = PyDict::new(py);
3951 kwargs
3952 .set_item("client_id", ClientId::from("ORIGINAL"))
3953 .unwrap();
3954 actor
3955 .bind(py)
3956 .call_method(
3957 if quotes {
3958 "subscribe_quotes"
3959 } else {
3960 "subscribe_trades"
3961 },
3962 (&argument,),
3963 Some(&kwargs),
3964 )
3965 .unwrap();
3966 }
3967
3968 let error = actor
3969 .bind(py)
3970 .call_method1(method, (&argument,))
3971 .unwrap_err();
3972 assert!(error.is_instance_of::<pyo3::exceptions::PyValueError>(py));
3973 assert_eq!(
3974 error.value(py).to_string(),
3975 "multiple instrument venues require an explicit client ID"
3976 );
3977 assert_eq!(saver.get_messages().len(), usize::from(!subscribe));
3978
3979 for id in [first, second] {
3980 assert_eq!(
3981 msgbus::exact_subscriber_count_quotes(get_quotes_topic(id)),
3982 usize::from(!subscribe && quotes),
3983 );
3984 assert_eq!(
3985 msgbus::exact_subscriber_count_trades(get_trades_topic(id)),
3986 usize::from(!subscribe && !quotes),
3987 );
3988 }
3989 });
3990 }
3991
3992 #[rstest]
3993 fn test_python_identifier_list_rejects_invalid_inputs_before_dispatch(
3994 #[values(
3995 "subscribe_quotes",
3996 "unsubscribe_quotes",
3997 "subscribe_trades",
3998 "unsubscribe_trades"
3999 )]
4000 method: &str,
4001 #[values(false, true)] empty: bool,
4002 clock: Rc<RefCell<VirtualClock>>,
4003 cache: Rc<RefCell<Cache>>,
4004 trader_id: TraderId,
4005 ) {
4006 Python::initialize();
4007 Python::attach(|py| {
4008 *get_message_bus().borrow_mut() = MessageBus::default();
4009 let actor = create_registered_actor(clock, cache, trader_id);
4010 let actor = Py::new(py, actor).unwrap();
4011 let (handler, saver) = get_typed_into_message_saving_handler::<DataCommand>(None);
4012 msgbus::register_data_command_endpoint(
4013 MessagingSwitchboard::data_engine_queue_execute(),
4014 handler,
4015 );
4016
4017 let argument = if empty {
4018 PyList::empty(py).into_any().unbind()
4019 } else {
4020 let instrument_id = InstrumentId::from("BTC/USD.SIM").into_py_any(py).unwrap();
4021 PyList::new(py, [instrument_id, 42.into_py_any(py).unwrap()])
4022 .unwrap()
4023 .into_any()
4024 .unbind()
4025 };
4026
4027 let error = actor
4028 .bind(py)
4029 .call_method1(method, (argument.bind(py),))
4030 .unwrap_err();
4031
4032 if empty {
4033 assert!(error.is_instance_of::<pyo3::exceptions::PyValueError>(py));
4034 assert_eq!(
4035 error.value(py).to_string(),
4036 "instrument IDs cannot be empty"
4037 );
4038 } else {
4039 assert!(error.is_instance_of::<pyo3::exceptions::PyTypeError>(py));
4040 assert_eq!(
4041 error.value(py).to_string(),
4042 "expected InstrumentId or a sequence of InstrumentId values"
4043 );
4044 }
4045
4046 assert_eq!(saver.get_messages().len(), 0);
4047 });
4048 }
4049
4050 #[rstest]
4051 fn test_new_actor_creation() {
4052 let actor = PyDataActor::new(None);
4053 assert!(actor.trader_id().is_none());
4054 }
4055
4056 #[rstest]
4057 fn test_actor_retains_python_config_object() {
4058 pyo3::Python::initialize();
4059 Python::attach(|py| {
4060 let config = py
4061 .eval(
4062 c_str!("type('_Cfg', (), {'actor_id': 'A-RETAIN-001'})()"),
4063 None,
4064 None,
4065 )
4066 .unwrap();
4067
4068 let actor = py
4069 .get_type::<PyDataActor>()
4070 .as_any()
4071 .call1((config.clone(),))
4072 .unwrap();
4073
4074 let retained = actor.getattr("config").unwrap();
4075
4076 assert!(retained.is(&config));
4077 });
4078 }
4079
4080 #[rstest]
4081 fn test_prepare_python_actor_applies_shared_registration_boundary() {
4082 pyo3::Python::initialize();
4083
4084 Python::attach(|py| {
4085 let namespace = PyDict::new(py);
4086 namespace
4087 .set_item("DataActor", py.get_type::<PyDataActor>())
4088 .unwrap();
4089 py.run(
4090 c_str!(
4091 r#"
4092class PreparedActor(DataActor):
4093 def __init__(self, _config=None):
4094 pass
4095"#
4096 ),
4097 Some(&namespace),
4098 None,
4099 )
4100 .unwrap();
4101 let actor_class = namespace.get_item("PreparedActor").unwrap();
4102
4103 let configured = py
4104 .eval(
4105 c_str!(
4106 "type('_Cfg', (), {'actor_id': 'CONFIGURED-001', 'log_events': False, 'log_commands': False})()"
4107 ),
4108 None,
4109 None,
4110 )
4111 .unwrap();
4112 let configured_actor = actor_class.call1((configured.clone(),)).unwrap();
4113 let configured_id = prepare_python_actor(&configured_actor, Some(&configured)).unwrap();
4114 let configured_ref = configured_actor.extract::<PyRef<PyDataActor>>().unwrap();
4115 let configured_wrapper = configured_ref.inner().python_instance().unwrap().unwrap();
4116
4117 let fallback_actor = actor_class.call0().unwrap();
4118 let fallback_id = prepare_python_actor(&fallback_actor, None).unwrap();
4119 let fallback_ref = fallback_actor.extract::<PyRef<PyDataActor>>().unwrap();
4120
4121 let invalid_logging = py
4122 .eval(
4123 c_str!(
4124 "type('_Cfg', (), {'actor_id': None, 'log_events': object(), 'log_commands': object()})()"
4125 ),
4126 None,
4127 None,
4128 )
4129 .unwrap();
4130 let invalid_logging_actor = actor_class.call1((invalid_logging.clone(),)).unwrap();
4131 let invalid_logging_id =
4132 prepare_python_actor(&invalid_logging_actor, Some(&invalid_logging)).unwrap();
4133 let invalid_logging_ref = invalid_logging_actor
4134 .extract::<PyRef<PyDataActor>>()
4135 .unwrap();
4136
4137 let invalid = py
4138 .eval(
4139 c_str!("type('_Cfg', (), {'actor_id': object()})()"),
4140 None,
4141 None,
4142 )
4143 .unwrap();
4144 let invalid_actor = actor_class.call1((invalid.clone(),)).unwrap();
4145 let error = prepare_python_actor(&invalid_actor, Some(&invalid)).unwrap_err();
4146
4147 assert_eq!(configured_id, ActorId::from("CONFIGURED-001"));
4148 assert_eq!(configured_ref.config.actor_id, Some(configured_id));
4149 assert!(!configured_ref.config.log_events);
4150 assert!(!configured_ref.config.log_commands);
4151 assert!(configured_wrapper.bind(py).is(&configured_actor));
4152 assert_eq!(fallback_id, ActorId::from("PreparedActor"));
4153 assert_eq!(fallback_ref.config.actor_id, Some(fallback_id));
4154 assert_eq!(invalid_logging_id, ActorId::from("PreparedActor"));
4155 assert!(invalid_logging_ref.config.log_events);
4156 assert!(invalid_logging_ref.config.log_commands);
4157 assert_eq!(error.to_string(), "Invalid `actor_id` type");
4158 });
4159 }
4160
4161 #[rstest]
4162 fn test_clock_access_before_registration_raises_error() {
4163 let actor = PyDataActor::new(None);
4164
4165 let result = actor.py_clock();
4167 assert!(result.is_err());
4168
4169 let error = result.unwrap_err();
4170 pyo3::Python::initialize();
4171
4172 pyo3::Python::attach(|py| {
4173 assert!(error.is_instance_of::<pyo3::exceptions::PyRuntimeError>(py));
4174 });
4175
4176 let error_msg = error.to_string();
4177 assert!(
4178 error_msg.contains("Actor must be registered with a trader before accessing clock")
4179 );
4180 }
4181
4182 #[rstest]
4183 fn test_unregistered_actor_methods_work() {
4184 let actor = create_unregistered_actor();
4185
4186 assert!(!actor.py_is_ready());
4187 assert!(!actor.py_is_running());
4188 assert!(!actor.py_is_stopped());
4189 assert!(!actor.py_is_disposed());
4190 assert!(!actor.py_is_degraded());
4191 assert!(!actor.py_is_faulted());
4192
4193 assert_eq!(actor.trader_id(), None);
4195 }
4196
4197 #[rstest]
4198 fn test_registration_success(
4199 clock: Rc<RefCell<VirtualClock>>,
4200 cache: Rc<RefCell<Cache>>,
4201 trader_id: TraderId,
4202 ) {
4203 let mut actor = create_unregistered_actor();
4204 actor.register(trader_id, clock, cache).unwrap();
4205 assert!(actor.trader_id().is_some());
4206 assert_eq!(actor.trader_id().unwrap(), trader_id);
4207 }
4208
4209 #[rstest]
4210 fn test_registered_actor_basic_properties(
4211 clock: Rc<RefCell<VirtualClock>>,
4212 cache: Rc<RefCell<Cache>>,
4213 trader_id: TraderId,
4214 ) {
4215 let actor = create_registered_actor(clock, cache, trader_id);
4216
4217 assert_eq!(actor.state(), ComponentState::Ready);
4218 assert_eq!(actor.trader_id(), Some(TraderId::from("TRADER-001")));
4219 assert!(actor.py_is_ready());
4220 assert!(!actor.py_is_running());
4221 assert!(!actor.py_is_stopped());
4222 assert!(!actor.py_is_disposed());
4223 assert!(!actor.py_is_degraded());
4224 assert!(!actor.py_is_faulted());
4225 }
4226
4227 #[rstest]
4228 fn test_basic_subscription_methods_compile(
4229 clock: Rc<RefCell<VirtualClock>>,
4230 cache: Rc<RefCell<Cache>>,
4231 trader_id: TraderId,
4232 data_type: DataType,
4233 client_id: ClientId,
4234 audusd_sim: CurrencyPair,
4235 ) {
4236 let mut actor = create_registered_actor(clock, cache, trader_id);
4237
4238 pyo3::Python::initialize();
4239
4240 pyo3::Python::attach(|py| {
4241 assert!(
4242 actor
4243 .py_subscribe_data(py, data_type.clone(), Some(client_id), None)
4244 .is_ok()
4245 );
4246 assert!(
4247 actor
4248 .py_subscribe_quotes(
4249 py,
4250 audusd_sim.id.into_py_any(py).unwrap().bind(py),
4251 Some(client_id),
4252 None
4253 )
4254 .is_ok()
4255 );
4256 assert!(
4257 actor
4258 .py_unsubscribe_data(py, data_type, Some(client_id), None)
4259 .is_ok()
4260 );
4261 assert!(
4262 actor
4263 .py_unsubscribe_quotes(
4264 py,
4265 audusd_sim.id.into_py_any(py).unwrap().bind(py),
4266 Some(client_id),
4267 None
4268 )
4269 .is_ok()
4270 );
4271 });
4272 }
4273
4274 #[rstest]
4275 fn test_shutdown_system_passes_through(
4276 clock: Rc<RefCell<VirtualClock>>,
4277 cache: Rc<RefCell<Cache>>,
4278 trader_id: TraderId,
4279 ) {
4280 let actor = create_registered_actor(clock, cache, trader_id);
4281
4282 assert!(
4283 actor
4284 .py_shutdown_system(Some("Test shutdown".to_string()))
4285 .is_ok()
4286 );
4287 assert!(actor.py_shutdown_system(None).is_ok());
4288 }
4289
4290 #[rstest]
4291 fn test_publish_data_delivers_to_any_subscriber(
4292 clock: Rc<RefCell<VirtualClock>>,
4293 cache: Rc<RefCell<Cache>>,
4294 trader_id: TraderId,
4295 ) {
4296 use crate::msgbus::{
4297 self, MessageBus, get_message_bus, switchboard::get_custom_topic,
4298 typed_handler::ShareableMessageHandler,
4299 };
4300
4301 *get_message_bus().borrow_mut() = MessageBus::default();
4303
4304 let actor = create_registered_actor(clock, cache, trader_id);
4305 let data = stub_custom_data(1, 42, None, None);
4306 let topic = get_custom_topic(&data.data_type);
4307
4308 let received: Rc<RefCell<Vec<CustomData>>> = Rc::new(RefCell::new(Vec::new()));
4309 let received_clone = received.clone();
4310 let handler = ShareableMessageHandler::from_typed(move |d: &CustomData| {
4311 received_clone.borrow_mut().push(d.clone());
4312 });
4313 msgbus::subscribe_any(topic.into(), handler, None);
4314
4315 actor.py_publish_data(&data.data_type, &data).unwrap();
4316
4317 let received = received.borrow();
4318 assert_eq!(received.len(), 1);
4319 assert_eq!(received[0].data_type, data.data_type);
4320 }
4321
4322 #[rstest]
4323 fn test_publish_signal_delivers_to_customdata_subscriber(
4324 clock: Rc<RefCell<VirtualClock>>,
4325 cache: Rc<RefCell<Cache>>,
4326 trader_id: TraderId,
4327 ) {
4328 use crate::{
4329 msgbus::{
4330 self, MessageBus, Pattern, get_message_bus, typed_handler::ShareableMessageHandler,
4331 },
4332 signal::Signal,
4333 };
4334
4335 *get_message_bus().borrow_mut() = MessageBus::default();
4336
4337 let actor = create_registered_actor(clock, cache, trader_id);
4338
4339 let received: Rc<RefCell<Vec<Signal>>> = Rc::new(RefCell::new(Vec::new()));
4342 let received_clone = received.clone();
4343 let handler = ShareableMessageHandler::from_typed(move |data: &CustomData| {
4344 if let Some(sig) = data.data.as_any().downcast_ref::<Signal>() {
4345 received_clone.borrow_mut().push(sig.clone());
4346 }
4347 });
4348 let pattern: crate::msgbus::MStr<Pattern> = "data.Signal*".to_string().into();
4349 msgbus::subscribe_any(pattern, handler, None);
4350
4351 pyo3::Python::initialize();
4352
4353 Python::attach(|py| {
4354 let val1: Py<PyAny> = 1.0_f64.into_py_any_unwrap(py);
4355 let val2: Py<PyAny> = "HIGH".into_py_any_unwrap(py);
4356 actor.py_publish_signal(py, "example", val1, 0).unwrap();
4357 actor
4358 .py_publish_signal(py, "risk", val2, 1_700_000_000_000_000_000)
4359 .unwrap();
4360 });
4361
4362 let received = received.borrow();
4363 assert_eq!(received.len(), 2);
4364 assert_eq!(received[0].name, "example");
4365 assert_eq!(received[0].value, "1.0");
4366 assert_eq!(received[1].name, "risk");
4367 assert_eq!(received[1].value, "HIGH");
4368 assert_eq!(
4369 received[1].ts_event,
4370 UnixNanos::from(1_700_000_000_000_000_000_u64)
4371 );
4372 }
4373
4374 #[rstest]
4375 fn test_publish_signal_accepts_numeric_py_values(
4376 clock: Rc<RefCell<VirtualClock>>,
4377 cache: Rc<RefCell<Cache>>,
4378 trader_id: TraderId,
4379 ) {
4380 use crate::{
4381 msgbus::{
4382 self, MessageBus, Pattern, get_message_bus, typed_handler::ShareableMessageHandler,
4383 },
4384 signal::Signal,
4385 };
4386
4387 *get_message_bus().borrow_mut() = MessageBus::default();
4388
4389 let actor = create_registered_actor(clock, cache, trader_id);
4390
4391 let received: Rc<RefCell<Vec<Signal>>> = Rc::new(RefCell::new(Vec::new()));
4392 let received_clone = received.clone();
4393 let handler = ShareableMessageHandler::from_typed(move |data: &CustomData| {
4394 if let Some(sig) = data.data.as_any().downcast_ref::<Signal>() {
4395 received_clone.borrow_mut().push(sig.clone());
4396 }
4397 });
4398 let pattern: crate::msgbus::MStr<Pattern> = "data.Signal*".to_string().into();
4399 msgbus::subscribe_any(pattern, handler, None);
4400
4401 pyo3::Python::initialize();
4402
4403 Python::attach(|py| {
4404 let int_value: Py<PyAny> = 42_i64.into_py_any_unwrap(py);
4405 let float_value: Py<PyAny> = 3.5_f64.into_py_any_unwrap(py);
4406 let bool_value: Py<PyAny> = true.into_py_any_unwrap(py);
4407 actor.py_publish_signal(py, "count", int_value, 0).unwrap();
4408 actor
4409 .py_publish_signal(py, "ratio", float_value, 0)
4410 .unwrap();
4411 actor
4412 .py_publish_signal(py, "active", bool_value, 0)
4413 .unwrap();
4414 });
4415
4416 let received = received.borrow();
4417 assert_eq!(received.len(), 3);
4418 assert_eq!(received[0].value, "42");
4419 assert_eq!(received[1].value, "3.5");
4420 assert_eq!(received[2].value, "True");
4421 }
4422
4423 #[rstest]
4424 fn test_subscribe_and_unsubscribe_signal_compile(
4425 clock: Rc<RefCell<VirtualClock>>,
4426 cache: Rc<RefCell<Cache>>,
4427 trader_id: TraderId,
4428 ) {
4429 use crate::msgbus::{MessageBus, get_message_bus};
4430
4431 *get_message_bus().borrow_mut() = MessageBus::default();
4432
4433 let actor = create_registered_actor(clock, cache, trader_id);
4434 Python::initialize();
4435 Python::attach(|py| {
4436 let actor = Bound::new(py, actor).unwrap();
4437 PyDataActor::py_subscribe_signal(&actor, "example", None).unwrap();
4438 PyDataActor::py_unsubscribe_signal(&actor, "example").unwrap();
4439 PyDataActor::py_subscribe_signal(&actor, "", None).unwrap();
4440 PyDataActor::py_unsubscribe_signal(&actor, "").unwrap();
4441 });
4442 }
4443
4444 #[rstest]
4445 fn test_py_subscribe_signal_forwards_priority(
4446 clock: Rc<RefCell<VirtualClock>>,
4447 cache: Rc<RefCell<Cache>>,
4448 trader_id: TraderId,
4449 ) {
4450 use crate::msgbus::{MessageBus, get_message_bus, switchboard::get_signal_topic};
4451
4452 *get_message_bus().borrow_mut() = MessageBus::default();
4453
4454 let actor = create_registered_actor(clock, cache, trader_id);
4455 Python::initialize();
4456 Python::attach(|py| {
4457 let actor = Bound::new(py, actor).unwrap();
4458 PyDataActor::py_subscribe_signal(&actor, "trigger", Some(50)).unwrap();
4459
4460 let topic = get_signal_topic("trigger");
4462 let subs = get_message_bus().borrow_mut().matching_subscriptions(topic);
4463 assert_eq!(subs.len(), 1);
4464 assert_eq!(subs[0].priority, 50);
4465 });
4466 }
4467
4468 #[rstest]
4469 fn test_register_in_global_registries_retains_python_wrapper(
4470 clock: Rc<RefCell<VirtualClock>>,
4471 cache: Rc<RefCell<Cache>>,
4472 trader_id: TraderId,
4473 ) {
4474 pyo3::Python::initialize();
4475
4476 Python::attach(|py| {
4477 let py_actor = create_tracking_python_actor(py).unwrap();
4478
4479 let mut rust_actor = PyDataActor::new(Some(DataActorConfig {
4480 actor_id: Some(ActorId::from("RETAINED-ACTOR")),
4481 ..Default::default()
4482 }));
4483 rust_actor.set_python_instance(py_actor.bind(py)).unwrap();
4484 rust_actor.register(trader_id, clock, cache).unwrap();
4485
4486 rust_actor.register_in_global_registries().unwrap();
4487
4488 let retained = get_python_wrapper(ComponentId::from("RETAINED-ACTOR"))
4489 .expect("registering must retain the actor's Python wrapper");
4490
4491 assert!(retained.bind(py).is(py_actor.bind(py)));
4492 assert!(get_component(&Ustr::from("RETAINED-ACTOR")).is_some());
4493 assert!(actor_exists(&Ustr::from("RETAINED-ACTOR")));
4494 });
4495 }
4496
4497 #[rstest]
4498 fn test_register_in_global_registries_rejects_missing_python_wrapper(
4499 clock: Rc<RefCell<VirtualClock>>,
4500 cache: Rc<RefCell<Cache>>,
4501 trader_id: TraderId,
4502 ) {
4503 pyo3::Python::initialize();
4504
4505 Python::attach(|_py| {
4506 let mut rust_actor = PyDataActor::new(Some(DataActorConfig {
4507 actor_id: Some(ActorId::from("UNWRAPPED-ACTOR")),
4508 ..Default::default()
4509 }));
4510 rust_actor.register(trader_id, clock, cache).unwrap();
4511
4512 let error = rust_actor
4513 .register_in_global_registries()
4514 .expect_err("registering without a Python wrapper must fail");
4515
4516 assert!(error.to_string().contains("without a Python wrapper"));
4517 assert!(get_component(&Ustr::from("UNWRAPPED-ACTOR")).is_none());
4518 assert!(!actor_exists(&Ustr::from("UNWRAPPED-ACTOR")));
4519 assert!(get_python_wrapper(ComponentId::from("UNWRAPPED-ACTOR")).is_none());
4520 });
4521 }
4522
4523 #[rstest]
4524 fn test_publish_data_dispatches_to_python_on_data(
4525 clock: Rc<RefCell<VirtualClock>>,
4526 cache: Rc<RefCell<Cache>>,
4527 trader_id: TraderId,
4528 ) {
4529 use crate::msgbus::{MessageBus, get_message_bus};
4530
4531 *get_message_bus().borrow_mut() = MessageBus::default();
4532
4533 pyo3::Python::initialize();
4534
4535 Python::attach(|py| {
4536 let py_actor = create_tracking_python_actor(py).unwrap();
4537
4538 let mut rust_actor = PyDataActor::new(None);
4539 rust_actor.set_python_instance(py_actor.bind(py)).unwrap();
4540 rust_actor.register(trader_id, clock, cache).unwrap();
4541 rust_actor.register_in_global_registries().unwrap();
4542 rust_actor.py_start().unwrap();
4543
4544 let data = stub_custom_data(1, 42, None, None);
4545 rust_actor
4546 .py_subscribe_data(py, data.data_type.clone(), None, None)
4547 .unwrap();
4548
4549 rust_actor.py_publish_data(&data.data_type, &data).unwrap();
4550 rust_actor.py_publish_data(&data.data_type, &data).unwrap();
4551
4552 assert!(python_method_was_called(&py_actor, py, "on_data"));
4553 assert_eq!(python_method_call_count(&py_actor, py, "on_data"), 2);
4554 });
4555 }
4556
4557 #[rstest]
4558 fn test_publish_signal_dispatches_to_python_on_signal(
4559 clock: Rc<RefCell<VirtualClock>>,
4560 cache: Rc<RefCell<Cache>>,
4561 trader_id: TraderId,
4562 ) {
4563 use crate::msgbus::{MessageBus, get_message_bus};
4564
4565 *get_message_bus().borrow_mut() = MessageBus::default();
4566
4567 pyo3::Python::initialize();
4568
4569 Python::attach(|py| {
4570 let py_actor = create_tracking_python_actor(py).unwrap();
4571
4572 let mut rust_actor = PyDataActor::new(None);
4573 rust_actor.set_python_instance(py_actor.bind(py)).unwrap();
4574 rust_actor.register(trader_id, clock, cache).unwrap();
4575 rust_actor.register_in_global_registries().unwrap();
4576 rust_actor.py_start().unwrap();
4577
4578 let bound_actor = Bound::new(py, rust_actor).unwrap();
4579 PyDataActor::py_subscribe_signal(&bound_actor, "example", None).unwrap();
4580 let rust_actor = bound_actor.borrow_mut();
4581 let val1: Py<PyAny> = "1.5".into_py_any_unwrap(py);
4582 let val2: Py<PyAny> = 2.0_f64.into_py_any_unwrap(py);
4583 rust_actor
4584 .py_publish_signal(py, "example", val1, 0)
4585 .unwrap();
4586 rust_actor
4587 .py_publish_signal(py, "example", val2, 1_700_000_000_000_000_000)
4588 .unwrap();
4589
4590 assert!(python_method_was_called(&py_actor, py, "on_signal"));
4591 assert_eq!(python_method_call_count(&py_actor, py, "on_signal"), 2);
4592 });
4593 }
4594
4595 #[rstest]
4596 fn test_unsubscribe_signal_stops_python_dispatch(
4597 clock: Rc<RefCell<VirtualClock>>,
4598 cache: Rc<RefCell<Cache>>,
4599 trader_id: TraderId,
4600 ) {
4601 use crate::msgbus::{MessageBus, get_message_bus};
4602
4603 *get_message_bus().borrow_mut() = MessageBus::default();
4604
4605 pyo3::Python::initialize();
4606
4607 Python::attach(|py| {
4608 let py_actor = create_tracking_python_actor(py).unwrap();
4609
4610 let mut rust_actor = PyDataActor::new(None);
4611 rust_actor.set_python_instance(py_actor.bind(py)).unwrap();
4612 rust_actor.register(trader_id, clock, cache).unwrap();
4613 rust_actor.register_in_global_registries().unwrap();
4614 rust_actor.py_start().unwrap();
4615
4616 let bound_actor = Bound::new(py, rust_actor).unwrap();
4617 PyDataActor::py_subscribe_signal(&bound_actor, "example", None).unwrap();
4618 let rust_actor = bound_actor.borrow_mut();
4619 let val1: Py<PyAny> = "1".into_py_any_unwrap(py);
4620 let val2: Py<PyAny> = "2".into_py_any_unwrap(py);
4621 rust_actor
4622 .py_publish_signal(py, "example", val1, 0)
4623 .unwrap();
4624
4625 drop(rust_actor);
4626 PyDataActor::py_unsubscribe_signal(&bound_actor, "example").unwrap();
4627 let rust_actor = bound_actor.borrow_mut();
4628 rust_actor
4629 .py_publish_signal(py, "example", val2, 0)
4630 .unwrap();
4631
4632 assert_eq!(python_method_call_count(&py_actor, py, "on_signal"), 1);
4633 });
4634 }
4635
4636 #[rstest]
4637 #[case(None)]
4638 #[case(Some(SystemChannel::ExecCommands))]
4639 fn test_queue_state_changed_subscription_dispatches_and_unsubscribes(
4640 clock: Rc<RefCell<VirtualClock>>,
4641 cache: Rc<RefCell<Cache>>,
4642 trader_id: TraderId,
4643 #[case] channel: Option<SystemChannel>,
4644 ) {
4645 *get_message_bus().borrow_mut() = MessageBus::default();
4646
4647 pyo3::Python::initialize();
4648
4649 Python::attach(|py| {
4650 let py_actor = create_tracking_python_actor(py).unwrap();
4651
4652 let mut rust_actor = PyDataActor::new(None);
4653 rust_actor.set_python_instance(py_actor.bind(py)).unwrap();
4654 rust_actor.register(trader_id, clock, cache).unwrap();
4655 rust_actor.register_in_global_registries().unwrap();
4656 rust_actor.py_start().unwrap();
4657 rust_actor
4658 .py_subscribe_queue_state(channel, Some(50))
4659 .unwrap();
4660
4661 let topic =
4662 MessagingSwitchboard::queue_state_changed_topic(SystemChannel::ExecCommands);
4663 let subscriptions = get_message_bus().borrow_mut().matching_subscriptions(topic);
4664 assert_eq!(subscriptions.len(), 1);
4665 assert_eq!(subscriptions[0].priority, 50);
4666 let unrelated =
4667 MessagingSwitchboard::queue_state_changed_topic(SystemChannel::DataEvents);
4668 assert_eq!(
4669 get_message_bus()
4670 .borrow_mut()
4671 .matching_subscriptions(unrelated)
4672 .len(),
4673 usize::from(channel.is_none())
4674 );
4675
4676 let triggered = sample_queue_state_changed(QueueState::Triggered);
4677 msgbus::publish_any(topic, &triggered);
4678
4679 let (received,) = py_actor
4680 .call_method1(py, "last_call_args", ("on_queue_state",))
4681 .unwrap()
4682 .extract::<(QueueStateChanged,)>(py)
4683 .unwrap();
4684 assert_eq!(received, triggered);
4685
4686 rust_actor.py_unsubscribe_queue_state(channel).unwrap();
4687 let cleared = sample_queue_state_changed(QueueState::Cleared);
4688 msgbus::publish_any(topic, &cleared);
4689
4690 assert_eq!(python_method_call_count(&py_actor, py, "on_queue_state"), 1);
4691 });
4692 }
4693
4694 #[rstest]
4695 #[case(None, None)]
4696 #[case(Some(ClientId::from("BINANCE")), None)]
4697 #[case(None, Some("binance-futures-market-streams"))]
4698 #[case(
4699 Some(ClientId::from("BINANCE")),
4700 Some("binance-futures-market-streams")
4701 )]
4702 fn test_socket_state_changed_subscription_dispatches_and_unsubscribes(
4703 clock: Rc<RefCell<VirtualClock>>,
4704 cache: Rc<RefCell<Cache>>,
4705 trader_id: TraderId,
4706 #[case] client_id: Option<ClientId>,
4707 #[case] endpoint: Option<&str>,
4708 ) {
4709 *get_message_bus().borrow_mut() = MessageBus::default();
4710
4711 pyo3::Python::initialize();
4712
4713 Python::attach(|py| {
4714 let py_actor = create_tracking_python_actor(py).unwrap();
4715
4716 let mut rust_actor = PyDataActor::new(None);
4717 rust_actor.set_python_instance(py_actor.bind(py)).unwrap();
4718 rust_actor.register(trader_id, clock, cache).unwrap();
4719 rust_actor.register_in_global_registries().unwrap();
4720 rust_actor.py_start().unwrap();
4721 rust_actor
4722 .py_subscribe_socket_state(client_id, endpoint, Some(50))
4723 .unwrap();
4724
4725 let topic = MessagingSwitchboard::socket_state_changed_topic(
4726 ClientId::from("BINANCE"),
4727 "binance-futures-market-streams",
4728 );
4729 let subscriptions = get_message_bus().borrow_mut().matching_subscriptions(topic);
4730 assert_eq!(subscriptions.len(), 1);
4731 assert_eq!(subscriptions[0].priority, 50);
4732 let unrelated =
4733 MessagingSwitchboard::socket_state_changed_topic(ClientId::from("BYBIT"), "orders");
4734 assert_eq!(
4735 get_message_bus()
4736 .borrow_mut()
4737 .matching_subscriptions(unrelated)
4738 .len(),
4739 usize::from(client_id.is_none() && endpoint.is_none())
4740 );
4741
4742 let connected = sample_socket_state_changed(SocketState::Connected);
4743 msgbus::publish_any(topic, &connected);
4744
4745 let (received,) = py_actor
4746 .call_method1(py, "last_call_args", ("on_socket_state",))
4747 .unwrap()
4748 .extract::<(SocketStateChanged,)>(py)
4749 .unwrap();
4750 assert_eq!(received, connected);
4751
4752 rust_actor
4753 .py_unsubscribe_socket_state(client_id, endpoint)
4754 .unwrap();
4755 let disconnected = sample_socket_state_changed(SocketState::Disconnected);
4756 msgbus::publish_any(topic, &disconnected);
4757
4758 assert_eq!(
4759 python_method_call_count(&py_actor, py, "on_socket_state"),
4760 1
4761 );
4762 });
4763 }
4764
4765 #[rstest]
4766 fn test_subscribe_signal_wildcard_dispatches_all_names_to_python(
4767 clock: Rc<RefCell<VirtualClock>>,
4768 cache: Rc<RefCell<Cache>>,
4769 trader_id: TraderId,
4770 ) {
4771 use crate::msgbus::{MessageBus, get_message_bus};
4772
4773 *get_message_bus().borrow_mut() = MessageBus::default();
4774
4775 pyo3::Python::initialize();
4776
4777 Python::attach(|py| {
4778 let py_actor = create_tracking_python_actor(py).unwrap();
4779
4780 let mut rust_actor = PyDataActor::new(None);
4781 rust_actor.set_python_instance(py_actor.bind(py)).unwrap();
4782 rust_actor.register(trader_id, clock, cache).unwrap();
4783 rust_actor.register_in_global_registries().unwrap();
4784 rust_actor.py_start().unwrap();
4785
4786 let bound_actor = Bound::new(py, rust_actor).unwrap();
4787 PyDataActor::py_subscribe_signal(&bound_actor, "", None).unwrap();
4788 let rust_actor = bound_actor.borrow_mut();
4789 let val1: Py<PyAny> = "1".into_py_any_unwrap(py);
4790 let val2: Py<PyAny> = "2".into_py_any_unwrap(py);
4791 let val3: Py<PyAny> = "3".into_py_any_unwrap(py);
4792 rust_actor.py_publish_signal(py, "alpha", val1, 0).unwrap();
4793 rust_actor.py_publish_signal(py, "beta", val2, 0).unwrap();
4794 rust_actor.py_publish_signal(py, "gamma", val3, 0).unwrap();
4795
4796 assert_eq!(python_method_call_count(&py_actor, py, "on_signal"), 3);
4797 });
4798 }
4799
4800 #[rstest]
4801 fn test_signal_customdata_unwraps_to_python_signal(
4802 clock: Rc<RefCell<VirtualClock>>,
4803 cache: Rc<RefCell<Cache>>,
4804 trader_id: TraderId,
4805 ) {
4806 use crate::msgbus::{MessageBus, get_message_bus};
4812
4813 *get_message_bus().borrow_mut() = MessageBus::default();
4814
4815 pyo3::Python::initialize();
4816
4817 Python::attach(|py| {
4818 let capture_code = c_str!(
4819 r#"
4820class CapturingActor:
4821 def __init__(self):
4822 self.captured = []
4823
4824 def on_start(self): pass
4825 def on_stop(self): pass
4826 def on_resume(self): pass
4827 def on_reset(self): pass
4828 def on_dispose(self): pass
4829 def on_degrade(self): pass
4830 def on_fault(self): pass
4831 def on_signal(self, signal): pass
4832
4833 def on_data(self, custom):
4834 # Exercise the CustomData.data getter: raises TypeError if the
4835 # inner payload cannot be converted back to a Python object.
4836 inner = custom.data
4837 self.captured.append((type(inner).__name__, inner.name, inner.value))
4838"#
4839 );
4840 py.run(capture_code, None, None).unwrap();
4841 let cls = py.eval(c_str!("CapturingActor"), None, None).unwrap();
4842 let py_actor: Py<PyAny> = cls.call0().unwrap().unbind();
4843
4844 let mut rust_actor = PyDataActor::new(None);
4845 rust_actor.set_python_instance(py_actor.bind(py)).unwrap();
4846 rust_actor.register(trader_id, clock, cache).unwrap();
4847 rust_actor.register_in_global_registries().unwrap();
4848 rust_actor.py_start().unwrap();
4849
4850 let data_type = DataType::new("SignalExample", None, None);
4853 rust_actor
4854 .py_subscribe_data(py, data_type, None, None)
4855 .unwrap();
4856
4857 let val: Py<PyAny> = "1.5".into_py_any_unwrap(py);
4858 rust_actor.py_publish_signal(py, "example", val, 0).unwrap();
4859
4860 let captured = py_actor
4861 .bind(py)
4862 .getattr("captured")
4863 .unwrap()
4864 .extract::<Vec<(String, String, String)>>()
4865 .unwrap();
4866 assert_eq!(captured.len(), 1);
4867 assert_eq!(captured[0].0, "Signal");
4868 assert_eq!(captured[0].1, "example");
4869 assert_eq!(captured[0].2, "1.5");
4870 });
4871 }
4872
4873 #[rstest]
4874 fn test_add_and_update_synthetic_via_pyo3(
4875 clock: Rc<RefCell<VirtualClock>>,
4876 cache: Rc<RefCell<Cache>>,
4877 trader_id: TraderId,
4878 ) {
4879 use nautilus_model::{
4880 identifiers::{InstrumentId, Symbol},
4881 instruments::SyntheticInstrument,
4882 };
4883
4884 let actor = create_registered_actor(clock, cache.clone(), trader_id);
4885
4886 let comp1 = InstrumentId::from_str("BTC-USD.VENUE").unwrap();
4887 let comp2 = InstrumentId::from_str("ETH-USD.VENUE").unwrap();
4888 let formula = format!("({comp1} + {comp2}) / 2.0");
4889 let synthetic = SyntheticInstrument::builder()
4890 .symbol(Symbol::from("SYN"))
4891 .price_precision(2)
4892 .components(vec![comp1, comp2])
4893 .formula(&formula)
4894 .ts_event(UnixNanos::default())
4895 .ts_init(UnixNanos::default())
4896 .build()
4897 .unwrap();
4898 let synthetic_id = synthetic.id;
4899
4900 actor.py_add_synthetic(synthetic.clone()).unwrap();
4901 assert!(cache.borrow().synthetic(&synthetic_id).is_some());
4902
4903 assert!(actor.py_add_synthetic(synthetic).is_err());
4905
4906 let new_formula = format!("{comp1} + {comp2}");
4907 let updated = SyntheticInstrument::builder()
4908 .symbol(Symbol::from("SYN"))
4909 .price_precision(2)
4910 .components(vec![comp1, comp2])
4911 .formula(&new_formula)
4912 .ts_event(UnixNanos::default())
4913 .ts_init(UnixNanos::default())
4914 .build()
4915 .unwrap();
4916 actor.py_update_synthetic(updated).unwrap();
4917 assert_eq!(
4918 cache.borrow().synthetic(&synthetic_id).unwrap().formula,
4919 new_formula
4920 );
4921
4922 let missing = SyntheticInstrument::builder()
4924 .symbol(Symbol::from("GONE"))
4925 .price_precision(2)
4926 .components(vec![comp1, comp2])
4927 .formula(&formula)
4928 .ts_event(UnixNanos::default())
4929 .ts_init(UnixNanos::default())
4930 .build()
4931 .unwrap();
4932 assert!(actor.py_update_synthetic(missing).is_err());
4933 }
4934
4935 #[rstest]
4936 fn test_book_at_interval_invalid_interval_ms(
4937 clock: Rc<RefCell<VirtualClock>>,
4938 cache: Rc<RefCell<Cache>>,
4939 trader_id: TraderId,
4940 audusd_sim: CurrencyPair,
4941 ) {
4942 pyo3::Python::initialize();
4943
4944 let mut actor = create_registered_actor(clock, cache, trader_id);
4945
4946 pyo3::Python::attach(|py| {
4947 let result = actor.py_subscribe_book_at_interval(
4948 py,
4949 &pyo3::Py::new(py, audusd_sim.id)
4950 .unwrap()
4951 .into_bound(py)
4952 .into_any(),
4953 BookType::L2_MBP,
4954 0,
4955 None,
4956 None,
4957 None,
4958 );
4959 assert!(result.is_err());
4960 assert_eq!(
4961 result.unwrap_err().to_string(),
4962 "ValueError: interval_ms must be > 0"
4963 );
4964
4965 let result = actor.py_unsubscribe_book_at_interval(
4966 py,
4967 &pyo3::Py::new(py, audusd_sim.id)
4968 .unwrap()
4969 .into_bound(py)
4970 .into_any(),
4971 0,
4972 None,
4973 None,
4974 );
4975 assert!(result.is_err());
4976 assert_eq!(
4977 result.unwrap_err().to_string(),
4978 "ValueError: interval_ms must be > 0"
4979 );
4980 });
4981 }
4982
4983 #[rstest]
4984 #[case(None)]
4985 #[case(Some(25))]
4986 fn test_book_depth_subscription_methods_manage_handler(
4987 #[case] depth: Option<usize>,
4988 clock: Rc<RefCell<VirtualClock>>,
4989 cache: Rc<RefCell<Cache>>,
4990 trader_id: TraderId,
4991 audusd_sim: CurrencyPair,
4992 ) {
4993 pyo3::Python::initialize();
4994
4995 let mut actor = create_registered_actor(clock, cache, trader_id);
4996
4997 Python::attach(|py| {
4998 actor
4999 .py_subscribe_book_depth(
5000 py,
5001 &pyo3::Py::new(py, audusd_sim.id)
5002 .unwrap()
5003 .into_bound(py)
5004 .into_any(),
5005 BookType::L2_MBP,
5006 depth,
5007 None,
5008 false,
5009 None,
5010 )
5011 .unwrap();
5012 assert_eq!(actor.inner().depth_handler_count(), 1);
5013
5014 actor
5015 .py_unsubscribe_book_depth(
5016 py,
5017 &pyo3::Py::new(py, audusd_sim.id)
5018 .unwrap()
5019 .into_bound(py)
5020 .into_any(),
5021 None,
5022 None,
5023 )
5024 .unwrap();
5025 assert_eq!(actor.inner().depth_handler_count(), 0);
5026 });
5027 }
5028
5029 #[rstest]
5030 fn test_request_methods_signatures_exist() {
5031 let actor = create_unregistered_actor();
5032 assert!(actor.trader_id().is_none());
5033 }
5034
5035 #[rstest]
5036 #[case("request_instrument", "Instrument")]
5037 #[case("request_book_snapshot", "BookSnapshot")]
5038 #[case("request_book_deltas", "BookDeltas")]
5039 #[case("request_book_depth", "BookDepth")]
5040 #[case("request_quotes", "Quotes")]
5041 #[case("request_trades", "Trades")]
5042 #[case("request_funding_rates", "FundingRates")]
5043 #[case("request_bars", "Bars")]
5044 fn test_python_request_identifier_shapes(
5045 clock: Rc<RefCell<VirtualClock>>,
5046 cache: Rc<RefCell<Cache>>,
5047 trader_id: TraderId,
5048 #[case] method: &str,
5049 #[case] variant: &str,
5050 #[values("scalar", "list", "tuple")] shape: &str,
5051 ) {
5052 Python::initialize();
5053 Python::attach(|py| {
5054 *get_message_bus().borrow_mut() = MessageBus::default();
5055 let actor = Py::new(py, create_registered_actor(clock, cache, trader_id)).unwrap();
5056 let (handler, saver) = get_typed_into_message_saving_handler::<DataCommand>(None);
5057 msgbus::register_data_command_endpoint(
5058 MessagingSwitchboard::data_engine_queue_execute(),
5059 handler,
5060 );
5061
5062 let (first, second, key) = if variant == "Bars" {
5063 let first = BarType::from_str("AUD/USD.SIM-1-MINUTE-LAST-EXTERNAL").unwrap();
5064 let second = BarType::from_str("NZD/USD.SIM-5-MINUTE-LAST-EXTERNAL").unwrap();
5065 (
5066 first.into_py_any(py).unwrap(),
5067 second.into_py_any(py).unwrap(),
5068 "bar_types",
5069 )
5070 } else {
5071 (
5072 InstrumentId::from("AUD/USD.SIM").into_py_any(py).unwrap(),
5073 InstrumentId::from("NZD/USD.SIM").into_py_any(py).unwrap(),
5074 "instrument_ids",
5075 )
5076 };
5077
5078 let argument = match shape {
5079 "scalar" => first.bind(py).clone(),
5080 "list" => PyList::new(py, [&first, &second, &first])
5081 .unwrap()
5082 .into_any(),
5083 "tuple" => PyTuple::new(py, [&first, &second, &first])
5084 .unwrap()
5085 .into_any(),
5086 _ => unreachable!(),
5087 };
5088
5089 let result = actor.bind(py).call_method1(method, (&argument,));
5090 let commands = saver.get_messages();
5091
5092 let root = result
5093 .unwrap()
5094 .extract::<String>()
5095 .unwrap()
5096 .parse::<UUID4>()
5097 .unwrap();
5098 assert_eq!(commands.len(), 1);
5099
5100 let DataCommand::Request(command) = &commands[0] else {
5101 panic!("expected request");
5102 };
5103
5104 assert_eq!(command.request_id(), &root);
5105 let wire = serde_json::to_value(command).unwrap();
5106
5107 let count = if shape == "scalar" { 1 } else { 2 };
5108
5109 let expected = if variant == "Bars" {
5110 serde_json::to_value(
5111 [
5112 "AUD/USD.SIM-1-MINUTE-LAST-EXTERNAL",
5113 "NZD/USD.SIM-5-MINUTE-LAST-EXTERNAL",
5114 ][..count]
5115 .to_vec(),
5116 )
5117 .unwrap()
5118 } else {
5119 serde_json::to_value(["AUD/USD.SIM", "NZD/USD.SIM"][..count].to_vec()).unwrap()
5120 };
5121
5122 assert_eq!(wire[variant][key], expected);
5123 assert!(actor.borrow(py).inner().core.is_pending_request(&root));
5124 });
5125 }
5126
5127 #[rstest]
5128 fn test_python_request_rejects_invalid_identifiers_before_dispatch(
5129 clock: Rc<RefCell<VirtualClock>>,
5130 cache: Rc<RefCell<Cache>>,
5131 trader_id: TraderId,
5132 #[values(
5133 "request_instrument",
5134 "request_book_snapshot",
5135 "request_book_deltas",
5136 "request_book_depth",
5137 "request_quotes",
5138 "request_trades",
5139 "request_funding_rates",
5140 "request_bars"
5141 )]
5142 method: &str,
5143 #[values(false, true)] empty: bool,
5144 ) {
5145 Python::initialize();
5146 Python::attach(|py| {
5147 *get_message_bus().borrow_mut() = MessageBus::default();
5148 let actor = Py::new(py, create_registered_actor(clock, cache, trader_id)).unwrap();
5149 let (handler, saver) = get_typed_into_message_saving_handler::<DataCommand>(None);
5150 msgbus::register_data_command_endpoint(
5151 MessagingSwitchboard::data_engine_queue_execute(),
5152 handler,
5153 );
5154
5155 let argument = if empty {
5156 PyList::empty(py)
5157 } else {
5158 PyList::new(py, [42]).unwrap()
5159 };
5160
5161 let error = actor
5162 .bind(py)
5163 .call_method1(method, (argument,))
5164 .unwrap_err();
5165
5166 let expected = match (method == "request_bars", empty) {
5167 (true, true) => "ValueError: bar types cannot be empty",
5168 (false, true) => "ValueError: instrument IDs cannot be empty",
5169 (true, false) => "TypeError: expected BarType or a sequence of BarType values",
5170 (false, false) => {
5171 "TypeError: expected InstrumentId or a sequence of InstrumentId values"
5172 }
5173 };
5174
5175 assert_eq!(error.to_string(), expected);
5176 assert!(saver.get_messages().is_empty());
5177 });
5178 }
5179
5180 #[rstest]
5181 fn test_data_actor_trait_implementation(
5182 clock: Rc<RefCell<VirtualClock>>,
5183 cache: Rc<RefCell<Cache>>,
5184 trader_id: TraderId,
5185 ) {
5186 let actor = create_registered_actor(clock, cache, trader_id);
5187 let state = actor.state();
5188 assert_eq!(state, ComponentState::Ready);
5189 }
5190
5191 #[rstest]
5192 fn test_python_reconnect_socket_enqueues_typed_command(
5193 clock: Rc<RefCell<VirtualClock>>,
5194 cache: Rc<RefCell<Cache>>,
5195 trader_id: TraderId,
5196 ) {
5197 let (system_tx, mut system_rx) = tokio::sync::mpsc::unbounded_channel();
5198 replace_system_command_sender(system_tx);
5199 let actor = create_registered_actor(clock, cache, trader_id);
5200
5201 actor
5202 .py_reconnect_socket(ClientId::from("POLYMARKET"), "polymarket-market-streams")
5203 .expect("valid reconnect command");
5204 let command = system_rx
5205 .try_recv()
5206 .expect("reconnect command should be queued");
5207 let SystemCommand::ReconnectSocket(command) = command;
5208
5209 assert_eq!(command.trader_id, trader_id);
5210 assert_eq!(command.client_id, ClientId::from("POLYMARKET"));
5211 assert_eq!(command.endpoint, "polymarket-market-streams");
5212 assert_eq!(command.ts_init, UnixNanos::default());
5213 }
5214
5215 #[rstest]
5216 fn test_python_reconnect_socket_returns_errors_without_panicking() {
5217 let actor = create_unregistered_actor();
5218
5219 assert!(
5220 actor
5221 .py_reconnect_socket(ClientId::from("POLYMARKET"), "polymarket-market-streams")
5222 .is_err()
5223 );
5224 assert!(
5225 actor
5226 .py_reconnect_socket(ClientId::from("POLYMARKET"), "wss://secret.example")
5227 .is_err()
5228 );
5229 }
5230
5231 fn sample_instrument() -> CurrencyPair {
5232 audusd_sim()
5233 }
5234
5235 fn sample_data() -> CustomData {
5236 stub_custom_data(1, 42, None, None)
5237 }
5238
5239 fn sample_time_event() -> TimeEvent {
5240 TimeEvent::new(
5241 Ustr::from("test_timer"),
5242 UUID4::new(),
5243 UnixNanos::default(),
5244 UnixNanos::default(),
5245 )
5246 }
5247
5248 fn sample_signal() -> Signal {
5249 Signal::new(
5250 Ustr::from("test_signal"),
5251 "1.0".to_string(),
5252 UnixNanos::default(),
5253 UnixNanos::default(),
5254 )
5255 }
5256
5257 fn sample_queue_state_changed(state: QueueState) -> QueueStateChanged {
5258 QueueStateChanged::new(
5259 TraderId::from("TRADER-001"),
5260 SystemChannel::ExecCommands,
5261 QueueCondition::Backlogged,
5262 state,
5263 17,
5264 23,
5265 UUID4::from("00000000-0000-4000-8000-000000000001"),
5266 UnixNanos::from(1_700_000_000_000_000_001),
5267 UnixNanos::from(1_700_000_000_000_000_002),
5268 )
5269 }
5270
5271 fn sample_socket_state_changed(state: SocketState) -> SocketStateChanged {
5272 SocketStateChanged::new(
5273 TraderId::from("TRADER-001"),
5274 ClientId::from("BINANCE"),
5275 Some(Venue::from("BINANCE")),
5276 Ustr::from("binance-futures-market-streams"),
5277 state,
5278 UUID4::from("00000000-0000-4000-8000-000000000001"),
5279 UnixNanos::from(1_700_000_000_000_000_001),
5280 UnixNanos::from(1_700_000_000_000_000_002),
5281 )
5282 }
5283
5284 fn sample_quote() -> QuoteTick {
5285 let instrument = sample_instrument();
5286 QuoteTick::new(
5287 instrument.id,
5288 Price::from("1.00000"),
5289 Price::from("1.00001"),
5290 Quantity::from(100_000),
5291 Quantity::from(100_000),
5292 UnixNanos::default(),
5293 UnixNanos::default(),
5294 )
5295 }
5296
5297 fn sample_trade() -> TradeTick {
5298 let instrument = sample_instrument();
5299 TradeTick::new(
5300 instrument.id,
5301 Price::from("1.00000"),
5302 Quantity::from(100_000),
5303 AggressorSide::Buy,
5304 TradeId::new("123456"),
5305 UnixNanos::default(),
5306 UnixNanos::default(),
5307 )
5308 }
5309
5310 fn sample_bar() -> Bar {
5311 let instrument = sample_instrument();
5312 let bar_type =
5313 BarType::from_str(&format!("{}-1-MINUTE-LAST-INTERNAL", instrument.id)).unwrap();
5314 Bar::new(
5315 bar_type,
5316 Price::from("1.00000"),
5317 Price::from("1.00010"),
5318 Price::from("0.99990"),
5319 Price::from("1.00005"),
5320 Quantity::from(100_000),
5321 UnixNanos::default(),
5322 UnixNanos::default(),
5323 )
5324 }
5325
5326 fn sample_book() -> OrderBook {
5327 OrderBook::new(sample_instrument().id, BookType::L2_MBP)
5328 }
5329
5330 fn sample_book_deltas() -> OrderBookDeltas {
5331 let instrument = sample_instrument();
5332 let delta =
5333 OrderBookDelta::clear(instrument.id, 0, UnixNanos::default(), UnixNanos::default());
5334 OrderBookDeltas::new(instrument.id, vec![delta])
5335 }
5336
5337 fn sample_book_depth() -> OrderBookDepth {
5338 stub_depth10()
5339 }
5340
5341 fn sample_mark_price() -> MarkPriceUpdate {
5342 MarkPriceUpdate::new(
5343 sample_instrument().id,
5344 Price::from("1.00000"),
5345 UnixNanos::default(),
5346 UnixNanos::default(),
5347 )
5348 }
5349
5350 fn sample_index_price() -> IndexPriceUpdate {
5351 IndexPriceUpdate::new(
5352 sample_instrument().id,
5353 Price::from("1.00000"),
5354 UnixNanos::default(),
5355 UnixNanos::default(),
5356 )
5357 }
5358
5359 fn sample_funding_rate() -> FundingRateUpdate {
5360 FundingRateUpdate::new(
5361 sample_instrument().id,
5362 "0.0001".parse().unwrap(),
5363 None,
5364 None,
5365 UnixNanos::default(),
5366 UnixNanos::default(),
5367 )
5368 }
5369
5370 fn sample_instrument_status() -> InstrumentStatus {
5371 InstrumentStatus::new(
5372 sample_instrument().id,
5373 MarketStatusAction::Trading,
5374 UnixNanos::default(),
5375 UnixNanos::default(),
5376 None,
5377 None,
5378 None,
5379 None,
5380 None,
5381 )
5382 }
5383
5384 fn sample_instrument_close() -> InstrumentClose {
5385 InstrumentClose::new(
5386 sample_instrument().id,
5387 Price::from("1.00000"),
5388 InstrumentCloseType::EndOfSession,
5389 UnixNanos::default(),
5390 UnixNanos::default(),
5391 )
5392 }
5393
5394 fn sample_option_greeks() -> OptionGreeks {
5395 OptionGreeks {
5396 instrument_id: sample_instrument().id,
5397 convention: GreeksConvention::BlackScholes,
5398 greeks: OptionGreekValues {
5399 delta: 0.55,
5400 gamma: 0.03,
5401 vega: 0.12,
5402 theta: -0.05,
5403 rho: 0.01,
5404 },
5405 mark_iv: Some(0.25),
5406 bid_iv: None,
5407 ask_iv: None,
5408 underlying_price: None,
5409 open_interest: None,
5410 ts_event: UnixNanos::default(),
5411 ts_init: UnixNanos::default(),
5412 }
5413 }
5414
5415 fn sample_option_chain() -> OptionChainSlice {
5416 OptionChainSlice {
5417 series_id: OptionSeriesId::new_derived(
5418 Venue::from("SIM"),
5419 Ustr::from("AUD"),
5420 Ustr::from("USD"),
5421 UnixNanos::from(1_711_036_800_000_000_000),
5422 ),
5423 atm_strike: None,
5424 calls: Default::default(),
5425 puts: Default::default(),
5426 ts_event: UnixNanos::default(),
5427 ts_init: UnixNanos::default(),
5428 }
5429 }
5430
5431 #[cfg(feature = "defi")]
5432 fn sample_block() -> Block {
5433 Block::new(
5434 "0x1234567890abcdef".to_string(),
5435 "0xabcdef1234567890".to_string(),
5436 12345,
5437 "0x742E4422b21FB8B4dF463F28689AC98bD56c39e0".into(),
5438 21000,
5439 20000,
5440 UnixNanos::default(),
5441 Some(Blockchain::Ethereum),
5442 )
5443 }
5444
5445 #[cfg(feature = "defi")]
5446 fn sample_pool_components() -> (Arc<Chain>, Arc<Dex>, Pool) {
5447 let chain = Arc::new(Chain::new(Blockchain::Ethereum, 1));
5448 let dex = Arc::new(Dex::new(
5449 Chain::new(Blockchain::Ethereum, 1),
5450 DexType::UniswapV3,
5451 "0x1F98431c8aD98523631AE4a59f267346ea31F984",
5452 0,
5453 AmmType::CLAMM,
5454 "PoolCreated",
5455 "Swap",
5456 "Mint",
5457 "Burn",
5458 "Collect",
5459 ));
5460 let token0 = Token::new(
5461 chain.clone(),
5462 "0xa0b86a33e6441c8c06dd7b111a8c4e82e2b2a5e1"
5463 .parse()
5464 .unwrap(),
5465 "USDC".into(),
5466 "USD Coin".into(),
5467 6,
5468 );
5469 let token1 = Token::new(
5470 chain.clone(),
5471 "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
5472 .parse()
5473 .unwrap(),
5474 "WETH".into(),
5475 "Wrapped Ether".into(),
5476 18,
5477 );
5478 let pool_address = "0x8ad599c3A0ff1De082011EFDDc58f1908eb6e6D8"
5479 .parse()
5480 .unwrap();
5481 let pool_identifier: PoolIdentifier = "0x8ad599c3A0ff1De082011EFDDc58f1908eb6e6D8"
5482 .parse()
5483 .unwrap();
5484
5485 let pool = Pool::new(
5486 chain.clone(),
5487 dex.clone(),
5488 pool_address,
5489 pool_identifier,
5490 12345,
5491 token0,
5492 token1,
5493 Some(500),
5494 Some(10),
5495 UnixNanos::default(),
5496 );
5497
5498 (chain, dex, pool)
5499 }
5500
5501 #[cfg(feature = "defi")]
5502 fn sample_pool_swap() -> PoolSwap {
5503 let (chain, dex, pool) = sample_pool_components();
5504 PoolSwap::new(
5505 chain,
5506 dex,
5507 pool.instrument_id,
5508 pool.pool_identifier,
5509 12345,
5510 "0xabc123".to_string(),
5511 0,
5512 0,
5513 UnixNanos::default(),
5514 UnixNanos::default(),
5515 "0x742E4422b21FB8B4dF463F28689AC98bD56c39e0"
5516 .parse()
5517 .unwrap(),
5518 "0x742E4422b21FB8B4dF463F28689AC98bD56c39e0"
5519 .parse()
5520 .unwrap(),
5521 I256::from_str("1000000000000000000").unwrap(),
5522 I256::from_str("400000000000000").unwrap(),
5523 U160::from(59000000000000u128),
5524 1000000,
5525 100,
5526 )
5527 }
5528
5529 #[cfg(feature = "defi")]
5530 fn sample_pool_liquidity_update() -> PoolLiquidityUpdate {
5531 let (chain, dex, pool) = sample_pool_components();
5532 PoolLiquidityUpdate::new(
5533 chain,
5534 dex,
5535 pool.instrument_id,
5536 pool.pool_identifier,
5537 PoolLiquidityUpdateType::Mint,
5538 12345,
5539 "0xabc123".to_string(),
5540 0,
5541 0,
5542 Some(
5543 "0x742E4422b21FB8B4dF463F28689AC98bD56c39e0"
5544 .parse()
5545 .unwrap(),
5546 ),
5547 "0x742E4422b21FB8B4dF463F28689AC98bD56c39e0"
5548 .parse()
5549 .unwrap(),
5550 1000,
5551 U256::from(1_000u64),
5552 U256::from(2_000u64),
5553 -10,
5554 10,
5555 UnixNanos::default(),
5556 UnixNanos::default(),
5557 )
5558 }
5559
5560 #[cfg(feature = "defi")]
5561 fn sample_pool_fee_collect() -> PoolFeeCollect {
5562 let (chain, dex, pool) = sample_pool_components();
5563 PoolFeeCollect::new(
5564 chain,
5565 dex,
5566 pool.instrument_id,
5567 pool.pool_identifier,
5568 12345,
5569 "0xabc123".to_string(),
5570 0,
5571 0,
5572 "0x742E4422b21FB8B4dF463F28689AC98bD56c39e0"
5573 .parse()
5574 .unwrap(),
5575 100,
5576 200,
5577 -10,
5578 10,
5579 UnixNanos::default(),
5580 UnixNanos::default(),
5581 )
5582 }
5583
5584 #[cfg(feature = "defi")]
5585 fn sample_pool_flash() -> PoolFlash {
5586 let (chain, dex, pool) = sample_pool_components();
5587 PoolFlash::new(
5588 chain,
5589 dex,
5590 pool.instrument_id,
5591 pool.pool_identifier,
5592 12345,
5593 "0xabc123".to_string(),
5594 0,
5595 0,
5596 UnixNanos::default(),
5597 UnixNanos::default(),
5598 "0x742E4422b21FB8B4dF463F28689AC98bD56c39e0"
5599 .parse()
5600 .unwrap(),
5601 "0x742E4422b21FB8B4dF463F28689AC98bD56c39e0"
5602 .parse()
5603 .unwrap(),
5604 U256::from(100u64),
5605 U256::from(200u64),
5606 U256::from(101u64),
5607 U256::from(201u64),
5608 )
5609 }
5610
5611 #[rstest]
5612 #[case("request_data")]
5613 #[case("request_instrument")]
5614 #[case("request_instruments")]
5615 #[case("request_book_snapshot")]
5616 #[case("request_book_deltas")]
5617 #[case("request_book_depth")]
5618 #[case("request_quotes")]
5619 #[case("request_trades")]
5620 #[case("request_funding_rates")]
5621 #[case("request_bars")]
5622 fn test_python_request_completion_callback_and_pending(
5623 #[case] method: &str,
5624 clock: Rc<RefCell<VirtualClock>>,
5625 cache: Rc<RefCell<Cache>>,
5626 trader_id: TraderId,
5627 ) {
5628 Python::initialize();
5629 Python::attach(|py| {
5630 *get_message_bus().borrow_mut() = MessageBus::default();
5631 let actor = Py::new(py, create_registered_actor(clock, cache, trader_id)).unwrap();
5632 let module = PyModule::from_code(
5633 py,
5634 c_str!(
5635 r#"
5636class CompletionActor:
5637 def __init__(self, native):
5638 self.native = native
5639 self.events = []
5640 def on_data_response(self, response):
5641 self.events.append(("response", response.correlation_id, response.completed))
5642 assert self.native.is_pending_request(response.correlation_id) == (not response.completed)
5643 def complete(self, request_id):
5644 assert not self.native.is_pending_request(request_id)
5645 assert self.native.pending_requests() == set()
5646 assert not self.native.has_pending_requests()
5647 self.events.append(("callback", request_id, True))
5648 self.next_request = self.native.request_instrument(instrument_id)
5649 def submit(self, method):
5650 if method == "request_data":
5651 args = (data_type, client_id)
5652 elif method == "request_instruments":
5653 args = ()
5654 elif method == "request_bars":
5655 args = (bar_type,)
5656 else:
5657 args = (instrument_id,)
5658 return getattr(self.native, method)(*args, callback=self.complete)
5659"#
5660 ),
5661 c_str!("completion_actor.py"),
5662 c_str!("completion_actor"),
5663 )
5664 .unwrap();
5665 module
5666 .setattr("instrument_id", sample_quote().instrument_id)
5667 .unwrap();
5668 module.setattr("bar_type", sample_bar().bar_type).unwrap();
5669 module
5670 .setattr("data_type", DataType::new("TestData", None, None))
5671 .unwrap();
5672 module
5673 .setattr("client_id", ClientId::new("HISTORY"))
5674 .unwrap();
5675 let tracker = module
5676 .getattr("CompletionActor")
5677 .unwrap()
5678 .call1((actor.clone_ref(py),))
5679 .unwrap();
5680 actor.borrow_mut(py).set_python_instance(&tracker).unwrap();
5681 actor.borrow(py).register_in_global_registries().unwrap();
5682 let (handler, saver) = get_typed_into_message_saving_handler::<DataCommand>(None);
5683 msgbus::register_data_command_endpoint(
5684 MessagingSwitchboard::data_engine_queue_execute(),
5685 handler,
5686 );
5687 let callback = tracker.getattr("complete").unwrap();
5688 tracker.setattr("complete", 42).unwrap();
5689 let error = tracker.call_method1("submit", (method,)).unwrap_err();
5690 assert!(error.is_instance_of::<pyo3::exceptions::PyTypeError>(py));
5691 assert!(saver.get_messages().is_empty());
5692 assert!(actor.borrow(py).inner().core.pending_requests().is_empty());
5693 tracker.setattr("complete", callback).unwrap();
5694 let root = tracker
5695 .call_method1("submit", (method,))
5696 .unwrap()
5697 .extract::<String>()
5698 .unwrap();
5699 let id: UUID4 = root.parse().unwrap();
5700 assert_eq!(
5701 actor
5702 .bind(py)
5703 .call_method0("pending_requests")
5704 .unwrap()
5705 .extract::<std::collections::HashSet<String>>()
5706 .unwrap(),
5707 [root.clone()].into()
5708 );
5709 let terminal = crate::messages::data::DataResponseEnvelope::terminal(
5710 id,
5711 Some("empty result failure".to_owned()),
5712 );
5713 msgbus::send_response_envelope(&terminal);
5714 msgbus::send_response_envelope(&terminal);
5715 assert_eq!(
5716 tracker
5717 .getattr("events")
5718 .unwrap()
5719 .extract::<Vec<(String, String, bool)>>()
5720 .unwrap(),
5721 vec![
5722 ("response".to_owned(), root.clone(), true),
5723 ("callback".to_owned(), root, true)
5724 ]
5725 );
5726 let next = tracker
5727 .getattr("next_request")
5728 .unwrap()
5729 .extract::<String>()
5730 .unwrap();
5731 assert_eq!(
5732 actor
5733 .bind(py)
5734 .call_method0("pending_requests")
5735 .unwrap()
5736 .extract::<std::collections::HashSet<String>>()
5737 .unwrap(),
5738 [next].into()
5739 );
5740 assert_eq!(saver.get_messages().len(), 2);
5741 });
5742 }
5743
5744 #[rstest]
5745 #[case::success(false)]
5746 #[case::failure(true)]
5747 fn test_python_request_join_callback_order_and_late_join(
5748 #[case] failed: bool,
5749 #[values("none", "hook", "callback")] raises: &str,
5750 clock: Rc<RefCell<VirtualClock>>,
5751 cache: Rc<RefCell<Cache>>,
5752 trader_id: TraderId,
5753 ) {
5754 Python::initialize();
5755 Python::attach(|py| {
5756 *get_message_bus().borrow_mut() = MessageBus::default();
5757 let actor = Py::new(py, create_registered_actor(clock, cache, trader_id)).unwrap();
5758 let module = PyModule::from_code(
5759 py,
5760 c_str!(
5761 r#"
5762class JoinActor:
5763 def __init__(self, native):
5764 self.native = native
5765 self.events = []
5766 def on_historical_quotes(self, quotes):
5767 self.events.append(("payload", len(quotes)))
5768 def on_data_response(self, response):
5769 self.events.append(("response", response.correlation_id))
5770 self.failure = response.failure_reason
5771 assert self.native.is_pending_request(response.correlation_id) == (not response.completed)
5772 if raises == "hook":
5773 raise RuntimeError("response hook failed")
5774 def complete(self, request_id):
5775 assert not self.native.is_pending_request(request_id)
5776 self.events.append(("callback", request_id))
5777 if raises == "callback":
5778 raise RuntimeError("completion callback failed")
5779 def late_complete(self, request_id):
5780 assert self.native.pending_requests() == set()
5781 self.events.append(("late", request_id))
5782 self.native.reset()
5783 def on_reset(self):
5784 pass
5785"#
5786 ),
5787 c_str!("join_actor.py"),
5788 c_str!("join_actor"),
5789 )
5790 .unwrap();
5791 module.setattr("raises", raises).unwrap();
5792 let tracker = module
5793 .getattr("JoinActor")
5794 .unwrap()
5795 .call1((actor.clone_ref(py),))
5796 .unwrap();
5797 actor.borrow_mut(py).set_python_instance(&tracker).unwrap();
5798 actor.borrow(py).register_in_global_registries().unwrap();
5799 let (handler, _) = get_typed_into_message_saving_handler::<DataCommand>(None);
5800 msgbus::register_data_command_endpoint(
5801 MessagingSwitchboard::data_engine_queue_execute(),
5802 handler,
5803 );
5804 let kwargs = PyDict::new(py);
5805 kwargs
5806 .set_item("callback", tracker.getattr("complete").unwrap())
5807 .unwrap();
5808 let quote = sample_quote();
5809 let root = actor
5810 .bind(py)
5811 .call_method("request_quotes", (quote.instrument_id,), Some(&kwargs))
5812 .unwrap()
5813 .extract::<String>()
5814 .unwrap();
5815
5816 for (children, message) in [
5817 (
5818 Vec::<String>::new(),
5819 "Request group must not be empty".to_owned(),
5820 ),
5821 (
5822 vec![root.clone(), root.clone()],
5823 format!("Duplicate request ID in group: {root}"),
5824 ),
5825 (
5826 vec![UUID4::new().to_string()],
5827 "Unknown request ID:".to_owned(),
5828 ),
5829 ] {
5830 let error = actor
5831 .bind(py)
5832 .call_method("request_join", (children,), Some(&kwargs))
5833 .unwrap_err();
5834 assert!(error.is_instance_of::<pyo3::exceptions::PyValueError>(py));
5835 assert!(error.to_string().contains(&message));
5836 assert_eq!(actor.borrow(py).inner().core.pending_requests().len(), 1);
5837 }
5838
5839 let group = actor
5840 .bind(py)
5841 .call_method("request_join", (vec![root.clone()],), Some(&kwargs))
5842 .unwrap()
5843 .extract::<String>()
5844 .unwrap();
5845 let id: UUID4 = root.parse().unwrap();
5846
5847 let payload = QuotesResponse::new(
5848 id,
5849 ClientId::new("HISTORY"),
5850 quote.instrument_id,
5851 vec![quote],
5852 None,
5853 None,
5854 UnixNanos::from(47),
5855 None,
5856 );
5857
5858 let intermediate = crate::messages::data::DataResponseEnvelope::new(
5859 crate::messages::data::DataResponse::Quotes(payload),
5860 false,
5861 None,
5862 );
5863 msgbus::send_response_envelope(&intermediate);
5864 let failure = failed.then(|| "partial failure".to_owned());
5865 let terminal = crate::messages::data::DataResponseEnvelope::terminal(id, failure);
5866 msgbus::send_response_envelope(&terminal);
5867 msgbus::send_response_envelope(&terminal);
5868 let events = tracker
5869 .getattr("events")
5870 .unwrap()
5871 .repr()
5872 .unwrap()
5873 .to_string();
5874 assert_eq!(
5875 events,
5876 format!(
5877 "[('payload', 1), ('response', '{root}'), ('response', '{root}'), ('callback', '{root}'), ('response', '{group}'), ('callback', '{group}')]"
5878 )
5879 );
5880 assert_eq!(
5881 tracker
5882 .getattr("failure")
5883 .unwrap()
5884 .extract::<Option<String>>()
5885 .unwrap(),
5886 failed.then(|| format!("Request {root}: partial failure"))
5887 );
5888 kwargs
5889 .set_item("callback", tracker.getattr("late_complete").unwrap())
5890 .unwrap();
5891 let late = UUID4::new().to_string();
5892 kwargs.set_item("request_id", &late).unwrap();
5893 let returned = actor
5894 .bind(py)
5895 .call_method("request_join", (vec![root, group],), Some(&kwargs))
5896 .unwrap()
5897 .extract::<String>()
5898 .unwrap();
5899 assert_eq!(returned, late);
5900 assert_eq!(
5901 tracker
5902 .getattr("events")
5903 .unwrap()
5904 .get_item(-1)
5905 .unwrap()
5906 .extract::<(String, String)>()
5907 .unwrap(),
5908 ("late".to_owned(), late)
5909 );
5910 });
5911 }
5912
5913 #[rstest]
5914 #[case::reset("reset")]
5915 #[case::dispose("dispose")]
5916 #[case::fault("fault")]
5917 fn test_python_request_callbacks_release_on_cleanup(
5918 #[case] action: &str,
5919 clock: Rc<RefCell<VirtualClock>>,
5920 cache: Rc<RefCell<Cache>>,
5921 trader_id: TraderId,
5922 ) {
5923 Python::initialize();
5924 Python::attach(|py| {
5925 let bus = py
5926 .get_type::<crate::python::msgbus::PyMessageBus>()
5927 .call1((trader_id,))
5928 .unwrap();
5929 let actor = Py::new(py, create_registered_actor(clock, cache, trader_id)).unwrap();
5930 actor
5931 .borrow_mut(py)
5932 .set_python_instance(actor.bind(py).as_any())
5933 .unwrap();
5934 actor.borrow(py).register_in_global_registries().unwrap();
5935 let (handler, _) = get_typed_into_message_saving_handler::<DataCommand>(None);
5936 msgbus::register_data_command_endpoint(
5937 MessagingSwitchboard::data_engine_queue_execute(),
5938 handler,
5939 );
5940 let module = PyModule::from_code(
5941 py,
5942 c_str!(
5943 r#"
5944released = []
5945called = []
5946class Callback:
5947 def __init__(self, name):
5948 self.name = name
5949 def __call__(self, request_id):
5950 called.append(request_id)
5951 def __del__(self):
5952 bus.endpoints()
5953 released.append(self.name)
5954"#
5955 ),
5956 c_str!("cleanup_callbacks.py"),
5957 c_str!("cleanup_callbacks"),
5958 )
5959 .unwrap();
5960 module.setattr("bus", bus).unwrap();
5961 let callback = module
5962 .getattr("Callback")
5963 .unwrap()
5964 .call1(("request",))
5965 .unwrap();
5966 let kwargs = PyDict::new(py);
5967 kwargs.set_item("callback", &callback).unwrap();
5968 let root = actor
5969 .bind(py)
5970 .call_method(
5971 "request_quotes",
5972 (sample_quote().instrument_id,),
5973 Some(&kwargs),
5974 )
5975 .unwrap()
5976 .extract::<String>()
5977 .unwrap();
5978 drop(callback);
5979 let callback = module
5980 .getattr("Callback")
5981 .unwrap()
5982 .call1(("group",))
5983 .unwrap();
5984 kwargs.set_item("callback", &callback).unwrap();
5985 let group = actor
5986 .bind(py)
5987 .call_method("request_join", (vec![root.clone()],), Some(&kwargs))
5988 .unwrap()
5989 .extract::<String>()
5990 .unwrap();
5991 drop(callback);
5992 drop(kwargs);
5993
5994 if action == "fault" {
5995 actor.bind(py).call_method0("start").unwrap();
5996 }
5997
5998 actor.bind(py).call_method0(action).unwrap();
5999 let root: UUID4 = root.parse().unwrap();
6000 msgbus::send_response_envelope(&crate::messages::data::DataResponseEnvelope::terminal(
6001 root, None,
6002 ));
6003 let mut released = module
6004 .getattr("released")
6005 .unwrap()
6006 .extract::<Vec<String>>()
6007 .unwrap();
6008 released.sort();
6009 assert_eq!(released, vec!["group", "request"]);
6010 assert_eq!(
6011 module
6012 .getattr("called")
6013 .unwrap()
6014 .extract::<Vec<String>>()
6015 .unwrap(),
6016 Vec::<String>::new()
6017 );
6018 assert!(
6019 !actor
6020 .bind(py)
6021 .call_method1("is_pending_request", (group,))
6022 .unwrap()
6023 .extract::<bool>()
6024 .unwrap()
6025 );
6026 assert!(actor.borrow(py).inner().core.pending_requests().is_empty());
6027 });
6028 }
6029
6030 #[rstest]
6031 #[case::payload("payload")]
6032 #[case::root_hook("root")]
6033 #[case::group_hook("group")]
6034 fn test_python_request_callback_reset_during_hook(
6035 #[case] reset_at: &str,
6036 clock: Rc<RefCell<VirtualClock>>,
6037 cache: Rc<RefCell<Cache>>,
6038 trader_id: TraderId,
6039 ) {
6040 Python::initialize();
6041 Python::attach(|py| {
6042 *get_message_bus().borrow_mut() = MessageBus::default();
6043 let actor = Py::new(py, create_registered_actor(clock, cache, trader_id)).unwrap();
6044 let module = PyModule::from_code(
6045 py,
6046 c_str!(
6047 r#"
6048class ResetActor:
6049 def __init__(self, native, reset_at):
6050 self.native = native
6051 self.reset_at = reset_at
6052 self.events = []
6053 def on_reset(self):
6054 pass
6055 def on_historical_quotes(self, quotes):
6056 self.events.append("payload")
6057 if self.reset_at == "payload":
6058 self.native.reset()
6059 def on_data_response(self, response):
6060 kind = "root" if response.correlation_id == self.root else "group"
6061 self.events.append(kind)
6062 if self.reset_at == kind:
6063 self.native.reset()
6064 def complete(self, request_id):
6065 assert not self.native.is_pending_request(request_id)
6066 self.events.append("callback:" + request_id)
6067"#
6068 ),
6069 c_str!("reset_callback_actor.py"),
6070 c_str!("reset_callback_actor"),
6071 )
6072 .unwrap();
6073 let tracker = module
6074 .getattr("ResetActor")
6075 .unwrap()
6076 .call1((actor.clone_ref(py), reset_at))
6077 .unwrap();
6078 actor.borrow_mut(py).set_python_instance(&tracker).unwrap();
6079 actor.borrow(py).register_in_global_registries().unwrap();
6080 let (handler, _) = get_typed_into_message_saving_handler::<DataCommand>(None);
6081 msgbus::register_data_command_endpoint(
6082 MessagingSwitchboard::data_engine_queue_execute(),
6083 handler,
6084 );
6085 let kwargs = PyDict::new(py);
6086 kwargs
6087 .set_item("callback", tracker.getattr("complete").unwrap())
6088 .unwrap();
6089 let quote = sample_quote();
6090 let root = actor
6091 .bind(py)
6092 .call_method("request_quotes", (quote.instrument_id,), Some(&kwargs))
6093 .unwrap()
6094 .extract::<String>()
6095 .unwrap();
6096 tracker.setattr("root", &root).unwrap();
6097 actor
6098 .bind(py)
6099 .call_method("request_join", (vec![root.clone()],), Some(&kwargs))
6100 .unwrap();
6101 let id: UUID4 = root.parse().unwrap();
6102
6103 let response = QuotesResponse::new(
6104 id,
6105 ClientId::new("HISTORY"),
6106 quote.instrument_id,
6107 vec![quote],
6108 None,
6109 None,
6110 UnixNanos::from(47),
6111 None,
6112 );
6113 msgbus::send_response(&id, &crate::messages::data::DataResponse::Quotes(response));
6114
6115 let expected = match reset_at {
6116 "payload" => vec!["payload".to_owned()],
6117 "root" => vec!["payload".to_owned(), "root".to_owned()],
6118 "group" => vec![
6119 "payload".to_owned(),
6120 "root".to_owned(),
6121 format!("callback:{root}"),
6122 "group".to_owned(),
6123 ],
6124 _ => unreachable!(),
6125 };
6126
6127 assert_eq!(
6128 tracker
6129 .getattr("events")
6130 .unwrap()
6131 .extract::<Vec<String>>()
6132 .unwrap(),
6133 expected
6134 );
6135 assert!(actor.borrow(py).inner().core.pending_requests().is_empty());
6136 });
6137 }
6138
6139 #[rstest]
6140 fn test_python_response_hook_can_submit_next_request(
6141 clock: Rc<RefCell<VirtualClock>>,
6142 cache: Rc<RefCell<Cache>>,
6143 trader_id: TraderId,
6144 ) {
6145 Python::initialize();
6146 Python::attach(|py| {
6147 *get_message_bus().borrow_mut() = MessageBus::default();
6148 let actor = Py::new(py, create_registered_actor(clock, cache, trader_id)).unwrap();
6149 let module = PyModule::from_code(
6150 py,
6151 c_str!(
6152 r#"
6153class ResponseActor:
6154 def __init__(self, native):
6155 self.native = native
6156 self.events = []
6157 self.next_request = None
6158 def on_historical_quotes(self, quotes):
6159 self.events.append("quotes")
6160 self.native.request_instrument(quotes[0].instrument_id)
6161 def on_data_response(self, response):
6162 self.events.append("complete")
6163 self.next_request = self.native.request_trades(response.data[0].instrument_id)
6164"#
6165 ),
6166 c_str!("response_actor.py"),
6167 c_str!("response_actor"),
6168 )
6169 .unwrap();
6170 let tracker = module
6171 .getattr("ResponseActor")
6172 .unwrap()
6173 .call1((actor.clone_ref(py),))
6174 .unwrap();
6175 actor.borrow_mut(py).set_python_instance(&tracker).unwrap();
6176 actor.borrow(py).register_in_global_registries().unwrap();
6177 let (handler, saver) = get_typed_into_message_saving_handler::<DataCommand>(None);
6178 msgbus::register_data_command_endpoint(
6179 MessagingSwitchboard::data_engine_queue_execute(),
6180 handler,
6181 );
6182 let quote = sample_quote();
6183 let root = actor
6184 .bind(py)
6185 .call_method1("request_quotes", (quote.instrument_id,))
6186 .unwrap()
6187 .extract::<String>()
6188 .unwrap();
6189 let root: UUID4 = root.parse().unwrap();
6190
6191 let response = QuotesResponse::new(
6192 root,
6193 ClientId::new("HISTORY"),
6194 quote.instrument_id,
6195 vec![quote],
6196 None,
6197 None,
6198 UnixNanos::from(47),
6199 None,
6200 );
6201 msgbus::send_response(
6202 &root,
6203 &crate::messages::data::DataResponse::Quotes(response),
6204 );
6205 let commands = saver.get_messages();
6206 assert_eq!(commands.len(), 3);
6207 assert!(
6208 matches!(&commands[1], DataCommand::Request(crate::messages::data::RequestCommand::Instrument(r)) if r.instrument_ids == vec![quote.instrument_id])
6209 );
6210
6211 let DataCommand::Request(crate::messages::data::RequestCommand::Trades(next)) =
6212 &commands[2]
6213 else {
6214 panic!("expected chained trade request");
6215 };
6216
6217 assert_eq!(
6218 tracker
6219 .getattr("events")
6220 .unwrap()
6221 .extract::<Vec<String>>()
6222 .unwrap(),
6223 vec!["quotes", "complete"]
6224 );
6225 assert_eq!(
6226 tracker
6227 .getattr("next_request")
6228 .unwrap()
6229 .extract::<String>()
6230 .unwrap(),
6231 next.request_id.to_string()
6232 );
6233 assert!(!actor.borrow(py).inner().core.is_pending_request(&root));
6234 assert!(
6235 actor
6236 .borrow(py)
6237 .inner()
6238 .core
6239 .is_pending_request(&next.request_id)
6240 );
6241 });
6242 }
6243
6244 #[rstest]
6245 #[case::complete("none")]
6246 #[case::payload_reset("payload")]
6247 #[case::child_reset("child")]
6248 #[case::group_reset("group")]
6249 #[case::child_error("error")]
6250 fn test_python_request_group_delivery_releases_actor_access(
6251 #[case] reset_at: &str,
6252 clock: Rc<RefCell<VirtualClock>>,
6253 cache: Rc<RefCell<Cache>>,
6254 trader_id: TraderId,
6255 ) {
6256 Python::initialize();
6257 Python::attach(|py| {
6258 *get_message_bus().borrow_mut() = MessageBus::default();
6259 let actor = Py::new(py, create_registered_actor(clock, cache, trader_id)).unwrap();
6260 let module = PyModule::from_code(
6261 py,
6262 c_str!(
6263 r#"
6264class ResponseActor:
6265 def __init__(self, native, reset_at):
6266 self.native = native
6267 self.reset_at = reset_at
6268 self.events = []
6269 self.next_request = None
6270 def on_reset(self):
6271 pass
6272 def on_historical_quotes(self, quotes):
6273 self.events.append("quotes")
6274 self.instrument_id = quotes[0].instrument_id
6275
6276 if self.reset_at == "payload":
6277 self.native.reset()
6278 def on_data_response(self, response):
6279 assert response.completed
6280 assert response.failure_reason is None
6281 self.events.append(response.correlation_id)
6282 if response.correlation_id == self.root:
6283
6284 if self.reset_at == "child":
6285 self.native.reset()
6286 elif self.reset_at == "error":
6287 raise RuntimeError("response hook failed")
6288 else:
6289 assert response.data is None
6290
6291 if self.reset_at == "group":
6292 self.native.reset()
6293 else:
6294 self.next_request = self.native.request_trades(self.instrument_id)
6295"#
6296 ),
6297 c_str!("group_actor.py"),
6298 c_str!("group_actor"),
6299 )
6300 .unwrap();
6301 let tracker = module
6302 .getattr("ResponseActor")
6303 .unwrap()
6304 .call1((actor.clone_ref(py), reset_at))
6305 .unwrap();
6306 actor.borrow_mut(py).set_python_instance(&tracker).unwrap();
6307 actor.borrow(py).register_in_global_registries().unwrap();
6308 let (handler, saver) = get_typed_into_message_saving_handler::<DataCommand>(None);
6309 msgbus::register_data_command_endpoint(
6310 MessagingSwitchboard::data_engine_queue_execute(),
6311 handler,
6312 );
6313 let quote = sample_quote();
6314 let root = actor
6315 .bind(py)
6316 .call_method1("request_quotes", (quote.instrument_id,))
6317 .unwrap()
6318 .extract::<String>()
6319 .unwrap();
6320 tracker.setattr("root", &root).unwrap();
6321 let root: UUID4 = root.parse().unwrap();
6322 let first = actor
6323 .borrow(py)
6324 .inner()
6325 .core
6326 .register_request_group(vec![root], None, None)
6327 .unwrap();
6328 let second = actor
6329 .borrow(py)
6330 .inner()
6331 .core
6332 .register_request_group(vec![root], None, None)
6333 .unwrap();
6334
6335 let payload = QuotesResponse::new(
6336 root,
6337 ClientId::new("SOURCE"),
6338 quote.instrument_id,
6339 vec![quote],
6340 None,
6341 None,
6342 UnixNanos::from(47),
6343 None,
6344 );
6345 msgbus::send_response(&root, &crate::messages::data::DataResponse::Quotes(payload));
6346 let mut expected = vec!["quotes".to_owned()];
6347 if reset_at != "payload" {
6348 expected.push(root.to_string());
6349 }
6350
6351 if !matches!(reset_at, "payload" | "child") {
6352 expected.push(first.to_string());
6353 }
6354
6355 if matches!(reset_at, "none" | "error") {
6356 expected.push(second.to_string());
6357 }
6358
6359 assert_eq!(
6360 tracker
6361 .getattr("events")
6362 .unwrap()
6363 .extract::<Vec<String>>()
6364 .unwrap(),
6365 expected
6366 );
6367 assert!(!actor.borrow(py).inner().core.is_pending_request(&root));
6368 assert!(!actor.borrow(py).inner().core.is_pending_request(&first));
6369 assert!(!actor.borrow(py).inner().core.is_pending_request(&second));
6370 let commands = saver.get_messages();
6371
6372 if matches!(reset_at, "none" | "error") {
6373 let [
6374 DataCommand::Request(RequestCommand::Quotes(_)),
6375 DataCommand::Request(RequestCommand::Trades(first)),
6376 DataCommand::Request(RequestCommand::Trades(second)),
6377 ] = commands.as_slice()
6378 else {
6379 panic!("expected quotes and two chained trades requests")
6380 };
6381
6382 assert_eq!(first.instrument_ids, vec![quote.instrument_id]);
6383 assert_eq!(second.instrument_ids, vec![quote.instrument_id]);
6384 assert_eq!(
6385 tracker
6386 .getattr("next_request")
6387 .unwrap()
6388 .extract::<String>()
6389 .unwrap(),
6390 second.request_id.to_string()
6391 );
6392 } else {
6393 assert_eq!(commands.len(), 1);
6394 assert!(tracker.getattr("next_request").unwrap().is_none());
6395 }
6396 });
6397 }
6398
6399 const TRACKING_ACTOR_CODE: &std::ffi::CStr = c_str!(
6400 r#"
6401class TrackingActor:
6402 """A mock Python actor that tracks all method calls."""
6403
6404 TRACKED_METHODS = {
6405 "on_start",
6406 "on_stop",
6407 "on_resume",
6408 "on_reset",
6409 "on_dispose",
6410 "on_degrade",
6411 "on_fault",
6412 "on_save",
6413 "on_load",
6414 "on_time_event",
6415 "on_data",
6416 "on_signal",
6417 "on_queue_state",
6418 "on_socket_state",
6419 "on_instrument",
6420 "on_quote",
6421 "on_trade",
6422 "on_bar",
6423 "on_book",
6424 "on_book_deltas",
6425 "on_book_depth",
6426 "on_mark_price",
6427 "on_index_price",
6428 "on_funding_rate",
6429 "on_instrument_status",
6430 "on_instrument_close",
6431 "on_option_greeks",
6432 "on_option_chain",
6433 "on_historical_data",
6434 "on_historical_book_deltas",
6435 "on_historical_book_depth",
6436 "on_historical_quotes",
6437 "on_historical_trades",
6438 "on_historical_funding_rates",
6439 "on_historical_bars",
6440 "on_historical_mark_prices",
6441 "on_historical_index_prices",
6442 "on_block",
6443 "on_pool",
6444 "on_pool_swap",
6445 "on_pool_liquidity_update",
6446 "on_pool_fee_collect",
6447 "on_pool_flash",
6448 }
6449
6450 def __init__(self):
6451 self.calls = []
6452 self.raises = False
6453
6454 def _record(self, method_name, *args):
6455 self.calls.append((method_name, args))
6456 if self.raises:
6457 raise RuntimeError("actor callback failure")
6458
6459 def was_called(self, method_name):
6460 return any(call[0] == method_name for call in self.calls)
6461
6462 def call_count(self, method_name):
6463 return sum(1 for call in self.calls if call[0] == method_name)
6464
6465 def last_call_args(self, method_name):
6466 for called_method, args in reversed(self.calls):
6467 if called_method == method_name:
6468 return args
6469 raise AssertionError(f"{method_name} was not called")
6470
6471 def last_loaded_state(self):
6472
6473 for method_name, args in reversed(self.calls):
6474 if method_name == "on_load":
6475 return args[0]
6476 return None
6477
6478 def on_save(self):
6479 self._record("on_save")
6480 return {"actor": b"saved"}
6481
6482 def on_load(self, state):
6483 self._record("on_load", dict(state))
6484
6485 def __getattr__(self, name):
6486 if name in self.TRACKED_METHODS:
6487 return lambda *args: self._record(name, *args)
6488 raise AttributeError(name)
6489"#
6490 );
6491
6492 fn create_tracking_python_actor(py: Python<'_>) -> PyResult<Py<PyAny>> {
6493 py.run(TRACKING_ACTOR_CODE, None, None)?;
6494 let tracking_actor_class = py.eval(c_str!("TrackingActor"), None, None)?;
6495 let instance = tracking_actor_class.call0()?;
6496 Ok(instance.unbind())
6497 }
6498
6499 fn python_method_was_called(py_actor: &Py<PyAny>, py: Python<'_>, method_name: &str) -> bool {
6500 py_actor
6501 .call_method1(py, "was_called", (method_name,))
6502 .and_then(|r| r.extract::<bool>(py))
6503 .unwrap_or(false)
6504 }
6505
6506 fn python_method_call_count(py_actor: &Py<PyAny>, py: Python<'_>, method_name: &str) -> i32 {
6507 py_actor
6508 .call_method1(py, "call_count", (method_name,))
6509 .and_then(|r| r.extract::<i32>(py))
6510 .unwrap_or(0)
6511 }
6512
6513 fn python_last_loaded_state(
6514 py_actor: &Py<PyAny>,
6515 py: Python<'_>,
6516 ) -> Option<HashMap<String, Vec<u8>>> {
6517 py_actor
6518 .call_method0(py, "last_loaded_state")
6519 .and_then(|result| result.extract::<Option<HashMap<String, Vec<u8>>>>(py))
6520 .unwrap_or(None)
6521 }
6522
6523 const TRACKING_INDICATOR_CODE: &std::ffi::CStr = c_str!(
6524 r#"
6525class TrackingIndicator:
6526 def __init__(self, events=None):
6527 self.initialized = False
6528 self.calls = []
6529 self.events = events
6530
6531 def handle_quote_tick(self, quote):
6532 self.calls.append("quote")
6533 if self.events is not None:
6534 self.events.append("indicator:quote")
6535
6536 def handle_trade_tick(self, trade):
6537 self.calls.append("trade")
6538 if self.events is not None:
6539 self.events.append("indicator:trade")
6540
6541 def handle_bar(self, bar):
6542 self.calls.append("bar")
6543 if self.events is not None:
6544 self.events.append("indicator:bar")
6545
6546 def call_count(self, name):
6547 return self.calls.count(name)
6548
6549class RaisingIndicator:
6550 initialized = True
6551
6552 def handle_quote_tick(self, quote):
6553 raise RuntimeError("indicator failed")
6554
6555class IndicatorEventActor:
6556 def __init__(self, events):
6557 self.events = events
6558
6559 def on_start(self):
6560 pass
6561
6562 def on_quote(self, quote):
6563 self.events.append("actor:quote")
6564
6565 def on_trade(self, trade):
6566 self.events.append("actor:trade")
6567
6568 def on_bar(self, bar):
6569 self.events.append("actor:bar")
6570"#
6571 );
6572
6573 fn create_tracking_python_indicator(py: Python<'_>) -> PyResult<Py<PyAny>> {
6574 py.run(TRACKING_INDICATOR_CODE, None, None)?;
6575 let indicator_class = py.eval(c_str!("TrackingIndicator"), None, None)?;
6576 Ok(indicator_class.call0()?.unbind())
6577 }
6578
6579 fn create_event_tracking_python_indicator(
6580 py: Python<'_>,
6581 events: &Bound<'_, PyList>,
6582 ) -> PyResult<Py<PyAny>> {
6583 py.run(TRACKING_INDICATOR_CODE, None, None)?;
6584 let indicator_class = py.eval(c_str!("TrackingIndicator"), None, None)?;
6585 Ok(indicator_class.call1((events,))?.unbind())
6586 }
6587
6588 fn create_raising_python_indicator(py: Python<'_>) -> PyResult<Py<PyAny>> {
6589 py.run(TRACKING_INDICATOR_CODE, None, None)?;
6590 let indicator_class = py.eval(c_str!("RaisingIndicator"), None, None)?;
6591 Ok(indicator_class.call0()?.unbind())
6592 }
6593
6594 fn create_indicator_event_actor(
6595 py: Python<'_>,
6596 events: &Bound<'_, PyList>,
6597 ) -> PyResult<Py<PyAny>> {
6598 py.run(TRACKING_INDICATOR_CODE, None, None)?;
6599 let actor_class = py.eval(c_str!("IndicatorEventActor"), None, None)?;
6600 Ok(actor_class.call1((events,))?.unbind())
6601 }
6602
6603 fn python_indicator_call_count(
6604 indicator: &Py<PyAny>,
6605 py: Python<'_>,
6606 method_name: &str,
6607 ) -> i32 {
6608 indicator
6609 .call_method1(py, "call_count", (method_name,))
6610 .and_then(|r| r.extract::<i32>(py))
6611 .unwrap_or(0)
6612 }
6613
6614 fn assert_python_dispatch<F>(
6615 py: Python<'_>,
6616 clock: Rc<RefCell<VirtualClock>>,
6617 cache: Rc<RefCell<Cache>>,
6618 trader_id: TraderId,
6619 method_name: &str,
6620 invoke: F,
6621 ) -> Py<PyAny>
6622 where
6623 F: FnOnce(&mut PyDataActor) -> anyhow::Result<()>,
6624 {
6625 let py_actor = create_tracking_python_actor(py).unwrap();
6626
6627 let mut rust_actor = PyDataActor::new(None);
6628 rust_actor.set_python_instance(py_actor.bind(py)).unwrap();
6629 rust_actor.register(trader_id, clock, cache).unwrap();
6630
6631 let result = invoke(&mut rust_actor);
6632
6633 assert!(result.is_ok());
6634 assert!(python_method_was_called(&py_actor, py, method_name));
6635 assert_eq!(python_method_call_count(&py_actor, py, method_name), 1);
6636
6637 py_actor
6638 }
6639
6640 #[rstest]
6641 fn test_python_actor_callback_exception_preserves_traceback() {
6642 Python::initialize();
6643 Python::attach(|py| {
6644 let tracker = create_tracking_python_actor(py).unwrap();
6645 tracker.setattr(py, "raises", true).unwrap();
6646 let mut actor = PyDataActor::new(None);
6647 actor.set_python_instance(tracker.bind(py)).unwrap();
6648 let error = DataActor::on_bar(actor.inner_mut(), &sample_bar()).unwrap_err();
6649 let message = error.to_string();
6650
6651 assert_eq!(python_method_call_count(&tracker, py, "on_bar"), 1);
6652 assert!(message.contains("Python on_bar failed:"));
6653 assert!(message.contains("in _record"));
6654 assert!(message.contains("RuntimeError: actor callback failure"));
6655 });
6656 }
6657
6658 #[rstest]
6659 #[case("on_start")]
6660 #[case("on_stop")]
6661 #[case("on_resume")]
6662 #[case("on_reset")]
6663 #[case("on_dispose")]
6664 #[case("on_degrade")]
6665 #[case("on_fault")]
6666 fn test_python_dispatch_lifecycle_matrix(
6667 clock: Rc<RefCell<VirtualClock>>,
6668 cache: Rc<RefCell<Cache>>,
6669 trader_id: TraderId,
6670 #[case] method_name: &str,
6671 ) {
6672 pyo3::Python::initialize();
6673
6674 Python::attach(|py| {
6675 assert_python_dispatch(py, clock, cache, trader_id, method_name, |rust_actor| {
6676 match method_name {
6677 "on_start" => DataActor::on_start(rust_actor.inner_mut()),
6678 "on_stop" => DataActor::on_stop(rust_actor.inner_mut()),
6679 "on_resume" => DataActor::on_resume(rust_actor.inner_mut()),
6680 "on_reset" => DataActor::on_reset(rust_actor.inner_mut()),
6681 "on_dispose" => DataActor::on_dispose(rust_actor.inner_mut()),
6682 "on_degrade" => DataActor::on_degrade(rust_actor.inner_mut()),
6683 "on_fault" => DataActor::on_fault(rust_actor.inner_mut()),
6684 _ => unreachable!("unhandled lifecycle case: {method_name}"),
6685 }
6686 });
6687 });
6688 }
6689
6690 #[rstest]
6691 #[case("on_save")]
6692 #[case("on_load")]
6693 fn test_python_dispatch_persistence_matrix(
6694 clock: Rc<RefCell<VirtualClock>>,
6695 cache: Rc<RefCell<Cache>>,
6696 trader_id: TraderId,
6697 #[case] method_name: &str,
6698 ) {
6699 pyo3::Python::initialize();
6700
6701 Python::attach(|py| {
6702 assert_python_dispatch(py, clock, cache, trader_id, method_name, |rust_actor| {
6703 match method_name {
6704 "on_save" => {
6705 let state = DataActor::on_save(rust_actor.inner()).unwrap();
6706 assert_eq!(
6707 state.get("actor").map(Vec::as_slice),
6708 Some(b"saved".as_slice())
6709 );
6710 Ok(())
6711 }
6712 "on_load" => {
6713 let mut state = IndexMap::new();
6714 state.insert("actor".to_string(), b"loaded".to_vec());
6715 DataActor::on_load(rust_actor.inner_mut(), state)
6716 }
6717 _ => unreachable!("unhandled persistence case: {method_name}"),
6718 }
6719 });
6720 });
6721 }
6722
6723 #[rstest]
6724 fn test_python_persistence_methods_convert_state(
6725 clock: Rc<RefCell<VirtualClock>>,
6726 cache: Rc<RefCell<Cache>>,
6727 trader_id: TraderId,
6728 ) {
6729 pyo3::Python::initialize();
6730
6731 Python::attach(|py| {
6732 let py_actor = create_tracking_python_actor(py).unwrap();
6733
6734 let mut rust_actor = PyDataActor::new(None);
6735 rust_actor.set_python_instance(py_actor.bind(py)).unwrap();
6736 rust_actor.register(trader_id, clock, cache).unwrap();
6737
6738 let saved = rust_actor.py_save(py).unwrap();
6739 let saved_state = saved
6740 .bind(py)
6741 .extract::<HashMap<String, Vec<u8>>>()
6742 .unwrap();
6743 assert_eq!(
6744 saved_state.get("actor").map(Vec::as_slice),
6745 Some(&b"saved"[..])
6746 );
6747
6748 let load_state = PyDict::new(py);
6749 load_state
6750 .set_item("actor", PyBytes::new(py, b"loaded-from-python"))
6751 .unwrap();
6752
6753 rust_actor.py_load(&load_state).unwrap();
6754
6755 let loaded_state = python_last_loaded_state(&py_actor, py).unwrap();
6756 assert_eq!(
6757 loaded_state.get("actor").map(Vec::as_slice),
6758 Some(&b"loaded-from-python"[..])
6759 );
6760 });
6761 }
6762
6763 #[rstest]
6764 fn test_indicator_registration_exposes_readiness_and_registered_view(
6765 audusd_sim: CurrencyPair,
6766 bar_type: BarType,
6767 ) {
6768 pyo3::Python::initialize();
6769
6770 Python::attach(|py| {
6771 let mut rust_actor = PyDataActor::new(None);
6772 let indicator = create_tracking_python_indicator(py).unwrap();
6773
6774 assert_eq!(
6775 rust_actor
6776 .py_registered_indicators(py)
6777 .unwrap()
6778 .bind(py)
6779 .len()
6780 .unwrap(),
6781 0
6782 );
6783 assert!(!rust_actor.py_indicators_initialized(py).unwrap());
6784
6785 rust_actor.py_register_indicator_for_quote_ticks(
6786 py,
6787 audusd_sim.id,
6788 indicator.clone_ref(py),
6789 );
6790 rust_actor.py_register_indicator_for_trade_ticks(
6791 py,
6792 audusd_sim.id,
6793 indicator.clone_ref(py),
6794 );
6795 rust_actor.py_register_indicator_for_bars(py, bar_type, indicator.clone_ref(py));
6796
6797 let registered = rust_actor.py_registered_indicators(py).unwrap();
6798 let registered = registered.bind(py);
6799
6800 assert_eq!(registered.len().unwrap(), 1);
6801 assert_eq!(
6802 registered.get_item(0).unwrap().as_ptr(),
6803 indicator.bind(py).as_ptr()
6804 );
6805 assert!(!rust_actor.py_indicators_initialized(py).unwrap());
6806
6807 indicator.bind(py).setattr("initialized", true).unwrap();
6808
6809 assert!(rust_actor.py_indicators_initialized(py).unwrap());
6810 });
6811 }
6812
6813 #[rstest]
6814 fn test_registered_indicators_receive_quote_trade_and_bar_before_actor_callbacks(
6815 clock: Rc<RefCell<VirtualClock>>,
6816 cache: Rc<RefCell<Cache>>,
6817 trader_id: TraderId,
6818 ) {
6819 pyo3::Python::initialize();
6820
6821 Python::attach(|py| {
6822 let events = PyList::empty(py);
6823 let py_actor = create_indicator_event_actor(py, &events).unwrap();
6824 let indicator = create_event_tracking_python_indicator(py, &events).unwrap();
6825
6826 let mut rust_actor = PyDataActor::new(None);
6827 rust_actor.set_python_instance(py_actor.bind(py)).unwrap();
6828 rust_actor.register(trader_id, clock, cache).unwrap();
6829 Component::start(rust_actor.inner_mut()).unwrap();
6830
6831 let quote = sample_quote();
6832 let trade = sample_trade();
6833 let bar = sample_bar();
6834 let external_bar_type = BarType::from_str(&format!(
6835 "{}-1-MINUTE-LAST-EXTERNAL",
6836 bar.bar_type.instrument_id()
6837 ))
6838 .unwrap();
6839
6840 rust_actor.py_register_indicator_for_quote_ticks(
6841 py,
6842 quote.instrument_id,
6843 indicator.clone_ref(py),
6844 );
6845 rust_actor.py_register_indicator_for_trade_ticks(
6846 py,
6847 trade.instrument_id,
6848 indicator.clone_ref(py),
6849 );
6850 rust_actor.py_register_indicator_for_bars(
6851 py,
6852 external_bar_type,
6853 indicator.clone_ref(py),
6854 );
6855
6856 DataActor::handle_quote(rust_actor.inner_mut(), "e);
6857 DataActor::handle_trade(rust_actor.inner_mut(), &trade);
6858 DataActor::handle_bar(rust_actor.inner_mut(), &bar);
6859
6860 let events = events.extract::<Vec<String>>().unwrap();
6861
6862 assert_eq!(python_indicator_call_count(&indicator, py, "quote"), 1);
6863 assert_eq!(python_indicator_call_count(&indicator, py, "trade"), 1);
6864 assert_eq!(python_indicator_call_count(&indicator, py, "bar"), 1);
6865 assert_eq!(
6866 events,
6867 vec![
6868 "indicator:quote",
6869 "actor:quote",
6870 "indicator:trade",
6871 "actor:trade",
6872 "indicator:bar",
6873 "actor:bar",
6874 ]
6875 );
6876 });
6877 }
6878
6879 #[rstest]
6880 fn test_registered_indicators_receive_live_data_when_actor_not_running(
6881 clock: Rc<RefCell<VirtualClock>>,
6882 cache: Rc<RefCell<Cache>>,
6883 trader_id: TraderId,
6884 ) {
6885 pyo3::Python::initialize();
6886
6887 Python::attach(|py| {
6888 let events = PyList::empty(py);
6889 let py_actor = create_indicator_event_actor(py, &events).unwrap();
6890 let indicator = create_event_tracking_python_indicator(py, &events).unwrap();
6891
6892 let mut rust_actor = PyDataActor::new(None);
6893 rust_actor.set_python_instance(py_actor.bind(py)).unwrap();
6894 rust_actor.register(trader_id, clock, cache).unwrap();
6895
6896 let quote = sample_quote();
6897
6898 rust_actor.py_register_indicator_for_quote_ticks(
6899 py,
6900 quote.instrument_id,
6901 indicator.clone_ref(py),
6902 );
6903
6904 DataActor::handle_quote(rust_actor.inner_mut(), "e);
6905
6906 let events = events.extract::<Vec<String>>().unwrap();
6907
6908 assert_eq!(python_indicator_call_count(&indicator, py, "quote"), 1);
6909 assert_eq!(events, vec!["indicator:quote"]);
6910 });
6911 }
6912
6913 #[rstest]
6914 fn test_registered_indicators_receive_historical_quote_trade_and_bar_batches() {
6915 pyo3::Python::initialize();
6916
6917 Python::attach(|py| {
6918 let mut rust_actor = PyDataActor::new(None);
6919 let indicator = create_tracking_python_indicator(py).unwrap();
6920 let quote = sample_quote();
6921 let trade = sample_trade();
6922 let bar = sample_bar();
6923 let quotes = vec![quote];
6924 let trades = vec![trade];
6925 let bars = vec![bar];
6926
6927 rust_actor.py_register_indicator_for_quote_ticks(
6928 py,
6929 quote.instrument_id,
6930 indicator.clone_ref(py),
6931 );
6932 rust_actor.py_register_indicator_for_trade_ticks(
6933 py,
6934 trade.instrument_id,
6935 indicator.clone_ref(py),
6936 );
6937 rust_actor.py_register_indicator_for_bars(py, bar.bar_type, indicator.clone_ref(py));
6938
6939 let client_id = ClientId::new("TEST");
6940 let quotes_response = QuotesResponse::new(
6941 UUID4::new(),
6942 client_id,
6943 quote.instrument_id,
6944 quotes,
6945 None,
6946 None,
6947 UnixNanos::default(),
6948 None,
6949 );
6950 let trades_response = TradesResponse::new(
6951 UUID4::new(),
6952 client_id,
6953 trade.instrument_id,
6954 trades,
6955 None,
6956 None,
6957 UnixNanos::default(),
6958 None,
6959 );
6960 let bars_response = BarsResponse::new(
6961 UUID4::new(),
6962 client_id,
6963 bar.bar_type,
6964 bars,
6965 None,
6966 None,
6967 UnixNanos::default(),
6968 None,
6969 );
6970
6971 DataActor::handle_quotes_response(rust_actor.inner_mut(), "es_response);
6972 DataActor::handle_trades_response(rust_actor.inner_mut(), &trades_response);
6973 DataActor::handle_bars_response(rust_actor.inner_mut(), &bars_response);
6974
6975 assert_eq!(python_indicator_call_count(&indicator, py, "quote"), 1);
6976 assert_eq!(python_indicator_call_count(&indicator, py, "trade"), 1);
6977 assert_eq!(python_indicator_call_count(&indicator, py, "bar"), 1);
6978 });
6979 }
6980
6981 #[rstest]
6982 fn test_indicators_initialized_requires_all_registered_indicators(audusd_sim: CurrencyPair) {
6983 pyo3::Python::initialize();
6984
6985 Python::attach(|py| {
6986 let mut rust_actor = PyDataActor::new(None);
6987 let first = create_tracking_python_indicator(py).unwrap();
6988 let second = create_tracking_python_indicator(py).unwrap();
6989
6990 rust_actor.py_register_indicator_for_quote_ticks(
6991 py,
6992 audusd_sim.id,
6993 first.clone_ref(py),
6994 );
6995 rust_actor.py_register_indicator_for_quote_ticks(
6996 py,
6997 audusd_sim.id,
6998 second.clone_ref(py),
6999 );
7000
7001 first.bind(py).setattr("initialized", true).unwrap();
7002
7003 assert!(!rust_actor.py_indicators_initialized(py).unwrap());
7004
7005 second.bind(py).setattr("initialized", true).unwrap();
7006
7007 assert!(rust_actor.py_indicators_initialized(py).unwrap());
7008 });
7009 }
7010
7011 #[rstest]
7012 fn test_duplicate_indicator_registration_does_not_duplicate_callbacks(
7013 clock: Rc<RefCell<VirtualClock>>,
7014 cache: Rc<RefCell<Cache>>,
7015 trader_id: TraderId,
7016 ) {
7017 pyo3::Python::initialize();
7018
7019 Python::attach(|py| {
7020 let mut rust_actor = PyDataActor::new(None);
7021 let indicator = create_tracking_python_indicator(py).unwrap();
7022 let quote = sample_quote();
7023 let trade = sample_trade();
7024 let bar = sample_bar();
7025 rust_actor.register(trader_id, clock, cache).unwrap();
7026 Component::start(rust_actor.inner_mut()).unwrap();
7027
7028 rust_actor.py_register_indicator_for_quote_ticks(
7029 py,
7030 quote.instrument_id,
7031 indicator.clone_ref(py),
7032 );
7033 rust_actor.py_register_indicator_for_quote_ticks(
7034 py,
7035 quote.instrument_id,
7036 indicator.clone_ref(py),
7037 );
7038 rust_actor.py_register_indicator_for_trade_ticks(
7039 py,
7040 trade.instrument_id,
7041 indicator.clone_ref(py),
7042 );
7043 rust_actor.py_register_indicator_for_trade_ticks(
7044 py,
7045 trade.instrument_id,
7046 indicator.clone_ref(py),
7047 );
7048 rust_actor.py_register_indicator_for_bars(py, bar.bar_type, indicator.clone_ref(py));
7049 rust_actor.py_register_indicator_for_bars(py, bar.bar_type, indicator.clone_ref(py));
7050
7051 DataActor::handle_quote(rust_actor.inner_mut(), "e);
7052 DataActor::handle_trade(rust_actor.inner_mut(), &trade);
7053 DataActor::handle_bar(rust_actor.inner_mut(), &bar);
7054
7055 assert_eq!(
7056 rust_actor
7057 .py_registered_indicators(py)
7058 .unwrap()
7059 .bind(py)
7060 .len()
7061 .unwrap(),
7062 1
7063 );
7064 assert_eq!(python_indicator_call_count(&indicator, py, "quote"), 1);
7065 assert_eq!(python_indicator_call_count(&indicator, py, "trade"), 1);
7066 assert_eq!(python_indicator_call_count(&indicator, py, "bar"), 1);
7067 });
7068 }
7069
7070 #[rstest]
7071 fn test_indicator_error_prevents_actor_callback(
7072 clock: Rc<RefCell<VirtualClock>>,
7073 cache: Rc<RefCell<Cache>>,
7074 trader_id: TraderId,
7075 ) {
7076 pyo3::Python::initialize();
7077
7078 Python::attach(|py| {
7079 let events = PyList::empty(py);
7080 let py_actor = create_indicator_event_actor(py, &events).unwrap();
7081 let indicator = create_raising_python_indicator(py).unwrap();
7082
7083 let mut rust_actor = PyDataActor::new(None);
7084 rust_actor.set_python_instance(py_actor.bind(py)).unwrap();
7085 rust_actor.register(trader_id, clock, cache).unwrap();
7086 Component::start(rust_actor.inner_mut()).unwrap();
7087
7088 let quote = sample_quote();
7089
7090 rust_actor.py_register_indicator_for_quote_ticks(py, quote.instrument_id, indicator);
7091
7092 DataActor::handle_quote(rust_actor.inner_mut(), "e);
7093 let events = events.extract::<Vec<String>>().unwrap();
7094
7095 assert!(events.is_empty());
7096 });
7097 }
7098
7099 #[rstest]
7100 #[case("on_time_event")]
7101 #[case("on_data")]
7102 #[case("on_signal")]
7103 #[case("on_queue_state")]
7104 #[case("on_socket_state")]
7105 #[case("on_instrument")]
7106 #[case("on_quote")]
7107 #[case("on_trade")]
7108 #[case("on_bar")]
7109 #[case("on_book")]
7110 #[case("on_book_deltas")]
7111 #[case("on_book_depth")]
7112 #[case("on_mark_price")]
7113 #[case("on_index_price")]
7114 #[case("on_funding_rate")]
7115 #[case("on_instrument_status")]
7116 #[case("on_instrument_close")]
7117 #[case("on_option_greeks")]
7118 #[case("on_option_chain")]
7119 fn test_python_dispatch_typed_callback_matrix(
7120 clock: Rc<RefCell<VirtualClock>>,
7121 cache: Rc<RefCell<Cache>>,
7122 trader_id: TraderId,
7123 #[case] method_name: &str,
7124 ) {
7125 pyo3::Python::initialize();
7126
7127 Python::attach(|py| {
7128 assert_python_dispatch(py, clock, cache, trader_id, method_name, |rust_actor| {
7129 match method_name {
7130 "on_time_event" => {
7131 let event = sample_time_event();
7132 rust_actor.inner_mut().on_time_event(&event)
7133 }
7134 "on_data" => {
7135 let data = sample_data();
7136 rust_actor.inner_mut().on_data(&data)
7137 }
7138 "on_signal" => {
7139 let signal = sample_signal();
7140 rust_actor.inner_mut().on_signal(&signal)
7141 }
7142 "on_queue_state" => {
7143 let event = sample_queue_state_changed(QueueState::Triggered);
7144 rust_actor.inner_mut().on_queue_state(&event)
7145 }
7146 "on_socket_state" => {
7147 let event = sample_socket_state_changed(SocketState::Connected);
7148 rust_actor.inner_mut().on_socket_state(&event)
7149 }
7150 "on_instrument" => {
7151 let instrument = InstrumentAny::CurrencyPair(sample_instrument());
7152 rust_actor.inner_mut().on_instrument(&instrument)
7153 }
7154 "on_quote" => {
7155 let quote = sample_quote();
7156 rust_actor.inner_mut().on_quote("e)
7157 }
7158 "on_trade" => {
7159 let trade = sample_trade();
7160 rust_actor.inner_mut().on_trade(&trade)
7161 }
7162 "on_bar" => {
7163 let bar = sample_bar();
7164 rust_actor.inner_mut().on_bar(&bar)
7165 }
7166 "on_book" => {
7167 let book = sample_book();
7168 rust_actor.inner_mut().on_book(&book)
7169 }
7170 "on_book_deltas" => {
7171 let deltas = sample_book_deltas();
7172 rust_actor.inner_mut().on_book_deltas(&deltas)
7173 }
7174 "on_book_depth" => {
7175 let depth = sample_book_depth();
7176 rust_actor.inner_mut().on_book_depth(&depth)
7177 }
7178 "on_mark_price" => {
7179 let update = sample_mark_price();
7180 rust_actor.inner_mut().on_mark_price(&update)
7181 }
7182 "on_index_price" => {
7183 let update = sample_index_price();
7184 rust_actor.inner_mut().on_index_price(&update)
7185 }
7186 "on_funding_rate" => {
7187 let update = sample_funding_rate();
7188 rust_actor.inner_mut().on_funding_rate(&update)
7189 }
7190 "on_instrument_status" => {
7191 let status = sample_instrument_status();
7192 rust_actor.inner_mut().on_instrument_status(&status)
7193 }
7194 "on_instrument_close" => {
7195 let close = sample_instrument_close();
7196 rust_actor.inner_mut().on_instrument_close(&close)
7197 }
7198 "on_option_greeks" => {
7199 let greeks = sample_option_greeks();
7200 rust_actor.inner_mut().on_option_greeks(&greeks)
7201 }
7202 "on_option_chain" => {
7203 let chain = sample_option_chain();
7204 rust_actor.inner_mut().on_option_chain(&chain)
7205 }
7206 _ => unreachable!("unhandled typed callback case: {method_name}"),
7207 }
7208 });
7209 });
7210 }
7211
7212 #[rstest]
7213 #[case("on_historical_data")]
7214 #[case("on_historical_book_deltas")]
7215 #[case("on_historical_book_depth")]
7216 #[case("on_historical_quotes")]
7217 #[case("on_historical_trades")]
7218 #[case("on_historical_funding_rates")]
7219 #[case("on_historical_bars")]
7220 #[case("on_historical_mark_prices")]
7221 #[case("on_historical_index_prices")]
7222 fn test_python_dispatch_historical_callback_matrix(
7223 clock: Rc<RefCell<VirtualClock>>,
7224 cache: Rc<RefCell<Cache>>,
7225 trader_id: TraderId,
7226 #[case] method_name: &str,
7227 ) {
7228 pyo3::Python::initialize();
7229
7230 Python::attach(|py| {
7231 assert_python_dispatch(py, clock, cache, trader_id, method_name, |rust_actor| {
7232 match method_name {
7233 "on_historical_data" => {
7234 let data = sample_data();
7235 rust_actor.inner_mut().on_historical_data(&data)
7236 }
7237 "on_historical_book_deltas" => {
7238 let deltas = sample_book_deltas().deltas;
7239 rust_actor.inner_mut().on_historical_book_deltas(&deltas)
7240 }
7241 "on_historical_book_depth" => {
7242 let depths = vec![sample_book_depth()];
7243 rust_actor.inner_mut().on_historical_book_depth(&depths)
7244 }
7245 "on_historical_quotes" => {
7246 let quotes = vec![sample_quote()];
7247 rust_actor.inner_mut().on_historical_quotes("es)
7248 }
7249 "on_historical_trades" => {
7250 let trades = vec![sample_trade()];
7251 rust_actor.inner_mut().on_historical_trades(&trades)
7252 }
7253 "on_historical_funding_rates" => {
7254 let funding_rates = vec![sample_funding_rate()];
7255 rust_actor
7256 .inner_mut()
7257 .on_historical_funding_rates(&funding_rates)
7258 }
7259 "on_historical_bars" => {
7260 let bars = vec![sample_bar()];
7261 rust_actor.inner_mut().on_historical_bars(&bars)
7262 }
7263 "on_historical_mark_prices" => {
7264 let mark_prices = vec![sample_mark_price()];
7265 rust_actor
7266 .inner_mut()
7267 .on_historical_mark_prices(&mark_prices)
7268 }
7269 "on_historical_index_prices" => {
7270 let index_prices = vec![sample_index_price()];
7271 rust_actor
7272 .inner_mut()
7273 .on_historical_index_prices(&index_prices)
7274 }
7275 _ => unreachable!("unhandled historical callback case: {method_name}"),
7276 }
7277 });
7278 });
7279 }
7280
7281 #[rstest]
7282 fn test_python_dispatch_historical_book_deltas_preserves_batch(
7283 clock: Rc<RefCell<VirtualClock>>,
7284 cache: Rc<RefCell<Cache>>,
7285 trader_id: TraderId,
7286 ) {
7287 pyo3::Python::initialize();
7288
7289 Python::attach(|py| {
7290 let expected = stub_deltas().deltas;
7291 let py_actor = assert_python_dispatch(
7292 py,
7293 clock,
7294 cache,
7295 trader_id,
7296 "on_historical_book_deltas",
7297 |rust_actor| rust_actor.inner_mut().on_historical_book_deltas(&expected),
7298 );
7299 let actual = py_actor
7300 .call_method1(py, "last_call_args", ("on_historical_book_deltas",))
7301 .unwrap()
7302 .bind(py)
7303 .get_item(0)
7304 .unwrap()
7305 .extract::<Vec<OrderBookDelta>>()
7306 .unwrap();
7307
7308 assert_eq!(actual, expected);
7309 });
7310 }
7311
7312 #[rstest]
7313 fn test_python_dispatch_historical_book_depth_preserves_batch(
7314 clock: Rc<RefCell<VirtualClock>>,
7315 cache: Rc<RefCell<Cache>>,
7316 trader_id: TraderId,
7317 ) {
7318 pyo3::Python::initialize();
7319
7320 Python::attach(|py| {
7321 let first = stub_depth10();
7322 let mut second = first.clone();
7323 second.sequence = 17;
7324 second.ts_event = UnixNanos::from(18);
7325 second.ts_init = UnixNanos::from(19);
7326 let expected = vec![first, second];
7327 let py_actor = assert_python_dispatch(
7328 py,
7329 clock,
7330 cache,
7331 trader_id,
7332 "on_historical_book_depth",
7333 |rust_actor| rust_actor.inner_mut().on_historical_book_depth(&expected),
7334 );
7335 let actual = py_actor
7336 .call_method1(py, "last_call_args", ("on_historical_book_depth",))
7337 .unwrap()
7338 .bind(py)
7339 .get_item(0)
7340 .unwrap()
7341 .extract::<Vec<OrderBookDepth>>()
7342 .unwrap();
7343
7344 assert_eq!(actual, expected);
7345 });
7346 }
7347
7348 #[cfg(feature = "defi")]
7349 #[rstest]
7350 #[case("on_block")]
7351 #[case("on_pool")]
7352 #[case("on_pool_swap")]
7353 #[case("on_pool_liquidity_update")]
7354 #[case("on_pool_fee_collect")]
7355 #[case("on_pool_flash")]
7356 fn test_python_dispatch_defi_callback_matrix(
7357 clock: Rc<RefCell<VirtualClock>>,
7358 cache: Rc<RefCell<Cache>>,
7359 trader_id: TraderId,
7360 #[case] method_name: &str,
7361 ) {
7362 pyo3::Python::initialize();
7363
7364 Python::attach(|py| {
7365 assert_python_dispatch(py, clock, cache, trader_id, method_name, |rust_actor| {
7366 match method_name {
7367 "on_block" => {
7368 let block = sample_block();
7369 rust_actor.inner_mut().on_block(&block)
7370 }
7371 "on_pool" => {
7372 let (_chain, _dex, pool) = sample_pool_components();
7373 rust_actor.inner_mut().on_pool(&pool)
7374 }
7375 "on_pool_swap" => {
7376 let swap = sample_pool_swap();
7377 rust_actor.inner_mut().on_pool_swap(&swap)
7378 }
7379 "on_pool_liquidity_update" => {
7380 let update = sample_pool_liquidity_update();
7381 rust_actor.inner_mut().on_pool_liquidity_update(&update)
7382 }
7383 "on_pool_fee_collect" => {
7384 let collect = sample_pool_fee_collect();
7385 rust_actor.inner_mut().on_pool_fee_collect(&collect)
7386 }
7387 "on_pool_flash" => {
7388 let flash = sample_pool_flash();
7389 rust_actor.inner_mut().on_pool_flash(&flash)
7390 }
7391 _ => unreachable!("unhandled defi callback case: {method_name}"),
7392 }
7393 });
7394 });
7395 }
7396
7397 #[rstest]
7398 fn test_python_dispatch_multiple_calls_tracked(
7399 clock: Rc<RefCell<VirtualClock>>,
7400 cache: Rc<RefCell<Cache>>,
7401 trader_id: TraderId,
7402 audusd_sim: CurrencyPair,
7403 ) {
7404 pyo3::Python::initialize();
7405
7406 Python::attach(|py| {
7407 let py_actor = create_tracking_python_actor(py).unwrap();
7408
7409 let mut rust_actor = PyDataActor::new(None);
7410 rust_actor.set_python_instance(py_actor.bind(py)).unwrap();
7411 rust_actor.register(trader_id, clock, cache).unwrap();
7412
7413 let quote = QuoteTick::new(
7414 audusd_sim.id,
7415 Price::from("1.00000"),
7416 Price::from("1.00001"),
7417 Quantity::from(100_000),
7418 Quantity::from(100_000),
7419 UnixNanos::default(),
7420 UnixNanos::default(),
7421 );
7422
7423 rust_actor.inner_mut().on_quote("e).unwrap();
7424 rust_actor.inner_mut().on_quote("e).unwrap();
7425 rust_actor.inner_mut().on_quote("e).unwrap();
7426
7427 assert_eq!(python_method_call_count(&py_actor, py, "on_quote"), 3);
7428 });
7429 }
7430
7431 #[rstest]
7432 fn test_python_dispatch_historical_custom_data_preserves_payload_shape(
7433 clock: Rc<RefCell<VirtualClock>>,
7434 cache: Rc<RefCell<Cache>>,
7435 trader_id: TraderId,
7436 client_id: ClientId,
7437 ) {
7438 pyo3::Python::initialize();
7439
7440 Python::attach(|py| {
7441 let py_actor = create_tracking_python_actor(py).unwrap();
7442 let mut rust_actor = PyDataActor::new(None);
7443 rust_actor.set_python_instance(py_actor.bind(py)).unwrap();
7444 rust_actor.register(trader_id, clock, cache).unwrap();
7445
7446 let data = vec![
7447 stub_custom_data(1, 42, None, None),
7448 stub_custom_data(2, 84, None, None),
7449 ];
7450 let scalar = stub_custom_data(3, 126, None, None);
7451 let scalar_response = CustomDataResponse::new(
7452 UUID4::new(),
7453 client_id,
7454 None,
7455 scalar.data_type.clone(),
7456 scalar.clone(),
7457 None,
7458 None,
7459 UnixNanos::default(),
7460 None,
7461 );
7462
7463 DataActor::handle_data_response(rust_actor.inner_mut(), &scalar_response);
7464
7465 let actual_scalar = py_actor
7466 .call_method1(py, "last_call_args", ("on_historical_data",))
7467 .unwrap()
7468 .bind(py)
7469 .get_item(0)
7470 .unwrap()
7471 .extract::<CustomData>()
7472 .unwrap();
7473
7474 assert_eq!(
7475 python_method_call_count(&py_actor, py, "on_historical_data"),
7476 1
7477 );
7478 assert_eq!(actual_scalar, scalar);
7479
7480 let empty_response = CustomDataResponse::new(
7481 UUID4::new(),
7482 client_id,
7483 None,
7484 data[0].data_type.clone(),
7485 Vec::<CustomData>::new(),
7486 None,
7487 None,
7488 UnixNanos::default(),
7489 None,
7490 );
7491
7492 DataActor::handle_data_response(rust_actor.inner_mut(), &empty_response);
7493
7494 let empty = py_actor
7495 .call_method1(py, "last_call_args", ("on_historical_data",))
7496 .unwrap()
7497 .bind(py)
7498 .get_item(0)
7499 .unwrap()
7500 .extract::<Vec<CustomData>>()
7501 .unwrap();
7502
7503 assert_eq!(
7504 python_method_call_count(&py_actor, py, "on_historical_data"),
7505 2
7506 );
7507 assert!(empty.is_empty());
7508
7509 let response = CustomDataResponse::new(
7510 UUID4::new(),
7511 client_id,
7512 None,
7513 data[0].data_type.clone(),
7514 data.clone(),
7515 None,
7516 None,
7517 UnixNanos::default(),
7518 None,
7519 );
7520
7521 DataActor::handle_data_response(rust_actor.inner_mut(), &response);
7522
7523 let actual = py_actor
7524 .call_method1(py, "last_call_args", ("on_historical_data",))
7525 .unwrap()
7526 .bind(py)
7527 .get_item(0)
7528 .unwrap()
7529 .extract::<Vec<CustomData>>()
7530 .unwrap();
7531
7532 assert_eq!(
7533 python_method_call_count(&py_actor, py, "on_historical_data"),
7534 3
7535 );
7536 assert_eq!(actual, data);
7537 });
7538 }
7539
7540 #[rstest]
7541 fn test_python_dispatch_no_call_when_py_self_not_set(
7542 clock: Rc<RefCell<VirtualClock>>,
7543 cache: Rc<RefCell<Cache>>,
7544 trader_id: TraderId,
7545 ) {
7546 pyo3::Python::initialize();
7547
7548 Python::attach(|_py| {
7549 let mut rust_actor = PyDataActor::new(None);
7550 rust_actor.register(trader_id, clock, cache).unwrap();
7551
7552 let result = DataActor::on_start(rust_actor.inner_mut());
7554 assert!(result.is_ok());
7555 });
7556 }
7557
7558 #[rstest]
7559 fn test_python_on_historical_data_rejects_non_custom_data(
7560 clock: Rc<RefCell<VirtualClock>>,
7561 cache: Rc<RefCell<Cache>>,
7562 trader_id: TraderId,
7563 ) {
7564 pyo3::Python::initialize();
7565
7566 let mut rust_actor = PyDataActor::new(None);
7567 rust_actor.register(trader_id, clock, cache).unwrap();
7568
7569 let non_custom: String = "not CustomData".to_string();
7570 let result = rust_actor.inner_mut().on_historical_data(&non_custom);
7571
7572 assert!(result.is_err());
7573 assert!(result.unwrap_err().to_string().contains("unsupported type"));
7574 }
7575
7576 #[rstest]
7577 fn test_python_self_is_weak() {
7578 Python::initialize();
7579
7580 Python::attach(|py| {
7581 let instance = py
7582 .get_type::<PyDataActor>()
7583 .call0()
7584 .expect("DataActor should construct");
7585 let weakref =
7586 PyWeakrefReference::new(&instance).expect("DataActor should be weak-referenceable");
7587 assert!(weakref.upgrade().is_some());
7588
7589 drop(instance);
7590
7591 assert!(
7593 weakref.upgrade().is_none(),
7594 "an unregistered DataActor must be collected once its last Python owner is dropped",
7595 );
7596 });
7597 }
7598
7599 #[rstest::rstest]
7600 #[case("on_start")]
7601 #[case("on_stop")]
7602 #[case("on_resume")]
7603 #[case("on_reset")]
7604 #[case("on_dispose")]
7605 #[case("on_degrade")]
7606 #[case("on_fault")]
7607 #[case("on_save")]
7608 #[case("on_load")]
7609 #[case("on_time_event")]
7610 #[case("on_data")]
7611 #[case("on_signal")]
7612 #[case("on_queue_state")]
7613 #[case("on_socket_state")]
7614 #[case("on_instrument")]
7615 #[case("on_quote")]
7616 #[case("on_trade")]
7617 #[case("on_bar")]
7618 #[case("on_book_deltas")]
7619 #[case("on_book_depth")]
7620 #[case("on_book")]
7621 #[case("on_mark_price")]
7622 #[case("on_index_price")]
7623 #[case("on_funding_rate")]
7624 #[case("on_instrument_status")]
7625 #[case("on_instrument_close")]
7626 #[case("on_option_greeks")]
7627 #[case("on_option_chain")]
7628 #[case("on_historical_data")]
7629 #[case("on_historical_book_deltas")]
7630 #[case("on_historical_book_depth")]
7631 #[case("on_historical_quotes")]
7632 #[case("on_historical_trades")]
7633 #[case("on_historical_funding_rates")]
7634 #[case("on_historical_bars")]
7635 #[case("on_historical_mark_prices")]
7636 #[case("on_historical_index_prices")]
7637 fn test_default_callback_during_exclusive_borrow(#[case] method: &str) {
7638 Python::initialize();
7639 Python::attach(|py| {
7640 let argument = match method {
7641 "on_start" | "on_stop" | "on_resume" | "on_reset" | "on_dispose" | "on_degrade"
7642 | "on_fault" | "on_save" => None,
7643 "on_load" => Some(PyDict::new(py).into_any().unbind()),
7644 "on_time_event" => Some(sample_time_event().into_py_any(py).unwrap()),
7645 "on_data" | "on_instrument" | "on_historical_data" => Some(py.None()),
7646 "on_signal" => Some(sample_signal().into_py_any(py).unwrap()),
7647 "on_queue_state" => Some(
7648 sample_queue_state_changed(QueueState::Triggered)
7649 .into_py_any(py)
7650 .unwrap(),
7651 ),
7652 "on_socket_state" => Some(
7653 sample_socket_state_changed(SocketState::Connected)
7654 .into_py_any(py)
7655 .unwrap(),
7656 ),
7657 "on_quote" => Some(sample_quote().into_py_any(py).unwrap()),
7658 "on_trade" => Some(sample_trade().into_py_any(py).unwrap()),
7659 "on_bar" => Some(sample_bar().into_py_any(py).unwrap()),
7660 "on_book_deltas" => Some(sample_book_deltas().into_py_any(py).unwrap()),
7661 "on_book_depth" => Some(sample_book_depth().into_py_any(py).unwrap()),
7662 "on_book" => Some(sample_book().into_py_any(py).unwrap()),
7663 "on_mark_price" => Some(sample_mark_price().into_py_any(py).unwrap()),
7664 "on_index_price" => Some(sample_index_price().into_py_any(py).unwrap()),
7665 "on_funding_rate" => Some(sample_funding_rate().into_py_any(py).unwrap()),
7666 "on_instrument_status" => Some(sample_instrument_status().into_py_any(py).unwrap()),
7667 "on_instrument_close" => Some(sample_instrument_close().into_py_any(py).unwrap()),
7668 "on_option_greeks" => Some(sample_option_greeks().into_py_any(py).unwrap()),
7669 "on_option_chain" => Some(sample_option_chain().into_py_any(py).unwrap()),
7670 "on_historical_book_deltas"
7671 | "on_historical_book_depth"
7672 | "on_historical_quotes"
7673 | "on_historical_trades"
7674 | "on_historical_funding_rates"
7675 | "on_historical_bars"
7676 | "on_historical_mark_prices"
7677 | "on_historical_index_prices" => Some(PyList::empty(py).into_any().unbind()),
7678 _ => unreachable!(),
7679 };
7680
7681 let instance = py.get_type::<PyDataActor>().call0().unwrap();
7682 let _borrow = instance
7683 .extract::<pyo3::PyRefMut<'_, PyDataActor>>()
7684 .unwrap();
7685
7686 let result = match argument {
7687 Some(argument) => instance.call_method1(method, (argument,)),
7688 None => instance.call_method0(method),
7689 }
7690 .unwrap();
7691
7692 if method == "on_save" {
7693 assert_eq!(result.len().unwrap(), 0);
7694 } else {
7695 assert!(result.is_none());
7696 }
7697 });
7698 }
7699
7700 #[cfg(feature = "defi")]
7701 #[rstest::rstest]
7702 #[case("on_block")]
7703 #[case("on_pool")]
7704 #[case("on_pool_swap")]
7705 #[case("on_pool_liquidity_update")]
7706 #[case("on_pool_fee_collect")]
7707 #[case("on_pool_flash")]
7708 fn test_default_defi_callback_during_exclusive_borrow(#[case] method: &str) {
7709 Python::initialize();
7710 Python::attach(|py| {
7711 let argument = match method {
7712 "on_block" => sample_block().into_py_any(py).unwrap(),
7713 "on_pool" => sample_pool_components().2.into_py_any(py).unwrap(),
7714 "on_pool_swap" => sample_pool_swap().into_py_any(py).unwrap(),
7715 "on_pool_liquidity_update" => {
7716 sample_pool_liquidity_update().into_py_any(py).unwrap()
7717 }
7718 "on_pool_fee_collect" => sample_pool_fee_collect().into_py_any(py).unwrap(),
7719 "on_pool_flash" => sample_pool_flash().into_py_any(py).unwrap(),
7720 _ => unreachable!(),
7721 };
7722
7723 let instance = py.get_type::<PyDataActor>().call0().unwrap();
7724 let _borrow = instance
7725 .extract::<pyo3::PyRefMut<'_, PyDataActor>>()
7726 .unwrap();
7727 assert!(
7728 instance
7729 .call_method1(method, (argument,))
7730 .unwrap()
7731 .is_none()
7732 );
7733 });
7734 }
7735
7736 #[rstest]
7737 fn test_python_instrument_lists_validate_before_dispatch(
7738 #[values(
7739 "instrument",
7740 "book_deltas",
7741 "book_depth",
7742 "book_at_interval",
7743 "mark_prices",
7744 "index_prices",
7745 "funding_rates",
7746 "instrument_status",
7747 "instrument_close",
7748 "option_greeks"
7749 )]
7750 family: &str,
7751 #[values(false, true)] subscribe: bool,
7752 #[values(false, true)] mixed_venues: bool,
7753 clock: Rc<RefCell<VirtualClock>>,
7754 cache: Rc<RefCell<Cache>>,
7755 trader_id: TraderId,
7756 ) {
7757 Python::initialize();
7758 Python::attach(|py| {
7759 let actor = Py::new(py, create_registered_actor(clock, cache, trader_id)).unwrap();
7760 let (handler, saver) = get_typed_into_message_saving_handler::<DataCommand>(None);
7761 msgbus::register_data_command_endpoint(
7762 MessagingSwitchboard::data_engine_queue_execute(),
7763 handler,
7764 );
7765
7766 let ids = if mixed_venues {
7767 vec![
7768 InstrumentId::from("BTC/USD.SIM"),
7769 InstrumentId::from("ETH/USD.OTHER"),
7770 ]
7771 } else {
7772 vec![]
7773 };
7774
7775 let argument = PyList::new(py, ids).unwrap();
7776 let kwargs = instrument_subscription_keywords(py, family, subscribe);
7777 let method = format!(
7778 "{}_{family}",
7779 if subscribe {
7780 "subscribe"
7781 } else {
7782 "unsubscribe"
7783 }
7784 );
7785 let error = actor
7786 .bind(py)
7787 .call_method(method.as_str(), (&argument,), Some(&kwargs))
7788 .unwrap_err();
7789 assert!(error.is_instance_of::<pyo3::exceptions::PyValueError>(py));
7790 assert_eq!(
7791 error.value(py).to_string(),
7792 if mixed_venues {
7793 "multiple instrument venues require an explicit client ID"
7794 } else {
7795 "instrument IDs cannot be empty"
7796 }
7797 );
7798 assert_eq!(saver.get_messages().len(), 0);
7799 });
7800 }
7801
7802 fn instrument_subscription_keywords<'py>(
7803 py: Python<'py>,
7804 family: &str,
7805 subscribe: bool,
7806 ) -> Bound<'py, PyDict> {
7807 let kwargs = PyDict::new(py);
7808 if family.starts_with("book_") && subscribe {
7809 kwargs.set_item("book_type", BookType::L2_MBP).unwrap();
7810 }
7811
7812 if family == "book_at_interval" {
7813 kwargs.set_item("interval_ms", 13).unwrap();
7814 }
7815
7816 kwargs
7817 }
7818}