Struct PortfolioAnalyzer 

#[repr(C)]
pub struct PortfolioAnalyzer {
    pub statistics: AHashMap<String, Statistic>,
    pub account_balances_starting: IndexMap<Currency, Money>,
    pub account_balances: IndexMap<Currency, Money>,
    pub positions: Vec<Position>,
    pub realized_pnls: AHashMap<Currency, Vec<(PositionId, f64)>>,
    pub position_returns: Returns,
    pub portfolio_returns: Returns,
    pub returns: Returns,
}

Analyzes portfolio performance and calculates various statistics.

The PortfolioAnalyzer tracks account balances, positions, and realized PnLs to provide portfolio analysis including returns, PnL calculations, and customizable statistics.

Fields

statistics: AHashMap<String, Statistic>

account_balances_starting: IndexMap<Currency, Money>

account_balances: IndexMap<Currency, Money>

positions: Vec<Position>

realized_pnls: AHashMap<Currency, Vec<(PositionId, f64)>>

position_returns: Returns

portfolio_returns: Returns

returns: Returns

Alias for the primary returns source.

Contains portfolio returns when available, otherwise position returns. Kept as a public field for API stability; prefer the returns() accessor.

Implementations

impl PortfolioAnalyzer

pub fn new() -> Self

Creates a new PortfolioAnalyzer instance.

Starts with empty state.

pub fn register_statistic(&mut self, statistic: Statistic)

Registers a new portfolio statistic for calculation.

pub fn deregister_statistic(&mut self, statistic: &Statistic)

Removes a specific statistic from calculation.

pub fn deregister_statistics(&mut self)

Removes all registered statistics.

pub fn reset(&mut self)

Resets all analysis data to initial state.

pub fn currencies(&self) -> Vec<&Currency>

Returns all tracked currencies.

pub fn statistic(&self, name: &str) -> Option<&Statistic>

Retrieves a specific statistic by name.

pub const fn returns(&self) -> &Returns

Returns the primary calculated returns.

This returns portfolio returns when available, otherwise it falls back to position returns for backward compatibility.

pub const fn position_returns(&self) -> &Returns

Returns the per-position calculated returns.

pub const fn portfolio_returns(&self) -> &Returns

Returns the portfolio calculated returns.

pub fn calculate_statistics( &mut self, account: &dyn Account, positions: &[Position], )

Calculates statistics based on account and position data.

This clears all previous state before calculating, so can be called multiple times without accumulating stale data.

pub fn add_positions(&mut self, positions: &[Position])

Adds new positions for analysis.

pub fn add_trade(&mut self, position_id: &PositionId, pnl: &Money)

Records a trade’s PnL.

pub fn add_position_return(&mut self, timestamp: UnixNanos, value: f64)

Records a position return at a specific timestamp.

pub fn add_return(&mut self, timestamp: UnixNanos, value: f64)

Records a return at a specific timestamp.

This is a backward-compatible alias for Self::add_position_return.

pub fn realized_pnls( &self, currency: Option<&Currency>, ) -> Option<Vec<(PositionId, f64)>>

Retrieves realized PnLs for a specific currency.

Returns None if no PnLs exist, or if multiple currencies exist without an explicit currency specified.

pub fn total_pnl( &self, currency: Option<&Currency>, unrealized_pnl: Option<&Money>, ) -> Result<f64, &'static str>

Calculates total PnL including unrealized PnL if provided.

Errors

Returns an error if:

• No currency is specified in a multi-currency portfolio.
• The specified currency is not found in account balances.
• The unrealized PnL currency does not match the specified currency.

pub fn total_pnl_percentage( &self, currency: Option<&Currency>, unrealized_pnl: Option<&Money>, ) -> Result<f64, &'static str>

Calculates total PnL as a percentage of starting balance.

Errors

Returns an error if:

• No currency is specified in a multi-currency portfolio.
• The specified currency is not found in account balances.
• The unrealized PnL currency does not match the specified currency.

pub fn get_performance_stats_pnls( &self, currency: Option<&Currency>, unrealized_pnl: Option<&Money>, ) -> Result<AHashMap<String, f64>, &'static str>

Gets all PnL-related performance statistics.

Errors

Returns an error if PnL calculations fail, for example due to:

• No currency specified for a multi-currency portfolio.
• Unrealized PnL currency not matching the specified currency.
• Specified currency not found in account balances.

pub fn get_performance_stats_returns(&self) -> AHashMap<String, f64>

Gets all return-based performance statistics.

pub fn get_performance_stats_position_returns(&self) -> AHashMap<String, f64>

Gets all position-return-based performance statistics.

pub fn get_performance_stats_portfolio_returns(&self) -> AHashMap<String, f64>

Gets all portfolio-return-based performance statistics.

pub fn get_performance_stats_general(&self) -> AHashMap<String, f64>

Gets general portfolio statistics.

pub fn get_stats_pnls_formatted( &self, currency: Option<&Currency>, unrealized_pnl: Option<&Money>, ) -> Result<Vec<String>, String>

Gets formatted PnL statistics as strings.

Errors

Returns an error if PnL statistics calculation fails.

pub fn get_stats_returns_formatted(&self) -> Vec<String>

Gets formatted return statistics as strings.

pub fn get_stats_position_returns_formatted(&self) -> Vec<String>

Gets formatted position-return statistics as strings.

pub fn get_stats_portfolio_returns_formatted(&self) -> Vec<String>

Gets formatted portfolio-return statistics as strings.

pub fn get_stats_general_formatted(&self) -> Vec<String>

Gets formatted general statistics as strings.

impl PortfolioAnalyzer

pub fn py_new() -> Self

Analyzes portfolio performance and calculates various statistics.

The PortfolioAnalyzer tracks account balances, positions, and realized PnLs to provide portfolio analysis including returns, PnL calculations, and customizable statistics.

Trait Implementations

impl Debug for PortfolioAnalyzer

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

Formats the value using the given formatter.

impl Default for PortfolioAnalyzer

fn default() -> Self

Creates a new default PortfolioAnalyzer instance.

impl<'py> IntoPyObject<'py> for PortfolioAnalyzer

type Target = PortfolioAnalyzer

The Python output type

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

const NAME: &str = "PortfolioAnalyzer"

Name of the class.

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for PortfolioAnalyzer

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 = /// Analyzes portfolio performance and calculates various statistics. /// /// The `PortfolioAnalyzer` tracks account balances, positions, and realized PnLs /// to provide portfolio analysis including returns, PnL calculations, /// and customizable statistics.

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

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

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 PortfolioAnalyzer

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

impl PyStubType for PortfolioAnalyzer

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 PortfolioAnalyzer

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 DerefToPyAny for PortfolioAnalyzer

impl ExtractPyClassWithClone for PortfolioAnalyzer