Struct PyExecutionAlgorithm 

pub struct PyExecutionAlgorithm { /* private fields */ }

Python-facing wrapper for execution algorithms.

Implementations

impl PyExecutionAlgorithm

pub fn new(config: Option<ExecutionAlgorithmConfig>) -> Self

Creates a new PyExecutionAlgorithm instance.

pub fn set_python_instance(&mut self, py_obj: &Bound<'_, PyAny>) -> PyResult<()>

Sets the Python instance reference for method dispatch.

Only a weak reference is stored, so the caller keeps ownership of py_obj. The trader owns registered wrappers; an unregistered execution algorithm stays collectable.

Errors

Returns an error if py_obj cannot be weakly referenced.

pub fn set_config(&mut self, config: Option<Py<PyAny>>)

Stores the original Python config object passed at construction.

pub fn set_exec_algorithm_id(&mut self, exec_algorithm_id: ExecAlgorithmId)

Updates the runtime execution algorithm ID before registration.

pub fn set_log_events(&mut self, log_events: bool)

Updates the runtime log_events setting.

pub fn set_log_commands(&mut self, log_commands: bool)

Updates the runtime log_commands setting.

pub fn exec_algorithm_id(&self) -> ExecAlgorithmId

Returns the execution algorithm ID.

impl PyExecutionAlgorithm

pub fn configure_from_py_config( &mut self, config: &Bound<'_, PyAny>, ) -> Result<bool>

Applies Python configuration overrides.

Returns whether the config supplied an execution algorithm ID.

Errors

Returns an error if an ID has an unsupported type or invalid value.

Trait Implementations

impl Clone for PyExecutionAlgorithm

fn clone(&self) -> PyExecutionAlgorithm

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl DataActor for PyExecutionAlgorithm

fn on_start(&mut self) -> Result<()>

Actions to be performed on start.

fn on_stop(&mut self) -> Result<()>

Actions to be performed on stop.

fn on_resume(&mut self) -> Result<()>

Actions to be performed on resume.

fn on_reset(&mut self) -> Result<()>

Actions to be performed on reset.

fn on_dispose(&mut self) -> Result<()>

Actions to be performed on dispose.

fn on_degrade(&mut self) -> Result<()>

Actions to be performed on degrade.

fn on_fault(&mut self) -> Result<()>

Actions to be performed on fault.

fn on_time_event(&mut self, event: &TimeEvent) -> Result<()>

Actions to be performed when receiving a time event.

fn on_signal(&mut self, signal: &Signal) -> Result<()>

Actions to be performed when receiving a signal.

fn on_queue_state(&mut self, event: &QueueStateChanged) -> Result<()>

Actions to be performed when receiving a queue state change.

fn on_socket_state(&mut self, event: &SocketStateChanged) -> Result<()>

Actions to be performed when receiving a socket state change.

fn actor_id(&self) -> ActorId

where Self: DataActorNative,

Returns the actor ID.

fn trader_id(&self) -> Option<TraderId>

where Self: DataActorNative,

Returns the trader ID this actor is registered to.

fn is_registered(&self) -> bool

where Self: DataActorNative,

Returns whether the actor is registered with a trader.

fn config(&self) -> &DataActorConfig

where Self: DataActorNative,

Returns the actor configuration.

fn on_save(&self) -> Result<IndexMap<String, Vec<u8>>, Error>

Actions to be performed when the actor state is saved.

fn on_load(&mut self, state: IndexMap<String, Vec<u8>>) -> Result<(), Error>

Actions to be performed when the actor state is loaded.

fn on_data(&mut self, data: &CustomData) -> Result<(), Error>

Actions to be performed when receiving custom data.

fn on_instrument(&mut self, instrument: &InstrumentAny) -> Result<(), Error>

Actions to be performed when receiving an instrument.

fn on_book_deltas(&mut self, deltas: &OrderBookDeltas) -> Result<(), Error>

Actions to be performed when receiving order book deltas.

fn on_book_depth(&mut self, depth: &OrderBookDepth10) -> Result<(), Error>

Actions to be performed when receiving an order book depth10 snapshot.

fn on_book(&mut self, order_book: &OrderBook) -> Result<(), Error>

Actions to be performed when receiving an order book.

fn on_quote(&mut self, quote: &QuoteTick) -> Result<(), Error>

Actions to be performed when receiving a quote.

fn on_trade(&mut self, tick: &TradeTick) -> Result<(), Error>

Actions to be performed when receiving a trade.

fn on_bar(&mut self, bar: &Bar) -> Result<(), Error>

Actions to be performed when receiving a bar.

fn on_mark_price(&mut self, mark_price: &MarkPriceUpdate) -> Result<(), Error>

Actions to be performed when receiving a mark price update.

fn on_index_price( &mut self, index_price: &IndexPriceUpdate, ) -> Result<(), Error>

Actions to be performed when receiving an index price update.

fn on_funding_rate( &mut self, funding_rate: &FundingRateUpdate, ) -> Result<(), Error>

Actions to be performed when receiving a funding rate update.

fn on_option_greeks(&mut self, greeks: &OptionGreeks) -> Result<(), Error>

Actions to be performed when receiving exchange-provided option greeks.

fn on_option_chain(&mut self, slice: &OptionChainSlice) -> Result<(), Error>

Actions to be performed when receiving an option chain slice snapshot.

fn on_instrument_status(&mut self, data: &InstrumentStatus) -> Result<(), Error>

Actions to be performed when receiving an instrument status update.

fn on_instrument_close(&mut self, update: &InstrumentClose) -> Result<(), Error>

Actions to be performed when receiving an instrument close update.

fn on_block(&mut self, block: &Block) -> Result<(), Error>

Actions to be performed when receiving a block.

fn on_pool(&mut self, pool: &Pool) -> Result<(), Error>

Actions to be performed when receiving a pool.

fn on_pool_swap(&mut self, swap: &PoolSwap) -> Result<(), Error>

Actions to be performed when receiving a pool swap.

fn on_pool_liquidity_update( &mut self, update: &PoolLiquidityUpdate, ) -> Result<(), Error>

Actions to be performed when receiving a pool liquidity update.

fn on_pool_fee_collect(&mut self, collect: &PoolFeeCollect) -> Result<(), Error>

Actions to be performed when receiving a pool fee collect event.

fn on_pool_flash(&mut self, flash: &PoolFlash) -> Result<(), Error>

Actions to be performed when receiving a pool flash event.

fn on_historical_data( &mut self, data: &(dyn Any + 'static), ) -> Result<(), Error>

Actions to be performed when receiving historical custom data.

fn on_historical_book_deltas( &mut self, deltas: &[OrderBookDelta], ) -> Result<(), Error>

Actions to be performed when receiving historical book deltas.

fn on_historical_book_depth( &mut self, depths: &[OrderBookDepth10], ) -> Result<(), Error>

Actions to be performed when receiving historical book depth.

fn on_historical_quotes(&mut self, quotes: &[QuoteTick]) -> Result<(), Error>

Actions to be performed when receiving historical quotes.

fn on_historical_trades(&mut self, trades: &[TradeTick]) -> Result<(), Error>

Actions to be performed when receiving historical trades.

fn on_historical_bars(&mut self, bars: &[Bar]) -> Result<(), Error>

Actions to be performed when receiving historical bars.

fn on_historical_mark_prices( &mut self, mark_prices: &[MarkPriceUpdate], ) -> Result<(), Error>

Actions to be performed when receiving historical mark prices.

fn on_historical_index_prices( &mut self, index_prices: &[IndexPriceUpdate], ) -> Result<(), Error>

Actions to be performed when receiving historical index prices.

fn on_historical_funding_rates( &mut self, funding_rates: &[FundingRateUpdate], ) -> Result<(), Error>

Actions to be performed when receiving historical funding rates.

fn clock(&self) -> ClockApi<'_>

where Self: DataActorNative,

Returns the user-facing clock API.

fn cache(&self) -> CacheApi<'_>

where Self: DataActorNative,

Returns the user-facing cache API.

fn shutdown_system(&self, reason: Option<String>)

where Self: DataActorNative,

Sends a shutdown command to the system with an optional reason.

fn publish_data(&self, data_type: &DataType, data: &CustomData)

where Self: DataActorNative,

Publishes data on the message bus under the topic derived from data_type.

fn publish_signal(&self, name: &str, value: String, ts_event: UnixNanos)

where Self: DataActorNative,

Publishes a [Signal] constructed from name and value.

fn add_synthetic(&self, synthetic: SyntheticInstrument) -> Result<(), Error>

where Self: DataActorNative,

Adds the synthetic instrument to the cache.

fn update_synthetic(&self, synthetic: SyntheticInstrument) -> Result<(), Error>

where Self: DataActorNative,

Updates the synthetic instrument in the cache, replacing the existing entry.

fn handle_time_event(&mut self, event: &TimeEvent)

where Self: Component,

Handles a received time event.

fn handle_data(&mut self, data: &CustomData)

where Self: Component,

Handles a received custom data point.

fn handle_signal(&mut self, signal: &Signal)

where Self: Component,

Handles a received signal.

fn handle_queue_state(&mut self, event: &QueueStateChanged)

where Self: Component,

Handles a received queue state change.

fn handle_socket_state(&mut self, event: &SocketStateChanged)

where Self: Component,

Handles a received socket state change.

fn handle_instrument(&mut self, instrument: &InstrumentAny)

where Self: Component,

Handles a received instrument.

fn handle_book_deltas(&mut self, deltas: &OrderBookDeltas)

where Self: Component,

Handles received order book deltas.

fn handle_book_depth(&mut self, depth: &OrderBookDepth10)

where Self: Component,

Handles a received order book depth10 snapshot.

fn handle_book(&mut self, book: &OrderBook)

where Self: Component,

Handles a received order book reference.

fn handle_quote(&mut self, quote: &QuoteTick)

where Self: DataActorNative + Component,

Handles a received quote.

fn handle_trade(&mut self, trade: &TradeTick)

where Self: DataActorNative + Component,

Handles a received trade.

fn handle_bar(&mut self, bar: &Bar)

where Self: DataActorNative + Component,

Handles a receiving bar.

fn handle_mark_price(&mut self, mark_price: &MarkPriceUpdate)

where Self: Component,

Handles a received mark price update.

fn handle_index_price(&mut self, index_price: &IndexPriceUpdate)

where Self: Component,

Handles a received index price update.

fn handle_funding_rate(&mut self, funding_rate: &FundingRateUpdate)

where Self: Component,

Handles a received funding rate update.

fn handle_option_greeks(&mut self, greeks: &OptionGreeks)

where Self: Component,

Handles a received option greeks update.

fn handle_option_chain(&mut self, slice: &OptionChainSlice)

where Self: Component,

Handles a received option chain slice snapshot.

fn handle_instrument_status(&mut self, status: &InstrumentStatus)

where Self: Component,

Handles a received instrument status.

fn handle_instrument_close(&mut self, close: &InstrumentClose)

where Self: Component,

Handles a received instrument close.

fn handle_block(&mut self, block: &Block)

where Self: Component,

Handles a received block.

fn handle_pool(&mut self, pool: &Pool)

where Self: Component,

Handles a received pool definition update.

fn handle_pool_swap(&mut self, swap: &PoolSwap)

where Self: Component,

Handles a received pool swap.

fn handle_pool_liquidity_update(&mut self, update: &PoolLiquidityUpdate)

where Self: Component,

Handles a received pool liquidity update.

fn handle_pool_fee_collect(&mut self, collect: &PoolFeeCollect)

where Self: Component,

Handles a received pool fee collect.

fn handle_pool_flash(&mut self, flash: &PoolFlash)

where Self: Component,

Handles a received pool flash event.

fn handle_historical_data(&mut self, data: &(dyn Any + 'static))

Handles received historical data.

fn handle_data_response(&mut self, resp: &CustomDataResponse)

Handles a data response.

fn handle_instrument_response(&mut self, resp: &InstrumentResponse)

Handles an instrument response.

fn handle_instruments_response(&mut self, resp: &InstrumentsResponse)

Handles an instruments response.

fn handle_book_response(&mut self, resp: &BookResponse)

Handles a book response.

fn handle_book_deltas_response(&mut self, resp: &BookDeltasResponse)

Handles a book deltas response.

fn handle_book_depth_response(&mut self, resp: &BookDepthResponse)

Handles a book depth response.

fn handle_quotes_response(&mut self, resp: &QuotesResponse)

where Self: DataActorNative,

Handles a quotes response.

fn handle_trades_response(&mut self, resp: &TradesResponse)

where Self: DataActorNative,

Handles a trades response.

fn handle_bars_response(&mut self, resp: &BarsResponse)

where Self: DataActorNative,

Handles a bars response.

fn handle_funding_rates_response(&mut self, resp: &FundingRatesResponse)

Handles a funding rates response.

fn subscribe_data( &mut self, data_type: DataType, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming data_type data.

fn subscribe_signal(&mut self, name: &str, priority: Option<u32>)

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to [Signal] data by name.

fn subscribe_queue_state(&mut self, priority: Option<u32>)

where Self: DataActorNative + Sized + 'static + Debug,

Subscribes to [QueueStateChanged] events.

fn subscribe_socket_state(&mut self, priority: Option<u32>)

where Self: DataActorNative + Sized + 'static + Debug,

Subscribes to [SocketStateChanged] events.

fn subscribe_quotes( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [QuoteTick] data for the instrument_id.

fn subscribe_instruments( &mut self, venue: Venue, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [InstrumentAny] data for the venue.

fn subscribe_instrument( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [InstrumentAny] data for the instrument_id.

fn subscribe_book_deltas( &mut self, instrument_id: InstrumentId, book_type: BookType, depth: Option<NonZero<usize>>, client_id: Option<ClientId>, managed: bool, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [OrderBookDeltas] data for the instrument_id.

fn subscribe_book_depth10( &mut self, instrument_id: InstrumentId, book_type: BookType, client_id: Option<ClientId>, managed: bool, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [OrderBookDepth10] data for the instrument_id.

fn subscribe_book_at_interval( &mut self, instrument_id: InstrumentId, book_type: BookType, depth: Option<NonZero<usize>>, interval_ms: NonZero<usize>, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to [OrderBook] snapshots at a specified interval for the instrument_id.

fn subscribe_trades( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [TradeTick] data for the instrument_id.

fn subscribe_bars( &mut self, bar_type: BarType, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [Bar] data for the bar_type.

fn subscribe_mark_prices( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [MarkPriceUpdate] data for the instrument_id.

fn subscribe_index_prices( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [IndexPriceUpdate] data for the instrument_id.

fn subscribe_funding_rates( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [FundingRateUpdate] data for the instrument_id.

fn subscribe_option_greeks( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [OptionGreeks] data for the instrument_id.

fn subscribe_instrument_status( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [InstrumentStatus] data for the instrument_id.

fn subscribe_instrument_close( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [InstrumentClose] data for the instrument_id.

fn subscribe_option_chain( &mut self, series_id: OptionSeriesId, strike_range: StrikeRange, snapshot_interval_ms: Option<u64>, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [OptionChainSlice] snapshots for the option series_id.

fn subscribe_blocks( &mut self, chain: Blockchain, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [Block] data for the chain.

fn subscribe_pool( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [Pool] definition updates for the AMM pool at the instrument_id.

fn subscribe_pool_swaps( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [PoolSwap] data for the instrument_id.

fn subscribe_pool_liquidity_updates( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [PoolLiquidityUpdate] data for the instrument_id.

fn subscribe_pool_fee_collects( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [PoolFeeCollect] data for the instrument_id.

fn subscribe_pool_flash_events( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Subscribe to streaming [PoolFlash] events for the given instrument_id.

fn unsubscribe_data( &mut self, data_type: DataType, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming data_type data.

fn unsubscribe_signal(&mut self, name: &str)

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from [Signal] data by name.

fn unsubscribe_queue_state(&mut self)

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribes from [QueueStateChanged] events.

fn unsubscribe_socket_state(&mut self)

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribes from [SocketStateChanged] events.

fn unsubscribe_instruments( &mut self, venue: Venue, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [InstrumentAny] data for the venue.

fn unsubscribe_instrument( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [InstrumentAny] data for the instrument_id.

fn unsubscribe_book_deltas( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [OrderBookDeltas] data for the instrument_id.

fn unsubscribe_book_depth10( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [OrderBookDepth10] data for the instrument_id.

fn unsubscribe_book_at_interval( &mut self, instrument_id: InstrumentId, interval_ms: NonZero<usize>, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from [OrderBook] snapshots at a specified interval for the instrument_id.

fn unsubscribe_quotes( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [QuoteTick] data for the instrument_id.

fn unsubscribe_trades( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [TradeTick] data for the instrument_id.

fn unsubscribe_bars( &mut self, bar_type: BarType, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [Bar] data for the bar_type.

fn unsubscribe_mark_prices( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [MarkPriceUpdate] data for the instrument_id.

fn unsubscribe_index_prices( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [IndexPriceUpdate] data for the instrument_id.

fn unsubscribe_funding_rates( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [FundingRateUpdate] data for the instrument_id.

fn unsubscribe_option_greeks( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [OptionGreeks] data for the instrument_id.

fn unsubscribe_instrument_status( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [InstrumentStatus] data for the instrument_id.

fn unsubscribe_instrument_close( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [InstrumentClose] data for the instrument_id.

fn unsubscribe_option_chain( &mut self, series_id: OptionSeriesId, client_id: Option<ClientId>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [OptionChainSlice] snapshots for the option series_id.

fn unsubscribe_blocks( &mut self, chain: Blockchain, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [Block] data for the chain.

fn unsubscribe_pool( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [Pool] definition updates for the AMM pool at the instrument_id.

fn unsubscribe_pool_swaps( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [PoolSwap] data for the instrument_id.

fn unsubscribe_pool_liquidity_updates( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [PoolLiquidityUpdate] data for the instrument_id.

fn unsubscribe_pool_fee_collects( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [PoolFeeCollect] data for the instrument_id.

fn unsubscribe_pool_flash_events( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

where Self: DataActorNative + Sized + 'static + Debug,

Unsubscribe from streaming [PoolFlash] events for the given instrument_id.

fn request_data( &mut self, data_type: DataType, client_id: ClientId, start: Option<Timestamp>, end: Option<Timestamp>, limit: Option<NonZero<usize>>, params: Option<Params>, ) -> Result<UUID4, Error>

where Self: DataActorNative + Sized + 'static + Debug,

Request historical custom data of the given data_type.

fn request_instrument( &mut self, instrument_id: InstrumentId, start: Option<Timestamp>, end: Option<Timestamp>, client_id: Option<ClientId>, params: Option<Params>, ) -> Result<UUID4, Error>

where Self: DataActorNative + Sized + 'static + Debug,

Request historical [InstrumentResponse] data for the given instrument_id.

fn request_instruments( &mut self, venue: Option<Venue>, start: Option<Timestamp>, end: Option<Timestamp>, client_id: Option<ClientId>, params: Option<Params>, ) -> Result<UUID4, Error>

where Self: DataActorNative + Sized + 'static + Debug,

Request historical [InstrumentsResponse] definitions for the optional venue.

fn request_book_snapshot( &mut self, instrument_id: InstrumentId, depth: Option<NonZero<usize>>, client_id: Option<ClientId>, params: Option<Params>, ) -> Result<UUID4, Error>

where Self: DataActorNative + Sized + 'static + Debug,

Request an [OrderBook] snapshot for the given instrument_id.

fn request_book_deltas( &mut self, instrument_id: InstrumentId, start: Option<Timestamp>, end: Option<Timestamp>, limit: Option<NonZero<usize>>, client_id: Option<ClientId>, params: Option<Params>, ) -> Result<UUID4, Error>

where Self: DataActorNative + Sized + 'static + Debug,

Request historical [OrderBookDelta] data for the given instrument_id.

fn request_book_depth( &mut self, instrument_id: InstrumentId, start: Option<Timestamp>, end: Option<Timestamp>, limit: Option<NonZero<usize>>, depth: Option<NonZero<usize>>, client_id: Option<ClientId>, params: Option<Params>, ) -> Result<UUID4, Error>

where Self: DataActorNative + Sized + 'static + Debug,

Request historical [OrderBookDepth10] data for the given instrument_id.

fn request_quotes( &mut self, instrument_id: InstrumentId, start: Option<Timestamp>, end: Option<Timestamp>, limit: Option<NonZero<usize>>, client_id: Option<ClientId>, params: Option<Params>, ) -> Result<UUID4, Error>

where Self: DataActorNative + Sized + 'static + Debug,

Request historical [QuoteTick] data for the given instrument_id.

fn request_trades( &mut self, instrument_id: InstrumentId, start: Option<Timestamp>, end: Option<Timestamp>, limit: Option<NonZero<usize>>, client_id: Option<ClientId>, params: Option<Params>, ) -> Result<UUID4, Error>

where Self: DataActorNative + Sized + 'static + Debug,

Request historical [TradeTick] data for the given instrument_id.

fn request_bars( &mut self, bar_type: BarType, start: Option<Timestamp>, end: Option<Timestamp>, limit: Option<NonZero<usize>>, client_id: Option<ClientId>, params: Option<Params>, ) -> Result<UUID4, Error>

where Self: DataActorNative + Sized + 'static + Debug,

Request historical [Bar] data for the given bar_type.

fn request_funding_rates( &mut self, instrument_id: InstrumentId, start: Option<Timestamp>, end: Option<Timestamp>, limit: Option<NonZero<usize>>, client_id: Option<ClientId>, params: Option<Params>, ) -> Result<UUID4, Error>

where Self: DataActorNative + Sized + 'static + Debug,

Request historical [FundingRateUpdate] data for the given instrument_id.

fn reconnect_socket( &self, client_id: ClientId, endpoint: &str, ) -> Result<(), Error>

where Self: DataActorNative,

Requests reconnect of one socket endpoint owned by client_id.

impl DataActorNative for PyExecutionAlgorithm

fn core(&self) -> &DataActorCore

Returns the actor core.

fn core_mut(&mut self) -> &mut DataActorCore

Returns the mutable actor core.

fn clock_mut(&mut self) -> RefMut<'_, dyn Clock + 'static>

Returns the mutable clock borrow for the actor.

fn clock_rc(&self) -> Rc<RefCell<dyn Clock>>

Returns a clone of the reference-counted clock.

fn cache_ref(&self) -> Ref<'_, Cache>

Returns a read-only cache borrow.

fn cache_rc(&self) -> Rc<RefCell<Cache>>

Returns a clone of the reference-counted cache.

impl Debug for PyExecutionAlgorithm

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl DerefToPyAny for PyExecutionAlgorithm

impl ExecutionAlgorithm for PyExecutionAlgorithm

fn on_order(&mut self, order: OrderAny) -> Result<()>

Called when a primary order is received for execution.

fn on_order_list( &mut self, order_list: OrderList, orders: Vec<OrderAny>, ) -> Result<()>

Called when an order list is received for execution.

fn on_start(&mut self) -> Result<()>

Called when the algorithm is started.

fn on_stop(&mut self) -> Result<()>

Called when the algorithm is stopped.

fn on_reset(&mut self) -> Result<()>

Called when the algorithm is reset.

fn on_time_event(&mut self, _event: &TimeEvent) -> Result<()>

Called when a time event is received.

fn on_order_initialized(&mut self, event: OrderInitialized)

Called when an order is initialized.

fn on_order_denied(&mut self, event: OrderDenied)

Called when an order is denied.

fn on_order_emulated(&mut self, event: OrderEmulated)

Called when an order is emulated.

fn on_order_released(&mut self, event: OrderReleased)

Called when an order is released from emulation.

fn on_order_submitted(&mut self, event: OrderSubmitted)

Called when an order is submitted.

fn on_order_rejected(&mut self, event: OrderRejected)

Called when an order is rejected.

fn on_order_accepted(&mut self, event: OrderAccepted)

Called when an order is accepted.

fn on_algo_order_canceled(&mut self, event: OrderCanceled)

Called when an order is canceled.

fn on_order_expired(&mut self, event: OrderExpired)

Called when an order expires.

fn on_order_triggered(&mut self, event: OrderTriggered)

Called when an order is triggered.

fn on_order_pending_update(&mut self, event: OrderPendingUpdate)

Called when an order modification is pending.

fn on_order_pending_cancel(&mut self, event: OrderPendingCancel)

Called when an order cancellation is pending.

fn on_order_modify_rejected(&mut self, event: OrderModifyRejected)

Called when an order modification is rejected.

fn on_order_cancel_rejected(&mut self, event: OrderCancelRejected)

Called when an order cancellation is rejected.

fn on_order_updated(&mut self, event: OrderUpdated)

Called when an order is updated.

fn on_algo_order_filled(&mut self, event: OrderFilled)

Called when an order is filled.

fn on_order_fill_voided(&mut self, event: &OrderFillVoided)

Called when an applied order fill is partly or fully voided.

fn on_order_event(&mut self, event: OrderEventAny)

Called for any order event (after specific handler).

fn on_position_opened(&mut self, event: PositionOpened)

Called when a position is opened.

fn on_position_changed(&mut self, event: PositionChanged)

Called when a position is changed.

fn on_position_closed(&mut self, event: PositionClosed)

Called when a position is closed.

fn on_position_event(&mut self, event: PositionEvent)

Called for any position event (after specific handler).

fn id(&self) -> ExecAlgorithmId

where Self: ExecutionAlgorithmNative,

Returns the execution algorithm ID.

fn execute(&mut self, command: TradingCommand) -> Result<()>

where Self: ExecutionAlgorithmNative + 'static + Debug + Sized,

Executes a trading command.

fn deny_order(&mut self, order: &OrderAny, reason: Ustr) -> Result<()>

where Self: ExecutionAlgorithmNative,

Denies an order by applying and publishing an OrderDenied event.

fn handle_cancel_order(&mut self, command: CancelOrder) -> Result<()>

where Self: ExecutionAlgorithmNative,

Handles a cancel order command for algorithm-managed orders.

fn handle_modify_order(&mut self, command: ModifyOrder) -> Result<()>

where Self: ExecutionAlgorithmNative,

Handles a modify order command for algorithm-managed orders.

fn generate_order_canceled(&mut self, order: &OrderAny) -> OrderCanceled

where Self: ExecutionAlgorithmNative,

Generates an OrderCanceled event for an order.

fn generate_order_pending_update( &mut self, order: &OrderAny, ) -> OrderPendingUpdate

where Self: ExecutionAlgorithmNative,

Generates an OrderPendingUpdate event for an order.

fn generate_order_pending_cancel( &mut self, order: &OrderAny, ) -> OrderPendingCancel

where Self: ExecutionAlgorithmNative,

Generates an OrderPendingCancel event for an order.

fn spawn_market( &mut self, primary: &mut OrderAny, quantity: Quantity, time_in_force: TimeInForce, reduce_only: bool, tags: Option<Vec<Ustr>>, reduce_primary: bool, ) -> MarketOrder

where Self: ExecutionAlgorithmNative,

Spawns a market order from a primary order.

fn spawn_limit( &mut self, primary: &mut OrderAny, quantity: Quantity, price: Price, time_in_force: TimeInForce, expire_time: Option<UnixNanos>, post_only: bool, reduce_only: bool, display_qty: Option<Quantity>, emulation_trigger: Option<TriggerType>, tags: Option<Vec<Ustr>>, reduce_primary: bool, ) -> LimitOrder

where Self: ExecutionAlgorithmNative,

Spawns a limit order from a primary order.

fn spawn_market_to_limit( &mut self, primary: &mut OrderAny, quantity: Quantity, time_in_force: TimeInForce, expire_time: Option<UnixNanos>, reduce_only: bool, display_qty: Option<Quantity>, _emulation_trigger: Option<TriggerType>, tags: Option<Vec<Ustr>>, reduce_primary: bool, ) -> MarketToLimitOrder

where Self: ExecutionAlgorithmNative,

Spawns a market-to-limit order from a primary order.

fn reduce_primary_order(&mut self, primary: &mut OrderAny, spawn_qty: Quantity)

where Self: ExecutionAlgorithmNative,

Reduces the primary order’s quantity by the spawn quantity.

fn restore_primary_order_quantity( &mut self, order: &OrderAny, refused_before_submission: bool, )

where Self: ExecutionAlgorithmNative,

Restores the cached primary order quantity after a spawned order fails before acceptance.

fn submit_order( &mut self, order: OrderAny, position_id: Option<PositionId>, client_id: Option<ClientId>, ) -> Result<()>

where Self: ExecutionAlgorithmNative,

Submits an order to the execution engine via the risk engine.

fn modify_order( &mut self, order: &mut OrderAny, quantity: Option<Quantity>, price: Option<Price>, trigger_price: Option<Price>, client_id: Option<ClientId>, ) -> Result<()>

where Self: ExecutionAlgorithmNative,

Modifies an order.

fn modify_order_in_place( &mut self, order: &mut OrderAny, quantity: Option<Quantity>, price: Option<Price>, trigger_price: Option<Price>, ) -> Result<()>

where Self: ExecutionAlgorithmNative,

Modifies an INITIALIZED or RELEASED order in place without sending a command.

fn cancel_order( &mut self, order: &mut OrderAny, client_id: Option<ClientId>, ) -> Result<()>

where Self: ExecutionAlgorithmNative,

Cancels an order.

fn subscribe_to_strategy_events(&mut self, strategy_id: StrategyId)

where Self: ExecutionAlgorithmNative + 'static + Debug + Sized,

Subscribes to events from a strategy.

fn unsubscribe_all_strategy_events(&mut self)

where Self: ExecutionAlgorithmNative,

Unsubscribes from all strategy event handlers.

fn handle_order_event(&mut self, event: OrderEventAny)

where Self: ExecutionAlgorithmNative,

Handles an order event, filtering for algorithm-owned orders.

fn handle_position_event(&mut self, event: PositionEvent)

where Self: ExecutionAlgorithmNative,

Handles a position event.

fn on_resume(&mut self) -> Result<()>

Called when the algorithm is resumed.

impl ExecutionAlgorithmNative for PyExecutionAlgorithm

fn exec_algorithm_core(&self) -> &ExecutionAlgorithmCore

Returns the execution algorithm core.

fn exec_algorithm_core_mut(&mut self) -> &mut ExecutionAlgorithmCore

Returns the mutable execution algorithm core.

fn portfolio_rc(&self) -> Rc<RefCell<Portfolio>>

Returns a clone of the reference-counted portfolio.

impl<'py> IntoPyObject<'py> for PyExecutionAlgorithm

type Target = PyExecutionAlgorithm

The Python output type

type Output = Bound<'py, <PyExecutionAlgorithm as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PyClass for PyExecutionAlgorithm

const NAME: &str = "ExecutionAlgorithm"

Name of the class.

type Frozen = False

Whether the pyclass is frozen.

impl PyClassBaseType for PyExecutionAlgorithm

type LayoutAsBase = <PyExecutionAlgorithm as PyClassImpl>::Layout

type BaseNativeType = <PyExecutionAlgorithm as PyClassImpl>::BaseNativeType

type Initializer = PyClassInitializer<PyExecutionAlgorithm>

type PyClassMutability = <PyExecutionAlgorithm as PyClassImpl>::PyClassMutability

type Layout<T: PyClassImpl> = <<PyExecutionAlgorithm as PyClassBaseType>::BaseNativeType as PyClassBaseType>::Layout<T>

The type of object layout to use for ancestors or descendants of this type.

impl PyClassImpl for PyExecutionAlgorithm

const MODULE: Option<&str>

Module which the class will be associated with.

const IS_BASETYPE: bool = true

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = /// Python-facing wrapper for execution algorithms.

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type Layout = <<PyExecutionAlgorithm as PyClassImpl>::BaseNativeType as PyClassBaseType>::Layout<PyExecutionAlgorithm>

Description of how this class is laid out in memory

type BaseType = PyAny

Base class

type ThreadChecker = ThreadCheckerImpl

This handles following two situations:

type Inventory = Pyo3MethodsInventoryForPyExecutionAlgorithm

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassWeakRefSlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn weaklist_offset() -> Option<PyObjectOffset>

Used to provide the weaklistoffset slot (equivalent to tp_weaklistoffset

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<PyObjectOffset>

Used to provide the dictoffset slot (equivalent to tp_dictoffset)

impl PyClassNewTextSignature for PyExecutionAlgorithm

const TEXT_SIGNATURE: &'static str = "(config=None)"

impl PyStubType for PyExecutionAlgorithm

fn type_output() -> TypeInfo

The type to be used in the output signature, i.e. return type of the Python function or methods.

fn type_input() -> TypeInfo

The type to be used in the input signature, i.e. the arguments of the Python function or methods.

impl PyTypeInfo for PyExecutionAlgorithm

const NAME: &str = <Self as ::pyo3::PyClass>::NAME

👎Deprecated since 0.28.0:

prefer using ::type_object(py).name() to get the correct runtime value

Class name.

const MODULE: Option<&str> = <Self as ::pyo3::impl_::pyclass::PyClassImpl>::MODULE

👎Deprecated since 0.28.0:

prefer using ::type_object(py).module() to get the correct runtime value

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.