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.

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

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

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

pub fn calculate_avg_px( &self, qty: f64, avg_pg: f64, last_px: f64, last_qty: f64, ) -> f64

pub fn calculate_avg_px_open_px(&self, last_px: f64, last_qty: f64) -> f64

pub fn calculate_avg_px_close_px(&self, last_px: f64, last_qty: f64) -> f64

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

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

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

pub fn calculate_return(&self, avg_px_open: f64, avg_px_close: f64) -> f64

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

pub fn last_event(&self) -> OrderFilled

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>

Trait Implementations

impl Clone for Position

fn clone(&self) -> Position

Returns a copy 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 IntoPy<Py<PyAny>> for Position

fn into_py(self, py: Python<'_>) -> PyObject

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)]

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 doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc

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

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClassNewTextSignature<Position> for PyClassImplCollector<Position>

fn new_text_signature(self) -> Option<&'static str>

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

type Holder = Option<PyRef<'py, Position>>

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

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

type Holder = Option<PyRefMut<'py, Position>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a 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_bound(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

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

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

fn is_exact_type_of_bound(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