1use 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
68pub struct PyExecutionAlgorithmInner {
70 core: ExecutionAlgorithmCore,
71 py_self: Option<Py<PyWeakrefReference>>,
72 config: Option<Py<PyAny>>,
73 logger: PyLogger,
74}
75
76impl PyExecutionAlgorithmInner {
77 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#[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 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 unsafe { &mut *self.inner.get() }
136 }
137}
138
139impl PyExecutionAlgorithm {
140 #[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 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 pub fn set_config(&mut self, config: Option<Py<PyAny>>) {
178 self.inner_mut().config = config;
179 }
180
181 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 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 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 #[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 #[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 #[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 #[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 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 #[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 #[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 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}