Struct StrategyConfig 

pub struct StrategyConfig {

    pub strategy_id: Option<StrategyId>,
    pub order_id_tag: Option<String>,
    pub use_uuid_client_order_ids: bool,
    pub use_hyphens_in_client_order_ids: bool,
    pub oms_type: Option<OmsType>,
    pub external_order_claims: Option<Vec<InstrumentId>>,
    pub manage_contingent_orders: bool,
    pub manage_gtd_expiry: bool,
    pub manage_stop: bool,
    pub market_exit_interval_ms: u64,
    pub market_exit_max_attempts: u64,
    pub market_exit_time_in_force: TimeInForce,
    pub market_exit_reduce_only: bool,
    pub log_events: bool,
    pub log_commands: bool,
    pub log_rejected_due_post_only_as_warning: bool,
}

The base model for all trading strategy configurations.

Fields

strategy_id: Option<StrategyId>

The unique ID for the strategy. Will become the strategy ID if not None.

order_id_tag: Option<String>

The unique order ID tag for the strategy. Must be unique amongst all running strategies for a particular trader ID.

use_uuid_client_order_ids: bool

If UUID4’s should be used for client order ID values.

use_hyphens_in_client_order_ids: bool

If hyphens should be used in generated client order ID values.

oms_type: Option<OmsType>

The order management system type for the strategy. This will determine how the ExecutionEngine handles position IDs.

external_order_claims: Option<Vec<InstrumentId>>

The external order claim instrument IDs. External orders for matching instrument IDs will be associated with (claimed by) the strategy.

manage_contingent_orders: bool

If OTO, OCO, and OUO open contingent orders should be managed automatically by the strategy. Any emulated orders which are active local will be managed by the OrderEmulator instead.

manage_gtd_expiry: bool

If all order GTD time in force expirations should be managed by the strategy. If True, then will ensure open orders have their GTD timers re-activated on start.

manage_stop: bool

If the strategy should automatically perform a market exit when stopped. If true, calling stop() will first cancel all orders and close all positions before the strategy transitions to the STOPPED state.

market_exit_interval_ms: u64

The interval in milliseconds to check for in-flight orders and open positions during a market exit.

market_exit_max_attempts: u64

The maximum number of attempts to wait for orders and positions to close during a market exit before completing. Defaults to 100 attempts (10 seconds at 100ms intervals).

market_exit_time_in_force: TimeInForce

The time in force for closing market orders during a market exit.

market_exit_reduce_only: bool

If closing market orders during a market exit should be reduce only.

log_events: bool

If events should be logged by the strategy. If False, then only warning events and above are logged.

log_commands: bool

If commands should be logged by the strategy.

log_rejected_due_post_only_as_warning: bool

If order rejected events where due_post_only is True should be logged as warnings.

Trait Implementations

impl Clone for StrategyConfig

fn clone(&self) -> StrategyConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StrategyConfig

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

Formats the value using the given formatter.

impl Default for StrategyConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for StrategyConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'py> IntoPyObject<'py> for StrategyConfig

type Target = StrategyConfig

The Python output type

type Output = Bound<'py, <StrategyConfig 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 StrategyConfig

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for StrategyConfig

const IS_BASETYPE: bool = false

#[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 = /// The base model for all trading strategy configurations.

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 BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<StrategyConfig>

This handles following two situations:

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 = PyClassDummySlot

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 lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClassNewTextSignature for StrategyConfig

const TEXT_SIGNATURE: &'static str = "(strategy_id=None, order_id_tag=None, oms_type=None, external_order_claims=None, manage_contingent_orders=False, manage_gtd_expiry=False, manage_stop=False, market_exit_interval_ms=100, market_exit_max_attempts=100, market_exit_time_in_force=..., market_exit_reduce_only=True, use_uuid_client_order_ids=False, use_hyphens_in_client_order_ids=True, log_events=True, log_commands=True, log_rejected_due_post_only_as_warning=True)"

impl PyMethods<StrategyConfig> for PyClassImplCollector<StrategyConfig>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for StrategyConfig

const NAME: &'static str = "StrategyConfig"

Class name.

const MODULE: Option<&'static str>

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.

impl Serialize for StrategyConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl DerefToPyAny for StrategyConfig

impl ExtractPyClassWithClone for StrategyConfig