Struct Position 

#[repr(C)]
pub struct Position {

    pub events: Vec<OrderFilled>,
    pub trader_id: TraderId,
    pub strategy_id: StrategyId,
    pub instrument_id: InstrumentId,
    pub id: PositionId,
    pub account_id: AccountId,
    pub opening_order_id: ClientOrderId,
    pub closing_order_id: Option<ClientOrderId>,
    pub entry: OrderSide,
    pub side: PositionSide,
    pub signed_qty: f64,
    pub quantity: Quantity,
    pub peak_qty: Quantity,
    pub price_precision: u8,
    pub size_precision: u8,
    pub multiplier: Quantity,
    pub is_inverse: bool,
    pub base_currency: Option<Currency>,
    pub quote_currency: Currency,
    pub settlement_currency: Currency,
    pub ts_init: UnixNanos,
    pub ts_opened: UnixNanos,
    pub ts_last: UnixNanos,
    pub ts_closed: Option<UnixNanos>,
    pub duration_ns: u64,
    pub avg_px_open: f64,
    pub avg_px_close: Option<f64>,
    pub realized_return: f64,
    pub realized_pnl: Option<Money>,
    pub trade_ids: Vec<TradeId>,
    pub buy_qty: Quantity,
    pub sell_qty: Quantity,
    pub commissions: HashMap<Currency, Money>,
}

Represents a position in a market.

The position ID may be assigned at the trading venue, or can be system generated depending on a strategies OMS (Order Management System) settings.

Fields

events: Vec<OrderFilled>

trader_id: TraderId

strategy_id: StrategyId

instrument_id: InstrumentId

id: PositionId

account_id: AccountId

opening_order_id: ClientOrderId

closing_order_id: Option<ClientOrderId>

entry: OrderSide

side: PositionSide

signed_qty: f64

quantity: Quantity

peak_qty: Quantity

price_precision: u8

size_precision: u8

multiplier: Quantity

is_inverse: bool

base_currency: Option<Currency>

quote_currency: Currency

settlement_currency: Currency

ts_init: UnixNanos

ts_opened: UnixNanos

ts_last: UnixNanos

ts_closed: Option<UnixNanos>

duration_ns: u64

avg_px_open: f64

avg_px_close: Option<f64>

realized_return: f64

realized_pnl: Option<Money>

trade_ids: Vec<TradeId>

buy_qty: Quantity

sell_qty: Quantity

commissions: HashMap<Currency, Money>

Implementations

impl Position

pub fn new(instrument: &InstrumentAny, fill: OrderFilled) -> Self

Creates a new Position instance.

Panics

This function panics if:

• The instrument.id() does not match the fill.instrument_id.
• The fill.order_side is NoOrderSide.
• The fill.position_id is None.

pub fn purge_events_for_order(&mut self, client_order_id: ClientOrderId)

Purges all order fill events for the given client order ID and recalculates derived state.

Warning

This operation recalculates the entire position from scratch after removing the specified order’s fills. This is an expensive operation and should be used sparingly.

Panics

Panics if after purging, no fills remain and the position cannot be reconstructed.

pub fn apply(&mut self, fill: &OrderFilled)

Applies an OrderFilled event to this position.

Panics

Panics if the fill.trade_id is already present in the position’s trade_ids.

pub fn calculate_pnl( &self, avg_px_open: f64, avg_px_close: f64, quantity: Quantity, ) -> Money

pub fn total_pnl(&self, last: Price) -> Money

pub fn unrealized_pnl(&self, last: Price) -> Money

pub fn closing_order_side(&self) -> OrderSide

pub fn is_opposite_side(&self, side: OrderSide) -> bool

pub fn symbol(&self) -> Symbol

pub fn venue(&self) -> Venue

pub fn event_count(&self) -> usize

pub fn client_order_ids(&self) -> Vec<ClientOrderId>

pub fn venue_order_ids(&self) -> Vec<VenueOrderId>

pub fn trade_ids(&self) -> Vec<TradeId>

pub fn notional_value(&self, last: Price) -> Money

Calculates the notional value based on the last price.

Panics

Panics if self.base_currency is None.

pub fn last_event(&self) -> Option<OrderFilled>

Returns the last OrderFilled event for the position (if any after purging).

pub fn last_trade_id(&self) -> Option<TradeId>

pub fn is_long(&self) -> bool

pub fn is_short(&self) -> bool

pub fn is_open(&self) -> bool

pub fn is_closed(&self) -> bool

pub fn commissions(&self) -> Vec<Money>

impl Position

pub fn py_from_dict(py: Python<'_>, values: Py<PyDict>) -> PyResult<Self>

Constructs a Position from a Python dict.

Errors

Returns a PyErr if deserialization from the Python dict fails.

Trait Implementations

impl Clone for Position

fn clone(&self) -> Position

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Position

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Position

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Position

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

Formats the value using the given formatter.

impl Hash for Position

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'py> IntoPyObject<'py> for Position

type Target = Position

The Python output type

type Output = Bound<'py, <Position 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 PartialEq for Position

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PyClass for Position

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for Position

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 = /// Represents a position in a market. /// /// The position ID may be assigned at the trading venue, or can be system /// generated depending on a strategies OMS (Order Management System) settings.

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<Position>

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 Position

const TEXT_SIGNATURE: &'static str = "(instrument, fill)"

impl<'a, 'holder, 'py> PyFunctionArgument<'a, 'holder, 'py, false> for &'holder Position

type Holder = Option<PyClassGuard<'a, Position>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'holder mut Self::Holder, ) -> PyResult<Self>

impl<'a, 'holder, 'py> PyFunctionArgument<'a, 'holder, 'py, false> for &'holder mut Position

type Holder = Option<PyClassGuardMut<'a, Position>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'holder mut Self::Holder, ) -> PyResult<Self>

impl PyMethods<Position> for PyClassImplCollector<Position>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for Position

const NAME: &'static str = "Position"

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 Position

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 Position

impl Eq for Position