Struct PyStrategy 

pub struct PyStrategy { /* private fields */ }

Python-facing wrapper for Strategy.

Implementations

impl PyStrategy

pub fn new_checked(config: Option<StrategyConfig>) -> CorrectnessResult<Self>

Creates a new PyStrategy instance with correctness checking.

Errors

Returns an error if the configured order ID tag contains the ‘-’ strategy ID separator, or if composing it into the strategy ID does not produce a valid StrategyId.

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

Creates a new PyStrategy instance.

Panics

Panics if the configured order ID tag contains the ‘-’ strategy ID separator, or if composing it into the strategy ID does not produce a valid StrategyId.

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 strategy 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.

Retained so the constructed instance exposes .config and instance-based registration can source strategy ID, order ID tag, and logging flags from the same single config object.

pub fn set_external_order_claims( &mut self, external_order_claims: Option<Vec<InstrumentId>>, )

Updates configured external order claim instrument IDs before registration.

pub fn external_order_claims(&self) -> Option<Vec<InstrumentId>>

Returns the configured external order claim instrument IDs.

pub fn set_actor_id(&mut self, actor_id: ActorId)

Updates the runtime component identity used until a strategy ID is assigned.

Must only be called before registration. See PyDataActor::set_actor_id.

pub fn set_strategy_id(&mut self, strategy_id: StrategyId) -> Result<()>

Updates the runtime strategy ID.

Must only be called before registration. See PyDataActor::set_actor_id.

Errors

Returns an error if composing the current order ID tag into strategy_id does not produce a valid StrategyId.

pub fn set_order_id_tag(&mut self, order_id_tag: &str) -> Result<()>

Updates the runtime order ID tag.

Errors

Returns an error if order_id_tag contains the ‘-’ strategy ID separator, or if composing it into the current strategy ID does not produce a valid StrategyId.

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 strategy_id(&self) -> StrategyId

Returns the strategy ID.

Until registration assigns an order ID tag, an unconfigured strategy reports the class-derived ID with the unassigned tag, such as MyStrategy-None.

pub fn configured_strategy_id(&self) -> Option<StrategyId>

Returns the strategy ID once configured or assigned, otherwise None.

pub fn order_id_tag(&self) -> Option<String>

Returns the runtime order ID tag.

pub fn is_registered(&self) -> bool

Returns a value indicating whether the strategy has been registered with a trader.

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

Register the strategy with a trader.

Errors

Returns an error if registration fails.

pub fn register_in_global_registries(&self) -> PyResult<()>

Registers this strategy in the global component, actor, and wrapper registries.

The Python wrapper is retained as part of the same act, so a registered strategy always has an owner for the wrapper its inner only weakly references.

Errors

Returns an error if no Python wrapper is attached, or if the attached wrapper has already been collected. Nothing is registered in that case.

Trait Implementations

impl Debug for PyStrategy

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

Formats the value using the given formatter.

impl DerefToPyAny for PyStrategy

impl ExtractPyClassWithClone for PyStrategy

impl<'py> IntoPyObject<'py> for PyStrategy

type Target = PyStrategy

The Python output type

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

const NAME: &str = "Strategy"

Name of the class.

type Frozen = False

Whether the pyclass is frozen.

impl PyClassBaseType for PyStrategy

type LayoutAsBase = <PyStrategy as PyClassImpl>::Layout

type BaseNativeType = <PyStrategy as PyClassImpl>::BaseNativeType

type Initializer = PyClassInitializer<PyStrategy>

type PyClassMutability = <PyStrategy as PyClassImpl>::PyClassMutability

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

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

impl PyClassImpl for PyStrategy

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 Strategy.

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 = <<PyStrategy as PyClassImpl>::BaseNativeType as PyClassBaseType>::Layout<PyStrategy>

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

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 PyStrategy

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

impl PyStubType for PyStrategy

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 PyStrategy

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.