Skip to main content

nautilus_trading/python/
algorithm.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Python bindings for execution algorithms.
17
18use std::{cell::UnsafeCell, collections::HashMap, fmt::Debug, rc::Rc};
19
20use jiff::Timestamp;
21use nautilus_common::{
22    actor::{DataActor, DataActorNative, data_actor::DataActorCore},
23    component::Component,
24    enums::ComponentState,
25    messages::system::{QueueStateChanged, SocketStateChanged},
26    python::{
27        cache::PyCache,
28        clock::PyClock,
29        logging::{PyLogger, format_exception},
30        wrappers::get_python_message_bus,
31    },
32    runner::SystemChannel,
33    signal::Signal,
34    timer::TimeEvent,
35};
36use nautilus_core::{
37    UnixNanos,
38    python::{to_pyruntime_err, to_pyvalue_err, upgrade_py_weakref},
39};
40use nautilus_model::{
41    data::{CustomData, DataType},
42    enums::{TimeInForce, TriggerType},
43    events::{
44        OrderAccepted, OrderCancelDenied, OrderCancelRejected, OrderCanceled, OrderDenied,
45        OrderEmulated, OrderEventAny, OrderExpired, OrderFillVoided, OrderFilled, OrderInitialized,
46        OrderModifyDenied, OrderModifyRejected, OrderPendingCancel, OrderPendingUpdate,
47        OrderRejected, OrderReleased, OrderSubmitted, OrderTriggered, OrderUpdated,
48        PositionChanged, PositionClosed, PositionEvent, PositionOpened,
49    },
50    identifiers::{ActorId, ClientId, ExecAlgorithmId, PositionId, TraderId},
51    orders::{LimitOrder, MarketOrder, MarketToLimitOrder, Order, OrderAny, OrderList},
52    python::{events::order::order_event_to_pyobject, orders::pyobject_to_order_any},
53    types::{Price, Quantity},
54};
55use nautilus_portfolio::python::PyPortfolio;
56use pyo3::{
57    IntoPyObjectExt,
58    prelude::*,
59    types::{PyDict, PyList, PyWeakrefReference},
60};
61use ustr::Ustr;
62
63use crate::algorithm::{
64    EmulatedOrderSubmissionError, ExecutionAlgorithm, ExecutionAlgorithmConfig,
65    ExecutionAlgorithmCore, ExecutionAlgorithmNative, ImportableExecutionAlgorithmConfig,
66};
67
68/// Inner state of `PyExecutionAlgorithm`, shared by the Python and Rust registries.
69pub struct PyExecutionAlgorithmInner {
70    core: ExecutionAlgorithmCore,
71    py_self: Option<Py<PyWeakrefReference>>,
72    config: Option<Py<PyAny>>,
73    logger: PyLogger,
74}
75
76impl PyExecutionAlgorithmInner {
77    // The trader owns the wrapper for as long as the algorithm stays registered, so a collected
78    // wrapper propagates as an error rather than a skipped callback.
79    fn python_instance(&self) -> PyResult<Option<Py<PyAny>>> {
80        upgrade_py_weakref(self.py_self.as_ref(), &self.core.exec_algorithm_id)
81    }
82}
83
84impl Debug for PyExecutionAlgorithmInner {
85    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
86        f.debug_struct(stringify!(PyExecutionAlgorithmInner))
87            .field("core", &self.core)
88            .field(
89                "py_self",
90                &self.py_self.as_ref().map(|_| "<Py<PyWeakrefReference>>"),
91            )
92            .field("config", &self.config.as_ref().map(|_| "<Py<PyAny>>"))
93            .field("logger", &self.logger)
94            .finish()
95    }
96}
97
98/// Python-facing wrapper for execution algorithms.
99#[allow(non_camel_case_types)]
100#[pyo3::pyclass(
101    module = "nautilus_trader.trading",
102    name = "ExecutionAlgorithm",
103    unsendable,
104    subclass,
105    weakref
106)]
107#[pyo3_stub_gen::derive::gen_stub_pyclass(module = "nautilus_trader.trading")]
108#[derive(Clone)]
109pub struct PyExecutionAlgorithm {
110    inner: Rc<UnsafeCell<PyExecutionAlgorithmInner>>,
111}
112
113impl Debug for PyExecutionAlgorithm {
114    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
115        f.debug_struct(stringify!(PyExecutionAlgorithm))
116            .field("inner", &self.inner())
117            .finish()
118    }
119}
120
121impl PyExecutionAlgorithm {
122    #[inline]
123    #[allow(unsafe_code)]
124    pub(crate) fn inner(&self) -> &PyExecutionAlgorithmInner {
125        // SAFETY: `PyExecutionAlgorithm` is `unsendable` so access is single-threaded, and
126        // callers never hold a mutable and shared reference simultaneously.
127        unsafe { &*self.inner.get() }
128    }
129
130    #[inline]
131    #[allow(unsafe_code, clippy::mut_from_ref)]
132    pub(crate) fn inner_mut(&self) -> &mut PyExecutionAlgorithmInner {
133        // SAFETY: `PyExecutionAlgorithm` is `unsendable` so access is single-threaded, and
134        // callers never hold a mutable and shared reference simultaneously.
135        unsafe { &mut *self.inner.get() }
136    }
137}
138
139impl PyExecutionAlgorithm {
140    /// Creates a new `PyExecutionAlgorithm` instance.
141    #[must_use]
142    pub fn new(config: Option<ExecutionAlgorithmConfig>) -> Self {
143        let mut config = config.unwrap_or_default();
144        if config.exec_algorithm_id.is_none() {
145            config.exec_algorithm_id = Some(ExecAlgorithmId::new(stringify!(ExecutionAlgorithm)));
146        }
147
148        let core = ExecutionAlgorithmCore::new(config);
149        let logger = PyLogger::new(core.actor.actor_id.as_str());
150
151        let inner = PyExecutionAlgorithmInner {
152            core,
153            py_self: None,
154            config: None,
155            logger,
156        };
157
158        Self {
159            inner: Rc::new(UnsafeCell::new(inner)),
160        }
161    }
162
163    /// Sets the Python instance reference for method dispatch.
164    ///
165    /// Only a weak reference is stored, so the caller keeps ownership of `py_obj`. The trader
166    /// owns registered wrappers; an unregistered execution algorithm stays collectable.
167    ///
168    /// # Errors
169    ///
170    /// Returns an error if `py_obj` cannot be weakly referenced.
171    pub fn set_python_instance(&mut self, py_obj: &Bound<'_, PyAny>) -> PyResult<()> {
172        self.inner_mut().py_self = Some(PyWeakrefReference::new(py_obj)?.unbind());
173        Ok(())
174    }
175
176    /// Stores the original Python config object passed at construction.
177    pub fn set_config(&mut self, config: Option<Py<PyAny>>) {
178        self.inner_mut().config = config;
179    }
180
181    /// Updates the runtime execution algorithm ID before registration.
182    pub fn set_exec_algorithm_id(&mut self, exec_algorithm_id: ExecAlgorithmId) {
183        let actor_id = ActorId::new(exec_algorithm_id.inner());
184        let inner = self.inner_mut();
185
186        inner.core.config.exec_algorithm_id = Some(exec_algorithm_id);
187        inner.core.exec_algorithm_id = exec_algorithm_id;
188        inner.core.actor.actor_id = actor_id;
189        inner.core.actor.config.actor_id = Some(actor_id);
190        inner.logger = PyLogger::new(inner.core.actor.actor_id.as_str());
191    }
192
193    /// Updates the runtime `log_events` setting.
194    pub fn set_log_events(&mut self, log_events: bool) {
195        let inner = self.inner_mut();
196        inner.core.config.log_events = log_events;
197        inner.core.actor.config.log_events = log_events;
198    }
199
200    /// Updates the runtime `log_commands` setting.
201    pub fn set_log_commands(&mut self, log_commands: bool) {
202        let inner = self.inner_mut();
203        inner.core.config.log_commands = log_commands;
204        inner.core.actor.config.log_commands = log_commands;
205    }
206
207    /// Returns the execution algorithm ID.
208    #[must_use]
209    pub fn exec_algorithm_id(&self) -> ExecAlgorithmId {
210        self.inner().core.exec_algorithm_id
211    }
212
213    fn dispatch_no_args(&self, method_name: &str) -> PyResult<()> {
214        if let Some(py_self) = self.inner().python_instance()? {
215            Python::attach(|py| py_self.call_method0(py, method_name))?;
216        }
217        Ok(())
218    }
219
220    fn dispatch_time_event(&self, event: &TimeEvent) -> PyResult<()> {
221        if let Some(py_self) = self.inner().python_instance()? {
222            Python::attach(|py| {
223                py_self.call_method1(py, "on_time_event", (event.clone().into_py_any(py)?,))
224            })?;
225        }
226        Ok(())
227    }
228
229    fn dispatch_on_signal(&self, signal: &Signal) -> PyResult<()> {
230        if let Some(py_self) = self.inner().python_instance()? {
231            Python::attach(|py| {
232                py_self.call_method1(py, "on_signal", (signal.clone().into_py_any(py)?,))
233            })?;
234        }
235        Ok(())
236    }
237
238    fn dispatch_on_queue_state(&self, event: &QueueStateChanged) -> PyResult<()> {
239        if let Some(py_self) = self.inner().python_instance()? {
240            Python::attach(|py| {
241                py_self.call_method1(py, "on_queue_state", (event.clone().into_py_any(py)?,))
242            })?;
243        }
244        Ok(())
245    }
246
247    fn dispatch_on_socket_state(&self, event: &SocketStateChanged) -> PyResult<()> {
248        if let Some(py_self) = self.inner().python_instance()? {
249            Python::attach(|py| {
250                py_self.call_method1(py, "on_socket_state", (event.clone().into_py_any(py)?,))
251            })?;
252        }
253        Ok(())
254    }
255
256    fn dispatch_on_order(&self, order: OrderAny) -> PyResult<()> {
257        if let Some(py_self) = self.inner().python_instance()? {
258            Python::attach(|py| {
259                let py_order = nautilus_model::python::orders::order_any_to_pyobject(py, order)?;
260                py_self.call_method1(py, "on_order", (py_order,))
261            })?;
262        }
263        Ok(())
264    }
265
266    fn dispatch_on_order_list(&self, order_list: OrderList, orders: Vec<OrderAny>) -> PyResult<()> {
267        if let Some(py_self) = self.inner().python_instance()? {
268            Python::attach(|py| -> PyResult<()> {
269                let py_order_list = order_list.into_py_any(py)?;
270                let py_orders: Vec<_> = orders
271                    .into_iter()
272                    .map(|order| nautilus_model::python::orders::order_any_to_pyobject(py, order))
273                    .collect::<PyResult<Vec<_>>>()?;
274                let py_orders = PyList::new(py, py_orders)?;
275                py_self.call_method1(py, "on_order_list", (py_order_list, py_orders))?;
276                Ok(())
277            })?;
278        }
279        Ok(())
280    }
281
282    fn has_python_override(&self, method_name: &str) -> PyResult<bool> {
283        Python::attach(|py| -> PyResult<bool> {
284            let Some(py_self) = self.inner().python_instance()? else {
285                return Ok(false);
286            };
287
288            let instance_type = py_self.bind(py).get_type();
289            let instance_method = instance_type.getattr(method_name)?;
290            let base_method = py.get_type::<Self>().getattr(method_name)?;
291
292            Ok(!instance_method.is(&base_method))
293        })
294    }
295
296    fn dispatch_order_event(&self, method_name: &str, event: OrderEventAny) -> PyResult<()> {
297        if let Some(py_self) = self.inner().python_instance()? {
298            Python::attach(|py| {
299                let py_event = order_event_to_pyobject(py, event)?;
300                py_self.call_method1(py, method_name, (py_event,))
301            })?;
302        }
303        Ok(())
304    }
305
306    fn dispatch_position_event(&self, method_name: &str, event: PositionEvent) -> PyResult<()> {
307        if let Some(py_self) = self.inner().python_instance()? {
308            Python::attach(|py| {
309                let py_event = match event {
310                    PositionEvent::PositionOpened(event) => event.into_py_any(py)?,
311                    PositionEvent::PositionChanged(event) => event.into_py_any(py)?,
312                    PositionEvent::PositionClosed(event) => event.into_py_any(py)?,
313                    PositionEvent::PositionAdjusted(event) => event.into_py_any(py)?,
314                };
315                py_self.call_method1(py, method_name, (py_event,))
316            })?;
317        }
318        Ok(())
319    }
320
321    fn tags_to_ustr(tags: Option<Vec<String>>) -> Option<Vec<Ustr>> {
322        tags.map(|tags| tags.into_iter().map(|s| Ustr::from(&s)).collect())
323    }
324
325    fn primary_order_for_spawn(
326        &self,
327        py: Python<'_>,
328        primary: Py<PyAny>,
329        quantity: Quantity,
330        reduce_primary: bool,
331    ) -> PyResult<OrderAny> {
332        if !self.inner().core.actor.is_registered() {
333            return Err(to_pyruntime_err(
334                "ExecutionAlgorithm must be registered before spawning orders",
335            ));
336        }
337
338        let primary = pyobject_to_order_any(py, primary)?;
339        let cached_primary = {
340            let cache = self.inner().core.actor.cache_ref();
341            cache
342                .order(&primary.client_order_id())
343                .map(|order| order.clone())
344        };
345
346        let primary = if reduce_primary {
347            cached_primary.ok_or_else(|| {
348                to_pyruntime_err(format!(
349                    "Cannot reduce primary order {}: order not found in cache",
350                    primary.client_order_id()
351                ))
352            })?
353        } else {
354            cached_primary.unwrap_or(primary)
355        };
356
357        if reduce_primary && quantity > primary.leaves_qty() {
358            return Err(to_pyvalue_err(format!(
359                "Spawn quantity {quantity} exceeds primary leaves_qty {}",
360                primary.leaves_qty()
361            )));
362        }
363
364        if reduce_primary && primary.is_closed() {
365            return Err(to_pyvalue_err(format!(
366                "Cannot reduce closed primary order {}",
367                primary.client_order_id()
368            )));
369        }
370
371        Ok(primary)
372    }
373}
374
375impl DataActorNative for PyExecutionAlgorithm {
376    fn core(&self) -> &DataActorCore {
377        DataActorNative::core(&self.inner().core)
378    }
379
380    fn core_mut(&mut self) -> &mut DataActorCore {
381        DataActorNative::core_mut(&mut self.inner_mut().core)
382    }
383}
384
385impl ExecutionAlgorithmNative for PyExecutionAlgorithm {
386    fn exec_algorithm_core(&self) -> &ExecutionAlgorithmCore {
387        &self.inner().core
388    }
389
390    fn exec_algorithm_core_mut(&mut self) -> &mut ExecutionAlgorithmCore {
391        &mut self.inner_mut().core
392    }
393}
394
395impl ExecutionAlgorithm for PyExecutionAlgorithm {
396    fn on_order(&mut self, order: OrderAny) -> anyhow::Result<()> {
397        self.dispatch_on_order(order)
398            .map_err(|e| anyhow::anyhow!("Python on_order failed:\n{}", format_exception(&e)))
399    }
400
401    fn on_order_list(
402        &mut self,
403        order_list: OrderList,
404        orders: Vec<OrderAny>,
405    ) -> anyhow::Result<()> {
406        if self.has_python_override("on_order_list").map_err(|e| {
407            anyhow::anyhow!("Python override lookup failed:\n{}", format_exception(&e))
408        })? {
409            return self
410                .dispatch_on_order_list(order_list, orders)
411                .map_err(|e| {
412                    anyhow::anyhow!("Python on_order_list failed:\n{}", format_exception(&e))
413                });
414        }
415
416        for order in orders {
417            self.on_order(order)?;
418        }
419        Ok(())
420    }
421
422    fn on_start(&mut self) -> anyhow::Result<()> {
423        log::info!("Starting {}", self.exec_algorithm_id());
424        Ok(())
425    }
426
427    fn on_stop(&mut self) -> anyhow::Result<()> {
428        Ok(())
429    }
430
431    fn on_reset(&mut self) -> anyhow::Result<()> {
432        self.unsubscribe_all_strategy_events();
433        self.inner_mut().core.reset();
434        Ok(())
435    }
436
437    fn on_time_event(&mut self, _event: &TimeEvent) -> anyhow::Result<()> {
438        Ok(())
439    }
440
441    fn on_order_initialized(&mut self, event: OrderInitialized) {
442        let result =
443            self.dispatch_order_event("on_order_initialized", OrderEventAny::Initialized(event));
444        self.inner()
445            .logger
446            .log_callback_error("on_order_initialized", result);
447    }
448
449    fn on_order_denied(&mut self, event: OrderDenied) {
450        let result = self.dispatch_order_event("on_order_denied", OrderEventAny::Denied(event));
451        self.inner()
452            .logger
453            .log_callback_error("on_order_denied", result);
454    }
455
456    fn on_order_emulated(&mut self, event: OrderEmulated) {
457        let result = self.dispatch_order_event("on_order_emulated", OrderEventAny::Emulated(event));
458        self.inner()
459            .logger
460            .log_callback_error("on_order_emulated", result);
461    }
462
463    fn on_order_released(&mut self, event: OrderReleased) {
464        let result = self.dispatch_order_event("on_order_released", OrderEventAny::Released(event));
465        self.inner()
466            .logger
467            .log_callback_error("on_order_released", result);
468    }
469
470    fn on_order_submitted(&mut self, event: OrderSubmitted) {
471        let result =
472            self.dispatch_order_event("on_order_submitted", OrderEventAny::Submitted(event));
473        self.inner()
474            .logger
475            .log_callback_error("on_order_submitted", result);
476    }
477
478    fn on_order_rejected(&mut self, event: OrderRejected) {
479        let result = self.dispatch_order_event("on_order_rejected", OrderEventAny::Rejected(event));
480        self.inner()
481            .logger
482            .log_callback_error("on_order_rejected", result);
483    }
484
485    fn on_order_accepted(&mut self, event: OrderAccepted) {
486        let result = self.dispatch_order_event("on_order_accepted", OrderEventAny::Accepted(event));
487        self.inner()
488            .logger
489            .log_callback_error("on_order_accepted", result);
490    }
491
492    fn on_algo_order_canceled(&mut self, event: OrderCanceled) {
493        let result = self.dispatch_order_event("on_order_canceled", OrderEventAny::Canceled(event));
494        self.inner()
495            .logger
496            .log_callback_error("on_order_canceled", result);
497    }
498
499    fn on_order_expired(&mut self, event: OrderExpired) {
500        let result = self.dispatch_order_event("on_order_expired", OrderEventAny::Expired(event));
501        self.inner()
502            .logger
503            .log_callback_error("on_order_expired", result);
504    }
505
506    fn on_order_triggered(&mut self, event: OrderTriggered) {
507        let result =
508            self.dispatch_order_event("on_order_triggered", OrderEventAny::Triggered(event));
509        self.inner()
510            .logger
511            .log_callback_error("on_order_triggered", result);
512    }
513
514    fn on_order_pending_update(&mut self, event: OrderPendingUpdate) {
515        let result = self.dispatch_order_event(
516            "on_order_pending_update",
517            OrderEventAny::PendingUpdate(event),
518        );
519        self.inner()
520            .logger
521            .log_callback_error("on_order_pending_update", result);
522    }
523
524    fn on_order_pending_cancel(&mut self, event: OrderPendingCancel) {
525        let result = self.dispatch_order_event(
526            "on_order_pending_cancel",
527            OrderEventAny::PendingCancel(event),
528        );
529        self.inner()
530            .logger
531            .log_callback_error("on_order_pending_cancel", result);
532    }
533
534    fn on_order_modify_denied(&mut self, event: OrderModifyDenied) {
535        let result =
536            self.dispatch_order_event("on_order_modify_denied", OrderEventAny::ModifyDenied(event));
537        self.inner()
538            .logger
539            .log_callback_error("on_order_modify_denied", result);
540    }
541
542    fn on_order_modify_rejected(&mut self, event: OrderModifyRejected) {
543        let result = self.dispatch_order_event(
544            "on_order_modify_rejected",
545            OrderEventAny::ModifyRejected(event),
546        );
547        self.inner()
548            .logger
549            .log_callback_error("on_order_modify_rejected", result);
550    }
551
552    fn on_order_cancel_denied(&mut self, event: OrderCancelDenied) {
553        let result =
554            self.dispatch_order_event("on_order_cancel_denied", OrderEventAny::CancelDenied(event));
555        self.inner()
556            .logger
557            .log_callback_error("on_order_cancel_denied", result);
558    }
559
560    fn on_order_cancel_rejected(&mut self, event: OrderCancelRejected) {
561        let result = self.dispatch_order_event(
562            "on_order_cancel_rejected",
563            OrderEventAny::CancelRejected(event),
564        );
565        self.inner()
566            .logger
567            .log_callback_error("on_order_cancel_rejected", result);
568    }
569
570    fn on_order_updated(&mut self, event: OrderUpdated) {
571        let result = self.dispatch_order_event("on_order_updated", OrderEventAny::Updated(event));
572        self.inner()
573            .logger
574            .log_callback_error("on_order_updated", result);
575    }
576
577    fn on_algo_order_filled(&mut self, event: OrderFilled) {
578        let result = self.dispatch_order_event("on_order_filled", OrderEventAny::Filled(event));
579        self.inner()
580            .logger
581            .log_callback_error("on_order_filled", result);
582    }
583
584    fn on_order_fill_voided(&mut self, event: &OrderFillVoided) {
585        let result = self.dispatch_order_event(
586            "on_order_fill_voided",
587            OrderEventAny::FillVoided(event.clone()),
588        );
589        self.inner()
590            .logger
591            .log_callback_error("on_order_fill_voided", result);
592    }
593
594    fn on_order_event(&mut self, event: OrderEventAny) {
595        let result = self.dispatch_order_event("on_order_event", event);
596        self.inner()
597            .logger
598            .log_callback_error("on_order_event", result);
599    }
600
601    fn on_position_opened(&mut self, event: PositionOpened) {
602        let result = self
603            .dispatch_position_event("on_position_opened", PositionEvent::PositionOpened(event));
604        self.inner()
605            .logger
606            .log_callback_error("on_position_opened", result);
607    }
608
609    fn on_position_changed(&mut self, event: PositionChanged) {
610        let result = self
611            .dispatch_position_event("on_position_changed", PositionEvent::PositionChanged(event));
612        self.inner()
613            .logger
614            .log_callback_error("on_position_changed", result);
615    }
616
617    fn on_position_closed(&mut self, event: PositionClosed) {
618        let result = self
619            .dispatch_position_event("on_position_closed", PositionEvent::PositionClosed(event));
620        self.inner()
621            .logger
622            .log_callback_error("on_position_closed", result);
623    }
624
625    fn on_position_event(&mut self, event: PositionEvent) {
626        let result = self.dispatch_position_event("on_position_event", event);
627        self.inner()
628            .logger
629            .log_callback_error("on_position_event", result);
630    }
631}
632
633impl DataActor for PyExecutionAlgorithm {
634    fn on_start(&mut self) -> anyhow::Result<()> {
635        ExecutionAlgorithm::on_start(self)?;
636        self.dispatch_no_args("on_start")
637            .map_err(|e| anyhow::anyhow!("Python on_start failed:\n{}", format_exception(&e)))
638    }
639
640    fn on_stop(&mut self) -> anyhow::Result<()> {
641        ExecutionAlgorithm::on_stop(self)?;
642        self.dispatch_no_args("on_stop")
643            .map_err(|e| anyhow::anyhow!("Python on_stop failed:\n{}", format_exception(&e)))
644    }
645
646    fn on_resume(&mut self) -> anyhow::Result<()> {
647        ExecutionAlgorithm::on_resume(self)?;
648        self.dispatch_no_args("on_resume")
649            .map_err(|e| anyhow::anyhow!("Python on_resume failed:\n{}", format_exception(&e)))
650    }
651
652    fn on_reset(&mut self) -> anyhow::Result<()> {
653        ExecutionAlgorithm::on_reset(self)?;
654        self.dispatch_no_args("on_reset")
655            .map_err(|e| anyhow::anyhow!("Python on_reset failed:\n{}", format_exception(&e)))
656    }
657
658    fn on_dispose(&mut self) -> anyhow::Result<()> {
659        self.dispatch_no_args("on_dispose")
660            .map_err(|e| anyhow::anyhow!("Python on_dispose failed:\n{}", format_exception(&e)))
661    }
662
663    fn on_degrade(&mut self) -> anyhow::Result<()> {
664        self.dispatch_no_args("on_degrade")
665            .map_err(|e| anyhow::anyhow!("Python on_degrade failed:\n{}", format_exception(&e)))
666    }
667
668    fn on_fault(&mut self) -> anyhow::Result<()> {
669        self.dispatch_no_args("on_fault")
670            .map_err(|e| anyhow::anyhow!("Python on_fault failed:\n{}", format_exception(&e)))
671    }
672
673    fn on_time_event(&mut self, event: &TimeEvent) -> anyhow::Result<()> {
674        ExecutionAlgorithm::on_time_event(self, event)?;
675        self.dispatch_time_event(event)
676            .map_err(|e| anyhow::anyhow!("Python on_time_event failed:\n{}", format_exception(&e)))
677    }
678
679    fn on_signal(&mut self, signal: &Signal) -> anyhow::Result<()> {
680        self.dispatch_on_signal(signal)
681            .map_err(|e| anyhow::anyhow!("Python on_signal failed:\n{}", format_exception(&e)))
682    }
683
684    fn on_queue_state(&mut self, event: &QueueStateChanged) -> anyhow::Result<()> {
685        self.dispatch_on_queue_state(event)
686            .map_err(|e| anyhow::anyhow!("Python on_queue_state failed:\n{}", format_exception(&e)))
687    }
688
689    fn on_socket_state(&mut self, event: &SocketStateChanged) -> anyhow::Result<()> {
690        self.dispatch_on_socket_state(event).map_err(|e| {
691            anyhow::anyhow!("Python on_socket_state failed:\n{}", format_exception(&e))
692        })
693    }
694}
695
696#[pyo3::pymethods]
697#[pyo3_stub_gen::derive::gen_stub_pymethods]
698#[allow(
699    clippy::large_types_passed_by_value,
700    reason = "PyO3 callbacks accept Python-owned event values"
701)]
702impl PyExecutionAlgorithm {
703    /// Creates a new [`PyExecutionAlgorithm`] instance.
704    #[new]
705    #[pyo3(signature = (config=None))]
706    fn py_new(config: Option<Py<PyAny>>) -> Self {
707        let algorithm_config = config
708            .as_ref()
709            .and_then(|obj| Python::attach(|py| obj.extract::<ExecutionAlgorithmConfig>(py).ok()));
710        let mut algorithm = Self::new(algorithm_config);
711        algorithm.set_config(config);
712        algorithm
713    }
714
715    /// Captures the Python self reference for Rust→Python event dispatch.
716    #[pyo3(signature = (config=None))]
717    fn __init__(slf: &Bound<'_, Self>, config: Option<Py<PyAny>>) -> PyResult<()> {
718        let retained_config = if config.is_none() {
719            Python::attach(|py| {
720                slf.borrow()
721                    .inner()
722                    .config
723                    .as_ref()
724                    .map(|config| config.clone_ref(py))
725            })
726        } else {
727            None
728        };
729        let has_configured_id = if let Some(config) = config.as_ref().or(retained_config.as_ref()) {
730            Python::attach(|py| slf.borrow_mut().configure_from_py_config(config.bind(py)))
731                .map_err(to_pyvalue_err)?
732        } else {
733            false
734        };
735
736        if !has_configured_id {
737            let py_type = slf.get_type();
738            let type_name = py_type.name()?;
739            let exec_algorithm_id =
740                ExecAlgorithmId::new_checked(type_name.to_str()?).map_err(to_pyvalue_err)?;
741            slf.borrow_mut().set_exec_algorithm_id(exec_algorithm_id);
742        }
743        let mut borrowed = slf.borrow_mut();
744        borrowed.set_python_instance(slf.as_any())?;
745        if config.is_some() {
746            borrowed.set_config(config);
747        }
748        Ok(())
749    }
750
751    #[getter]
752    #[pyo3(name = "trader_id")]
753    fn py_trader_id(&self) -> Option<TraderId> {
754        self.inner().core.actor.trader_id()
755    }
756
757    #[getter]
758    #[pyo3(name = "exec_algorithm_id")]
759    fn py_exec_algorithm_id(&self) -> ExecAlgorithmId {
760        self.exec_algorithm_id()
761    }
762
763    #[getter]
764    #[pyo3(name = "config")]
765    fn py_config(&self, py: Python<'_>) -> Option<Py<PyAny>> {
766        self.inner()
767            .config
768            .as_ref()
769            .map(|config| config.clone_ref(py))
770    }
771
772    /// Returns an importable configuration for this execution algorithm.
773    #[pyo3(name = "to_importable_config")]
774    fn py_to_importable_config(
775        &self,
776        py: Python<'_>,
777    ) -> PyResult<ImportableExecutionAlgorithmConfig> {
778        let py_self = self
779            .inner()
780            .python_instance()?
781            .ok_or_else(|| to_pyruntime_err("Python execution algorithm instance is not set"))?;
782        let exec_algorithm_path = py_type_path(py_self.bind(py))?;
783
784        let Some(config) = self.inner().config.as_ref() else {
785            return Ok(ImportableExecutionAlgorithmConfig {
786                exec_algorithm_path,
787                config_path: String::new(),
788                config: HashMap::new(),
789            });
790        };
791        let config = config.bind(py);
792
793        Ok(ImportableExecutionAlgorithmConfig {
794            exec_algorithm_path,
795            config_path: py_type_path(config)?,
796            config: py_config_to_json(config)?,
797        })
798    }
799
800    #[getter]
801    #[pyo3(name = "clock")]
802    fn py_clock(&self) -> Option<PyClock> {
803        self.inner()
804            .core
805            .actor
806            .is_registered()
807            .then(|| PyClock::from_rc(self.inner().core.actor.clock_rc()))
808    }
809
810    #[getter]
811    #[pyo3(name = "cache")]
812    fn py_cache(&self) -> Option<PyCache> {
813        self.inner()
814            .core
815            .actor
816            .is_registered()
817            .then(|| PyCache::from_rc(self.inner().core.actor.cache_rc()))
818    }
819
820    #[getter]
821    #[pyo3(name = "portfolio")]
822    fn py_portfolio(&self) -> PyResult<PyPortfolio> {
823        if self.inner().core.actor.is_registered() {
824            Ok(PyPortfolio::from_rc(self.portfolio_rc()))
825        } else {
826            Err(to_pyruntime_err(
827                "ExecutionAlgorithm must be registered with a trader before accessing portfolio",
828            ))
829        }
830    }
831
832    #[getter]
833    #[pyo3(name = "log")]
834    fn py_log(&self) -> PyLogger {
835        self.inner().logger.clone()
836    }
837
838    #[getter]
839    #[pyo3(name = "state")]
840    fn py_state(&self) -> ComponentState {
841        self.inner().core.actor.state()
842    }
843
844    #[pyo3(name = "is_registered")]
845    fn py_is_registered(&self) -> bool {
846        self.inner().core.actor.is_registered()
847    }
848
849    #[pyo3(name = "is_ready")]
850    fn py_is_ready(&self) -> bool {
851        Component::is_ready(self)
852    }
853
854    #[pyo3(name = "is_running")]
855    fn py_is_running(&self) -> bool {
856        Component::is_running(self)
857    }
858
859    #[pyo3(name = "is_stopped")]
860    fn py_is_stopped(&self) -> bool {
861        Component::is_stopped(self)
862    }
863
864    #[pyo3(name = "is_disposed")]
865    fn py_is_disposed(&self) -> bool {
866        Component::is_disposed(self)
867    }
868
869    #[pyo3(name = "is_degraded")]
870    fn py_is_degraded(&self) -> bool {
871        Component::is_degraded(self)
872    }
873
874    #[pyo3(name = "is_faulted")]
875    fn py_is_faulted(&self) -> bool {
876        Component::is_faulted(self)
877    }
878
879    #[pyo3(name = "start")]
880    fn py_start(slf: PyRef<'_, Self>) -> PyResult<()> {
881        let mut exec_algorithm = slf.clone();
882        drop(slf);
883        Component::start(&mut exec_algorithm).map_err(to_pyruntime_err)
884    }
885
886    #[pyo3(name = "stop")]
887    fn py_stop(slf: PyRef<'_, Self>) -> PyResult<()> {
888        let mut exec_algorithm = slf.clone();
889        drop(slf);
890        Component::stop(&mut exec_algorithm).map_err(to_pyruntime_err)
891    }
892
893    #[pyo3(name = "resume")]
894    fn py_resume(slf: PyRef<'_, Self>) -> PyResult<()> {
895        let mut exec_algorithm = slf.clone();
896        drop(slf);
897        Component::resume(&mut exec_algorithm).map_err(to_pyruntime_err)
898    }
899
900    #[pyo3(name = "reset")]
901    fn py_reset(slf: PyRef<'_, Self>) -> PyResult<()> {
902        let mut exec_algorithm = slf.clone();
903        drop(slf);
904        Component::reset(&mut exec_algorithm).map_err(to_pyruntime_err)
905    }
906
907    #[pyo3(name = "dispose")]
908    fn py_dispose(slf: PyRef<'_, Self>) -> PyResult<()> {
909        let mut exec_algorithm = slf.clone();
910        drop(slf);
911        Component::dispose(&mut exec_algorithm).map_err(to_pyruntime_err)
912    }
913
914    #[pyo3(name = "degrade")]
915    fn py_degrade(slf: PyRef<'_, Self>) -> PyResult<()> {
916        let mut exec_algorithm = slf.clone();
917        drop(slf);
918        Component::degrade(&mut exec_algorithm).map_err(to_pyruntime_err)
919    }
920
921    #[pyo3(name = "fault")]
922    fn py_fault(slf: PyRef<'_, Self>) -> PyResult<()> {
923        let mut exec_algorithm = slf.clone();
924        drop(slf);
925        Component::fault(&mut exec_algorithm).map_err(to_pyruntime_err)
926    }
927
928    #[pyo3(name = "publish_data")]
929    fn py_publish_data(&self, data_type: &DataType, data: &CustomData) -> PyResult<()> {
930        self.ensure_registered_for_data()?;
931        DataActor::publish_data(self, data_type, data);
932        Ok(())
933    }
934
935    #[pyo3(name = "publish_signal")]
936    #[pyo3(signature = (name, value, ts_event=0))]
937    #[expect(
938        clippy::needless_pass_by_value,
939        reason = "PyO3 accepts an owned PyAny handle for Python signal values"
940    )]
941    fn py_publish_signal(
942        &self,
943        py: Python<'_>,
944        name: &str,
945        value: Py<PyAny>,
946        ts_event: u64,
947    ) -> PyResult<()> {
948        self.ensure_registered_for_data()?;
949        let value_str: String = value.bind(py).str()?.extract()?;
950        DataActor::publish_signal(self, name, value_str, UnixNanos::from(ts_event));
951        Ok(())
952    }
953
954    #[pyo3(name = "subscribe_signal")]
955    #[pyo3(signature = (name="", priority=None))]
956    fn py_subscribe_signal(&mut self, name: &str, priority: Option<u32>) -> PyResult<()> {
957        self.ensure_registered()?;
958        DataActor::subscribe_signal(self, name, priority);
959        Ok(())
960    }
961
962    #[pyo3(name = "subscribe_queue_state")]
963    #[pyo3(signature = (channel=None, priority=None))]
964    fn py_subscribe_queue_state(
965        &mut self,
966        channel: Option<SystemChannel>,
967        priority: Option<u32>,
968    ) -> PyResult<()> {
969        self.ensure_registered()?;
970        DataActor::subscribe_queue_state(self, channel, priority);
971        Ok(())
972    }
973
974    #[pyo3(name = "subscribe_socket_state")]
975    #[pyo3(signature = (client_id=None, endpoint=None, priority=None))]
976    fn py_subscribe_socket_state(
977        &mut self,
978        client_id: Option<ClientId>,
979        endpoint: Option<&str>,
980        priority: Option<u32>,
981    ) -> PyResult<()> {
982        self.ensure_registered()?;
983        DataActor::subscribe_socket_state(self, client_id, endpoint, priority);
984        Ok(())
985    }
986
987    #[pyo3(name = "unsubscribe_signal")]
988    #[pyo3(signature = (name=""))]
989    fn py_unsubscribe_signal(&mut self, name: &str) -> PyResult<()> {
990        self.ensure_registered()?;
991        DataActor::unsubscribe_signal(self, name);
992        Ok(())
993    }
994
995    #[pyo3(name = "unsubscribe_queue_state")]
996    #[pyo3(signature = (channel=None))]
997    fn py_unsubscribe_queue_state(&mut self, channel: Option<SystemChannel>) -> PyResult<()> {
998        self.ensure_registered()?;
999        DataActor::unsubscribe_queue_state(self, channel);
1000        Ok(())
1001    }
1002
1003    #[pyo3(name = "unsubscribe_socket_state")]
1004    #[pyo3(signature = (client_id=None, endpoint=None))]
1005    fn py_unsubscribe_socket_state(
1006        &mut self,
1007        client_id: Option<ClientId>,
1008        endpoint: Option<&str>,
1009    ) -> PyResult<()> {
1010        self.ensure_registered()?;
1011        DataActor::unsubscribe_socket_state(self, client_id, endpoint);
1012        Ok(())
1013    }
1014
1015    #[pyo3(name = "on_start")]
1016    fn py_on_start(_slf: &Bound<'_, Self>) {}
1017
1018    #[pyo3(name = "on_stop")]
1019    fn py_on_stop(_slf: &Bound<'_, Self>) {}
1020
1021    #[pyo3(name = "on_resume")]
1022    fn py_on_resume(_slf: &Bound<'_, Self>) {}
1023
1024    #[pyo3(name = "on_reset")]
1025    fn py_on_reset(_slf: &Bound<'_, Self>) {}
1026
1027    #[pyo3(name = "on_dispose")]
1028    fn py_on_dispose(_slf: &Bound<'_, Self>) {}
1029
1030    #[pyo3(name = "on_degrade")]
1031    fn py_on_degrade(_slf: &Bound<'_, Self>) {}
1032
1033    #[pyo3(name = "on_fault")]
1034    fn py_on_fault(_slf: &Bound<'_, Self>) {}
1035
1036    #[allow(unused_variables, clippy::needless_pass_by_value)]
1037    #[pyo3(name = "on_time_event")]
1038    fn py_on_time_event(_slf: &Bound<'_, Self>, event: TimeEvent) {}
1039
1040    #[allow(unused_variables)]
1041    #[pyo3(name = "on_signal")]
1042    fn py_on_signal(_slf: &Bound<'_, Self>, signal: &Signal) {}
1043
1044    #[allow(unused_variables, clippy::needless_pass_by_value)]
1045    #[pyo3(name = "on_queue_state")]
1046    fn py_on_queue_state(_slf: &Bound<'_, Self>, event: QueueStateChanged) {}
1047
1048    #[allow(unused_variables, clippy::needless_pass_by_value)]
1049    #[pyo3(name = "on_socket_state")]
1050    fn py_on_socket_state(_slf: &Bound<'_, Self>, event: SocketStateChanged) {}
1051
1052    #[allow(clippy::needless_pass_by_value)]
1053    #[pyo3(name = "execute")]
1054    fn py_execute(_slf: &Bound<'_, Self>, command: Py<PyAny>) -> PyResult<()> {
1055        let _ = command;
1056        Err(to_pyruntime_err(
1057            "ExecutionAlgorithm.execute is invoked by the v2 runtime endpoint",
1058        ))
1059    }
1060
1061    #[allow(unused_variables, clippy::needless_pass_by_value)]
1062    #[pyo3(name = "on_order")]
1063    fn py_on_order(_slf: &Bound<'_, Self>, order: Py<PyAny>) {}
1064
1065    #[allow(unused_variables, clippy::needless_pass_by_value)]
1066    #[pyo3(name = "on_order_list")]
1067    fn py_on_order_list(_slf: &Bound<'_, Self>, order_list: Py<PyAny>, orders: Py<PyAny>) {}
1068
1069    #[pyo3(name = "spawn_market")]
1070    #[pyo3(signature = (
1071        primary,
1072        quantity,
1073        time_in_force = TimeInForce::Gtc,
1074        reduce_only = false,
1075        tags = None,
1076        reduce_primary = true
1077    ))]
1078    #[expect(clippy::too_many_arguments)]
1079    fn py_spawn_market(
1080        &mut self,
1081        py: Python<'_>,
1082        primary: Py<PyAny>,
1083        quantity: Quantity,
1084        time_in_force: TimeInForce,
1085        reduce_only: bool,
1086        tags: Option<Vec<String>>,
1087        reduce_primary: bool,
1088    ) -> PyResult<MarketOrder> {
1089        let mut primary = self.primary_order_for_spawn(py, primary, quantity, reduce_primary)?;
1090        ExecutionAlgorithm::spawn_market(
1091            self,
1092            &mut primary,
1093            quantity,
1094            time_in_force,
1095            reduce_only,
1096            Self::tags_to_ustr(tags),
1097            reduce_primary,
1098        )
1099        .map_err(to_pyvalue_err)
1100    }
1101
1102    #[pyo3(name = "spawn_limit")]
1103    #[pyo3(signature = (
1104        primary,
1105        quantity,
1106        price,
1107        time_in_force = TimeInForce::Gtc,
1108        expire_time = None,
1109        post_only = false,
1110        reduce_only = false,
1111        display_qty = None,
1112        emulation_trigger = None,
1113        tags = None,
1114        reduce_primary = true
1115    ))]
1116    #[expect(clippy::too_many_arguments)]
1117    fn py_spawn_limit(
1118        &mut self,
1119        py: Python<'_>,
1120        primary: Py<PyAny>,
1121        quantity: Quantity,
1122        price: Price,
1123        time_in_force: TimeInForce,
1124        expire_time: Option<Timestamp>,
1125        post_only: bool,
1126        reduce_only: bool,
1127        display_qty: Option<Quantity>,
1128        emulation_trigger: Option<TriggerType>,
1129        tags: Option<Vec<String>>,
1130        reduce_primary: bool,
1131    ) -> PyResult<LimitOrder> {
1132        let mut primary = self.primary_order_for_spawn(py, primary, quantity, reduce_primary)?;
1133        ExecutionAlgorithm::spawn_limit(
1134            self,
1135            &mut primary,
1136            quantity,
1137            price,
1138            time_in_force,
1139            expire_time.map(UnixNanos::from),
1140            post_only,
1141            reduce_only,
1142            display_qty,
1143            emulation_trigger,
1144            Self::tags_to_ustr(tags),
1145            reduce_primary,
1146        )
1147        .map_err(to_pyvalue_err)
1148    }
1149
1150    #[pyo3(name = "spawn_market_to_limit")]
1151    #[pyo3(signature = (
1152        primary,
1153        quantity,
1154        time_in_force = TimeInForce::Gtc,
1155        expire_time = None,
1156        reduce_only = false,
1157        display_qty = None,
1158        emulation_trigger = None,
1159        tags = None,
1160        reduce_primary = true
1161    ))]
1162    #[expect(clippy::too_many_arguments)]
1163    fn py_spawn_market_to_limit(
1164        &mut self,
1165        py: Python<'_>,
1166        primary: Py<PyAny>,
1167        quantity: Quantity,
1168        time_in_force: TimeInForce,
1169        expire_time: Option<Timestamp>,
1170        reduce_only: bool,
1171        display_qty: Option<Quantity>,
1172        emulation_trigger: Option<TriggerType>,
1173        tags: Option<Vec<String>>,
1174        reduce_primary: bool,
1175    ) -> PyResult<MarketToLimitOrder> {
1176        let mut primary = self.primary_order_for_spawn(py, primary, quantity, reduce_primary)?;
1177        ExecutionAlgorithm::spawn_market_to_limit(
1178            self,
1179            &mut primary,
1180            quantity,
1181            time_in_force,
1182            expire_time.map(UnixNanos::from),
1183            reduce_only,
1184            display_qty,
1185            emulation_trigger,
1186            Self::tags_to_ustr(tags),
1187            reduce_primary,
1188        )
1189        .map_err(to_pyvalue_err)
1190    }
1191
1192    #[pyo3(name = "deny_order")]
1193    fn py_deny_order(&mut self, py: Python<'_>, order: Py<PyAny>, reason: &str) -> PyResult<()> {
1194        let order = pyobject_to_order_any(py, order)?;
1195        ExecutionAlgorithm::deny_order(self, &order, Ustr::from(reason)).map_err(to_pyruntime_err)
1196    }
1197
1198    #[pyo3(name = "submit_order")]
1199    #[pyo3(signature = (order, position_id=None, client_id=None))]
1200    fn py_submit_order(
1201        &mut self,
1202        py: Python<'_>,
1203        order: Py<PyAny>,
1204        position_id: Option<PositionId>,
1205        client_id: Option<ClientId>,
1206    ) -> PyResult<()> {
1207        let order = pyobject_to_order_any(py, order)?;
1208        let order = self.resolve_order(order)?;
1209        ExecutionAlgorithm::submit_order(self, order, position_id, client_id).map_err(|e| {
1210            if e.downcast_ref::<EmulatedOrderSubmissionError>().is_some() {
1211                to_pyvalue_err(e)
1212            } else {
1213                to_pyruntime_err(e)
1214            }
1215        })
1216    }
1217
1218    #[pyo3(name = "modify_order")]
1219    #[pyo3(signature = (order, quantity=None, price=None, trigger_price=None, client_id=None))]
1220    fn py_modify_order(
1221        &mut self,
1222        py: Python<'_>,
1223        order: Py<PyAny>,
1224        quantity: Option<Quantity>,
1225        price: Option<Price>,
1226        trigger_price: Option<Price>,
1227        client_id: Option<ClientId>,
1228    ) -> PyResult<()> {
1229        let order = pyobject_to_order_any(py, order)?;
1230        let mut order = self.resolve_order(order)?;
1231        ExecutionAlgorithm::modify_order(
1232            self,
1233            &mut order,
1234            quantity,
1235            price,
1236            trigger_price,
1237            client_id,
1238        )
1239        .map_err(to_pyruntime_err)
1240    }
1241
1242    #[pyo3(name = "modify_order_in_place")]
1243    #[pyo3(signature = (order, quantity=None, price=None, trigger_price=None))]
1244    fn py_modify_order_in_place(
1245        &mut self,
1246        py: Python<'_>,
1247        order: Py<PyAny>,
1248        quantity: Option<Quantity>,
1249        price: Option<Price>,
1250        trigger_price: Option<Price>,
1251    ) -> PyResult<()> {
1252        let order = pyobject_to_order_any(py, order)?;
1253        let mut order = self.resolve_order(order)?;
1254        ExecutionAlgorithm::modify_order_in_place(self, &mut order, quantity, price, trigger_price)
1255            .map_err(to_pyruntime_err)
1256    }
1257
1258    #[pyo3(name = "cancel_order")]
1259    #[pyo3(signature = (order, client_id=None))]
1260    fn py_cancel_order(
1261        &mut self,
1262        py: Python<'_>,
1263        order: Py<PyAny>,
1264        client_id: Option<ClientId>,
1265    ) -> PyResult<()> {
1266        let order = pyobject_to_order_any(py, order)?;
1267        let mut order = self.resolve_order(order)?;
1268        ExecutionAlgorithm::cancel_order(self, &mut order, client_id).map_err(to_pyruntime_err)
1269    }
1270
1271    #[allow(unused_variables, clippy::needless_pass_by_value)]
1272    #[pyo3(name = "on_order_initialized")]
1273    fn py_on_order_initialized(_slf: &Bound<'_, Self>, event: OrderInitialized) {}
1274
1275    #[allow(unused_variables, clippy::needless_pass_by_value)]
1276    #[pyo3(name = "on_order_event")]
1277    fn py_on_order_event(_slf: &Bound<'_, Self>, event: Py<PyAny>) {}
1278
1279    #[allow(unused_variables)]
1280    #[pyo3(name = "on_order_denied")]
1281    fn py_on_order_denied(_slf: &Bound<'_, Self>, event: OrderDenied) {}
1282
1283    #[allow(unused_variables)]
1284    #[pyo3(name = "on_order_emulated")]
1285    fn py_on_order_emulated(_slf: &Bound<'_, Self>, event: OrderEmulated) {}
1286
1287    #[allow(unused_variables)]
1288    #[pyo3(name = "on_order_released")]
1289    fn py_on_order_released(_slf: &Bound<'_, Self>, event: OrderReleased) {}
1290
1291    #[allow(unused_variables)]
1292    #[pyo3(name = "on_order_submitted")]
1293    fn py_on_order_submitted(_slf: &Bound<'_, Self>, event: OrderSubmitted) {}
1294
1295    #[allow(unused_variables)]
1296    #[pyo3(name = "on_order_rejected")]
1297    fn py_on_order_rejected(_slf: &Bound<'_, Self>, event: OrderRejected) {}
1298
1299    #[allow(unused_variables)]
1300    #[pyo3(name = "on_order_accepted")]
1301    fn py_on_order_accepted(_slf: &Bound<'_, Self>, event: OrderAccepted) {}
1302
1303    #[allow(unused_variables)]
1304    #[pyo3(name = "on_order_expired")]
1305    fn py_on_order_expired(_slf: &Bound<'_, Self>, event: OrderExpired) {}
1306
1307    #[allow(unused_variables)]
1308    #[pyo3(name = "on_order_triggered")]
1309    fn py_on_order_triggered(_slf: &Bound<'_, Self>, event: OrderTriggered) {}
1310
1311    #[allow(unused_variables)]
1312    #[pyo3(name = "on_order_pending_update")]
1313    fn py_on_order_pending_update(_slf: &Bound<'_, Self>, event: OrderPendingUpdate) {}
1314
1315    #[allow(unused_variables)]
1316    #[pyo3(name = "on_order_pending_cancel")]
1317    fn py_on_order_pending_cancel(_slf: &Bound<'_, Self>, event: OrderPendingCancel) {}
1318
1319    #[allow(unused_variables)]
1320    #[pyo3(name = "on_order_modify_denied")]
1321    fn py_on_order_modify_denied(_slf: &Bound<'_, Self>, event: OrderModifyDenied) {}
1322
1323    #[allow(unused_variables)]
1324    #[pyo3(name = "on_order_modify_rejected")]
1325    fn py_on_order_modify_rejected(_slf: &Bound<'_, Self>, event: OrderModifyRejected) {}
1326
1327    #[allow(unused_variables)]
1328    #[pyo3(name = "on_order_cancel_denied")]
1329    fn py_on_order_cancel_denied(_slf: &Bound<'_, Self>, event: OrderCancelDenied) {}
1330
1331    #[allow(unused_variables)]
1332    #[pyo3(name = "on_order_cancel_rejected")]
1333    fn py_on_order_cancel_rejected(_slf: &Bound<'_, Self>, event: OrderCancelRejected) {}
1334
1335    #[allow(unused_variables)]
1336    #[pyo3(name = "on_order_updated")]
1337    fn py_on_order_updated(_slf: &Bound<'_, Self>, event: OrderUpdated) {}
1338
1339    #[allow(unused_variables)]
1340    #[pyo3(name = "on_order_canceled")]
1341    fn py_on_order_canceled(_slf: &Bound<'_, Self>, event: OrderCanceled) {}
1342
1343    #[allow(unused_variables, clippy::needless_pass_by_value)]
1344    #[pyo3(name = "on_order_filled")]
1345    fn py_on_order_filled(_slf: &Bound<'_, Self>, event: OrderFilled) {}
1346
1347    #[allow(unused_variables, clippy::needless_pass_by_value)]
1348    #[pyo3(name = "on_order_fill_voided")]
1349    fn py_on_order_fill_voided(_slf: &Bound<'_, Self>, event: OrderFillVoided) {}
1350
1351    #[allow(unused_variables, clippy::needless_pass_by_value)]
1352    #[pyo3(name = "on_position_opened")]
1353    fn py_on_position_opened(_slf: &Bound<'_, Self>, event: PositionOpened) {}
1354
1355    #[allow(unused_variables, clippy::needless_pass_by_value)]
1356    #[pyo3(name = "on_position_event")]
1357    fn py_on_position_event(_slf: &Bound<'_, Self>, event: Py<PyAny>) {}
1358
1359    #[allow(unused_variables, clippy::needless_pass_by_value)]
1360    #[pyo3(name = "on_position_changed")]
1361    fn py_on_position_changed(_slf: &Bound<'_, Self>, event: PositionChanged) {}
1362
1363    #[allow(unused_variables, clippy::needless_pass_by_value)]
1364    #[pyo3(name = "on_position_closed")]
1365    fn py_on_position_closed(_slf: &Bound<'_, Self>, event: PositionClosed) {}
1366}
1367
1368#[pyo3_stub_gen::derive::gen_stub_pymethods]
1369#[pyo3::pymethods]
1370impl PyExecutionAlgorithm {
1371    #[pyo3(name = "publish_message", signature = (topic, message))]
1372    fn py_publish_message(
1373        slf: &Bound<'_, Self>,
1374        topic: &str,
1375        #[gen_stub(override_type(type_repr = "object"))] message: Py<PyAny>,
1376    ) -> PyResult<()> {
1377        let messages = get_python_message_bus(slf.as_any())?;
1378        messages.publish_message(topic, message)
1379    }
1380
1381    #[pyo3(name = "subscribe_topic")]
1382    #[pyo3(signature = (topic, handler, priority=0))]
1383    fn py_subscribe_topic(
1384        slf: &Bound<'_, Self>,
1385        topic: &str,
1386        #[gen_stub(override_type(type_repr = "collections.abc.Callable[[object], None]", imports = ("collections.abc",)))]
1387        handler: Py<PyAny>,
1388        priority: u32,
1389    ) -> PyResult<()> {
1390        let messages = get_python_message_bus(slf.as_any())?;
1391        messages.subscribe_topic(slf.py(), topic, handler, priority)
1392    }
1393
1394    #[pyo3(name = "unsubscribe_topic", signature = (topic, handler))]
1395    fn py_unsubscribe_topic(
1396        slf: &Bound<'_, Self>,
1397        topic: &str,
1398        #[gen_stub(override_type(type_repr = "collections.abc.Callable[[object], None]", imports = ("collections.abc",)))]
1399        handler: &Bound<'_, PyAny>,
1400    ) -> PyResult<()> {
1401        let messages = get_python_message_bus(slf.as_any())?;
1402        messages.unsubscribe_topic(topic, handler)
1403    }
1404}
1405
1406impl PyExecutionAlgorithm {
1407    /// Applies Python configuration overrides.
1408    ///
1409    /// Returns whether the config supplied an execution algorithm ID.
1410    ///
1411    /// # Errors
1412    ///
1413    /// Returns an error if an ID has an unsupported type or invalid value.
1414    pub fn configure_from_py_config(&mut self, config: &Bound<'_, PyAny>) -> anyhow::Result<bool> {
1415        let id = config
1416            .getattr("exec_algorithm_id")
1417            .ok()
1418            .filter(|id| !id.is_none())
1419            .or_else(|| config.getattr("actor_id").ok().filter(|id| !id.is_none()));
1420        let has_id = if let Some(id) = id {
1421            let exec_algorithm_id = if let Ok(exec_algorithm_id) = id.extract::<ExecAlgorithmId>() {
1422                exec_algorithm_id
1423            } else if let Ok(actor_id) = id.extract::<ActorId>() {
1424                ExecAlgorithmId::new_checked(actor_id.inner())?
1425            } else if let Ok(id) = id.extract::<String>() {
1426                ExecAlgorithmId::new_checked(&id)?
1427            } else {
1428                anyhow::bail!("Invalid `exec_algorithm_id`/`actor_id` type");
1429            };
1430            self.set_exec_algorithm_id(exec_algorithm_id);
1431            true
1432        } else {
1433            false
1434        };
1435
1436        if let Ok(log_events) = config.getattr("log_events")
1437            && let Ok(log_events) = log_events.extract::<bool>()
1438        {
1439            self.set_log_events(log_events);
1440        }
1441
1442        if let Ok(log_commands) = config.getattr("log_commands")
1443            && let Ok(log_commands) = log_commands.extract::<bool>()
1444        {
1445            self.set_log_commands(log_commands);
1446        }
1447
1448        Ok(has_id)
1449    }
1450
1451    fn resolve_order(&self, order: OrderAny) -> PyResult<OrderAny> {
1452        let cached = self
1453            .try_cache_ref()
1454            .map_err(to_pyruntime_err)?
1455            .order_owned(&order.client_order_id());
1456        Ok(cached.unwrap_or(order))
1457    }
1458
1459    fn ensure_registered_for_data(&self) -> PyResult<()> {
1460        if self.inner().core.actor.is_registered() {
1461            Ok(())
1462        } else {
1463            Err(to_pyruntime_err(
1464                "ExecutionAlgorithm must be registered before publishing data",
1465            ))
1466        }
1467    }
1468
1469    fn ensure_registered(&self) -> PyResult<()> {
1470        if self.inner().core.actor.is_registered() {
1471            Ok(())
1472        } else {
1473            Err(to_pyruntime_err(
1474                "ExecutionAlgorithm must be registered before managing subscriptions",
1475            ))
1476        }
1477    }
1478}
1479
1480#[pyo3::pymethods]
1481#[pyo3_stub_gen::derive::gen_stub_pymethods]
1482impl ExecutionAlgorithmConfig {
1483    /// Configuration for an execution algorithm.
1484    #[new]
1485    #[pyo3(signature = (
1486        exec_algorithm_id=None,
1487        log_events=true,
1488        log_commands=true,
1489        **_kwargs
1490    ))]
1491    fn py_new(
1492        #[gen_stub(override_type(type_repr = "model.ExecAlgorithmId | str | None"))]
1493        exec_algorithm_id: Option<&Bound<'_, PyAny>>,
1494        log_events: bool,
1495        log_commands: bool,
1496        _kwargs: Option<&Bound<'_, PyDict>>,
1497    ) -> PyResult<Self> {
1498        let exec_algorithm_id = exec_algorithm_id
1499            .map(|value| -> PyResult<ExecAlgorithmId> {
1500                if let Ok(exec_algorithm_id) = value.extract::<ExecAlgorithmId>() {
1501                    Ok(exec_algorithm_id)
1502                } else {
1503                    let value: String = value.extract()?;
1504                    ExecAlgorithmId::new_checked(&value).map_err(to_pyvalue_err)
1505                }
1506            })
1507            .transpose()?;
1508
1509        Ok(Self {
1510            exec_algorithm_id,
1511            log_events,
1512            log_commands,
1513        })
1514    }
1515
1516    #[getter]
1517    fn exec_algorithm_id(&self) -> Option<ExecAlgorithmId> {
1518        self.exec_algorithm_id
1519    }
1520
1521    #[getter]
1522    fn log_events(&self) -> bool {
1523        self.log_events
1524    }
1525
1526    #[getter]
1527    fn log_commands(&self) -> bool {
1528        self.log_commands
1529    }
1530}
1531
1532#[pyo3::pymethods]
1533#[pyo3_stub_gen::derive::gen_stub_pymethods]
1534impl ImportableExecutionAlgorithmConfig {
1535    /// Configuration for creating execution algorithms from importable paths.
1536    #[new]
1537    #[expect(clippy::needless_pass_by_value)]
1538    fn py_new(
1539        exec_algorithm_path: String,
1540        config_path: String,
1541        config: Py<PyDict>,
1542    ) -> PyResult<Self> {
1543        let json_config = Python::attach(|py| py_dict_to_json(config.bind(py)))?;
1544
1545        Ok(Self {
1546            exec_algorithm_path,
1547            config_path,
1548            config: json_config,
1549        })
1550    }
1551
1552    #[getter]
1553    fn exec_algorithm_path(&self) -> &String {
1554        &self.exec_algorithm_path
1555    }
1556
1557    #[getter]
1558    fn config_path(&self) -> &String {
1559        &self.config_path
1560    }
1561
1562    #[getter]
1563    fn config(&self, py: Python<'_>) -> PyResult<Py<PyDict>> {
1564        let py_dict = PyDict::new(py);
1565
1566        for (key, value) in &self.config {
1567            let json_str = serde_json::to_string(value).map_err(to_pyvalue_err)?;
1568            let py_value = PyModule::import(py, "json")?.call_method("loads", (json_str,), None)?;
1569            py_dict.set_item(key, py_value)?;
1570        }
1571        Ok(py_dict.unbind())
1572    }
1573}
1574
1575fn py_type_path(value: &Bound<'_, PyAny>) -> PyResult<String> {
1576    let value_type = value.get_type();
1577    let module: String = value_type.getattr("__module__")?.extract()?;
1578    let qualname: String = value_type.getattr("__qualname__")?.extract()?;
1579    Ok(format!("{module}:{qualname}"))
1580}
1581
1582fn py_config_to_json(config: &Bound<'_, PyAny>) -> PyResult<HashMap<String, serde_json::Value>> {
1583    let py = config.py();
1584    let config_dict = PyDict::new(py);
1585
1586    if let Ok(attributes) = config.getattr("__dict__")
1587        && let Ok(attributes) = attributes.cast::<PyDict>()
1588    {
1589        for (key, value) in attributes.iter() {
1590            config_dict.set_item(key, value)?;
1591        }
1592    }
1593
1594    for field in [
1595        "exec_algorithm_id",
1596        "actor_id",
1597        "log_events",
1598        "log_commands",
1599    ] {
1600        if let Ok(value) = config.getattr(field) {
1601            config_dict.set_item(field, value)?;
1602        }
1603    }
1604
1605    py_dict_to_json(&config_dict)
1606}
1607
1608fn py_dict_to_json(config: &Bound<'_, PyDict>) -> PyResult<HashMap<String, serde_json::Value>> {
1609    let py = config.py();
1610    let kwargs = PyDict::new(py);
1611    kwargs.set_item("default", py.eval(pyo3::ffi::c_str!("str"), None, None)?)?;
1612    let json_str: String = PyModule::import(py, "json")?
1613        .call_method("dumps", (config,), Some(&kwargs))?
1614        .extract()?;
1615
1616    let json_value: serde_json::Value = serde_json::from_str(&json_str).map_err(to_pyvalue_err)?;
1617
1618    if let serde_json::Value::Object(map) = json_value {
1619        Ok(map.into_iter().collect())
1620    } else {
1621        Err(to_pyvalue_err("Config must be a dictionary"))
1622    }
1623}
1624
1625#[cfg(test)]
1626mod tests {
1627    use std::{cell::RefCell, rc::Rc};
1628
1629    use nautilus_common::{
1630        cache::Cache,
1631        clock::{Clock, VirtualClock},
1632        logging::{
1633            arm_shutdown_on_error, disarm_shutdown_on_error, init_logging,
1634            take_shutdown_on_error_trigger,
1635        },
1636        messages::{
1637            execution::TradingCommand,
1638            system::{
1639                QueueCondition, QueueState, QueueStateChanged, SocketState, SocketStateChanged,
1640            },
1641        },
1642        msgbus::{
1643            self, MessageBus, MessagingSwitchboard, get_message_bus,
1644            stubs::{TypedIntoMessageSavingHandler, get_typed_into_message_saving_handler},
1645            switchboard::get_signal_topic,
1646        },
1647        runner::SystemChannel,
1648    };
1649    use nautilus_core::{UUID4, UnixNanos};
1650    use nautilus_model::{
1651        enums::{OrderSide, OrderStatus, OrderType, TriggerType},
1652        events::order::spec::{OrderFillVoidedSpec, OrderFilledSpec},
1653        identifiers::{
1654            AccountId, ClientId, ClientOrderId, InstrumentId, OrderListId, PositionId, StrategyId,
1655            TraderId, Venue, VenueOrderId,
1656        },
1657        instruments::{InstrumentAny, stubs::audusd_sim},
1658        orders::{OrderTestBuilder, stubs::TestOrderEventStubs},
1659        position::Position,
1660        types::{Price, Quantity},
1661    };
1662    use pyo3::{
1663        IntoPyObjectExt,
1664        ffi::c_str,
1665        types::{PyList, PyWeakrefMethods, PyWeakrefReference},
1666    };
1667    use rstest::{fixture, rstest};
1668    use ustr::Ustr;
1669
1670    use super::*;
1671
1672    #[rstest]
1673    fn test_python_submit_order_maps_emulation_refusal_to_value_error() {
1674        Python::initialize();
1675
1676        Python::attach(|py| {
1677            *get_message_bus().borrow_mut() = MessageBus::default();
1678
1679            let mut algorithm = PyExecutionAlgorithm::new(None);
1680            let clock: Rc<RefCell<dyn Clock>> = Rc::new(RefCell::new(VirtualClock::new()));
1681            let cache = Rc::new(RefCell::new(Cache::default()));
1682            Component::register(&mut algorithm, TraderId::from("TRADER-001"), clock, cache)
1683                .unwrap();
1684
1685            let client_order_id = ClientOrderId::from("O-EMULATED-SUBMISSION");
1686            let emulated_order = OrderTestBuilder::new(OrderType::Limit)
1687                .instrument_id(InstrumentId::from("AUDUSD.SIM"))
1688                .client_order_id(client_order_id)
1689                .side(OrderSide::Buy)
1690                .price(Price::from("1.00000"))
1691                .quantity(Quantity::from("100"))
1692                .emulation_trigger(TriggerType::BidAsk)
1693                .build();
1694            let emulated_order =
1695                nautilus_model::python::orders::order_any_to_pyobject(py, emulated_order).unwrap();
1696
1697            let e = algorithm
1698                .py_submit_order(py, emulated_order, None, None)
1699                .unwrap_err();
1700            assert!(e.is_instance_of::<pyo3::exceptions::PyValueError>(py));
1701            let message = e.to_string();
1702            assert!(message.contains(client_order_id.as_str()), "{message}");
1703            assert!(message.contains("live emulation trigger"), "{message}");
1704
1705            let mut unregistered_algorithm = PyExecutionAlgorithm::new(None);
1706            let order = OrderTestBuilder::new(OrderType::Market)
1707                .instrument_id(InstrumentId::from("AUDUSD.SIM"))
1708                .side(OrderSide::Buy)
1709                .quantity(Quantity::from("100"))
1710                .build();
1711            let order = nautilus_model::python::orders::order_any_to_pyobject(py, order).unwrap();
1712            let e = unregistered_algorithm
1713                .py_submit_order(py, order, None, None)
1714                .unwrap_err();
1715            assert!(e.is_instance_of::<pyo3::exceptions::PyRuntimeError>(py));
1716        });
1717    }
1718
1719    fn sample_queue_state_changed() -> QueueStateChanged {
1720        QueueStateChanged::new(
1721            TraderId::from("TRADER-001"),
1722            SystemChannel::ExecCommands,
1723            QueueCondition::Backlogged,
1724            QueueState::Triggered,
1725            17,
1726            23,
1727            UUID4::from("00000000-0000-4000-8000-000000000001"),
1728            UnixNanos::from(1_700_000_000_000_000_001),
1729            UnixNanos::from(1_700_000_000_000_000_002),
1730        )
1731    }
1732
1733    fn sample_socket_state_changed() -> SocketStateChanged {
1734        SocketStateChanged::new(
1735            TraderId::from("TRADER-001"),
1736            ClientId::from("BINANCE"),
1737            Some(Venue::from("BINANCE")),
1738            Ustr::from("binance-futures-market-streams"),
1739            SocketState::Connected,
1740            UUID4::from("00000000-0000-4000-8000-000000000001"),
1741            UnixNanos::from(1_700_000_000_000_000_001),
1742            UnixNanos::from(1_700_000_000_000_000_002),
1743        )
1744    }
1745
1746    #[rstest]
1747    fn test_python_queue_state_dispatches_exact_event() {
1748        Python::initialize();
1749
1750        let tracker = Python::attach(|py| {
1751            py.run(
1752                c_str!(
1753                    r#"
1754class QueueStateTracker:
1755    def __init__(self):
1756        self.event = None
1757
1758    def on_queue_state(self, event):
1759        self.event = event
1760"#
1761                ),
1762                None,
1763                None,
1764            )
1765            .unwrap();
1766            py.eval(c_str!("QueueStateTracker()"), None, None)
1767                .unwrap()
1768                .unbind()
1769        });
1770        let mut algorithm = PyExecutionAlgorithm::new(None);
1771        Python::attach(|py| algorithm.set_python_instance(tracker.bind(py))).unwrap();
1772        let event = sample_queue_state_changed();
1773
1774        DataActor::on_queue_state(&mut algorithm, &event).unwrap();
1775
1776        let received = Python::attach(|py| {
1777            tracker
1778                .getattr(py, "event")
1779                .unwrap()
1780                .extract::<QueueStateChanged>(py)
1781                .unwrap()
1782        });
1783        assert_eq!(received, event);
1784    }
1785
1786    #[rstest]
1787    fn test_python_socket_state_dispatches_exact_event() {
1788        Python::initialize();
1789
1790        let tracker = Python::attach(|py| {
1791            py.run(
1792                c_str!(
1793                    r#"
1794class SocketStateTracker:
1795    def __init__(self):
1796        self.event = None
1797
1798    def on_socket_state(self, event):
1799        self.event = event
1800"#
1801                ),
1802                None,
1803                None,
1804            )
1805            .unwrap();
1806            py.eval(c_str!("SocketStateTracker()"), None, None)
1807                .unwrap()
1808                .unbind()
1809        });
1810        let mut algorithm = PyExecutionAlgorithm::new(None);
1811        Python::attach(|py| algorithm.set_python_instance(tracker.bind(py))).unwrap();
1812        let event = sample_socket_state_changed();
1813
1814        DataActor::on_socket_state(&mut algorithm, &event).unwrap();
1815
1816        let received = Python::attach(|py| {
1817            tracker
1818                .getattr(py, "event")
1819                .unwrap()
1820                .extract::<SocketStateChanged>(py)
1821                .unwrap()
1822        });
1823        assert_eq!(received, event);
1824    }
1825
1826    #[rstest]
1827    fn test_python_subscribe_and_unsubscribe_signal_update_msgbus() {
1828        *get_message_bus().borrow_mut() = MessageBus::default();
1829
1830        let mut algorithm = PyExecutionAlgorithm::new(None);
1831        let clock: Rc<RefCell<dyn Clock>> = Rc::new(RefCell::new(VirtualClock::new()));
1832        let cache = Rc::new(RefCell::new(Cache::default()));
1833        Component::register(&mut algorithm, TraderId::from("TRADER-001"), clock, cache).unwrap();
1834
1835        algorithm.py_subscribe_signal("risk", Some(50)).unwrap();
1836
1837        let topic = get_signal_topic("risk");
1838        let subscriptions = get_message_bus().borrow_mut().matching_subscriptions(topic);
1839        assert_eq!(subscriptions.len(), 1);
1840        assert_eq!(subscriptions[0].priority, 50);
1841
1842        algorithm.py_unsubscribe_signal("risk").unwrap();
1843
1844        let subscriptions = get_message_bus().borrow_mut().matching_subscriptions(topic);
1845        assert!(subscriptions.is_empty());
1846    }
1847
1848    #[rstest]
1849    #[case(None)]
1850    #[case(Some(SystemChannel::ExecCommands))]
1851    fn test_python_subscribe_and_unsubscribe_queue_state_update_msgbus(
1852        #[case] channel: Option<SystemChannel>,
1853    ) {
1854        *get_message_bus().borrow_mut() = MessageBus::default();
1855
1856        let mut algorithm = PyExecutionAlgorithm::new(None);
1857        let clock: Rc<RefCell<dyn Clock>> = Rc::new(RefCell::new(VirtualClock::new()));
1858        let cache = Rc::new(RefCell::new(Cache::default()));
1859        Component::register(&mut algorithm, TraderId::from("TRADER-001"), clock, cache).unwrap();
1860
1861        algorithm
1862            .py_subscribe_queue_state(channel, Some(50))
1863            .unwrap();
1864
1865        let topic = MessagingSwitchboard::queue_state_changed_topic(SystemChannel::ExecCommands);
1866        let subscriptions = get_message_bus().borrow_mut().matching_subscriptions(topic);
1867        assert_eq!(subscriptions.len(), 1);
1868        assert_eq!(subscriptions[0].priority, 50);
1869        let unrelated = MessagingSwitchboard::queue_state_changed_topic(SystemChannel::DataEvents);
1870        assert_eq!(
1871            get_message_bus()
1872                .borrow_mut()
1873                .matching_subscriptions(unrelated)
1874                .len(),
1875            usize::from(channel.is_none())
1876        );
1877
1878        algorithm.py_unsubscribe_queue_state(channel).unwrap();
1879
1880        let subscriptions = get_message_bus().borrow_mut().matching_subscriptions(topic);
1881        assert!(subscriptions.is_empty());
1882    }
1883
1884    #[rstest]
1885    #[case(None, None)]
1886    #[case(Some(ClientId::from("BINANCE")), None)]
1887    #[case(None, Some("binance-futures-market-streams"))]
1888    #[case(
1889        Some(ClientId::from("BINANCE")),
1890        Some("binance-futures-market-streams")
1891    )]
1892    fn test_python_subscribe_and_unsubscribe_socket_state_update_msgbus(
1893        #[case] client_id: Option<ClientId>,
1894        #[case] endpoint: Option<&str>,
1895    ) {
1896        *get_message_bus().borrow_mut() = MessageBus::default();
1897
1898        let mut algorithm = PyExecutionAlgorithm::new(None);
1899        let clock: Rc<RefCell<dyn Clock>> = Rc::new(RefCell::new(VirtualClock::new()));
1900        let cache = Rc::new(RefCell::new(Cache::default()));
1901        Component::register(&mut algorithm, TraderId::from("TRADER-001"), clock, cache).unwrap();
1902
1903        algorithm
1904            .py_subscribe_socket_state(client_id, endpoint, Some(50))
1905            .unwrap();
1906
1907        let topic = MessagingSwitchboard::socket_state_changed_topic(
1908            ClientId::from("BINANCE"),
1909            "binance-futures-market-streams",
1910        );
1911        let subscriptions = get_message_bus().borrow_mut().matching_subscriptions(topic);
1912        assert_eq!(subscriptions.len(), 1);
1913        assert_eq!(subscriptions[0].priority, 50);
1914        let unrelated =
1915            MessagingSwitchboard::socket_state_changed_topic(ClientId::from("BYBIT"), "orders");
1916        assert_eq!(
1917            get_message_bus()
1918                .borrow_mut()
1919                .matching_subscriptions(unrelated)
1920                .len(),
1921            usize::from(client_id.is_none() && endpoint.is_none())
1922        );
1923
1924        algorithm
1925            .py_unsubscribe_socket_state(client_id, endpoint)
1926            .unwrap();
1927
1928        let subscriptions = get_message_bus().borrow_mut().matching_subscriptions(topic);
1929        assert!(subscriptions.is_empty());
1930    }
1931
1932    #[rstest]
1933    fn test_python_order_list_override_receives_resolved_orders_without_fanout() {
1934        Python::initialize();
1935
1936        let tracker = Python::attach(|py| {
1937            py.run(
1938                c_str!(
1939                    r#"
1940class OrderListTracker:
1941    def __init__(self):
1942        self.list_calls = 0
1943        self.list_ids = []
1944        self.resolved_ids = []
1945        self.order_ids = []
1946
1947    def on_order_list(self, order_list, orders):
1948        self.list_calls += 1
1949        self.list_ids = [str(value) for value in order_list.client_order_ids()]
1950        self.resolved_ids = [str(order.client_order_id) for order in orders]
1951
1952    def on_order(self, order):
1953        self.order_ids.append(str(order.client_order_id))
1954
1955    def observations(self):
1956        return self.list_calls, self.list_ids, self.resolved_ids, self.order_ids
1957"#
1958                ),
1959                None,
1960                None,
1961            )
1962            .unwrap();
1963            py.eval(c_str!("OrderListTracker()"), None, None)
1964                .unwrap()
1965                .unbind()
1966        });
1967        let mut algorithm = PyExecutionAlgorithm::new(None);
1968        Python::attach(|py| algorithm.set_python_instance(tracker.bind(py))).unwrap();
1969
1970        let instrument_id = InstrumentId::from("BTC/USDT.BINANCE");
1971        let strategy_id = StrategyId::from("STRAT-LIST-OVERRIDE");
1972        let first = OrderTestBuilder::new(OrderType::Market)
1973            .strategy_id(strategy_id)
1974            .instrument_id(instrument_id)
1975            .client_order_id(ClientOrderId::from("O-LIST-OVERRIDE-001"))
1976            .quantity(Quantity::from("1.0"))
1977            .build();
1978        let second = OrderTestBuilder::new(OrderType::Market)
1979            .strategy_id(strategy_id)
1980            .instrument_id(instrument_id)
1981            .client_order_id(ClientOrderId::from("O-LIST-OVERRIDE-002"))
1982            .quantity(Quantity::from("2.0"))
1983            .build();
1984        let order_list = OrderList::new(
1985            OrderListId::from("OL-OVERRIDE-001"),
1986            instrument_id,
1987            strategy_id,
1988            vec![first.client_order_id(), second.client_order_id()],
1989            0.into(),
1990        );
1991
1992        ExecutionAlgorithm::on_order_list(&mut algorithm, order_list, vec![first, second]).unwrap();
1993
1994        let observations = Python::attach(|py| {
1995            tracker
1996                .call_method0(py, "observations")
1997                .unwrap()
1998                .extract::<(usize, Vec<String>, Vec<String>, Vec<String>)>(py)
1999                .unwrap()
2000        });
2001        assert_eq!(
2002            observations,
2003            (
2004                1,
2005                vec![
2006                    "O-LIST-OVERRIDE-001".to_string(),
2007                    "O-LIST-OVERRIDE-002".to_string(),
2008                ],
2009                vec![
2010                    "O-LIST-OVERRIDE-001".to_string(),
2011                    "O-LIST-OVERRIDE-002".to_string(),
2012                ],
2013                Vec::new(),
2014            ),
2015        );
2016    }
2017
2018    #[rstest]
2019    fn test_python_self_is_weak() {
2020        Python::initialize();
2021
2022        Python::attach(|py| {
2023            let instance = py
2024                .get_type::<PyExecutionAlgorithm>()
2025                .call0()
2026                .expect("ExecutionAlgorithm should construct");
2027            let weakref = PyWeakrefReference::new(&instance)
2028                .expect("ExecutionAlgorithm should be weak-referenceable");
2029            assert!(weakref.upgrade().is_some());
2030
2031            drop(instance);
2032
2033            // A strong `py_self` would form an untraceable Rust-Python cycle and keep this alive
2034            assert!(
2035                weakref.upgrade().is_none(),
2036                "an unregistered ExecutionAlgorithm must be collected once its last Python owner is dropped",
2037            );
2038        });
2039    }
2040
2041    #[rstest]
2042    #[case("on_order_initialized")]
2043    #[case("on_order_denied")]
2044    #[case("on_order_emulated")]
2045    #[case("on_order_released")]
2046    #[case("on_order_submitted")]
2047    #[case("on_order_rejected")]
2048    #[case("on_order_accepted")]
2049    #[case("on_order_canceled")]
2050    #[case("on_order_expired")]
2051    #[case("on_order_triggered")]
2052    #[case("on_order_pending_update")]
2053    #[case("on_order_pending_cancel")]
2054    #[case("on_order_modify_denied")]
2055    #[case("on_order_modify_rejected")]
2056    #[case("on_order_cancel_denied")]
2057    #[case("on_order_cancel_rejected")]
2058    #[case("on_order_updated")]
2059    #[case("on_order_filled")]
2060    #[case("on_order_fill_voided")]
2061    #[case("on_order_event")]
2062    #[case("on_position_opened")]
2063    #[case("on_position_changed")]
2064    #[case("on_position_closed")]
2065    #[case("on_position_event")]
2066    fn test_python_callback_errors(
2067        #[case] method: &str,
2068        #[values(false, true)] raises: bool,
2069        #[values(false, true)] shutdown: bool,
2070    ) {
2071        Python::initialize();
2072        let _guard = init_logging(
2073            TraderId::from("TRADER-001"),
2074            UUID4::new(),
2075            Default::default(),
2076            Default::default(),
2077        )
2078        .unwrap();
2079        Python::attach(|py| {
2080            let fill = OrderFilledSpec::builder()
2081                .position_id(PositionId::from("P-001"))
2082                .build();
2083            let position = Position::new(&InstrumentAny::CurrencyPair(audusd_sim()), fill.clone());
2084            let tracker = create_callback_algorithm(py, raises);
2085            let mut algorithm = PyExecutionAlgorithm::new(None);
2086            algorithm.set_python_instance(tracker.bind(py)).unwrap();
2087            arm_shutdown_on_error(shutdown);
2088
2089            match method {
2090                "on_order_initialized" => ExecutionAlgorithm::on_order_initialized(
2091                    &mut algorithm,
2092                    OrderInitialized::default(),
2093                ),
2094                "on_order_denied" => {
2095                    ExecutionAlgorithm::on_order_denied(&mut algorithm, OrderDenied::default());
2096                }
2097                "on_order_emulated" => {
2098                    ExecutionAlgorithm::on_order_emulated(&mut algorithm, OrderEmulated::default());
2099                }
2100                "on_order_released" => {
2101                    ExecutionAlgorithm::on_order_released(&mut algorithm, OrderReleased::default());
2102                }
2103                "on_order_submitted" => ExecutionAlgorithm::on_order_submitted(
2104                    &mut algorithm,
2105                    OrderSubmitted::default(),
2106                ),
2107                "on_order_rejected" => {
2108                    ExecutionAlgorithm::on_order_rejected(&mut algorithm, OrderRejected::default());
2109                }
2110                "on_order_accepted" => {
2111                    ExecutionAlgorithm::on_order_accepted(&mut algorithm, OrderAccepted::default());
2112                }
2113                "on_order_canceled" => ExecutionAlgorithm::on_algo_order_canceled(
2114                    &mut algorithm,
2115                    OrderCanceled::default(),
2116                ),
2117                "on_order_expired" => {
2118                    ExecutionAlgorithm::on_order_expired(&mut algorithm, OrderExpired::default());
2119                }
2120                "on_order_triggered" => ExecutionAlgorithm::on_order_triggered(
2121                    &mut algorithm,
2122                    OrderTriggered::default(),
2123                ),
2124                "on_order_pending_update" => ExecutionAlgorithm::on_order_pending_update(
2125                    &mut algorithm,
2126                    OrderPendingUpdate::default(),
2127                ),
2128                "on_order_pending_cancel" => ExecutionAlgorithm::on_order_pending_cancel(
2129                    &mut algorithm,
2130                    OrderPendingCancel::default(),
2131                ),
2132                "on_order_modify_denied" => ExecutionAlgorithm::on_order_modify_denied(
2133                    &mut algorithm,
2134                    OrderModifyDenied::default(),
2135                ),
2136                "on_order_modify_rejected" => ExecutionAlgorithm::on_order_modify_rejected(
2137                    &mut algorithm,
2138                    OrderModifyRejected::default(),
2139                ),
2140                "on_order_cancel_denied" => ExecutionAlgorithm::on_order_cancel_denied(
2141                    &mut algorithm,
2142                    OrderCancelDenied::default(),
2143                ),
2144                "on_order_cancel_rejected" => ExecutionAlgorithm::on_order_cancel_rejected(
2145                    &mut algorithm,
2146                    OrderCancelRejected::default(),
2147                ),
2148                "on_order_updated" => {
2149                    ExecutionAlgorithm::on_order_updated(&mut algorithm, OrderUpdated::default());
2150                }
2151                "on_order_filled" => ExecutionAlgorithm::on_algo_order_filled(
2152                    &mut algorithm,
2153                    OrderFilledSpec::builder().build(),
2154                ),
2155                "on_order_fill_voided" => ExecutionAlgorithm::on_order_fill_voided(
2156                    &mut algorithm,
2157                    &OrderFillVoidedSpec::builder().build(),
2158                ),
2159                "on_order_event" => ExecutionAlgorithm::on_order_event(
2160                    &mut algorithm,
2161                    OrderEventAny::Accepted(OrderAccepted::default()),
2162                ),
2163                "on_position_opened" => ExecutionAlgorithm::on_position_opened(
2164                    &mut algorithm,
2165                    PositionOpened::create(&position, &fill, UUID4::new(), UnixNanos::default()),
2166                ),
2167                "on_position_changed" => ExecutionAlgorithm::on_position_changed(
2168                    &mut algorithm,
2169                    PositionChanged::create(&position, &fill, UUID4::new(), UnixNanos::default()),
2170                ),
2171                "on_position_closed" => ExecutionAlgorithm::on_position_closed(
2172                    &mut algorithm,
2173                    PositionClosed::create(&position, &fill, UUID4::new(), UnixNanos::default()),
2174                ),
2175                "on_position_event" => ExecutionAlgorithm::on_position_event(
2176                    &mut algorithm,
2177                    PositionEvent::PositionOpened(PositionOpened::create(
2178                        &position,
2179                        &fill,
2180                        UUID4::new(),
2181                        UnixNanos::default(),
2182                    )),
2183                ),
2184                _ => unreachable!(),
2185            }
2186
2187            let trigger = take_shutdown_on_error_trigger();
2188            disarm_shutdown_on_error();
2189            let calls = tracker
2190                .getattr(py, "calls")
2191                .unwrap()
2192                .extract::<Vec<String>>(py)
2193                .unwrap();
2194
2195            assert_eq!(calls, [method]);
2196
2197            if raises && shutdown {
2198                let trigger = trigger.expect("Python callback failure must request shutdown");
2199                assert_eq!(
2200                    trigger.component.as_str(),
2201                    algorithm.inner().core.actor.actor_id.as_str()
2202                );
2203                assert!(
2204                    trigger
2205                        .message
2206                        .contains(&format!("Python {method} failed:"))
2207                );
2208                assert!(trigger.message.contains("in callback"));
2209                assert!(
2210                    trigger
2211                        .message
2212                        .contains("RuntimeError: algorithm callback failure")
2213                );
2214            } else {
2215                assert_eq!(trigger, None);
2216            }
2217        });
2218    }
2219
2220    #[rstest]
2221    fn test_python_algorithm_callback_exception_preserves_traceback() {
2222        Python::initialize();
2223        Python::attach(|py| {
2224            let tracker = create_callback_algorithm(py, true);
2225            let mut algorithm = PyExecutionAlgorithm::new(None);
2226            algorithm.set_python_instance(tracker.bind(py)).unwrap();
2227
2228            let event = TimeEvent::new(
2229                "ALERT".into(),
2230                UUID4::new(),
2231                UnixNanos::from(10),
2232                UnixNanos::from(11),
2233            );
2234            let error = DataActor::on_time_event(&mut algorithm, &event).unwrap_err();
2235            let message = error.to_string();
2236            let calls = tracker
2237                .getattr(py, "calls")
2238                .unwrap()
2239                .extract::<Vec<String>>(py)
2240                .unwrap();
2241
2242            assert_eq!(calls, ["on_time_event"]);
2243            assert!(message.contains("Python on_time_event failed:"));
2244            assert!(message.contains("in callback"));
2245            assert!(message.contains("RuntimeError: algorithm callback failure"));
2246        });
2247    }
2248
2249    fn create_callback_algorithm(py: Python<'_>, raises: bool) -> Py<PyAny> {
2250        let module = PyModule::from_code(
2251            py,
2252            c_str!(
2253                r#"
2254class CallbackAlgorithm:
2255    def __init__(self, raises):
2256        self.raises = raises
2257        self.calls = []
2258
2259    def __getattr__(self, name):
2260        def callback(event):
2261            self.calls.append(name)
2262            if self.raises:
2263                raise RuntimeError("algorithm callback failure")
2264        return callback
2265"#
2266            ),
2267            c_str!("algorithm_callback.py"),
2268            c_str!("algorithm_callback"),
2269        )
2270        .unwrap();
2271        module
2272            .getattr("CallbackAlgorithm")
2273            .unwrap()
2274            .call1((raises,))
2275            .unwrap()
2276            .unbind()
2277    }
2278
2279    #[rstest::rstest]
2280    #[case("on_start")]
2281    #[case("on_stop")]
2282    #[case("on_resume")]
2283    #[case("on_reset")]
2284    #[case("on_dispose")]
2285    #[case("on_degrade")]
2286    #[case("on_fault")]
2287    #[case("on_time_event")]
2288    #[case("on_signal")]
2289    #[case("on_queue_state")]
2290    #[case("on_socket_state")]
2291    #[case("on_order")]
2292    #[case("on_order_list")]
2293    #[case("on_order_initialized")]
2294    #[case("on_order_event")]
2295    #[case("on_order_denied")]
2296    #[case("on_order_emulated")]
2297    #[case("on_order_released")]
2298    #[case("on_order_submitted")]
2299    #[case("on_order_rejected")]
2300    #[case("on_order_accepted")]
2301    #[case("on_order_canceled")]
2302    #[case("on_order_expired")]
2303    #[case("on_order_triggered")]
2304    #[case("on_order_pending_update")]
2305    #[case("on_order_pending_cancel")]
2306    #[case("on_order_modify_denied")]
2307    #[case("on_order_modify_rejected")]
2308    #[case("on_order_cancel_denied")]
2309    #[case("on_order_cancel_rejected")]
2310    #[case("on_order_updated")]
2311    #[case("on_order_filled")]
2312    #[case("on_order_fill_voided")]
2313    #[case("on_position_opened")]
2314    #[case("on_position_event")]
2315    #[case("on_position_changed")]
2316    #[case("on_position_closed")]
2317    fn test_default_callback_during_exclusive_borrow(#[case] method: &str) {
2318        Python::initialize();
2319        Python::attach(|py| {
2320            let instrument = audusd_sim();
2321            let fill = OrderFilledSpec::builder()
2322                .instrument_id(instrument.id)
2323                .position_id(PositionId::from("P-001"))
2324                .build();
2325            let position = Position::new(&InstrumentAny::CurrencyPair(instrument), fill.clone());
2326
2327            let argument = match method {
2328                "on_start" | "on_stop" | "on_resume" | "on_reset" | "on_dispose" | "on_degrade"
2329                | "on_fault" => None,
2330                "on_time_event" => Some(
2331                    TimeEvent::new(
2332                        Ustr::from("CALLBACK"),
2333                        UUID4::new(),
2334                        UnixNanos::default(),
2335                        UnixNanos::default(),
2336                    )
2337                    .into_py_any(py)
2338                    .unwrap(),
2339                ),
2340                "on_signal" => Some(
2341                    Signal::new(
2342                        Ustr::from("SIGNAL"),
2343                        "1.0".to_string(),
2344                        UnixNanos::default(),
2345                        UnixNanos::default(),
2346                    )
2347                    .into_py_any(py)
2348                    .unwrap(),
2349                ),
2350                "on_queue_state" => Some(sample_queue_state_changed().into_py_any(py).unwrap()),
2351                "on_socket_state" => Some(sample_socket_state_changed().into_py_any(py).unwrap()),
2352                "on_order" | "on_order_list" | "on_order_event" | "on_position_event" => {
2353                    Some(py.None())
2354                }
2355                "on_order_initialized" => {
2356                    Some(OrderInitialized::default().into_py_any(py).unwrap())
2357                }
2358                "on_order_denied" => Some(OrderDenied::default().into_py_any(py).unwrap()),
2359                "on_order_emulated" => Some(OrderEmulated::default().into_py_any(py).unwrap()),
2360                "on_order_released" => Some(OrderReleased::default().into_py_any(py).unwrap()),
2361                "on_order_submitted" => Some(OrderSubmitted::default().into_py_any(py).unwrap()),
2362                "on_order_rejected" => Some(OrderRejected::default().into_py_any(py).unwrap()),
2363                "on_order_accepted" => Some(OrderAccepted::default().into_py_any(py).unwrap()),
2364                "on_order_canceled" => Some(OrderCanceled::default().into_py_any(py).unwrap()),
2365                "on_order_expired" => Some(OrderExpired::default().into_py_any(py).unwrap()),
2366                "on_order_triggered" => Some(OrderTriggered::default().into_py_any(py).unwrap()),
2367                "on_order_pending_update" => {
2368                    Some(OrderPendingUpdate::default().into_py_any(py).unwrap())
2369                }
2370                "on_order_pending_cancel" => {
2371                    Some(OrderPendingCancel::default().into_py_any(py).unwrap())
2372                }
2373                "on_order_modify_denied" => {
2374                    Some(OrderModifyDenied::default().into_py_any(py).unwrap())
2375                }
2376                "on_order_modify_rejected" => {
2377                    Some(OrderModifyRejected::default().into_py_any(py).unwrap())
2378                }
2379                "on_order_cancel_denied" => {
2380                    Some(OrderCancelDenied::default().into_py_any(py).unwrap())
2381                }
2382                "on_order_cancel_rejected" => {
2383                    Some(OrderCancelRejected::default().into_py_any(py).unwrap())
2384                }
2385                "on_order_updated" => Some(OrderUpdated::default().into_py_any(py).unwrap()),
2386                "on_order_filled" => {
2387                    Some(OrderFilledSpec::builder().build().into_py_any(py).unwrap())
2388                }
2389                "on_order_fill_voided" => Some(
2390                    OrderFillVoidedSpec::builder()
2391                        .build()
2392                        .into_py_any(py)
2393                        .unwrap(),
2394                ),
2395                "on_position_opened" => Some(
2396                    PositionOpened::create(&position, &fill, UUID4::new(), UnixNanos::default())
2397                        .into_py_any(py)
2398                        .unwrap(),
2399                ),
2400                "on_position_changed" => Some(
2401                    PositionChanged::create(&position, &fill, UUID4::new(), UnixNanos::default())
2402                        .into_py_any(py)
2403                        .unwrap(),
2404                ),
2405                "on_position_closed" => Some(
2406                    PositionClosed::create(&position, &fill, UUID4::new(), UnixNanos::default())
2407                        .into_py_any(py)
2408                        .unwrap(),
2409                ),
2410                _ => unreachable!(),
2411            };
2412
2413            let instance = py.get_type::<PyExecutionAlgorithm>().call0().unwrap();
2414            let _borrow = instance
2415                .extract::<pyo3::PyRefMut<'_, PyExecutionAlgorithm>>()
2416                .unwrap();
2417
2418            let result = match argument {
2419                Some(argument) if method == "on_order_list" => {
2420                    instance.call_method1(method, (argument, PyList::empty(py)))
2421                }
2422                Some(argument) => instance.call_method1(method, (argument,)),
2423                None => instance.call_method0(method),
2424            }
2425            .unwrap();
2426
2427            assert!(result.is_none());
2428        });
2429    }
2430
2431    #[rstest]
2432    #[case("modify_order", true)]
2433    #[case("modify_order", false)]
2434    #[case("modify_order_in_place", true)]
2435    #[case("cancel_order", true)]
2436    #[case("cancel_order", false)]
2437    fn test_order_commands_refresh_python_snapshot(
2438        registered_algorithm: PyExecutionAlgorithm,
2439        #[case] method: &str,
2440        #[case] in_cache: bool,
2441    ) {
2442        Python::initialize();
2443        Python::attach(|py| {
2444            let cache = registered_algorithm.cache_rc();
2445            let (handler, messages): (_, TypedIntoMessageSavingHandler<TradingCommand>) =
2446                get_typed_into_message_saving_handler(None);
2447            msgbus::register_trading_command_endpoint(
2448                MessagingSwitchboard::risk_engine_queue_execute(),
2449                handler.clone(),
2450            );
2451            msgbus::register_trading_command_endpoint(
2452                MessagingSwitchboard::exec_engine_queue_execute(),
2453                handler,
2454            );
2455            let order = OrderTestBuilder::new(OrderType::Limit)
2456                .trader_id(TraderId::from("TRADER-001"))
2457                .strategy_id(StrategyId::from("S-REFRESH-001"))
2458                .instrument_id(InstrumentId::from("AUD/USD.SIM"))
2459                .client_order_id(ClientOrderId::from("O-REFRESH-001"))
2460                .quantity(Quantity::from(123))
2461                .price(Price::from("1.23456"))
2462                .build();
2463            let argument =
2464                nautilus_model::python::orders::order_any_to_pyobject(py, order.clone()).unwrap();
2465            let account_id = AccountId::from("SIM-009");
2466            let venue_order_id = VenueOrderId::from("V-REFRESH-009");
2467
2468            let before = if in_cache {
2469                let mut cache = cache.borrow_mut();
2470                cache.add_order(order.clone(), None, None, true).unwrap();
2471                let submitted = TestOrderEventStubs::submitted(&order, account_id);
2472                cache.update_order(&submitted).unwrap();
2473                let accepted = TestOrderEventStubs::accepted(&order, account_id, venue_order_id);
2474                cache.update_order(&accepted).unwrap()
2475            } else {
2476                order.clone()
2477            };
2478
2479            let instance = Py::new(py, registered_algorithm).unwrap();
2480            let new_qty = Quantity::from(234);
2481
2482            let result = if method == "cancel_order" {
2483                instance.call_method1(py, method, (argument.clone_ref(py),))
2484            } else {
2485                instance.call_method1(py, method, (argument.clone_ref(py), new_qty))
2486            };
2487
2488            let cached = cache.borrow().order_owned(&order.client_order_id());
2489            let commands = messages.get_messages();
2490
2491            if method == "modify_order_in_place" {
2492                let e = result.unwrap_err();
2493                assert!(e.is_instance_of::<pyo3::exceptions::PyRuntimeError>(py));
2494                assert_eq!(
2495                    e.to_string(),
2496                    "RuntimeError: Cannot modify order in place: status is Accepted, expected INITIALIZED or RELEASED"
2497                );
2498                assert_eq!(
2499                    serde_json::to_value(&cached).unwrap(),
2500                    serde_json::to_value(&before).unwrap()
2501                );
2502                assert!(commands.is_empty());
2503            } else {
2504                result.unwrap();
2505                assert_eq!(commands.len(), 1);
2506
2507                match &commands[0] {
2508                    TradingCommand::ModifyOrder(command) if method == "modify_order" => {
2509                        assert_eq!(command.trader_id, order.trader_id());
2510                        assert_eq!(command.strategy_id, order.strategy_id());
2511                        assert_eq!(command.instrument_id, order.instrument_id());
2512                        assert_eq!(command.client_order_id, order.client_order_id());
2513                        assert_eq!(command.venue_order_id, in_cache.then_some(venue_order_id));
2514                        assert_eq!(command.quantity, Some(new_qty));
2515                        assert_eq!(command.price, None);
2516                        assert_eq!(command.trigger_price, None);
2517                        assert_eq!(command.client_id, None);
2518                        assert_eq!(command.params, None);
2519                        assert_eq!(command.correlation_id, None);
2520                        assert_eq!(command.causation_id, None);
2521                        assert_eq!(command.ts_init, UnixNanos::default());
2522                        assert_eq!(
2523                            cached.as_ref().map(Order::status),
2524                            in_cache.then_some(OrderStatus::PendingUpdate)
2525                        );
2526                    }
2527                    TradingCommand::CancelOrder(command) if method == "cancel_order" => {
2528                        assert_eq!(command.trader_id, order.trader_id());
2529                        assert_eq!(command.strategy_id, order.strategy_id());
2530                        assert_eq!(command.instrument_id, order.instrument_id());
2531                        assert_eq!(command.client_order_id, order.client_order_id());
2532                        assert_eq!(command.venue_order_id, in_cache.then_some(venue_order_id));
2533                        assert_eq!(command.client_id, None);
2534                        assert_eq!(command.params, None);
2535                        assert_eq!(command.correlation_id, None);
2536                        assert_eq!(command.causation_id, None);
2537                        assert_eq!(command.ts_init, UnixNanos::default());
2538                        assert_eq!(
2539                            cached.as_ref().map(Order::status),
2540                            in_cache.then_some(OrderStatus::PendingCancel)
2541                        );
2542                    }
2543                    command => panic!("Unexpected command: {command:?}"),
2544                }
2545
2546                if let Some(cached) = cached {
2547                    assert_eq!(cached.quantity(), order.quantity());
2548                    assert_eq!(cached.price(), order.price());
2549                    assert_eq!(cached.venue_order_id(), Some(venue_order_id));
2550                    assert_eq!(cached.account_id(), Some(account_id));
2551                    assert_eq!(cached.events().len(), before.events().len() + 1);
2552                }
2553            }
2554
2555            let retained = pyobject_to_order_any(py, argument).unwrap();
2556            assert_eq!(
2557                serde_json::to_value(&retained).unwrap(),
2558                serde_json::to_value(&order).unwrap()
2559            );
2560        });
2561    }
2562
2563    #[rstest]
2564    fn test_order_commands_respect_cached_status(
2565        registered_algorithm: PyExecutionAlgorithm,
2566        #[values("modify_order", "cancel_order")] method: &str,
2567        #[values(OrderStatus::Canceled, OrderStatus::PendingCancel)] status: OrderStatus,
2568    ) {
2569        Python::attach(|py| {
2570            let cache = registered_algorithm.cache_rc();
2571            let order = OrderTestBuilder::new(OrderType::Limit)
2572                .trader_id(TraderId::from("TRADER-001"))
2573                .strategy_id(StrategyId::from("S-STATUS-001"))
2574                .instrument_id(InstrumentId::from("AUD/USD.SIM"))
2575                .client_order_id(ClientOrderId::from("O-STATUS-001"))
2576                .quantity(Quantity::from(123))
2577                .price(Price::from("1.23456"))
2578                .build();
2579            let argument =
2580                nautilus_model::python::orders::order_any_to_pyobject(py, order.clone()).unwrap();
2581            let account_id = AccountId::from("SIM-009");
2582            let venue_order_id = VenueOrderId::from("V-STATUS-009");
2583
2584            let before = {
2585                let mut cache = cache.borrow_mut();
2586                cache.add_order(order.clone(), None, None, true).unwrap();
2587                let submitted = TestOrderEventStubs::submitted(&order, account_id);
2588                cache.update_order(&submitted).unwrap();
2589                let accepted = TestOrderEventStubs::accepted(&order, account_id, venue_order_id);
2590                cache.update_order(&accepted).unwrap();
2591
2592                let event = if status == OrderStatus::Canceled {
2593                    TestOrderEventStubs::canceled(&order, account_id, Some(venue_order_id))
2594                } else {
2595                    OrderEventAny::PendingCancel(OrderPendingCancel::new(
2596                        order.trader_id(),
2597                        order.strategy_id(),
2598                        order.instrument_id(),
2599                        order.client_order_id(),
2600                        Some(account_id),
2601                        UUID4::new(),
2602                        UnixNanos::default(),
2603                        UnixNanos::default(),
2604                        false,
2605                        Some(venue_order_id),
2606                    ))
2607                };
2608
2609                cache.update_order(&event).unwrap()
2610            };
2611
2612            let (handler, messages): (_, TypedIntoMessageSavingHandler<TradingCommand>) =
2613                get_typed_into_message_saving_handler(None);
2614            msgbus::register_trading_command_endpoint(
2615                MessagingSwitchboard::risk_engine_queue_execute(),
2616                handler.clone(),
2617            );
2618            msgbus::register_trading_command_endpoint(
2619                MessagingSwitchboard::exec_engine_queue_execute(),
2620                handler,
2621            );
2622            let instance = Py::new(py, registered_algorithm).unwrap();
2623            let result = if method == "cancel_order" {
2624                instance.call_method1(py, method, (argument,))
2625            } else {
2626                instance.call_method1(py, method, (argument, Quantity::from(234)))
2627            };
2628
2629            let after = cache
2630                .borrow()
2631                .order_owned(&order.client_order_id())
2632                .unwrap();
2633
2634            result.unwrap();
2635            assert_eq!(after.status(), status);
2636            assert_eq!(
2637                serde_json::to_value(&after).unwrap(),
2638                serde_json::to_value(&before).unwrap()
2639            );
2640            assert!(messages.get_messages().is_empty());
2641        });
2642    }
2643
2644    #[rstest]
2645    fn test_submit_order_after_modify_in_place_submits_current_values(
2646        registered_algorithm: PyExecutionAlgorithm,
2647        #[values(true, false)] in_cache: bool,
2648    ) {
2649        Python::attach(|py| {
2650            let cache = registered_algorithm.cache_rc();
2651            let (handler, messages): (_, TypedIntoMessageSavingHandler<TradingCommand>) =
2652                get_typed_into_message_saving_handler(None);
2653            msgbus::register_trading_command_endpoint(
2654                MessagingSwitchboard::risk_engine_queue_execute(),
2655                handler,
2656            );
2657            let order = OrderTestBuilder::new(OrderType::StopLimit)
2658                .trader_id(TraderId::from("TRADER-001"))
2659                .strategy_id(StrategyId::from("S-SUBMIT-001"))
2660                .instrument_id(InstrumentId::from("AUD/USD.SIM"))
2661                .client_order_id(ClientOrderId::from("O-SUBMIT-001"))
2662                .quantity(Quantity::from(123))
2663                .price(Price::from("1.23456"))
2664                .trigger_price(Price::from("1.23400"))
2665                .build();
2666            let argument =
2667                nautilus_model::python::orders::order_any_to_pyobject(py, order.clone()).unwrap();
2668            let new_qty = Quantity::from(100);
2669            let new_price = Price::from("1.23500");
2670            let new_trigger_price = Price::from("1.23450");
2671
2672            if in_cache {
2673                cache
2674                    .borrow_mut()
2675                    .add_order(order.clone(), None, None, false)
2676                    .unwrap();
2677            }
2678
2679            let instance = Py::new(py, registered_algorithm).unwrap();
2680
2681            if in_cache {
2682                instance
2683                    .call_method1(
2684                        py,
2685                        "modify_order_in_place",
2686                        (
2687                            argument.clone_ref(py),
2688                            new_qty,
2689                            new_price,
2690                            new_trigger_price,
2691                        ),
2692                    )
2693                    .unwrap();
2694            }
2695
2696            instance
2697                .call_method1(py, "submit_order", (argument.clone_ref(py),))
2698                .unwrap();
2699
2700            let cached = cache
2701                .borrow()
2702                .order_owned(&order.client_order_id())
2703                .unwrap();
2704            let commands = messages.get_messages();
2705            let [TradingCommand::SubmitOrder(command)] = commands.as_slice() else {
2706                panic!("Expected exactly one SubmitOrder command, was {commands:?}");
2707            };
2708            let (expected_qty, expected_price, expected_trigger_price) = if in_cache {
2709                (new_qty, new_price, new_trigger_price)
2710            } else {
2711                (
2712                    Quantity::from(123),
2713                    Price::from("1.23456"),
2714                    Price::from("1.23400"),
2715                )
2716            };
2717
2718            assert_eq!(command.client_order_id, order.client_order_id());
2719            assert_eq!(command.order_init.order_type, OrderType::StopLimit);
2720            assert_eq!(command.order_init.quantity, expected_qty);
2721            assert_eq!(command.order_init.price, Some(expected_price));
2722            assert_eq!(
2723                command.order_init.trigger_price,
2724                Some(expected_trigger_price)
2725            );
2726            assert_eq!(cached.status(), OrderStatus::Initialized);
2727            assert_eq!(cached.quantity(), expected_qty);
2728            assert_eq!(cached.price(), Some(expected_price));
2729            assert_eq!(cached.trigger_price(), Some(expected_trigger_price));
2730
2731            if in_cache {
2732                assert_eq!(cached.events().len(), 2);
2733            } else {
2734                assert_eq!(
2735                    serde_json::to_value(&cached).unwrap(),
2736                    serde_json::to_value(&order).unwrap()
2737                );
2738            }
2739
2740            let retained = pyobject_to_order_any(py, argument).unwrap();
2741            assert_eq!(retained.quantity(), order.quantity());
2742            assert_eq!(retained.price(), order.price());
2743            assert_eq!(retained.trigger_price(), order.trigger_price());
2744        });
2745    }
2746
2747    #[fixture]
2748    fn registered_algorithm() -> PyExecutionAlgorithm {
2749        Python::initialize();
2750        *get_message_bus().borrow_mut() = MessageBus::default();
2751        let mut algorithm = PyExecutionAlgorithm::new(None);
2752        let clock: Rc<RefCell<dyn Clock>> = Rc::new(RefCell::new(VirtualClock::new()));
2753        let cache = Rc::new(RefCell::new(Cache::default()));
2754        Component::register(&mut algorithm, TraderId::from("TRADER-001"), clock, cache).unwrap();
2755        algorithm
2756    }
2757
2758    #[rstest::rstest]
2759    #[case(false)]
2760    #[case(true)]
2761    fn test_modify_order_no_changes_returns_error_without_logging(#[case] same_values: bool) {
2762        Python::initialize();
2763        let _guard = init_logging(
2764            TraderId::from("TRADER-001"),
2765            UUID4::new(),
2766            Default::default(),
2767            Default::default(),
2768        )
2769        .unwrap();
2770        Python::attach(|py| {
2771            let mut algorithm = PyExecutionAlgorithm::new(None);
2772            let clock: Rc<RefCell<dyn Clock>> = Rc::new(RefCell::new(VirtualClock::new()));
2773            let cache = Rc::new(RefCell::new(Cache::default()));
2774            Component::register(
2775                &mut algorithm,
2776                TraderId::from("TRADER-001"),
2777                clock,
2778                cache.clone(),
2779            )
2780            .unwrap();
2781            let strategy_id = StrategyId::from("S-001");
2782            let instance = Py::new(py, algorithm).unwrap();
2783            let client_order_id = ClientOrderId::from("O-NO-CHANGE-001");
2784            let order = OrderTestBuilder::new(OrderType::Limit)
2785                .instrument_id(InstrumentId::from("AUD/USD.SIM"))
2786                .strategy_id(strategy_id)
2787                .client_order_id(client_order_id)
2788                .price(Price::from("1.23456"))
2789                .quantity(Quantity::from(123))
2790                .submit(true)
2791                .build();
2792            cache
2793                .borrow_mut()
2794                .add_order(order.clone(), None, None, true)
2795                .unwrap();
2796            let argument =
2797                nautilus_model::python::orders::order_any_to_pyobject(py, order.clone()).unwrap();
2798            let quantity = same_values.then_some(order.quantity());
2799            let price = same_values.then_some(order.price().unwrap());
2800            arm_shutdown_on_error(true);
2801            let result = instance.call_method1(py, "modify_order", (argument, quantity, price));
2802            let trigger = take_shutdown_on_error_trigger();
2803            disarm_shutdown_on_error();
2804
2805            let e = result.unwrap_err();
2806            assert!(e.is_instance_of::<pyo3::exceptions::PyRuntimeError>(py));
2807            assert_eq!(
2808                e.to_string(),
2809                "RuntimeError: Cannot create command ModifyOrder: quantity, price, and trigger were either None or the same as existing values"
2810            );
2811            assert_eq!(trigger, None);
2812            assert_eq!(cache.borrow().order(&client_order_id).unwrap(), &order);
2813        });
2814    }
2815
2816    #[rstest]
2817    fn test_execute_refusal_during_exclusive_borrow() {
2818        Python::initialize();
2819        Python::attach(|py| {
2820            let instance = py.get_type::<PyExecutionAlgorithm>().call0().unwrap();
2821            let _borrow = instance
2822                .extract::<PyRefMut<'_, PyExecutionAlgorithm>>()
2823                .unwrap();
2824            let e = instance.call_method1("execute", (py.None(),)).unwrap_err();
2825            assert!(e.is_instance_of::<pyo3::exceptions::PyRuntimeError>(py));
2826            assert_eq!(
2827                e.to_string(),
2828                "RuntimeError: ExecutionAlgorithm.execute is invoked by the v2 runtime endpoint"
2829            );
2830        });
2831    }
2832}