Struct PyStrategyInner 

pub struct PyStrategyInner { /* private fields */ }

Inner state of PyStrategy, shared between Python wrapper and Rust registries.

Methods from Deref<Target = DataActorCore>

pub fn registered_indicators(&self) -> Vec<Rc<dyn ActorIndicator>>

Returns the registered indicators.

pub fn indicators_initialized(&self) -> Result<bool, Error>

Returns whether all registered indicators are initialized.

Errors

Returns an error if a registered indicator cannot report readiness.

pub fn register_indicator_for_quote_ticks( &mut self, instrument_id: InstrumentId, indicator: Rc<dyn ActorIndicator>, )

Registers an indicator to receive quote ticks for an instrument.

pub fn register_indicator_for_trade_ticks( &mut self, instrument_id: InstrumentId, indicator: Rc<dyn ActorIndicator>, )

Registers an indicator to receive trade ticks for an instrument.

pub fn register_indicator_for_bars( &mut self, bar_type: BarType, indicator: Rc<dyn ActorIndicator>, )

Registers an indicator to receive bars for a bar type.

pub fn mem_address(&self) -> String

Returns the memory address of this instance as a hexadecimal string.

pub fn state(&self) -> ComponentState

Returns the actors state.

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

Returns the trader ID this actor is registered to.

pub fn actor_id(&self) -> ActorId

Returns the actors ID.

pub fn timestamp_ns(&self) -> UnixNanos

Returns a UNIX nanoseconds timestamp from the actor’s internal clock.

pub fn register( &mut self, trader_id: TraderId, clock: Rc<RefCell<dyn Clock>>, cache: Rc<RefCell<Cache>>, ) -> Result<(), Error>

Register the data actor with a trader.

Errors

Returns an error if the actor has already been registered with a trader or if the provided dependencies are invalid.

pub fn register_warning_event(&mut self, event_type: &str)

Register an event type for warning log levels.

pub fn deregister_warning_event(&mut self, event_type: &str)

Deregister an event type from warning log levels.

pub fn message_bus(&self) -> Rc<PyMessageBusScope>

Returns this component’s shared Python message-bus state.

pub fn is_registered(&self) -> bool

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

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

Panics

Panics if the actor is not registered or has no trader ID.

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

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

data_type is kept as an explicit parameter (rather than deriving it from data.data_type) to mirror the v1 Python publish_data(data_type, data) API and to allow callers to override the routing topic from the payload’s intrinsic type.

Panics

Panics if the actor is not registered with a trader.

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

Publishes a [Signal] constructed from name and value, wrapped in [CustomData] so it is consumed by signal subscribers and by any CustomData-aware pipeline (for example the feather persistence writer).

The topic mirrors the v1 Python scheme data.Signal<TitleName> so subscribers using either a specific name or the global wildcard are both notified. If ts_event is zero then the current clock timestamp is used.

Panics

Panics if the actor is not registered with a trader.

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

Adds the synthetic instrument to the cache.

Errors

Returns an error if a synthetic with the same ID already exists, or if the backing cache fails to persist it. Panics if the actor is not registered with a trader. // panics-doc-ok

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

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

Errors

Returns an error if no synthetic with the same ID already exists, or if the backing cache fails to persist the replacement. Panics if the actor is not registered with a trader. // panics-doc-ok

pub fn subscribe_data( &mut self, handler: TypedHandler<dyn Any>, data_type: DataType, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to data.

Panics

Panics if the actor is not properly registered.

pub fn subscribe_signal( &mut self, handler: TypedHandler<dyn Any>, name: &str, priority: Option<u32>, )

Subscribes the actor to signal.

An empty name subscribes to every signal via the data.Signal* wildcard pattern.

Panics

Panics if the actor is not registered with a trader.

pub fn subscribe_queue_state( &mut self, handler: TypedHandler<dyn Any>, channel: Option<SystemChannel>, priority: Option<u32>, )

Registers a queue state change subscription from the trait.

Panics

Panics if the actor is not registered with a trader.

pub fn subscribe_socket_state( &mut self, handler: TypedHandler<dyn Any>, client_id: Option<ClientId>, endpoint: Option<&str>, priority: Option<u32>, )

Registers a socket state change subscription from the trait.

Panics

Panics if the actor is not registered with a trader.

pub fn subscribe_quotes( &mut self, topic: MStr<Topic>, handler: TypedHandler<QuoteTick>, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to quotes.

pub fn subscribe_instruments( &mut self, pattern: MStr<Pattern>, handler: TypedHandler<InstrumentAny>, venue: Venue, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to instruments.

pub fn subscribe_instrument( &mut self, topic: MStr<Topic>, handler: TypedHandler<InstrumentAny>, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to instrument.

pub fn subscribe_book_deltas( &mut self, pattern: MStr<Pattern>, handler: TypedHandler<OrderBookDeltas>, instrument_id: InstrumentId, book_type: BookType, depth: Option<NonZero<usize>>, client_id: Option<ClientId>, managed: bool, params: Option<Params>, )

Subscribes the actor to book deltas.

pub fn subscribe_book_depth( &mut self, pattern: MStr<Pattern>, handler: TypedHandler<OrderBookDepth>, instrument_id: InstrumentId, book_type: BookType, depth: Option<NonZero<usize>>, client_id: Option<ClientId>, managed: bool, params: Option<Params>, )

Subscribes the actor to book depth.

pub fn subscribe_book_at_interval( &mut self, topic: MStr<Topic>, handler: TypedHandler<OrderBook>, instrument_id: InstrumentId, book_type: BookType, depth: Option<NonZero<usize>>, interval_ms: NonZero<usize>, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to book snapshots.

pub fn subscribe_trades( &mut self, topic: MStr<Topic>, handler: TypedHandler<TradeTick>, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to trades.

pub fn subscribe_bars( &mut self, topic: MStr<Topic>, handler: TypedHandler<Bar>, bar_type: BarType, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to bars.

pub fn subscribe_mark_prices( &mut self, topic: MStr<Topic>, handler: TypedHandler<MarkPriceUpdate>, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to mark prices.

pub fn subscribe_index_prices( &mut self, topic: MStr<Topic>, handler: TypedHandler<IndexPriceUpdate>, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to index prices.

pub fn subscribe_funding_rates( &mut self, topic: MStr<Topic>, handler: TypedHandler<FundingRateUpdate>, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to funding rates.

pub fn subscribe_option_greeks( &mut self, topic: MStr<Topic>, handler: TypedHandler<OptionGreeks>, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to option greeks.

pub fn subscribe_instrument_status( &mut self, topic: MStr<Topic>, handler: TypedHandler<dyn Any>, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to instrument status.

pub fn subscribe_instrument_close( &mut self, topic: MStr<Topic>, handler: TypedHandler<dyn Any>, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to instrument close.

pub fn subscribe_option_chain( &mut self, topic: MStr<Topic>, handler: TypedHandler<OptionChainSlice>, series_id: OptionSeriesId, strike_range: StrikeRange, snapshot_interval_ms: Option<u64>, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to option chain snapshots.

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

Unsubscribes the actor from data.

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

Unsubscribes the actor from signals.

Panics

Panics if the actor is not registered with a trader.

pub fn unsubscribe_queue_state(&mut self, channel: Option<SystemChannel>)

Unsubscribes from queue state changes.

Panics

Panics if the actor is not registered with a trader.

pub fn unsubscribe_socket_state( &mut self, client_id: Option<ClientId>, endpoint: Option<&str>, )

Unsubscribes from socket state changes.

Panics

Panics if the actor is not registered with a trader.

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

Unsubscribes the actor from instruments.

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

Unsubscribes the actor from instrument.

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

Unsubscribes the actor from book deltas.

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

Unsubscribes the actor from book depth snapshots.

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

Unsubscribes the actor from book snapshots at interval.

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

Unsubscribes the actor from quotes.

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

Unsubscribes the actor from trades.

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

Unsubscribes the actor from bars.

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

Unsubscribes the actor from mark prices.

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

Unsubscribes the actor from index prices.

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

Unsubscribes the actor from funding rates.

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

Unsubscribes the actor from option greeks.

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

Unsubscribes the actor from instrument status.

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

Unsubscribes the actor from instrument close.

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

Unsubscribes the actor from option chain snapshots.

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

Requests data for the actor.

Errors

Returns an error if input parameters are invalid.

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

Requests instrument for the actor.

Errors

Returns an error if input parameters are invalid.

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

Requests instruments for the actor.

Errors

Returns an error if input parameters are invalid.

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

Requests book snapshot for the actor.

Errors

Returns an error if input parameters are invalid.

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

Requests book deltas for the actor.

Errors

Returns an error if input parameters are invalid.

pub fn request_book_depth( &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>, handler: TypedHandler<dyn Any>, ) -> Result<UUID4, Error>

Sends a request for historical book depth.

Errors

Returns an error if input parameters are invalid.

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

Requests quotes for the actor.

Errors

Returns an error if input parameters are invalid.

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

Requests trades for the actor.

Errors

Returns an error if input parameters are invalid.

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

Requests bars for the actor.

Errors

Returns an error if input parameters are invalid.

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

Requests funding rates for the actor.

Errors

Returns an error if input parameters are invalid.

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

Sends a fire-and-observe reconnect command.

Errors

Returns an error if the actor is not registered, the endpoint label is invalid, the live runner is unavailable, or the command channel is closed.

pub fn subscribe_blocks( &mut self, topic: MStr<Topic>, handler: TypedHandler<Block>, chain: Blockchain, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to block.

pub fn subscribe_pool( &mut self, topic: MStr<Topic>, handler: TypedHandler<Pool>, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to pool.

pub fn subscribe_pool_swaps( &mut self, topic: MStr<Topic>, handler: TypedHandler<PoolSwap>, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to pool swap.

pub fn subscribe_pool_liquidity_updates( &mut self, topic: MStr<Topic>, handler: TypedHandler<PoolLiquidityUpdate>, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to pool liquidity update.

pub fn subscribe_pool_fee_collects( &mut self, topic: MStr<Topic>, handler: TypedHandler<PoolFeeCollect>, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to pool fee collect.

pub fn subscribe_pool_flash_events( &mut self, topic: MStr<Topic>, handler: TypedHandler<PoolFlash>, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

Subscribes the actor to pool flash event.

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

Unsubscribes the actor from blocks.

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

Unsubscribes the actor from pool definition updates.

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

Unsubscribes the actor from pool swaps.

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

Unsubscribes the actor from pool liquidity updates.

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

Unsubscribes the actor from pool fee collects.

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

Unsubscribes the actor from pool flash events.

Trait Implementations

impl DataActor for PyStrategyInner

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_save(&self) -> Result<IndexMap<String, Vec<u8>>>

Actions to be performed when the actor state is saved.

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

Actions to be performed when the actor state is loaded.

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

Actions to be performed when receiving a time event.

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

Actions to be performed when receiving custom data.

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 on_instrument(&mut self, instrument: &InstrumentAny) -> Result<()>

Actions to be performed when receiving an instrument.

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

Actions to be performed when receiving a quote.

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

Actions to be performed when receiving a trade.

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

Actions to be performed when receiving a bar.

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

Actions to be performed when receiving order book deltas.

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

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

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

Actions to be performed when receiving an order book.

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

Actions to be performed when receiving a mark price update.

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

Actions to be performed when receiving an index price update.

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

Actions to be performed when receiving a funding rate update.

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

Actions to be performed when receiving an instrument status update.

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

Actions to be performed when receiving an instrument close update.

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

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

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

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

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

Actions to be performed when receiving historical custom data.

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

Actions to be performed when receiving historical book deltas.

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

Actions to be performed when receiving historical book depth.

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

Actions to be performed when receiving historical quotes.

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

Actions to be performed when receiving historical trades.

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

Actions to be performed when receiving historical funding rates.

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

Actions to be performed when receiving historical bars.

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

Actions to be performed when receiving historical mark prices.

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

Actions to be performed when receiving historical index prices.

fn actor_id(&self) -> ActorId

where Self: DataActorBinding,

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_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 clock(&self) -> ClockApi<'_>

where Self: DataActorBinding,

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: &OrderBookDepth)

where Self: Component,

Handles a received order book depth 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, channel: Option<SystemChannel>, priority: Option<u32>, )

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

Subscribes to [QueueStateChanged] events.

fn subscribe_socket_state( &mut self, client_id: Option<ClientId>, endpoint: Option<&str>, 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_depth( &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 [OrderBookDepth] 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, channel: Option<SystemChannel>)

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

Unsubscribes from [QueueStateChanged] events for the same subscription filters.

fn unsubscribe_socket_state( &mut self, client_id: Option<ClientId>, endpoint: Option<&str>, )

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

Unsubscribes from [SocketStateChanged] events for the same subscription filters.

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_depth( &mut self, instrument_id: InstrumentId, client_id: Option<ClientId>, params: Option<Params>, )

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

Unsubscribe from streaming [OrderBookDepth] 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 [OrderBookDepth] 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 PyStrategyInner

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 try_clock_mut( &mut self, ) -> Result<RefMut<'_, dyn Clock + 'static>, ComponentAccessError>

Returns a mutable clock borrow without panicking on an access conflict.

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 try_cache_ref(&self) -> Result<Ref<'_, Cache>, ComponentAccessError>

Returns a cache borrow without panicking on an access conflict.

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

Returns a clone of the reference-counted cache.

impl Debug for PyStrategyInner

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

Formats the value using the given formatter.

impl Deref for PyStrategyInner

type Target = DataActorCore

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for PyStrategyInner

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Strategy for PyStrategyInner

fn external_order_instrument_ids(&self) -> Option<Vec<InstrumentId>>

Returns the instrument IDs this strategy intends to claim for external order routing.

fn on_market_exit(&mut self)

Called when a market exit has been initiated.

fn post_market_exit(&mut self)

Called after a market exit has completed.

fn on_order_initialized(&mut self, event: OrderInitialized)

Called when an order is initialized.

fn on_order_event(&mut self, event: OrderEventAny)

Called when any order event is received after the specific order handler runs.

fn on_order_denied(&mut self, event: OrderDenied)

Called when an order is denied by the system.

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 to the venue.

fn on_order_rejected(&mut self, event: OrderRejected)

Called when an order is rejected by the venue.

fn on_order_accepted(&mut self, event: OrderAccepted)

Called when an order is accepted by the venue.

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_order_canceled(&mut self, event: &OrderCanceled)

Called when an order is canceled.

fn on_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_position_opened(&mut self, event: PositionOpened)

Called when a position is opened.

fn on_position_event(&mut self, event: PositionEvent)

Called after a position opened, changed, or closed handler runs.

fn on_position_changed(&mut self, event: PositionChanged)

Called when a position is changed (quantity or price updated).

fn on_position_closed(&mut self, event: PositionClosed)

Called when a position is closed.

fn set_external_order_instrument_ids( &mut self, instrument_ids: Vec<InstrumentId>, ) -> Result<()>

where Self: StrategyNative,

Replaces this strategy’s active external order claims with instrument_ids.

fn strategy_id(&self) -> Option<StrategyId>

where Self: StrategyNative,

Returns the runtime strategy ID, when configured or registered.

fn order(&self) -> OrderApi<'_>

where Self: StrategyNative,

Returns the user-facing order creation API.

fn portfolio(&self) -> PortfolioApi<'_>

where Self: StrategyNative,

Returns the user-facing portfolio read API.

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

where Self: StrategyBinding,

Submits an order.

fn submit_order_list( &mut self, orders: Vec<OrderAny>, position_id: Option<PositionId>, client_id: Option<ClientId>, params: Option<Params>, ) -> Result<()>

where Self: StrategyNative,

Submits an order list.

fn modify_order( &mut self, client_order_id: ClientOrderId, quantity: Option<Quantity>, price: Option<Price>, trigger_price: Option<Price>, client_id: Option<ClientId>, params: Option<Params>, ) -> Result<()>

where Self: StrategyNative,

Modifies an order.

fn modify_orders( &mut self, updates: Vec<BatchModifyOrder>, client_id: Option<ClientId>, params: Option<Params>, ) -> Result<()>

where Self: StrategyNative,

Batch modifies multiple orders for the same instrument.

fn cancel_order( &mut self, client_order_id: ClientOrderId, client_id: Option<ClientId>, params: Option<Params>, ) -> Result<()>

where Self: StrategyNative,

Cancels an order.

fn cancel_orders( &mut self, client_order_ids: Vec<ClientOrderId>, client_id: Option<ClientId>, params: Option<Params>, ) -> Result<()>

where Self: StrategyNative,

Batch cancels multiple orders for the same instrument.

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

where Self: StrategyNative,

Marks an order as pending update locally before the modify command leaves the strategy.

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

where Self: StrategyNative,

Marks an order as pending cancel locally before the cancel command leaves the strategy.

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

where Self: StrategyNative,

Generates an OrderPendingUpdate event for an order.

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

where Self: StrategyNative,

Generates an OrderPendingCancel event for an order.

fn cancel_all_orders( &mut self, instrument_id: InstrumentId, order_side: Option<OrderSide>, client_id: Option<ClientId>, strategy_only: bool, params: Option<Params>, ) -> Result<()>

where Self: StrategyNative,

Cancels all open orders for the given instrument.

fn close_position( &mut self, position: &Position, client_id: Option<ClientId>, tags: Option<Vec<Ustr>>, time_in_force: Option<TimeInForce>, reduce_only: Option<bool>, quote_quantity: Option<bool>, params: Option<Params>, ) -> Result<()>

where Self: StrategyNative,

Closes a position by submitting a market order for the opposite side.

fn close_all_positions( &mut self, instrument_id: InstrumentId, position_side: Option<PositionSide>, client_id: Option<ClientId>, tags: Option<Vec<Ustr>>, time_in_force: Option<TimeInForce>, reduce_only: Option<bool>, quote_quantity: Option<bool>, params: Option<Params>, ) -> Result<()>

where Self: StrategyNative,

Closes all open positions for the given instrument.

fn query_account( &mut self, account_id: AccountId, client_id: Option<ClientId>, params: Option<Params>, ) -> Result<()>

where Self: StrategyNative,

Queries account state from the execution client.

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

where Self: StrategyNative,

Queries order state from the execution client.

fn handle_order_event(&mut self, event: OrderEventAny)

where Self: StrategyNative,

Handles an order event, dispatching to the appropriate handler.

fn dispatch_manager_actions(&mut self, actions: Vec<OrderManagerAction>)

where Self: StrategyNative,

fn handle_position_event(&mut self, event: PositionEvent)

where Self: StrategyNative,

Handles a position event, dispatching to the appropriate handler.

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

where Self: StrategyNative,

Called when the strategy is started.

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

where Self: StrategyNative + Component,

Routes a time event through the framework-managed strategy handlers when called directly.

fn is_exiting(&self) -> bool

where Self: StrategyNative,

Returns whether the strategy is currently executing a market exit.

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

where Self: StrategyNative,

Initiates an iterative market exit for the strategy.

fn check_market_exit(&mut self, _event: TimeEvent)

where Self: StrategyNative + Component,

Checks if the market exit is complete and finalizes if so.

fn finalize_market_exit(&mut self)

where Self: StrategyNative + Component,

Finalizes the market exit process.

fn cancel_market_exit(&mut self)

where Self: StrategyNative,

Cancels an active market exit without calling hooks.

fn stop(&mut self) -> bool

where Self: StrategyNative,

Stops the strategy with optional managed stop behavior.

fn deny_order(&mut self, order: &OrderAny, reason: Ustr)

where Self: StrategyNative,

Denies an order by generating an OrderDenied event.

fn deny_order_list(&mut self, orders: &[OrderAny], reason: Ustr)

where Self: StrategyNative,

Denies all orders in an order list.

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

where Self: StrategyNative,

Sets a GTD expiry timer for an order.

fn cancel_gtd_expiry(&mut self, client_order_id: &ClientOrderId)

where Self: StrategyNative,

Cancels a GTD expiry timer for an order.

fn has_gtd_expiry_timer(&mut self, client_order_id: &ClientOrderId) -> bool

where Self: StrategyNative,

Checks if a GTD expiry timer exists for an order.

fn expire_gtd_order(&mut self, event: TimeEvent)

where Self: StrategyNative,

Handles GTD order expiry by canceling the order.

fn reactivate_gtd_timers(&mut self)

where Self: StrategyNative,

Reactivates GTD timers for open orders on strategy start.

impl StrategyNative for PyStrategyInner

fn strategy_core(&self) -> &StrategyCore

Returns the strategy core.

fn strategy_core_mut(&mut self) -> &mut StrategyCore

Returns the mutable strategy core.

fn order_factory(&mut self) -> RefMut<'_, OrderFactory>

Returns a mutable borrow of the order factory.

fn order_factory_rc(&self) -> Rc<RefCell<OrderFactory>>

Returns a clone of the reference-counted order factory.

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

Returns a clone of the reference-counted portfolio.