Struct AccountState 

#[repr(C)]
pub struct AccountState {
    pub account_id: AccountId,
    pub account_type: AccountType,
    pub base_currency: Option<Currency>,
    pub balances: Vec<AccountBalance>,
    pub margins: Vec<MarginBalance>,
    pub is_reported: bool,
    pub event_id: UUID4,
    pub ts_event: UnixNanos,
    pub ts_init: UnixNanos,
}

Represents an event which includes information on the state of the account.

Fields

account_id: AccountId

The account ID associated with the event.

account_type: AccountType

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

base_currency: Option<Currency>

The base currency for the account, if applicable.

balances: Vec<AccountBalance>

The balances in the account.

margins: Vec<MarginBalance>

The margin balances in the account.

is_reported: bool

Indicates if the account state is reported by the exchange (as opposed to system-calculated).

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 AccountState

pub fn new( account_id: AccountId, account_type: AccountType, balances: Vec<AccountBalance>, margins: Vec<MarginBalance>, is_reported: bool, event_id: UUID4, ts_event: UnixNanos, ts_init: UnixNanos, base_currency: Option<Currency>, ) -> Self

Creates a new AccountState instance.

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

Returns true if this account state has the same balances and margins as another.

This compares all balances and margins for equality, returning true only if all balances and margins are equal. If any balance or margin is different or missing, returns false.

Note

This method does not compare event IDs, timestamps, or other metadata - only the actual balance and margin values.

impl AccountState

pub fn py_from_dict(values: &Bound<'_, PyDict>) -> PyResult<Self>

Constructs an AccountState from a Python dict.

Errors

Returns a PyErr if any required field is missing or type conversion fails.

Panics

Panics if any unwrap on parsed values fails (e.g., invalid formats or missing items).

pub fn py_to_dict(&self, py: Python<'_>) -> PyResult<PyObject>

Converts this AccountState into a Python dict.

Errors

Returns a PyErr if serialization into a Python dict fails.

Trait Implementations

impl Clone for AccountState

fn clone(&self) -> AccountState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AccountState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AccountState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for AccountState

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

Formats the value using the given formatter.

impl From<AccountState> for AccountAny

fn from(event: AccountState) -> Self

Converts to this type from the input type.

impl<'py> IntoPyObject<'py> for AccountState

type Target = AccountState

The Python output type

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

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 AccountState

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for AccountState

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

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<AccountState>

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<AccountState> for PyClassImplCollector<AccountState>

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

impl<'a, 'py> PyFunctionArgument<'a, 'py, false> for &'a AccountState

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

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

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

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

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

impl PyMethods<AccountState> for PyClassImplCollector<AccountState>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for AccountState

const NAME: &'static str = "AccountState"

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 AccountState

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 AccountState