Struct PortfolioSnapshot 

#[repr(C)]
pub struct PortfolioSnapshot {

    pub account_id: AccountId,
    pub account_type: AccountType,
    pub base_currency: Option<Currency>,
    pub balances: Vec<AccountBalance>,
    pub margins: Vec<MarginBalance>,
    pub unrealized_pnls: Vec<Money>,
    pub realized_pnls: Vec<Money>,
    pub total_equity: Vec<Money>,
    pub base_currency_equity: Option<Money>,
    pub is_stale: bool,
    pub stale_instruments: Vec<InstrumentId>,
    pub stale_currencies: Vec<Currency>,
    pub unpriced_instruments: Vec<InstrumentId>,
    pub event_id: UUID4,
    pub ts_event: UnixNanos,
    pub ts_init: UnixNanos,
}

Represents a point-in-time snapshot of portfolio state for a single account.

Unlike AccountState, which fires only on balance or margin changes, PortfolioSnapshot carries a continuous mark-to-market view by folding open-position valuations into the totals. The default equity curve records one snapshot at account registration, at every UTC midnight, and at shutdown, including while the account is flat. An optional fine-grained stream records additional snapshots while positions are open. Totals span every venue the account holds positions on, so multi-venue accounts (e.g., a prime broker routing across exchanges) produce a single account-wide snapshot rather than per-venue slices.

Fields

account_id: AccountId

The account ID this snapshot belongs to.

account_type: AccountType

The type of the account (e.g., cash, margin).

base_currency: Option<Currency>

The base currency for the account, if applicable.

balances: Vec<AccountBalance>

The per-currency account balances at snapshot time.

margins: Vec<MarginBalance>

The per-instrument margin balances at snapshot time (margin accounts only).

unrealized_pnls: Vec<Money>

The per-currency unrealized PnL across all open positions at snapshot time.

realized_pnls: Vec<Money>

The per-currency realized PnL accumulated for positions opened in this session.

total_equity: Vec<Money>

The per-currency total equity (mark-to-market).

For cash accounts: balance.total + Σ mark_value(open positions) in the same currency. For margin accounts: balance.total + Σ unrealized_pnl(open positions) in the same currency.

base_currency_equity: Option<Money>

The resolved total equity in the account base currency, when conversion is enabled.

is_stale: bool

Whether this sample contains carried or unavailable valuation inputs.

stale_instruments: Vec<InstrumentId>

Instruments valued with a carried price.

stale_currencies: Vec<Currency>

Source currencies converted with a carried exchange rate.

unpriced_instruments: Vec<InstrumentId>

Open-position instruments excluded because no complete valid valuation was ever available.

event_id: UUID4

The unique identifier for the event.

ts_event: UnixNanos

UNIX timestamp (nanoseconds) when the event occurred.

ts_init: UnixNanos

UNIX timestamp (nanoseconds) when the event was initialized.

Implementations

impl PortfolioSnapshot

pub fn new( account_id: AccountId, account_type: AccountType, base_currency: Option<Currency>, balances: Vec<AccountBalance>, margins: Vec<MarginBalance>, unrealized_pnls: Vec<Money>, realized_pnls: Vec<Money>, total_equity: Vec<Money>, base_currency_equity: Option<Money>, is_stale: bool, stale_instruments: Vec<InstrumentId>, stale_currencies: Vec<Currency>, unpriced_instruments: Vec<InstrumentId>, event_id: UUID4, ts_event: UnixNanos, ts_init: UnixNanos, ) -> Self

Creates a new PortfolioSnapshot instance.

Trait Implementations

impl CatalogPathPrefix for PortfolioSnapshot

fn path_prefix() -> &'static str

Returns the path prefix (directory name) for this data type.

impl Clone for PortfolioSnapshot

fn clone(&self) -> PortfolioSnapshot

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PortfolioSnapshot

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

Formats the value using the given formatter.

impl DerefToPyAny for PortfolioSnapshot

impl<'de> Deserialize<'de> for PortfolioSnapshot

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for PortfolioSnapshot

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

Formats the value using the given formatter.

impl<'a, 'py> FromPyObject<'a, 'py> for PortfolioSnapshot

where Self: Clone,

type Error = PyClassGuardError<'a, 'py>

The type returned in the event of a conversion error.

fn extract( obj: Borrowed<'a, 'py, PyAny>, ) -> Result<Self, <Self as FromPyObject<'a, 'py>>::Error>

Extracts Self from the bound smart pointer obj.

impl HasTsInit for PortfolioSnapshot

fn ts_init(&self) -> UnixNanos

Returns the UNIX timestamp (nanoseconds) when the instance was created.

impl<'py> IntoPyObject<'py> for PortfolioSnapshot

type Target = PortfolioSnapshot

The Python output type

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

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

Equality operator ==.

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

Inequality operator !=.

impl PyClass for PortfolioSnapshot

const NAME: &str = "PortfolioSnapshot"

Name of the class.

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for PortfolioSnapshot

const MODULE: Option<&str>

Module which the class will be associated with.

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 point-in-time snapshot of portfolio state for a single account. /// /// Unlike [`AccountState`](crate::events::AccountState), which fires only on /// balance or margin changes, `PortfolioSnapshot` carries a continuous /// mark-to-market view by folding open-position valuations into the totals. /// The default equity curve records one snapshot at account registration, at every /// UTC midnight, and at shutdown, including while the account is flat. An optional /// fine-grained stream records additional snapshots while positions are open. /// Totals span every venue the account holds positions on, so multi-venue /// accounts (e.g., a prime broker routing across exchanges) produce a single /// account-wide snapshot rather than per-venue slices.

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

Description of how this class is laid out in memory

type BaseType = PyAny

Base class

type ThreadChecker = NoopThreadChecker

This handles following two situations:

type Inventory = Pyo3MethodsInventoryForPortfolioSnapshot

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

Used to provide the dictoffset slot (equivalent to tp_dictoffset)

fn weaklist_offset() -> Option<PyObjectOffset>

Used to provide the weaklistoffset slot (equivalent to tp_weaklistoffset

impl PyClassNewTextSignature for PortfolioSnapshot

const TEXT_SIGNATURE: &'static str = "(account_id, account_type, balances, margins, unrealized_pnls, realized_pnls, total_equity, event_id, ts_event, ts_init, base_currency=None, base_currency_equity=None, is_stale=False, stale_instruments=None, stale_currencies=None, unpriced_instruments=None)"

impl PyStubType for PortfolioSnapshot

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 PortfolioSnapshot

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.

impl Serialize for PortfolioSnapshot

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

where __S: Serializer,

Serialize this value into the given Serde serializer.