Skip to main content

nautilus_common/python/
actor.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
5//  You may not use this file except in compliance with the License.
6//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
7//  Unless required by applicable law or agreed to in writing, software
8//  distributed under the License is distributed on an "AS IS" BASIS,
9//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10//  See the License for the specific language governing permissions and
11//  limitations under the License.
12// -------------------------------------------------------------------------------------------------
13
14//! Python bindings for `DataActor` with complete command and event handler forwarding.
15
16use 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    /// Common configuration for `DataActor` based components.
100    #[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    /// Configuration for creating actors from importable paths.
150    #[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        // Convert HashMap<String, serde_json::Value> back to Python dict
190        let py_dict = PyDict::new(py);
191
192        for (key, value) in &self.config {
193            // Convert serde_json::Value back to Python object via JSON
194            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
202/// Inner state of `PyDataActor`, shared between Python wrapper and Rust registries.
203///
204/// This type holds the actual actor state and implements all the actor traits.
205/// It is wrapped in `Rc<UnsafeCell<>>` to allow shared ownership between Python
206/// and the global registries without copying.
207pub 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    // The trader owns the wrapper for as long as the actor stays registered, so a collected
747    // wrapper propagates as an error rather than a skipped callback.
748    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/// Python-facing wrapper for `DataActor`.
780///
781/// This wrapper holds shared ownership of `PyDataActorInner` via `Rc<UnsafeCell<>>`.
782/// Both Python (through this wrapper) and the global registries share the same
783/// underlying actor instance, ensuring mutations are visible from both sides.
784#[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    /// Returns a reference to the inner actor state.
807    ///
808    /// # Safety
809    ///
810    /// This is safe for single-threaded use. The `UnsafeCell` allows interior
811    /// mutability which is required for the registries to mutate the actor.
812    #[inline]
813    #[allow(unsafe_code)]
814    pub(crate) fn inner(&self) -> &PyDataActorInner {
815        unsafe { &*self.inner.get() }
816    }
817
818    /// Returns a mutable reference to the inner actor state.
819    ///
820    /// # Safety
821    ///
822    /// This is safe for single-threaded use. Callers must ensure no aliasing
823    /// mutable references exist.
824    #[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    // Rust constructor for tests and direct Rust usage
847    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(); // Temporary clock, will be updated on registration
851        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    /// Creates a new [`PyDataActor`] from a Python config object.
867    ///
868    /// Extracts a [`DataActorConfig`] when the object provides one, falling back to defaults
869    /// otherwise, and retains the original object so `.config` returns what the caller passed.
870    /// Subclass constructors share this so the base is built the same way everywhere.
871    #[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    /// Sets the Python instance reference for method dispatch.
882    ///
883    /// This enables the `PyDataActor` to forward method calls (like `on_start`, `on_stop`)
884    /// to the original Python instance that contains this `PyDataActor`. This is essential
885    /// for Python inheritance to work correctly, allowing Python subclasses to override
886    /// `DataActor` methods and have them called by the Rust system.
887    ///
888    /// Only a weak reference is stored, so the caller keeps ownership of `py_obj`. The trader
889    /// owns registered wrappers; an unregistered actor stays collectable.
890    ///
891    /// # Errors
892    ///
893    /// Returns an error if `py_obj` cannot be weakly referenced.
894    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    /// Stores the original Python config object passed at construction.
900    ///
901    /// Retained so the constructed instance exposes `.config` and instance-based registration can
902    /// source the actor ID and logging flags from the same single config object.
903    pub fn set_config(&mut self, config: Option<Py<PyAny>>) {
904        self.inner_mut().config = config;
905    }
906
907    /// Updates the `actor_id` in both the core config and the `actor_id` field.
908    ///
909    /// This method is only exposed for the Python actor to assist with configuration and should
910    /// **never** be called post registration. Calling this after registration will cause
911    /// inconsistent state where the actor is registered under one ID but its internal `actor_id`
912    /// field contains another, breaking message routing and lifecycle management.
913    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    /// Updates the `log_events` setting in the core config.
921    pub fn set_log_events(&mut self, log_events: bool) {
922        self.inner_mut().core.config.log_events = log_events;
923    }
924
925    /// Updates the `log_commands` setting in the core config.
926    pub fn set_log_commands(&mut self, log_commands: bool) {
927        self.inner_mut().core.config.log_commands = log_commands;
928    }
929
930    /// Returns the memory address of this instance as a hexadecimal string.
931    pub fn mem_address(&self) -> String {
932        self.inner().core.mem_address()
933    }
934
935    /// Returns a value indicating whether the actor has been registered with a trader.
936    pub fn is_registered(&self) -> bool {
937        self.inner().core.is_registered()
938    }
939
940    /// Register the actor with a trader.
941    ///
942    /// # Errors
943    ///
944    /// Returns an error if the actor is already registered or if the registration process fails.
945    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        // Register default time event handler for this actor
957        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    /// Registers this actor in the global component, actor, and wrapper registries.
974    ///
975    /// Clones the internal `Rc` and inserts into both registries. This ensures
976    /// Python and the registries share the exact same actor instance. The Python wrapper is
977    /// retained as part of the same act, so a registered actor always has an owner for the
978    /// wrapper its inner only weakly references.
979    ///
980    /// # Errors
981    ///
982    /// Returns an error if no Python wrapper is attached, or if the attached wrapper has already
983    /// been collected. Nothing is registered in that case.
984    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    /// Creates a new [`PyDataActor`] instance.
1352    ///
1353    /// Accepts `None` or any Python object. If the object is a [`DataActorConfig`]
1354    /// (or can be extracted as one via `from_py_object`), its values are used;
1355    /// otherwise the actor falls back to [`DataActorConfig::default()`].
1356    ///
1357    /// This permissive signature is required so that Python subclasses can pass a
1358    /// **custom** config dataclass to their `__init__`. The original object is retained
1359    /// here in `__new__`, which always receives the constructor arguments, so `.config`
1360    /// and registration see the config even when a subclass omits forwarding it to
1361    /// `super().__init__()`.
1362    #[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            // `__new__` retained the config; only a forwarded config overrides it
1374            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    /// Requests reconnect of one socket endpoint owned by `client_id`.
3055    #[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        // Default implementation - can be overridden in Python subclasses
3068    }
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        // Default implementation - can be overridden in Python subclasses
3082    }
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        // Default implementation - can be overridden in Python subclasses
3088    }
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        // Default implementation - can be overridden in Python subclasses
3097    }
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        // Default implementation - can be overridden in Python subclasses
3103    }
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        // Default implementation - can be overridden in Python subclasses
3109    }
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        // Default implementation - can be overridden in Python subclasses
3115    }
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
3407/// Prepares a Python actor for registration and returns its final actor ID.
3408///
3409/// Applies optional config overrides and stores a weak reference to the Python instance used for
3410/// method dispatch. Missing or unreadable attributes are ignored, and non-boolean `log_events` or
3411/// `log_commands` values leave the existing settings unchanged. When neither the config nor
3412/// `DataActor.__init__` supplies an ID, the runtime class name replaces the shared default so
3413/// subclasses that skip the base initializer still receive distinct IDs.
3414///
3415/// # Errors
3416///
3417/// Returns an error if the actor cannot be extracted, its configured `actor_id` is neither an
3418/// [`ActorId`] nor a valid ID string, its class-derived ID is invalid, or its Python instance
3419/// cannot be weakly referenced.
3420pub 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
3494/// Returns whether the config retained by the actor supplies an actor ID.
3495///
3496/// The config is read through Python rather than the extracted [`DataActorConfig`] so that a
3497/// custom subclass config which cannot be extracted still counts as configuring an ID. The actor
3498/// borrow is released before the attribute lookup, which can run user code.
3499fn 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
3516/// Extracts one instrument ID or a sequence into a normalized, non-empty list.
3517///
3518/// Duplicate IDs are removed in first-occurrence order.
3519///
3520/// # Errors
3521///
3522/// Returns an error if:
3523/// - The value is not an instrument ID or a sequence of instrument IDs.
3524/// - The sequence is empty.
3525pub 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
3537/// Extracts one bar type or a sequence into a normalized, non-empty list.
3538///
3539/// Duplicate bar types are removed in first-occurrence order.
3540///
3541/// # Errors
3542///
3543/// Returns an error if the sequence is empty or the value is not a bar type or sequence of bar types.
3544pub 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        // Set up sync data command sender for tests
3674        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        // Accessing clock before registration should raise PyRuntimeError
4166        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        // Verify unregistered state
4194        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        // Ensure clean msgbus for this test
4302        *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        // Signals travel as `CustomData` on the bus so persistence and other
4340        // `CustomData`-aware subscribers pick them up. Downcast inside the handler.
4341        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            // The PyO3 binding must forward the priority to the bus unchanged.
4461            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        // Exercises the `Signal::to_pyobject` path: a `CustomData` wrapping a
4807        // `Signal` reaches Python `on_data`, and the PyO3 `.data` getter must
4808        // successfully unwrap the inner `Arc<dyn CustomDataTrait>` into a
4809        // Python `Signal`. Without `Signal::to_pyobject`, the getter raises
4810        // `TypeError` and this assertion fails.
4811        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            // Subscribe as custom-data for the signal's advertised DataType
4851            // (`data.SignalExample`) so `on_data` fires with the wrapping CustomData.
4852            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        // Adding again raises
4904        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        // Updating a non-existent raises
4923        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(), &quote);
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(), &quote);
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(), &quotes_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(), &quote);
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(), &quote);
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(&quote)
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(&quotes)
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(&quote).unwrap();
7424            rust_actor.inner_mut().on_quote(&quote).unwrap();
7425            rust_actor.inner_mut().on_quote(&quote).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            // When py_self is None, the dispatch returns Ok(()) without calling Python
7553            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            // A strong `py_self` would form an untraceable Rust-Python cycle and keep this alive
7592            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}