Instruments
Defines tradable asset/contract instruments with specific properties dependent on the asset class and instrument class.
class Instrument
Bases: Data
Instrument(InstrumentId instrument_id, Symbol raw_symbol, AssetClass asset_class, InstrumentClass instrument_class, Currency quote_currency, bool is_inverse, int price_precision, int size_precision, Quantity size_increment, Quantity multiplier, margin_init: Decimal, margin_maint: Decimal, maker_fee: Decimal, taker_fee: Decimal, uint64_t ts_event, uint64_t ts_init, Price price_increment: Price | None = None, Quantity lot_size: Quantity | None = None, Quantity max_quantity: Quantity | None = None, Quantity min_quantity: Quantity | None = None, Money max_notional: Money | None = None, Money min_notional: Money | None = None, Price max_price: Price | None = None, Price min_price: Price | None = None, unicode tick_scheme_name=None, dict info=None)
The base class for all instruments.
Represents a tradable instrument. This class can be used to define an instrument, or act as a parent class for more specific instruments.
- Parameters:
- instrument_id (InstrumentId) – The instrument ID for the instrument.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- asset_class (AssetClass) – The instrument asset class.
- instrument_class (InstrumentClass) – The instrument class.
- quote_currency (Currency) – The quote currency.
- is_inverse (bool) – If the instrument costing is inverse (quantity expressed in quote currency units).
- price_precision (int) – The price decimal precision.
- size_precision (int) – The trading size decimal precision.
- size_increment (Price) – The minimum size increment.
- multiplier (Decimal) – The contract value multiplier (determines tick value).
- lot_size (Quantity , optional) – The rounded lot unit size (standard/board).
- margin_init (Decimal) – The initial (order) margin requirement in percentage of order value.
- margin_maint (Decimal) – The maintenance (position) margin in percentage of position value.
- maker_fee (Decimal) – The fee rate for liquidity makers as a percentage of order value (where 1.0 is 100%).
- taker_fee (Decimal) – The fee rate for liquidity takers as a percentage of order value (where 1.0 is 100%).
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- price_increment (Price , optional) – The minimum price increment (tick size).
- max_quantity (Quantity , optional) – The maximum allowable order quantity.
- min_quantity (Quantity , optional) – The minimum allowable order quantity.
- max_notional (Money , optional) – The maximum allowable order notional value.
- min_notional (Money , optional) – The minimum allowable order notional value.
- max_price (Price , optional) – The maximum allowable quoted price.
- min_price (Price , optional) – The minimum allowable quoted price.
- tick_scheme_name (str , optional) – The name of the tick scheme.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If tick_scheme_name is not a valid string.
- ValueError – If price_precision is negative (< 0).
- ValueError – If size_precision is negative (< 0).
- ValueError – If price_increment is not positive (> 0).
- ValueError – If size_increment is not positive (> 0).
- ValueError – If price_precision is not equal to price_increment.precision.
- ValueError – If size_increment is not equal to size_increment.precision.
- ValueError – If multiplier is not positive (> 0).
- ValueError – If lot size is not positive (> 0).
- ValueError – If max_quantity is not positive (> 0).
- ValueError – If min_quantity is negative (< 0).
- ValueError – If max_notional is not positive (> 0).
- ValueError – If min_notional is negative (< 0).
- ValueError – If max_price is not positive (> 0).
- ValueError – If min_price is negative (< 0).
asset_class
The asset class of the instrument.
- Returns: AssetClass
static base_from_dict(dict values) → Instrument
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: Instrument
static base_to_dict(Instrument obj)
Return a dictionary representation of this object.
- Return type: dict[str, object]
calculate_base_quantity(self, Quantity quantity, Price last_px) → Quantity
Calculate the base asset quantity from the given quote asset quantity and last price.
- Parameters:
- Return type: Quantity
get_base_currency(self) → Currency
Return the instruments base currency (if applicable).
- Return type:
Currency or
None
get_settlement_currency(self) → Currency
Return the currency used to settle a trade of the instrument.
- Standard linear instruments = quote_currency
- Inverse instruments = base_currency
- Quanto instruments = settlement_currency
- Return type: Currency
id
The instrument ID.
- Returns: InstrumentId
info
The raw info for the instrument.
- Returns: dict[str, object]
instrument_class
The class of the instrument.
- Returns: InstrumentClass
is_inverse
If the quantity is expressed in quote currency.
- Returns: Currency
lot_size
The rounded lot unit size (standard/board) for the instrument.
- Returns:
Quantity or
None
make_price(self, value) → Price
Return a new price from the given value using the instruments price precision.
- Parameters: value (integer , float , str or Decimal) – The value of the price.
- Return type: Price
make_qty(self, value) → Quantity
Return a new quantity from the given value using the instruments size precision.
- Parameters: value (integer , float , str or Decimal) – The value of the quantity.
- Return type: Quantity
- Raises: ValueError – If a non zero value is rounded to zero due to the instruments size increment or size precision.
maker_fee
The fee rate for liquidity makers as a percentage of order value (where 1.0 is 100%).
- Returns: Decimal
margin_init
The initial (order) margin rate for the instrument.
- Returns: Decimal
margin_maint
The maintenance (position) margin rate for the instrument.
- Returns: Decimal
max_notional
The maximum notional order value for the instrument.
- Returns:
Money or
None
max_price
The maximum printable price for the instrument.
- Returns:
Price or
None
max_quantity
The maximum order quantity for the instrument.
- Returns:
Quantity or
None
min_notional
The minimum notional order value for the instrument.
- Returns:
Money or
None
min_price
The minimum printable price for the instrument.
- Returns:
Price or
None
min_quantity
The minimum order quantity for the instrument.
- Returns:
Quantity or
None
multiplier
The contract multiplier for the instrument (determines tick value).
- Returns: Quantity
next_ask_price(self, double value, int num_ticks=0) → Price
Return the price n ask ticks away from value.
If a given price is between two ticks, n=0 will find the nearest ask tick.
- Parameters:
- value (double) – The reference value.
- num_ticks (int , default 0) – The number of ticks to move.
- Return type: Price
- Raises: ValueError – If a tick scheme is not initialized.
next_bid_price(self, double value, int num_ticks=0) → Price
Return the price n bid ticks away from value.
If a given price is between two ticks, n=0 will find the nearest bid tick.
- Parameters:
- value (double) – The reference value.
- num_ticks (int , default 0) – The number of ticks to move.
- Return type: Price
- Raises: ValueError – If a tick scheme is not initialized.
notional_value(self, Quantity quantity, Price price, bool use_quote_for_inverse=False) → Money
Calculate the notional value.
Result will be in quote currency for standard instruments, or base currency for inverse instruments.
- Parameters:
- Return type: Money
price_increment
The minimum price increment or tick size for the instrument.
- Returns: Price
price_precision
The price precision of the instrument.
- Returns: int
quote_currency
The quote currency for the instrument.
- Returns: Currency
raw_symbol
The raw/local/native symbol for the instrument, assigned by the venue.
- Returns: Symbol
size_increment
The minimum size increment for the instrument.
- Returns: Quantity
size_precision
The size precision of the instrument.
- Returns: int
symbol
Return the instruments ticker symbol.
- Return type: Symbol
taker_fee
The fee rate for liquidity takers as a percentage of order value (where 1.0 is 100%).
- Returns: Decimal
tick_scheme_name
The tick scheme name.
- Returns:
str or
None
ts_event
UNIX timestamp (nanoseconds) when the data event occurred.
- Returns: uint64_t
ts_init
UNIX timestamp (nanoseconds) when the object was initialized.
- Returns: uint64_t
venue
Return the instruments trading venue.
- Return type: Venue
instruments_from_pyo3(list pyo3_instruments) → list
class BettingInstrument
Bases: Instrument
BettingInstrument(unicode venue_name, int event_type_id, unicode event_type_name, int competition_id, unicode competition_name, int event_id, unicode event_name, unicode event_country_code, datetime event_open_date, unicode betting_type, unicode market_id, unicode market_name, datetime market_start_time, unicode market_type, int selection_id, unicode selection_name, unicode currency, float selection_handicap, int8_t price_precision, int8_t size_precision, uint64_t ts_event, uint64_t ts_init, unicode tick_scheme_name=None, Price min_price=None, Price max_price=None, dict info=None)
Represents an instrument in a betting market.
betting_type
competition_id
competition_name
event_country_code
event_id
event_name
event_open_date
event_type_id
event_type_name
static from_dict(dict values) → BettingInstrument
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: BettingInstrument
market_id
market_name
market_start_time
market_type
notional_value(self, Quantity quantity, Price price, bool use_quote_for_inverse=False) → Money
selection_handicap
selection_id
selection_name
static to_dict(BettingInstrument obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
class BinaryOption
Bases: Instrument
BinaryOption(InstrumentId instrument_id, Symbol raw_symbol, AssetClass asset_class, Currency currency, int price_precision, int size_precision, Price price_increment, Quantity size_increment, uint64_t activation_ns, uint64_t expiration_ns, maker_fee: Decimal, taker_fee: Decimal, uint64_t ts_event, uint64_t ts_init, unicode outcome=None, unicode description=None, Quantity max_quantity: Quantity | None = None, Quantity min_quantity: Quantity | None = None, dict info=None) -> None
Represents a generic binary option instrument.
- Parameters:
- instrument_id (InstrumentId) – The instrument ID.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- asset_class (AssetClass) – The options contract asset class.
- currency (Currency) – The options contract currency.
- price_precision (int) – The price decimal precision.
- size_precision (int) – The trading size decimal precision.
- price_increment (Price) – The minimum price increment (tick size).
- size_increment (Quantity) – The minimum size increment.
- activation_ns (uint64_t) – UNIX timestamp (nanoseconds) for contract activation.
- expiration_ns (uint64_t) – UNIX timestamp (nanoseconds) for contract expiration.
- maker_fee (Decimal) – The fee rate for liquidity makers as a percentage of order value.
- taker_fee (Decimal) – The fee rate for liquidity takers as a percentage of order value.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- outcome (str , optional) – The binary outcome of the market.
- description (str , optional) – The market description.
- max_quantity (Quantity , optional) – The maximum allowable order quantity.
- min_quantity (Quantity , optional) – The minimum allowable order quantity.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If price_precision is negative (< 0).
- ValueError – If size_precision is negative (< 0).
- ValueError – If price_increment is not positive (> 0).
- ValueError – If size_increment is not positive (> 0).
activation_ns
UNIX timestamp (nanoseconds) for contract activation.
- Returns: unit64_t
activation_utc
pd.Timestamp
Return the contract activation timestamp (UTC).
- Returns: tz-aware UTC.
- Return type: pd.Timestamp
- Type: BinaryOption.activation_utc
description
The market description.
- Returns:
str or
None
expiration_ns
UNIX timestamp (nanoseconds) for contract expiration.
- Returns: unit64_t
expiration_utc
pd.Timestamp
Return the contract expriation timestamp (UTC).
- Returns: tz-aware UTC.
- Return type: pd.Timestamp
- Type: BinaryOption.expiration_utc
static from_dict(dict values) → BinaryOption
Return an instrument from the given initialization values.
values : The values to initialize the instrument with.
BinaryOption
outcome
The binary outcome of the market.
- Returns:
str or
None
static to_dict(BinaryOption obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
class Cfd
Bases: Instrument
Cfd(InstrumentId instrument_id, Symbol raw_symbol, AssetClass asset_class, Currency quote_currency, int price_precision, int size_precision, Price price_increment, Quantity size_increment, margin_init: Decimal, margin_maint: Decimal, maker_fee: Decimal, taker_fee: Decimal, uint64_t ts_event, uint64_t ts_init, Currency base_currency: Currency | None = None, Quantity lot_size: Quantity | None = None, Quantity max_quantity: Quantity | None = None, Quantity min_quantity: Quantity | None = None, Money max_notional: Money | None = None, Money min_notional: Money | None = None, Price max_price: Price | None = None, Price min_price: Price | None = None, unicode tick_scheme_name=None, dict info=None)
Represents a Contract for Difference (CFD) instrument.
Can represent both Fiat FX and Cryptocurrency pairs.
- Parameters:
- instrument_id (InstrumentId) – The instrument ID for the instrument.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- asset_class (AssetClass) – The CFD contract asset class.
- quote_currency (Currency) – The quote currency.
- price_precision (int) – The price decimal precision.
- size_precision (int) – The trading size decimal precision.
- price_increment (Price) – The minimum price increment (tick size).
- size_increment (Quantity) – The minimum size increment.
- margin_init (Decimal) – The initial (order) margin requirement in percentage of order value.
- margin_maint (Decimal) – The maintenance (position) margin in percentage of position value.
- maker_fee (Decimal) – The fee rate for liquidity makers as a percentage of order value.
- taker_fee (Decimal) – The fee rate for liquidity takers as a percentage of order value.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- base_currency (Currency , optional) – The base currency.
- lot_size (Quantity , optional) – The rounded lot unit size.
- max_quantity (Quantity , optional) – The maximum allowable order quantity.
- min_quantity (Quantity , optional) – The minimum allowable order quantity.
- max_notional (Money , optional) – The maximum allowable order notional value.
- min_notional (Money , optional) – The minimum allowable order notional value.
- max_price (Price , optional) – The maximum allowable quoted price.
- min_price (Price , optional) – The minimum allowable quoted price.
- tick_scheme_name (str , optional) – The name of the tick scheme.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If tick_scheme_name is not a valid string.
- ValueError – If price_precision is negative (< 0).
- ValueError – If size_precision is negative (< 0).
- ValueError – If price_increment is not positive (> 0).
- ValueError – If size_increment is not positive (> 0).
- ValueError – If price_precision is not equal to price_increment.precision.
- ValueError – If size_increment is not equal to size_increment.precision.
- ValueError – If lot_size is not positive (> 0).
- ValueError – If max_quantity is not positive (> 0).
- ValueError – If min_quantity is negative (< 0).
- ValueError – If max_notional is not positive (> 0).
- ValueError – If min_notional is negative (< 0).
- ValueError – If max_price is not positive (> 0).
- ValueError – If min_price is negative (< 0).
base_currency
The base currency for the instrument.
- Returns:
Currency or
None
static from_dict(dict values) → Cfd
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: Cfd
static from_pyo3(pyo3_instrument)
isin
The instruments International Securities Identification Number (ISIN).
- Returns:
str or
None
static to_dict(Cfd obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
class Commodity
Bases: Instrument
Commodity(InstrumentId instrument_id, Symbol raw_symbol, AssetClass asset_class, Currency quote_currency, int price_precision, int size_precision, Price price_increment, Quantity size_increment, margin_init: Decimal, margin_maint: Decimal, maker_fee: Decimal, taker_fee: Decimal, uint64_t ts_event, uint64_t ts_init, Currency base_currency: Currency | None = None, Quantity lot_size: Quantity | None = None, Quantity max_quantity: Quantity | None = None, Quantity min_quantity: Quantity | None = None, Money max_notional: Money | None = None, Money min_notional: Money | None = None, Price max_price: Price | None = None, Price min_price: Price | None = None, unicode tick_scheme_name=None, dict info=None)
Represents a commodity instrument in a spot/cash market.
- Parameters:
- instrument_id (InstrumentId) – The instrument ID for the instrument.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- asset_class (AssetClass) – The Commodity contract asset class.
- quote_currency (Currency) – The quote currency.
- price_precision (int) – The price decimal precision.
- size_precision (int) – The trading size decimal precision.
- price_increment (Price) – The minimum price increment (tick size).
- size_increment (Quantity) – The minimum size increment.
- margin_init (Decimal) – The initial (order) margin requirement in percentage of order value.
- margin_maint (Decimal) – The maintenance (position) margin in percentage of position value.
- maker_fee (Decimal) – The fee rate for liquidity makers as a percentage of order value.
- taker_fee (Decimal) – The fee rate for liquidity takers as a percentage of order value.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- lot_size (Quantity , optional) – The rounded lot unit size.
- max_quantity (Quantity , optional) – The maximum allowable order quantity.
- min_quantity (Quantity , optional) – The minimum allowable order quantity.
- max_notional (Money , optional) – The maximum allowable order notional value.
- min_notional (Money , optional) – The minimum allowable order notional value.
- max_price (Price , optional) – The maximum allowable quoted price.
- min_price (Price , optional) – The minimum allowable quoted price.
- tick_scheme_name (str , optional) – The name of the tick scheme.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If tick_scheme_name is not a valid string.
- ValueError – If price_precision is negative (< 0).
- ValueError – If size_precision is negative (< 0).
- ValueError – If price_increment is not positive (> 0).
- ValueError – If size_increment is not positive (> 0).
- ValueError – If price_precision is not equal to price_increment.precision.
- ValueError – If size_increment is not equal to size_increment.precision.
- ValueError – If lot_size is not positive (> 0).
- ValueError – If max_quantity is not positive (> 0).
- ValueError – If min_quantity is negative (< 0).
- ValueError – If max_notional is not positive (> 0).
- ValueError – If min_notional is negative (< 0).
- ValueError – If max_price is not positive (> 0).
- ValueError – If min_price is negative (< 0).
static from_dict(dict values) → Commodity
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: Commodity
static from_pyo3(pyo3_instrument)
isin
The instruments International Securities Identification Number (ISIN).
- Returns:
str or
None
static to_dict(Commodity obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
class CryptoFuture
Bases: Instrument
CryptoFuture(InstrumentId instrument_id, Symbol raw_symbol, Currency underlying, Currency quote_currency, Currency settlement_currency, bool is_inverse, uint64_t activation_ns, uint64_t expiration_ns, int price_precision, int size_precision, Price price_increment, Quantity size_increment, margin_init: Decimal, margin_maint: Decimal, maker_fee: Decimal, taker_fee: Decimal, uint64_t ts_event, uint64_t ts_init, multiplier=Quantity.from_int_c(1), lot_size=Quantity.from_int_c(1), Quantity max_quantity: Quantity | None = None, Quantity min_quantity: Quantity | None = None, Money max_notional: Money | None = None, Money min_notional: Money | None = None, Price max_price: Price | None = None, Price min_price: Price | None = None, dict info=None)
Represents a deliverable futures contract instrument, with crypto assets as underlying and for settlement.
- Parameters:
- instrument_id (InstrumentId) – The instrument ID for the instrument.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- underlying (Currency) – The underlying asset.
- quote_currency (Currency) – The contract quote currency.
- settlement_currency (Currency) – The settlement currency.
- is_inverse (bool) – If the instrument costing is inverse (quantity expressed in quote currency units).
- activation_ns (uint64_t) – UNIX timestamp (nanoseconds) for contract activation.
- expiration_ns (uint64_t) – UNIX timestamp (nanoseconds) for contract expiration.
- price_precision (int) – The price decimal precision.
- size_precision (int) – The trading size decimal precision.
- price_increment (Price) – The minimum price increment (tick size).
- size_increment (Quantity) – The minimum size increment.
- margin_init (Decimal) – The initial (order) margin requirement in percentage of order value.
- margin_maint (Decimal) – The maintenance (position) margin in percentage of position value.
- maker_fee (Decimal) – The fee rate for liquidity makers as a percentage of order value.
- taker_fee (Decimal) – The fee rate for liquidity takers as a percentage of order value.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- multiplier (Quantity , default 1) – The contract multiplier.
- lot_size (Quantity) – The rounded lot unit size (standard/board).
- max_quantity (Quantity , optional) – The maximum allowable order quantity.
- min_quantity (Quantity , optional) – The minimum allowable order quantity.
- max_notional (Money , optional) – The maximum allowable order notional value.
- min_notional (Money , optional) – The minimum allowable order notional value.
- max_price (Price , optional) – The maximum allowable quoted price.
- min_price (Price , optional) – The minimum allowable quoted price.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If price_precision is negative (< 0).
- ValueError – If size_precision is negative (< 0).
- ValueError – If price_increment is not positive (> 0).
- ValueError – If size_increment is not positive (> 0).
- ValueError – If price_precision is not equal to price_increment.precision.
- ValueError – If size_increment is not equal to size_increment.precision.
- ValueError – If lot size is not positive (> 0).
- ValueError – If max_quantity is not positive (> 0).
- ValueError – If min_quantity is negative (< 0).
- ValueError – If max_notional is not positive (> 0).
- ValueError – If min_notional is negative (< 0).
- ValueError – If max_price is not positive (> 0).
- ValueError – If min_price is negative (< 0).
activation_ns
UNIX timestamp (nanoseconds) for contract activation.
- Returns: unit64_t
activation_utc
pd.Timestamp
Return the contract activation timestamp (UTC).
- Returns: tz-aware UTC.
- Return type: pd.Timestamp
- Type: CryptoFuture.activation_utc
expiration_ns
UNIX timestamp (nanoseconds) for contract expiration.
- Returns: unit64_t
expiration_utc
pd.Timestamp
Return the contract expriation timestamp (UTC).
- Returns: tz-aware UTC.
- Return type: pd.Timestamp
- Type: CryptoFuture.expiration_utc
static from_dict(dict values) → CryptoFuture
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: CryptoFuture
static from_pyo3(pyo3_instrument)
get_base_currency(self) → Currency
Return the instruments base currency.
- Return type: Currency
settlement_currency
The settlement currency for the contract.
- Returns: Currency
static to_dict(CryptoFuture obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
underlying
The underlying asset for the contract.
- Returns: Currency
class CryptoPerpetual
Bases: Instrument
CryptoPerpetual(InstrumentId instrument_id, Symbol raw_symbol, Currency base_currency, Currency quote_currency, Currency settlement_currency, bool is_inverse, int price_precision, int size_precision, Price price_increment, Quantity size_increment, margin_init: Decimal, margin_maint: Decimal, maker_fee: Decimal, taker_fee: Decimal, uint64_t ts_event, uint64_t ts_init, multiplier=Quantity.from_int_c(1), Quantity max_quantity: Quantity | None = None, Quantity min_quantity: Quantity | None = None, Money max_notional: Money | None = None, Money min_notional: Money | None = None, Price max_price: Price | None = None, Price min_price: Price | None = None, dict info=None)
Represents a crypto perpetual futures contract instrument (a.k.a. perpetual swap).
- Parameters:
- instrument_id (InstrumentId) – The instrument ID for the instrument.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- base_currency (Currency , optional) – The base currency.
- quote_currency (Currency) – The quote currency.
- settlement_currency (Currency) – The settlement currency.
- is_inverse (bool) – If the instrument costing is inverse (quantity expressed in quote currency units).
- price_precision (int) – The price decimal precision.
- size_precision (int) – The trading size decimal precision.
- price_increment (Price) – The minimum price increment (tick size).
- size_increment (Quantity) – The minimum size increment.
- margin_init (Decimal) – The initial (order) margin requirement in percentage of order value.
- margin_maint (Decimal) – The maintenance (position) margin in percentage of position value.
- maker_fee (Decimal) – The fee rate for liquidity makers as a percentage of order value.
- taker_fee (Decimal) – The fee rate for liquidity takers as a percentage of order value.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- multiplier (Quantity , default 1) – The contract multiplier.
- max_quantity (Quantity , optional) – The maximum allowable order quantity.
- min_quantity (Quantity , optional) – The minimum allowable order quantity.
- max_notional (Money , optional) – The maximum allowable order notional value.
- min_notional (Money , optional) – The minimum allowable order notional value.
- max_price (Price , optional) – The maximum allowable quoted price.
- min_price (Price , optional) – The minimum allowable quoted price.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If price_precision is negative (< 0).
- ValueError – If size_precision is negative (< 0).
- ValueError – If price_increment is not positive (> 0).
- ValueError – If size_increment is not positive (> 0).
- ValueError – If price_precision is not equal to price_increment.precision.
- ValueError – If size_increment is not equal to size_increment.precision.
- ValueError – If multiplier is not positive (> 0).
- ValueError – If max_quantity is not positive (> 0).
- ValueError – If min_quantity is negative (< 0).
- ValueError – If max_notional is not positive (> 0).
- ValueError – If min_notional is negative (< 0).
- ValueError – If max_price is not positive (> 0).
- ValueError – If min_price is negative (< 0).
base_currency
The base currency for the instrument.
- Returns: Currency
static from_dict(dict values) → CryptoPerpetual
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: CryptoPerpetual
static from_pyo3(pyo3_instrument)
get_base_currency(self) → Currency
Return the instruments base currency.
- Return type: Currency
is_quanto
If the instrument is quanto.
- Returns: bool
settlement_currency
The settlement currency for the instrument.
- Returns: Currency
static to_dict(CryptoPerpetual obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
class CurrencyPair
Bases: Instrument
CurrencyPair(InstrumentId instrument_id, Symbol raw_symbol, Currency base_currency, Currency quote_currency, int price_precision, int size_precision, Price price_increment, Quantity size_increment, margin_init: Decimal, margin_maint: Decimal, maker_fee: Decimal, taker_fee: Decimal, uint64_t ts_event, uint64_t ts_init, Quantity lot_size: Quantity | None = None, Quantity max_quantity: Quantity | None = None, Quantity min_quantity: Quantity | None = None, Money max_notional: Money | None = None, Money min_notional: Money | None = None, Price max_price: Price | None = None, Price min_price: Price | None = None, unicode tick_scheme_name=None, dict info=None)
Represents a generic currency pair instrument in a spot/cash market.
Can represent both Fiat FX and Cryptocurrency pairs.
- Parameters:
- instrument_id (InstrumentId) – The instrument ID for the instrument.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- base_currency (Currency) – The base currency.
- quote_currency (Currency) – The quote currency.
- price_precision (int) – The price decimal precision.
- size_precision (int) – The trading size decimal precision.
- price_increment (Price) – The minimum price increment (tick size).
- size_increment (Quantity) – The minimum size increment.
- margin_init (Decimal) – The initial (order) margin requirement in percentage of order value.
- margin_maint (Decimal) – The maintenance (position) margin in percentage of position value.
- maker_fee (Decimal) – The fee rate for liquidity makers as a percentage of order value.
- taker_fee (Decimal) – The fee rate for liquidity takers as a percentage of order value.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- lot_size (Quantity , optional) – The rounded lot unit size.
- max_quantity (Quantity , optional) – The maximum allowable order quantity.
- min_quantity (Quantity , optional) – The minimum allowable order quantity.
- max_notional (Money , optional) – The maximum allowable order notional value.
- min_notional (Money , optional) – The minimum allowable order notional value.
- max_price (Price , optional) – The maximum allowable quoted price.
- min_price (Price , optional) – The minimum allowable quoted price.
- tick_scheme_name (str , optional) – The name of the tick scheme.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If tick_scheme_name is not a valid string.
- ValueError – If price_precision is negative (< 0).
- ValueError – If size_precision is negative (< 0).
- ValueError – If price_increment is not positive (> 0).
- ValueError – If size_increment is not positive (> 0).
- ValueError – If price_precision is not equal to price_increment.precision.
- ValueError – If size_increment is not equal to size_increment.precision.
- ValueError – If lot_size is not positive (> 0).
- ValueError – If max_quantity is not positive (> 0).
- ValueError – If min_quantity is negative (< 0).
- ValueError – If max_notional is not positive (> 0).
- ValueError – If min_notional is negative (< 0).
- ValueError – If max_price is not positive (> 0).
- ValueError – If min_price is negative (< 0).
base_currency
The base currency for the instrument.
- Returns: Currency
static from_dict(dict values) → CurrencyPair
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: CurrencyPair
static from_pyo3(pyo3_instrument)
get_base_currency(self) → Currency
Return the instruments base currency.
- Return type: Currency
static to_dict(CurrencyPair obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
class Equity
Bases: Instrument
Equity(InstrumentId instrument_id, Symbol raw_symbol, Currency currency, int price_precision, Price price_increment, Quantity lot_size, uint64_t ts_event, uint64_t ts_init, unicode isin: str | None = None, margin_init: Decimal | None = None, margin_maint: Decimal | None = None, maker_fee: Decimal | None = None, taker_fee: Decimal | None = None, max_quantity: Quantity | None = None, min_quantity: Quantity | None = None, dict info=None)
Represents a generic equity instrument.
- Parameters:
- instrument_id (InstrumentId) – The instrument ID.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- currency (Currency) – The futures contract currency.
- price_precision (int) – The price decimal precision.
- price_increment (Decimal) – The minimum price increment (tick size).
- lot_size (Quantity) – The rounded lot unit size (standard/board).
- isin (str , optional) – The instruments International Securities Identification Number (ISIN).
- margin_init (Decimal , optional) – The initial (order) margin requirement in percentage of order value.
- margin_maint (Decimal , optional) – The maintenance (position) margin in percentage of position value.
- maker_fee (Decimal , optional) – The fee rate for liquidity makers as a percentage of order value.
- taker_fee (Decimal , optional) – The fee rate for liquidity takers as a percentage of order value.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If price_precision is negative (< 0).
- ValueError – If price_increment is not positive (> 0).
- ValueError – If lot_size is not positive (> 0).
- ValueError – If isin is not
Noneand not a valid string.
static from_dict(dict values) → Instrument
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: Equity
static from_pyo3(pyo3_instrument) → Equity
Return legacy Cython equity instrument converted from the given pyo3 Rust object.
- Parameters: pyo3_instrument (nautilus_pyo3.Equity) – The pyo3 Rust equity instrument to convert from.
- Return type: Equity
isin
The instruments International Securities Identification Number (ISIN).
- Returns:
str or
None
static to_dict(Instrument obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
class FuturesContract
Bases: Instrument
FuturesContract(InstrumentId instrument_id, Symbol raw_symbol, AssetClass asset_class, Currency currency, int price_precision, Price price_increment, Quantity multiplier, Quantity lot_size, unicode underlying, uint64_t activation_ns, uint64_t expiration_ns, uint64_t ts_event, uint64_t ts_init, unicode exchange=None, dict info=None)
Represents a generic deliverable futures contract instrument.
- Parameters:
- instrument_id (InstrumentId) – The instrument ID.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- asset_class (AssetClass) – The futures contract asset class.
- currency (Currency) – The futures contract currency.
- price_precision (int) – The price decimal precision.
- price_increment (Decimal) – The minimum price increment (tick size).
- multiplier (Quantity) – The contract multiplier.
- lot_size (Quantity) – The rounded lot unit size (standard/board).
- underlying (str) – The underlying asset.
- activation_ns (uint64_t) – UNIX timestamp (nanoseconds) for contract activation.
- expiration_ns (uint64_t) – UNIX timestamp (nanoseconds) for contract expiration.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- exchange (str , optional) – The exchange ISO 10383 Market Identifier Code (MIC) where the instrument trades.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If multiplier is not positive (> 0).
- ValueError – If price_precision is negative (< 0).
- ValueError – If tick_size is not positive (> 0).
- ValueError – If lot_size is not positive (> 0).
- ValueError – If exchange is not
Noneand not a valid string.
activation_ns
UNIX timestamp (nanoseconds) for contract activation.
- Returns: unit64_t
activation_utc
pd.Timestamp
Return the contract activation timestamp (UTC).
- Returns: tz-aware UTC.
- Return type: pd.Timestamp
- Type: FuturesContract.activation_utc
exchange
The exchange ISO 10383 Market Identifier Code (MIC) where the instrument trades.
- Returns:
str or
None
expiration_ns
UNIX timestamp (nanoseconds) for contract expiration.
- Returns: unit64_t
expiration_utc
pd.Timestamp
Return the contract expriation timestamp (UTC).
- Returns: tz-aware UTC.
- Return type: pd.Timestamp
- Type: FuturesContract.expiration_utc
static from_dict(dict values) → FuturesContract
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: FuturesContract
static from_pyo3(pyo3_instrument) → FuturesContract
Return legacy Cython futures contract instrument converted from the given pyo3 Rust object.
- Parameters: pyo3_instrument (nautilus_pyo3.FuturesContract) – The pyo3 Rust futures contract instrument to convert from.
- Return type: FuturesContract
static to_dict(FuturesContract obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
underlying
The underlying asset for the contract.
- Returns: str
class FuturesSpread
Bases: Instrument
FuturesSpread(InstrumentId instrument_id, Symbol raw_symbol, AssetClass asset_class, Currency currency, int price_precision, Price price_increment, Quantity multiplier, Quantity lot_size, unicode underlying, unicode strategy_type, uint64_t activation_ns, uint64_t expiration_ns, uint64_t ts_event, uint64_t ts_init, unicode exchange=None, dict info=None)
Represents a generic deliverable futures spread instrument.
- Parameters:
- instrument_id (InstrumentId) – The instrument ID.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- asset_class (AssetClass) – The futures spread asset class.
- currency (Currency) – The futures spread currency.
- price_precision (int) – The price decimal precision.
- price_increment (Decimal) – The minimum price increment (tick size).
- multiplier (Quantity) – The contract multiplier.
- lot_size (Quantity) – The rounded lot unit size (standard/board).
- underlying (str) – The underlying asset.
- strategy_type (str) – The strategy type for the spread.
- activation_ns (uint64_t) – UNIX timestamp (nanoseconds) for contract activation.
- expiration_ns (uint64_t) – UNIX timestamp (nanoseconds) for contract expiration.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- exchange (str , optional) – The exchange ISO 10383 Market Identifier Code (MIC) where the instrument trades.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If strategy_type is not a valid string.
- ValueError – If multiplier is not positive (> 0).
- ValueError – If price_precision is negative (< 0).
- ValueError – If tick_size is not positive (> 0).
- ValueError – If lot_size is not positive (> 0).
activation_ns
UNIX timestamp (nanoseconds) for contract activation.
- Returns: unit64_t
activation_utc
pd.Timestamp
Return the contract activation timestamp (UTC).
- Returns: tz-aware UTC.
- Return type: pd.Timestamp
- Type: FuturesSpread.activation_utc
exchange
The exchange ISO 10383 Market Identifier Code (MIC) where the instrument trades.
- Returns:
str or
None
expiration_ns
UNIX timestamp (nanoseconds) for contract expiration.
- Returns: unit64_t
expiration_utc
pd.Timestamp
Return the contract expriation timestamp (UTC).
- Returns: tz-aware UTC.
- Return type: pd.Timestamp
- Type: FuturesSpread.expiration_utc
static from_dict(dict values) → FuturesSpread
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: FuturesSpread
static from_pyo3(pyo3_instrument) → FuturesSpread
Return legacy Cython futures spread instrument converted from the given pyo3 Rust object.
- Parameters: pyo3_instrument (nautilus_pyo3.FuturesSpread) – The pyo3 Rust futures spread instrument to convert from.
- Return type: FuturesSpread
strategy_type
The strategy type of the spread.
- Returns: str
static to_dict(FuturesSpread obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
underlying
The underlying asset for the spread.
- Returns: str
class IndexInstrument
Bases: Instrument
IndexInstrument(InstrumentId instrument_id, Symbol raw_symbol, Currency currency, int price_precision, int size_precision, Price price_increment, Quantity size_increment, uint64_t ts_event, uint64_t ts_init, dict info=None)
Represents a generic index instrument.
This instrument is typically not tradable.
- Parameters:
- instrument_id (InstrumentId) – The instrument ID.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- currency (Currency) – The futures contract currency.
- price_precision (int) – The price decimal precision.
- price_increment (Price) – The minimum price increment (tick size).
- size_precision (int) – The trading size decimal precision.
- size_increment (Quantity) – The minimum size increment.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If price_precision is negative (< 0).
- ValueError – If size_precision is negative (< 0).
- ValueError – If price_increment is not positive (> 0).
- ValueError – If size_increment is not positive (> 0).
- ValueError – If price_precision is not equal to price_increment.precision.
- ValueError – If size_increment is not equal to size_increment.precision.
static from_dict(dict values) → Instrument
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: IndexInstrument
static from_pyo3(pyo3_instrument) → IndexInstrument
Return legacy Cython index instrument converted from the given pyo3 Rust object.
- Parameters: pyo3_instrument (nautilus_pyo3.IndexInstrument) – The pyo3 Rust index instrument to convert from.
- Return type: IndexInstrument
static to_dict(Instrument obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
class OptionsContract
Bases: Instrument
OptionsContract(InstrumentId instrument_id, Symbol raw_symbol, AssetClass asset_class, Currency currency, int price_precision, Price price_increment, Quantity multiplier, Quantity lot_size, unicode underlying, OptionKind option_kind, Price strike_price, uint64_t activation_ns, uint64_t expiration_ns, uint64_t ts_event, uint64_t ts_init, unicode exchange=None, dict info=None)
Represents a generic options contract instrument.
- Parameters:
- instrument_id (InstrumentId) – The instrument ID.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- asset_class (AssetClass) – The options contract asset class.
- currency (Currency) – The options contract currency.
- price_precision (int) – The price decimal precision.
- price_increment (Price) – The minimum price increment (tick size).
- multiplier (Quantity) – The option multiplier.
- lot_size (Quantity) – The rounded lot unit size (standard/board).
- underlying (str) – The underlying asset.
- option_kind (OptionKind) – The kind of option (PUT | CALL).
- strike_price (Price) – The option strike price.
- activation_ns (uint64_t) – UNIX timestamp (nanoseconds) for contract activation.
- expiration_ns (uint64_t) – UNIX timestamp (nanoseconds) for contract expiration.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- exchange (str , optional) – The exchange ISO 10383 Market Identifier Code (MIC) where the instrument trades.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If multiplier is not positive (> 0).
- ValueError – If price_precision is negative (< 0).
- ValueError – If tick_size is not positive (> 0).
- ValueError – If lot_size is not positive (> 0).
activation_ns
UNIX timestamp (nanoseconds) for contract activation.
- Returns: unit64_t
activation_utc
pd.Timestamp
Return the contract activation timestamp (UTC).
- Returns: tz-aware UTC.
- Return type: pd.Timestamp
- Type: OptionsContract.activation_utc
exchange
The exchange ISO 10383 Market Identifier Code (MIC) where the instrument trades.
- Returns:
str or
None
expiration_ns
UNIX timestamp (nanoseconds) for contract expiration.
- Returns: unit64_t
expiration_utc
pd.Timestamp
Return the contract expriation timestamp (UTC).
- Returns: tz-aware UTC.
- Return type: pd.Timestamp
- Type: OptionsContract.expiration_utc
static from_dict(dict values) → OptionsContract
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: OptionsContract
static from_pyo3(pyo3_instrument) → OptionsContract
Return legacy Cython options contract instrument converted from the given pyo3 Rust object.
- Parameters: pyo3_instrument (nautilus_pyo3.OptionsContract) – The pyo3 Rust options contract instrument to convert from.
- Return type: OptionsContract
option_kind
The option kind (PUT | CALL) for the contract.
- Returns: OptionKind
strike_price
The strike price for the contract.
- Returns: Price
static to_dict(OptionsContract obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
underlying
The underlying asset for the contract.
- Returns: str
class OptionsSpread
Bases: Instrument
OptionsSpread(InstrumentId instrument_id, Symbol raw_symbol, AssetClass asset_class, Currency currency, int price_precision, Price price_increment, Quantity multiplier, Quantity lot_size, unicode underlying, unicode strategy_type, uint64_t activation_ns, uint64_t expiration_ns, uint64_t ts_event, uint64_t ts_init, unicode exchange=None, dict info=None)
Represents a generic options spread instrument.
- Parameters:
- instrument_id (InstrumentId) – The instrument ID.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- asset_class (AssetClass) – The options contract asset class.
- currency (Currency) – The options contract currency.
- price_precision (int) – The price decimal precision.
- price_increment (Price) – The minimum price increment (tick size).
- multiplier (Quantity) – The option multiplier.
- lot_size (Quantity) – The rounded lot unit size (standard/board).
- underlying (str) – The underlying asset.
- strategy_type (str) – The strategy type of the spread.
- activation_ns (uint64_t) – UNIX timestamp (nanoseconds) for contract activation.
- expiration_ns (uint64_t) – UNIX timestamp (nanoseconds) for contract expiration.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- exchange (str , optional) – The exchange ISO 10383 Market Identifier Code (MIC) where the instrument trades.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If strategy_type is not a valid string.
- ValueError – If multiplier is not positive (> 0).
- ValueError – If price_precision is negative (< 0).
- ValueError – If tick_size is not positive (> 0).
- ValueError – If lot_size is not positive (> 0).
activation_ns
UNIX timestamp (nanoseconds) for contract activation.
- Returns: unit64_t
activation_utc
pd.Timestamp
Return the contract activation timestamp (UTC).
- Returns: tz-aware UTC.
- Return type: pd.Timestamp
- Type: OptionsSpread.activation_utc
exchange
The exchang ISO 10383 Market Identifier Code (MIC) where the instrument trades.
- Returns:
str or
None
expiration_ns
UNIX timestamp (nanoseconds) for contract expiration.
- Returns: unit64_t
expiration_utc
pd.Timestamp
Return the contract expriation timestamp (UTC).
- Returns: tz-aware UTC.
- Return type: pd.Timestamp
- Type: OptionsSpread.expiration_utc
static from_dict(dict values) → OptionsSpread
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: OptionsSpread
static from_pyo3(pyo3_instrument) → OptionsSpread
Return legacy Cython options contract instrument converted from the given pyo3 Rust object.
- Parameters: pyo3_instrument (nautilus_pyo3.OptionsSpread) – The pyo3 Rust options contract instrument to convert from.
- Return type: OptionsSpread
strategy_type
The strategy type of the spread.
- Returns: str
static to_dict(OptionsSpread obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
underlying
The underlying asset for the contract.
- Returns: str
class SyntheticInstrument
Bases: Data
SyntheticInstrument(Symbol symbol, uint8_t price_precision, list components, unicode formula, uint64_t ts_event, uint64_t ts_init)
Represents a synthetic instrument with prices derived from component instruments using a formula.
The id for the synthetic will become {symbol}.{SYNTH}.
- Parameters:
- symbol (Symbol) – The symbol for the synethic instrument.
- price_precision (uint8_t) – The price precision for the synthetic instrument.
- components (list [InstrumentId ]) – The component instruments for the synthetic instrument.
- formula (str) – The derivation formula for the synthetic instrument.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- Raises:
- ValueError – If price_precision is greater than 9.
- OverflowError – If price_precision is negative (< 0).
- ValueError – If the components list does not contain at least 2 instrument IDs.
- ValueError – If the formula is not a valid string.
- ValueError – If the formula is not a valid expression.
WARNING
All component instruments should already be defined and exist in the cache prior to defining a new synthetic instrument.
calculate(self, list inputs) → Price
Calculate the price of the synthetic instrument from the given inputs.
- Parameters: inputs (list *[*double ])
- Return type: Price
- Raises:
- ValueError – If inputs is empty, contains a NaN value, or length is different from components count.
- RuntimeError – If an internal error occurs when calculating the price.
change_formula(self, unicode formula) → void
Change the internal derivation formula for the synthetic instrument.
- Parameters: formula (str) – The derivation formula to change to.
- Raises:
- ValueError – If the formula is not a valid string.
- ValueError – If the formula is not a valid expression.
components
list[InstrumentId]
Return the components of the synthetic instrument.
- Return type: list[InstrumentId]
- Type: SyntheticInstrument.components
formula
str
Return the synthetic instrument internal derivation formula.
- Return type: str
- Type: SyntheticInstrument.formula
static from_dict(dict values) → SyntheticInstrument
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: SyntheticInstrument
id
The instrument ID.
- Returns: InstrumentId
price_increment
Price
Return the minimum price increment (tick size) for the synthetic instrument.
- Return type: Price
- Type: SyntheticInstrument.price_increment
price_precision
int
Return the precision for the synthetic instrument.
- Return type: int
- Type: SyntheticInstrument.price_precision
static to_dict(SyntheticInstrument obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
ts_event
int
UNIX timestamp (nanoseconds) when the data event occurred.
- Return type: int
- Type: SyntheticInstrument.ts_event
ts_init
int
UNIX timestamp (nanoseconds) when the object was initialized.
- Return type: int
- Type: SyntheticInstrument.ts_init
class BettingInstrument
Bases: Instrument
BettingInstrument(unicode venue_name, int event_type_id, unicode event_type_name, int competition_id, unicode competition_name, int event_id, unicode event_name, unicode event_country_code, datetime event_open_date, unicode betting_type, unicode market_id, unicode market_name, datetime market_start_time, unicode market_type, int selection_id, unicode selection_name, unicode currency, float selection_handicap, int8_t price_precision, int8_t size_precision, uint64_t ts_event, uint64_t ts_init, unicode tick_scheme_name=None, Price min_price=None, Price max_price=None, dict info=None)
Represents an instrument in a betting market.
asset_class
The asset class of the instrument.
- Returns: AssetClass
static base_from_dict(dict values) → Instrument
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: Instrument
static base_to_dict(Instrument obj)
Return a dictionary representation of this object.
- Return type: dict[str, object]
betting_type
calculate_base_quantity(self, Quantity quantity, Price last_px) → Quantity
Calculate the base asset quantity from the given quote asset quantity and last price.
- Parameters:
- Return type: Quantity
competition_id
competition_name
event_country_code
event_id
event_name
event_open_date
event_type_id
event_type_name
static from_dict(dict values) → BettingInstrument
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: BettingInstrument
classmethod fully_qualified_name(cls) → str
Return the fully qualified name for the Data class.
- Return type: str
get_base_currency(self) → Currency
Return the instruments base currency (if applicable).
- Return type:
Currency or
None
get_settlement_currency(self) → Currency
Return the currency used to settle a trade of the instrument.
- Standard linear instruments = quote_currency
- Inverse instruments = base_currency
- Quanto instruments = settlement_currency
- Return type: Currency
id
The instrument ID.
- Returns: InstrumentId
info
The raw info for the instrument.
- Returns: dict[str, object]
instrument_class
The class of the instrument.
- Returns: InstrumentClass
is_inverse
If the quantity is expressed in quote currency.
- Returns: Currency
classmethod is_signal(cls, unicode name=u'') → bool
Determine if the current class is a signal type, optionally checking for a specific signal name.
- Parameters: name (str , optional) – The specific signal name to check. If name not provided or if an empty string is passed, the method checks whether the class name indicates a general signal type. If name is provided, the method checks if the class name corresponds to that specific signal.
- Returns: True if the class name matches the signal type or the specific signal name, otherwise False.
- Return type: bool
lot_size
The rounded lot unit size (standard/board) for the instrument.
- Returns:
Quantity or
None
make_price(self, value) → Price
Return a new price from the given value using the instruments price precision.
- Parameters: value (integer , float , str or Decimal) – The value of the price.
- Return type: Price
make_qty(self, value) → Quantity
Return a new quantity from the given value using the instruments size precision.
- Parameters: value (integer , float , str or Decimal) – The value of the quantity.
- Return type: Quantity
- Raises: ValueError – If a non zero value is rounded to zero due to the instruments size increment or size precision.
maker_fee
The fee rate for liquidity makers as a percentage of order value (where 1.0 is 100%).
- Returns: Decimal
margin_init
The initial (order) margin rate for the instrument.
- Returns: Decimal
margin_maint
The maintenance (position) margin rate for the instrument.
- Returns: Decimal
market_id
market_name
market_start_time
market_type
max_notional
The maximum notional order value for the instrument.
- Returns:
Money or
None
max_price
The maximum printable price for the instrument.
- Returns:
Price or
None
max_quantity
The maximum order quantity for the instrument.
- Returns:
Quantity or
None
min_notional
The minimum notional order value for the instrument.
- Returns:
Money or
None
min_price
The minimum printable price for the instrument.
- Returns:
Price or
None
min_quantity
The minimum order quantity for the instrument.
- Returns:
Quantity or
None
multiplier
The contract multiplier for the instrument (determines tick value).
- Returns: Quantity
next_ask_price(self, double value, int num_ticks=0) → Price
Return the price n ask ticks away from value.
If a given price is between two ticks, n=0 will find the nearest ask tick.
- Parameters:
- value (double) – The reference value.
- num_ticks (int , default 0) – The number of ticks to move.
- Return type: Price
- Raises: ValueError – If a tick scheme is not initialized.
next_bid_price(self, double value, int num_ticks=0) → Price
Return the price n bid ticks away from value.
If a given price is between two ticks, n=0 will find the nearest bid tick.
- Parameters:
- value (double) – The reference value.
- num_ticks (int , default 0) – The number of ticks to move.
- Return type: Price
- Raises: ValueError – If a tick scheme is not initialized.
notional_value(self, Quantity quantity, Price price, bool use_quote_for_inverse=False) → Money
price_increment
The minimum price increment or tick size for the instrument.
- Returns: Price
price_precision
The price precision of the instrument.
- Returns: int
quote_currency
The quote currency for the instrument.
- Returns: Currency
raw_symbol
The raw/local/native symbol for the instrument, assigned by the venue.
- Returns: Symbol
selection_handicap
selection_id
selection_name
size_increment
The minimum size increment for the instrument.
- Returns: Quantity
size_precision
The size precision of the instrument.
- Returns: int
symbol
Return the instruments ticker symbol.
- Return type: Symbol
taker_fee
The fee rate for liquidity takers as a percentage of order value (where 1.0 is 100%).
- Returns: Decimal
tick_scheme_name
The tick scheme name.
- Returns:
str or
None
static to_dict(BettingInstrument obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
ts_event
UNIX timestamp (nanoseconds) when the data event occurred.
- Returns: uint64_t
ts_init
UNIX timestamp (nanoseconds) when the object was initialized.
- Returns: uint64_t
venue
Return the instruments trading venue.
- Return type: Venue
make_symbol(unicode market_id, int selection_id, float selection_handicap) → Symbol
Make symbol.
>>> make_symbol(market_id="1.201070830", selection_id=123456, selection_handicap=null_handicap())
Symbol('1-201070830-123456-None')
null_handicap() → double
class CryptoPerpetual
Bases: Instrument
CryptoPerpetual(InstrumentId instrument_id, Symbol raw_symbol, Currency base_currency, Currency quote_currency, Currency settlement_currency, bool is_inverse, int price_precision, int size_precision, Price price_increment, Quantity size_increment, margin_init: Decimal, margin_maint: Decimal, maker_fee: Decimal, taker_fee: Decimal, uint64_t ts_event, uint64_t ts_init, multiplier=Quantity.from_int_c(1), Quantity max_quantity: Quantity | None = None, Quantity min_quantity: Quantity | None = None, Money max_notional: Money | None = None, Money min_notional: Money | None = None, Price max_price: Price | None = None, Price min_price: Price | None = None, dict info=None)
Represents a crypto perpetual futures contract instrument (a.k.a. perpetual swap).
- Parameters:
- instrument_id (InstrumentId) – The instrument ID for the instrument.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- base_currency (Currency , optional) – The base currency.
- quote_currency (Currency) – The quote currency.
- settlement_currency (Currency) – The settlement currency.
- is_inverse (bool) – If the instrument costing is inverse (quantity expressed in quote currency units).
- price_precision (int) – The price decimal precision.
- size_precision (int) – The trading size decimal precision.
- price_increment (Price) – The minimum price increment (tick size).
- size_increment (Quantity) – The minimum size increment.
- margin_init (Decimal) – The initial (order) margin requirement in percentage of order value.
- margin_maint (Decimal) – The maintenance (position) margin in percentage of position value.
- maker_fee (Decimal) – The fee rate for liquidity makers as a percentage of order value.
- taker_fee (Decimal) – The fee rate for liquidity takers as a percentage of order value.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- multiplier (Quantity , default 1) – The contract multiplier.
- max_quantity (Quantity , optional) – The maximum allowable order quantity.
- min_quantity (Quantity , optional) – The minimum allowable order quantity.
- max_notional (Money , optional) – The maximum allowable order notional value.
- min_notional (Money , optional) – The minimum allowable order notional value.
- max_price (Price , optional) – The maximum allowable quoted price.
- min_price (Price , optional) – The minimum allowable quoted price.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If price_precision is negative (< 0).
- ValueError – If size_precision is negative (< 0).
- ValueError – If price_increment is not positive (> 0).
- ValueError – If size_increment is not positive (> 0).
- ValueError – If price_precision is not equal to price_increment.precision.
- ValueError – If size_increment is not equal to size_increment.precision.
- ValueError – If multiplier is not positive (> 0).
- ValueError – If max_quantity is not positive (> 0).
- ValueError – If min_quantity is negative (< 0).
- ValueError – If max_notional is not positive (> 0).
- ValueError – If min_notional is negative (< 0).
- ValueError – If max_price is not positive (> 0).
- ValueError – If min_price is negative (< 0).
asset_class
The asset class of the instrument.
- Returns: AssetClass
base_currency
The base currency for the instrument.
- Returns: Currency
static base_from_dict(dict values) → Instrument
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: Instrument
static base_to_dict(Instrument obj)
Return a dictionary representation of this object.
- Return type: dict[str, object]
calculate_base_quantity(self, Quantity quantity, Price last_px) → Quantity
Calculate the base asset quantity from the given quote asset quantity and last price.
- Parameters:
- Return type: Quantity
static from_dict(dict values) → CryptoPerpetual
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: CryptoPerpetual
static from_pyo3(pyo3_instrument)
classmethod fully_qualified_name(cls) → str
Return the fully qualified name for the Data class.
- Return type: str
get_base_currency(self) → Currency
Return the instruments base currency.
- Return type: Currency
get_settlement_currency(self) → Currency
Return the currency used to settle a trade of the instrument.
- Standard linear instruments = quote_currency
- Inverse instruments = base_currency
- Quanto instruments = settlement_currency
- Return type: Currency
id
The instrument ID.
- Returns: InstrumentId
info
The raw info for the instrument.
- Returns: dict[str, object]
instrument_class
The class of the instrument.
- Returns: InstrumentClass
is_inverse
If the quantity is expressed in quote currency.
- Returns: Currency
is_quanto
If the instrument is quanto.
- Returns: bool
classmethod is_signal(cls, unicode name=u'') → bool
Determine if the current class is a signal type, optionally checking for a specific signal name.
- Parameters: name (str , optional) – The specific signal name to check. If name not provided or if an empty string is passed, the method checks whether the class name indicates a general signal type. If name is provided, the method checks if the class name corresponds to that specific signal.
- Returns: True if the class name matches the signal type or the specific signal name, otherwise False.
- Return type: bool
lot_size
The rounded lot unit size (standard/board) for the instrument.
- Returns:
Quantity or
None
make_price(self, value) → Price
Return a new price from the given value using the instruments price precision.
- Parameters: value (integer , float , str or Decimal) – The value of the price.
- Return type: Price
make_qty(self, value) → Quantity
Return a new quantity from the given value using the instruments size precision.
- Parameters: value (integer , float , str or Decimal) – The value of the quantity.
- Return type: Quantity
- Raises: ValueError – If a non zero value is rounded to zero due to the instruments size increment or size precision.
maker_fee
The fee rate for liquidity makers as a percentage of order value (where 1.0 is 100%).
- Returns: Decimal
margin_init
The initial (order) margin rate for the instrument.
- Returns: Decimal
margin_maint
The maintenance (position) margin rate for the instrument.
- Returns: Decimal
max_notional
The maximum notional order value for the instrument.
- Returns:
Money or
None
max_price
The maximum printable price for the instrument.
- Returns:
Price or
None
max_quantity
The maximum order quantity for the instrument.
- Returns:
Quantity or
None
min_notional
The minimum notional order value for the instrument.
- Returns:
Money or
None
min_price
The minimum printable price for the instrument.
- Returns:
Price or
None
min_quantity
The minimum order quantity for the instrument.
- Returns:
Quantity or
None
multiplier
The contract multiplier for the instrument (determines tick value).
- Returns: Quantity
next_ask_price(self, double value, int num_ticks=0) → Price
Return the price n ask ticks away from value.
If a given price is between two ticks, n=0 will find the nearest ask tick.
- Parameters:
- value (double) – The reference value.
- num_ticks (int , default 0) – The number of ticks to move.
- Return type: Price
- Raises: ValueError – If a tick scheme is not initialized.
next_bid_price(self, double value, int num_ticks=0) → Price
Return the price n bid ticks away from value.
If a given price is between two ticks, n=0 will find the nearest bid tick.
- Parameters:
- value (double) – The reference value.
- num_ticks (int , default 0) – The number of ticks to move.
- Return type: Price
- Raises: ValueError – If a tick scheme is not initialized.
notional_value(self, Quantity quantity, Price price, bool use_quote_for_inverse=False) → Money
Calculate the notional value.
Result will be in quote currency for standard instruments, or base currency for inverse instruments.
- Parameters:
- Return type: Money
price_increment
The minimum price increment or tick size for the instrument.
- Returns: Price
price_precision
The price precision of the instrument.
- Returns: int
quote_currency
The quote currency for the instrument.
- Returns: Currency
raw_symbol
The raw/local/native symbol for the instrument, assigned by the venue.
- Returns: Symbol
settlement_currency
The settlement currency for the instrument.
- Returns: Currency
size_increment
The minimum size increment for the instrument.
- Returns: Quantity
size_precision
The size precision of the instrument.
- Returns: int
symbol
Return the instruments ticker symbol.
- Return type: Symbol
taker_fee
The fee rate for liquidity takers as a percentage of order value (where 1.0 is 100%).
- Returns: Decimal
tick_scheme_name
The tick scheme name.
- Returns:
str or
None
static to_dict(CryptoPerpetual obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
ts_event
UNIX timestamp (nanoseconds) when the data event occurred.
- Returns: uint64_t
ts_init
UNIX timestamp (nanoseconds) when the object was initialized.
- Returns: uint64_t
venue
Return the instruments trading venue.
- Return type: Venue
class CryptoFuture
Bases: Instrument
CryptoFuture(InstrumentId instrument_id, Symbol raw_symbol, Currency underlying, Currency quote_currency, Currency settlement_currency, bool is_inverse, uint64_t activation_ns, uint64_t expiration_ns, int price_precision, int size_precision, Price price_increment, Quantity size_increment, margin_init: Decimal, margin_maint: Decimal, maker_fee: Decimal, taker_fee: Decimal, uint64_t ts_event, uint64_t ts_init, multiplier=Quantity.from_int_c(1), lot_size=Quantity.from_int_c(1), Quantity max_quantity: Quantity | None = None, Quantity min_quantity: Quantity | None = None, Money max_notional: Money | None = None, Money min_notional: Money | None = None, Price max_price: Price | None = None, Price min_price: Price | None = None, dict info=None)
Represents a deliverable futures contract instrument, with crypto assets as underlying and for settlement.
- Parameters:
- instrument_id (InstrumentId) – The instrument ID for the instrument.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- underlying (Currency) – The underlying asset.
- quote_currency (Currency) – The contract quote currency.
- settlement_currency (Currency) – The settlement currency.
- is_inverse (bool) – If the instrument costing is inverse (quantity expressed in quote currency units).
- activation_ns (uint64_t) – UNIX timestamp (nanoseconds) for contract activation.
- expiration_ns (uint64_t) – UNIX timestamp (nanoseconds) for contract expiration.
- price_precision (int) – The price decimal precision.
- size_precision (int) – The trading size decimal precision.
- price_increment (Price) – The minimum price increment (tick size).
- size_increment (Quantity) – The minimum size increment.
- margin_init (Decimal) – The initial (order) margin requirement in percentage of order value.
- margin_maint (Decimal) – The maintenance (position) margin in percentage of position value.
- maker_fee (Decimal) – The fee rate for liquidity makers as a percentage of order value.
- taker_fee (Decimal) – The fee rate for liquidity takers as a percentage of order value.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- multiplier (Quantity , default 1) – The contract multiplier.
- lot_size (Quantity) – The rounded lot unit size (standard/board).
- max_quantity (Quantity , optional) – The maximum allowable order quantity.
- min_quantity (Quantity , optional) – The minimum allowable order quantity.
- max_notional (Money , optional) – The maximum allowable order notional value.
- min_notional (Money , optional) – The minimum allowable order notional value.
- max_price (Price , optional) – The maximum allowable quoted price.
- min_price (Price , optional) – The minimum allowable quoted price.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If price_precision is negative (< 0).
- ValueError – If size_precision is negative (< 0).
- ValueError – If price_increment is not positive (> 0).
- ValueError – If size_increment is not positive (> 0).
- ValueError – If price_precision is not equal to price_increment.precision.
- ValueError – If size_increment is not equal to size_increment.precision.
- ValueError – If lot size is not positive (> 0).
- ValueError – If max_quantity is not positive (> 0).
- ValueError – If min_quantity is negative (< 0).
- ValueError – If max_notional is not positive (> 0).
- ValueError – If min_notional is negative (< 0).
- ValueError – If max_price is not positive (> 0).
- ValueError – If min_price is negative (< 0).
activation_ns
UNIX timestamp (nanoseconds) for contract activation.
- Returns: unit64_t
activation_utc
pd.Timestamp
Return the contract activation timestamp (UTC).
- Returns: tz-aware UTC.
- Return type: pd.Timestamp
- Type: CryptoFuture.activation_utc
asset_class
The asset class of the instrument.
- Returns: AssetClass
static base_from_dict(dict values) → Instrument
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: Instrument
static base_to_dict(Instrument obj)
Return a dictionary representation of this object.
- Return type: dict[str, object]
calculate_base_quantity(self, Quantity quantity, Price last_px) → Quantity
Calculate the base asset quantity from the given quote asset quantity and last price.
- Parameters:
- Return type: Quantity
expiration_ns
UNIX timestamp (nanoseconds) for contract expiration.
- Returns: unit64_t
expiration_utc
pd.Timestamp
Return the contract expriation timestamp (UTC).
- Returns: tz-aware UTC.
- Return type: pd.Timestamp
- Type: CryptoFuture.expiration_utc
static from_dict(dict values) → CryptoFuture
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: CryptoFuture
static from_pyo3(pyo3_instrument)
classmethod fully_qualified_name(cls) → str
Return the fully qualified name for the Data class.
- Return type: str
get_base_currency(self) → Currency
Return the instruments base currency.
- Return type: Currency
get_settlement_currency(self) → Currency
Return the currency used to settle a trade of the instrument.
- Standard linear instruments = quote_currency
- Inverse instruments = base_currency
- Quanto instruments = settlement_currency
- Return type: Currency
id
The instrument ID.
- Returns: InstrumentId
info
The raw info for the instrument.
- Returns: dict[str, object]
instrument_class
The class of the instrument.
- Returns: InstrumentClass
is_inverse
If the quantity is expressed in quote currency.
- Returns: Currency
classmethod is_signal(cls, unicode name=u'') → bool
Determine if the current class is a signal type, optionally checking for a specific signal name.
- Parameters: name (str , optional) – The specific signal name to check. If name not provided or if an empty string is passed, the method checks whether the class name indicates a general signal type. If name is provided, the method checks if the class name corresponds to that specific signal.
- Returns: True if the class name matches the signal type or the specific signal name, otherwise False.
- Return type: bool
lot_size
The rounded lot unit size (standard/board) for the instrument.
- Returns:
Quantity or
None
make_price(self, value) → Price
Return a new price from the given value using the instruments price precision.
- Parameters: value (integer , float , str or Decimal) – The value of the price.
- Return type: Price
make_qty(self, value) → Quantity
Return a new quantity from the given value using the instruments size precision.
- Parameters: value (integer , float , str or Decimal) – The value of the quantity.
- Return type: Quantity
- Raises: ValueError – If a non zero value is rounded to zero due to the instruments size increment or size precision.
maker_fee
The fee rate for liquidity makers as a percentage of order value (where 1.0 is 100%).
- Returns: Decimal
margin_init
The initial (order) margin rate for the instrument.
- Returns: Decimal
margin_maint
The maintenance (position) margin rate for the instrument.
- Returns: Decimal
max_notional
The maximum notional order value for the instrument.
- Returns:
Money or
None
max_price
The maximum printable price for the instrument.
- Returns:
Price or
None
max_quantity
The maximum order quantity for the instrument.
- Returns:
Quantity or
None
min_notional
The minimum notional order value for the instrument.
- Returns:
Money or
None
min_price
The minimum printable price for the instrument.
- Returns:
Price or
None
min_quantity
The minimum order quantity for the instrument.
- Returns:
Quantity or
None
multiplier
The contract multiplier for the instrument (determines tick value).
- Returns: Quantity
next_ask_price(self, double value, int num_ticks=0) → Price
Return the price n ask ticks away from value.
If a given price is between two ticks, n=0 will find the nearest ask tick.
- Parameters:
- value (double) – The reference value.
- num_ticks (int , default 0) – The number of ticks to move.
- Return type: Price
- Raises: ValueError – If a tick scheme is not initialized.
next_bid_price(self, double value, int num_ticks=0) → Price
Return the price n bid ticks away from value.
If a given price is between two ticks, n=0 will find the nearest bid tick.
- Parameters:
- value (double) – The reference value.
- num_ticks (int , default 0) – The number of ticks to move.
- Return type: Price
- Raises: ValueError – If a tick scheme is not initialized.
notional_value(self, Quantity quantity, Price price, bool use_quote_for_inverse=False) → Money
Calculate the notional value.
Result will be in quote currency for standard instruments, or base currency for inverse instruments.
- Parameters:
- Return type: Money
price_increment
The minimum price increment or tick size for the instrument.
- Returns: Price
price_precision
The price precision of the instrument.
- Returns: int
quote_currency
The quote currency for the instrument.
- Returns: Currency
raw_symbol
The raw/local/native symbol for the instrument, assigned by the venue.
- Returns: Symbol
settlement_currency
The settlement currency for the contract.
- Returns: Currency
size_increment
The minimum size increment for the instrument.
- Returns: Quantity
size_precision
The size precision of the instrument.
- Returns: int
symbol
Return the instruments ticker symbol.
- Return type: Symbol
taker_fee
The fee rate for liquidity takers as a percentage of order value (where 1.0 is 100%).
- Returns: Decimal
tick_scheme_name
The tick scheme name.
- Returns:
str or
None
static to_dict(CryptoFuture obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
ts_event
UNIX timestamp (nanoseconds) when the data event occurred.
- Returns: uint64_t
ts_init
UNIX timestamp (nanoseconds) when the object was initialized.
- Returns: uint64_t
underlying
The underlying asset for the contract.
- Returns: Currency
venue
Return the instruments trading venue.
- Return type: Venue
class CurrencyPair
Bases: Instrument
CurrencyPair(InstrumentId instrument_id, Symbol raw_symbol, Currency base_currency, Currency quote_currency, int price_precision, int size_precision, Price price_increment, Quantity size_increment, margin_init: Decimal, margin_maint: Decimal, maker_fee: Decimal, taker_fee: Decimal, uint64_t ts_event, uint64_t ts_init, Quantity lot_size: Quantity | None = None, Quantity max_quantity: Quantity | None = None, Quantity min_quantity: Quantity | None = None, Money max_notional: Money | None = None, Money min_notional: Money | None = None, Price max_price: Price | None = None, Price min_price: Price | None = None, unicode tick_scheme_name=None, dict info=None)
Represents a generic currency pair instrument in a spot/cash market.
Can represent both Fiat FX and Cryptocurrency pairs.
- Parameters:
- instrument_id (InstrumentId) – The instrument ID for the instrument.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- base_currency (Currency) – The base currency.
- quote_currency (Currency) – The quote currency.
- price_precision (int) – The price decimal precision.
- size_precision (int) – The trading size decimal precision.
- price_increment (Price) – The minimum price increment (tick size).
- size_increment (Quantity) – The minimum size increment.
- margin_init (Decimal) – The initial (order) margin requirement in percentage of order value.
- margin_maint (Decimal) – The maintenance (position) margin in percentage of position value.
- maker_fee (Decimal) – The fee rate for liquidity makers as a percentage of order value.
- taker_fee (Decimal) – The fee rate for liquidity takers as a percentage of order value.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- lot_size (Quantity , optional) – The rounded lot unit size.
- max_quantity (Quantity , optional) – The maximum allowable order quantity.
- min_quantity (Quantity , optional) – The minimum allowable order quantity.
- max_notional (Money , optional) – The maximum allowable order notional value.
- min_notional (Money , optional) – The minimum allowable order notional value.
- max_price (Price , optional) – The maximum allowable quoted price.
- min_price (Price , optional) – The minimum allowable quoted price.
- tick_scheme_name (str , optional) – The name of the tick scheme.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If tick_scheme_name is not a valid string.
- ValueError – If price_precision is negative (< 0).
- ValueError – If size_precision is negative (< 0).
- ValueError – If price_increment is not positive (> 0).
- ValueError – If size_increment is not positive (> 0).
- ValueError – If price_precision is not equal to price_increment.precision.
- ValueError – If size_increment is not equal to size_increment.precision.
- ValueError – If lot_size is not positive (> 0).
- ValueError – If max_quantity is not positive (> 0).
- ValueError – If min_quantity is negative (< 0).
- ValueError – If max_notional is not positive (> 0).
- ValueError – If min_notional is negative (< 0).
- ValueError – If max_price is not positive (> 0).
- ValueError – If min_price is negative (< 0).
asset_class
The asset class of the instrument.
- Returns: AssetClass
base_currency
The base currency for the instrument.
- Returns: Currency
static base_from_dict(dict values) → Instrument
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: Instrument
static base_to_dict(Instrument obj)
Return a dictionary representation of this object.
- Return type: dict[str, object]
calculate_base_quantity(self, Quantity quantity, Price last_px) → Quantity
Calculate the base asset quantity from the given quote asset quantity and last price.
- Parameters:
- Return type: Quantity
static from_dict(dict values) → CurrencyPair
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: CurrencyPair
static from_pyo3(pyo3_instrument)
classmethod fully_qualified_name(cls) → str
Return the fully qualified name for the Data class.
- Return type: str
get_base_currency(self) → Currency
Return the instruments base currency.
- Return type: Currency
get_settlement_currency(self) → Currency
Return the currency used to settle a trade of the instrument.
- Standard linear instruments = quote_currency
- Inverse instruments = base_currency
- Quanto instruments = settlement_currency
- Return type: Currency
id
The instrument ID.
- Returns: InstrumentId
info
The raw info for the instrument.
- Returns: dict[str, object]
instrument_class
The class of the instrument.
- Returns: InstrumentClass
is_inverse
If the quantity is expressed in quote currency.
- Returns: Currency
classmethod is_signal(cls, unicode name=u'') → bool
Determine if the current class is a signal type, optionally checking for a specific signal name.
- Parameters: name (str , optional) – The specific signal name to check. If name not provided or if an empty string is passed, the method checks whether the class name indicates a general signal type. If name is provided, the method checks if the class name corresponds to that specific signal.
- Returns: True if the class name matches the signal type or the specific signal name, otherwise False.
- Return type: bool
lot_size
The rounded lot unit size (standard/board) for the instrument.
- Returns:
Quantity or
None
make_price(self, value) → Price
Return a new price from the given value using the instruments price precision.
- Parameters: value (integer , float , str or Decimal) – The value of the price.
- Return type: Price
make_qty(self, value) → Quantity
Return a new quantity from the given value using the instruments size precision.
- Parameters: value (integer , float , str or Decimal) – The value of the quantity.
- Return type: Quantity
- Raises: ValueError – If a non zero value is rounded to zero due to the instruments size increment or size precision.
maker_fee
The fee rate for liquidity makers as a percentage of order value (where 1.0 is 100%).
- Returns: Decimal
margin_init
The initial (order) margin rate for the instrument.
- Returns: Decimal
margin_maint
The maintenance (position) margin rate for the instrument.
- Returns: Decimal
max_notional
The maximum notional order value for the instrument.
- Returns:
Money or
None
max_price
The maximum printable price for the instrument.
- Returns:
Price or
None
max_quantity
The maximum order quantity for the instrument.
- Returns:
Quantity or
None
min_notional
The minimum notional order value for the instrument.
- Returns:
Money or
None
min_price
The minimum printable price for the instrument.
- Returns:
Price or
None
min_quantity
The minimum order quantity for the instrument.
- Returns:
Quantity or
None
multiplier
The contract multiplier for the instrument (determines tick value).
- Returns: Quantity
next_ask_price(self, double value, int num_ticks=0) → Price
Return the price n ask ticks away from value.
If a given price is between two ticks, n=0 will find the nearest ask tick.
- Parameters:
- value (double) – The reference value.
- num_ticks (int , default 0) – The number of ticks to move.
- Return type: Price
- Raises: ValueError – If a tick scheme is not initialized.
next_bid_price(self, double value, int num_ticks=0) → Price
Return the price n bid ticks away from value.
If a given price is between two ticks, n=0 will find the nearest bid tick.
- Parameters:
- value (double) – The reference value.
- num_ticks (int , default 0) – The number of ticks to move.
- Return type: Price
- Raises: ValueError – If a tick scheme is not initialized.
notional_value(self, Quantity quantity, Price price, bool use_quote_for_inverse=False) → Money
Calculate the notional value.
Result will be in quote currency for standard instruments, or base currency for inverse instruments.
- Parameters:
- Return type: Money
price_increment
The minimum price increment or tick size for the instrument.
- Returns: Price
price_precision
The price precision of the instrument.
- Returns: int
quote_currency
The quote currency for the instrument.
- Returns: Currency
raw_symbol
The raw/local/native symbol for the instrument, assigned by the venue.
- Returns: Symbol
size_increment
The minimum size increment for the instrument.
- Returns: Quantity
size_precision
The size precision of the instrument.
- Returns: int
symbol
Return the instruments ticker symbol.
- Return type: Symbol
taker_fee
The fee rate for liquidity takers as a percentage of order value (where 1.0 is 100%).
- Returns: Decimal
tick_scheme_name
The tick scheme name.
- Returns:
str or
None
static to_dict(CurrencyPair obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
ts_event
UNIX timestamp (nanoseconds) when the data event occurred.
- Returns: uint64_t
ts_init
UNIX timestamp (nanoseconds) when the object was initialized.
- Returns: uint64_t
venue
Return the instruments trading venue.
- Return type: Venue
class Equity
Bases: Instrument
Equity(InstrumentId instrument_id, Symbol raw_symbol, Currency currency, int price_precision, Price price_increment, Quantity lot_size, uint64_t ts_event, uint64_t ts_init, unicode isin: str | None = None, margin_init: Decimal | None = None, margin_maint: Decimal | None = None, maker_fee: Decimal | None = None, taker_fee: Decimal | None = None, max_quantity: Quantity | None = None, min_quantity: Quantity | None = None, dict info=None)
Represents a generic equity instrument.
- Parameters:
- instrument_id (InstrumentId) – The instrument ID.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- currency (Currency) – The futures contract currency.
- price_precision (int) – The price decimal precision.
- price_increment (Decimal) – The minimum price increment (tick size).
- lot_size (Quantity) – The rounded lot unit size (standard/board).
- isin (str , optional) – The instruments International Securities Identification Number (ISIN).
- margin_init (Decimal , optional) – The initial (order) margin requirement in percentage of order value.
- margin_maint (Decimal , optional) – The maintenance (position) margin in percentage of position value.
- maker_fee (Decimal , optional) – The fee rate for liquidity makers as a percentage of order value.
- taker_fee (Decimal , optional) – The fee rate for liquidity takers as a percentage of order value.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If price_precision is negative (< 0).
- ValueError – If price_increment is not positive (> 0).
- ValueError – If lot_size is not positive (> 0).
- ValueError – If isin is not
Noneand not a valid string.
asset_class
The asset class of the instrument.
- Returns: AssetClass
static base_from_dict(dict values) → Instrument
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: Instrument
static base_to_dict(Instrument obj)
Return a dictionary representation of this object.
- Return type: dict[str, object]
calculate_base_quantity(self, Quantity quantity, Price last_px) → Quantity
Calculate the base asset quantity from the given quote asset quantity and last price.
- Parameters:
- Return type: Quantity
static from_dict(dict values) → Instrument
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: Equity
static from_pyo3(pyo3_instrument) → Equity
Return legacy Cython equity instrument converted from the given pyo3 Rust object.
- Parameters: pyo3_instrument (nautilus_pyo3.Equity) – The pyo3 Rust equity instrument to convert from.
- Return type: Equity
classmethod fully_qualified_name(cls) → str
Return the fully qualified name for the Data class.
- Return type: str
get_base_currency(self) → Currency
Return the instruments base currency (if applicable).
- Return type:
Currency or
None
get_settlement_currency(self) → Currency
Return the currency used to settle a trade of the instrument.
- Standard linear instruments = quote_currency
- Inverse instruments = base_currency
- Quanto instruments = settlement_currency
- Return type: Currency
id
The instrument ID.
- Returns: InstrumentId
info
The raw info for the instrument.
- Returns: dict[str, object]
instrument_class
The class of the instrument.
- Returns: InstrumentClass
is_inverse
If the quantity is expressed in quote currency.
- Returns: Currency
classmethod is_signal(cls, unicode name=u'') → bool
Determine if the current class is a signal type, optionally checking for a specific signal name.
- Parameters: name (str , optional) – The specific signal name to check. If name not provided or if an empty string is passed, the method checks whether the class name indicates a general signal type. If name is provided, the method checks if the class name corresponds to that specific signal.
- Returns: True if the class name matches the signal type or the specific signal name, otherwise False.
- Return type: bool
isin
The instruments International Securities Identification Number (ISIN).
- Returns:
str or
None
lot_size
The rounded lot unit size (standard/board) for the instrument.
- Returns:
Quantity or
None
make_price(self, value) → Price
Return a new price from the given value using the instruments price precision.
- Parameters: value (integer , float , str or Decimal) – The value of the price.
- Return type: Price
make_qty(self, value) → Quantity
Return a new quantity from the given value using the instruments size precision.
- Parameters: value (integer , float , str or Decimal) – The value of the quantity.
- Return type: Quantity
- Raises: ValueError – If a non zero value is rounded to zero due to the instruments size increment or size precision.
maker_fee
The fee rate for liquidity makers as a percentage of order value (where 1.0 is 100%).
- Returns: Decimal
margin_init
The initial (order) margin rate for the instrument.
- Returns: Decimal
margin_maint
The maintenance (position) margin rate for the instrument.
- Returns: Decimal
max_notional
The maximum notional order value for the instrument.
- Returns:
Money or
None
max_price
The maximum printable price for the instrument.
- Returns:
Price or
None
max_quantity
The maximum order quantity for the instrument.
- Returns:
Quantity or
None
min_notional
The minimum notional order value for the instrument.
- Returns:
Money or
None
min_price
The minimum printable price for the instrument.
- Returns:
Price or
None
min_quantity
The minimum order quantity for the instrument.
- Returns:
Quantity or
None
multiplier
The contract multiplier for the instrument (determines tick value).
- Returns: Quantity
next_ask_price(self, double value, int num_ticks=0) → Price
Return the price n ask ticks away from value.
If a given price is between two ticks, n=0 will find the nearest ask tick.
- Parameters:
- value (double) – The reference value.
- num_ticks (int , default 0) – The number of ticks to move.
- Return type: Price
- Raises: ValueError – If a tick scheme is not initialized.
next_bid_price(self, double value, int num_ticks=0) → Price
Return the price n bid ticks away from value.
If a given price is between two ticks, n=0 will find the nearest bid tick.
- Parameters:
- value (double) – The reference value.
- num_ticks (int , default 0) – The number of ticks to move.
- Return type: Price
- Raises: ValueError – If a tick scheme is not initialized.
notional_value(self, Quantity quantity, Price price, bool use_quote_for_inverse=False) → Money
Calculate the notional value.
Result will be in quote currency for standard instruments, or base currency for inverse instruments.
- Parameters:
- Return type: Money
price_increment
The minimum price increment or tick size for the instrument.
- Returns: Price
price_precision
The price precision of the instrument.
- Returns: int
quote_currency
The quote currency for the instrument.
- Returns: Currency
raw_symbol
The raw/local/native symbol for the instrument, assigned by the venue.
- Returns: Symbol
size_increment
The minimum size increment for the instrument.
- Returns: Quantity
size_precision
The size precision of the instrument.
- Returns: int
symbol
Return the instruments ticker symbol.
- Return type: Symbol
taker_fee
The fee rate for liquidity takers as a percentage of order value (where 1.0 is 100%).
- Returns: Decimal
tick_scheme_name
The tick scheme name.
- Returns:
str or
None
static to_dict(Instrument obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
ts_event
UNIX timestamp (nanoseconds) when the data event occurred.
- Returns: uint64_t
ts_init
UNIX timestamp (nanoseconds) when the object was initialized.
- Returns: uint64_t
venue
Return the instruments trading venue.
- Return type: Venue
class FuturesContract
Bases: Instrument
FuturesContract(InstrumentId instrument_id, Symbol raw_symbol, AssetClass asset_class, Currency currency, int price_precision, Price price_increment, Quantity multiplier, Quantity lot_size, unicode underlying, uint64_t activation_ns, uint64_t expiration_ns, uint64_t ts_event, uint64_t ts_init, unicode exchange=None, dict info=None)
Represents a generic deliverable futures contract instrument.
- Parameters:
- instrument_id (InstrumentId) – The instrument ID.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- asset_class (AssetClass) – The futures contract asset class.
- currency (Currency) – The futures contract currency.
- price_precision (int) – The price decimal precision.
- price_increment (Decimal) – The minimum price increment (tick size).
- multiplier (Quantity) – The contract multiplier.
- lot_size (Quantity) – The rounded lot unit size (standard/board).
- underlying (str) – The underlying asset.
- activation_ns (uint64_t) – UNIX timestamp (nanoseconds) for contract activation.
- expiration_ns (uint64_t) – UNIX timestamp (nanoseconds) for contract expiration.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- exchange (str , optional) – The exchange ISO 10383 Market Identifier Code (MIC) where the instrument trades.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If multiplier is not positive (> 0).
- ValueError – If price_precision is negative (< 0).
- ValueError – If tick_size is not positive (> 0).
- ValueError – If lot_size is not positive (> 0).
- ValueError – If exchange is not
Noneand not a valid string.
activation_ns
UNIX timestamp (nanoseconds) for contract activation.
- Returns: unit64_t
activation_utc
pd.Timestamp
Return the contract activation timestamp (UTC).
- Returns: tz-aware UTC.
- Return type: pd.Timestamp
- Type: FuturesContract.activation_utc
asset_class
The asset class of the instrument.
- Returns: AssetClass
static base_from_dict(dict values) → Instrument
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: Instrument
static base_to_dict(Instrument obj)
Return a dictionary representation of this object.
- Return type: dict[str, object]
calculate_base_quantity(self, Quantity quantity, Price last_px) → Quantity
Calculate the base asset quantity from the given quote asset quantity and last price.
- Parameters:
- Return type: Quantity
exchange
The exchange ISO 10383 Market Identifier Code (MIC) where the instrument trades.
- Returns:
str or
None
expiration_ns
UNIX timestamp (nanoseconds) for contract expiration.
- Returns: unit64_t
expiration_utc
pd.Timestamp
Return the contract expriation timestamp (UTC).
- Returns: tz-aware UTC.
- Return type: pd.Timestamp
- Type: FuturesContract.expiration_utc
static from_dict(dict values) → FuturesContract
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: FuturesContract
static from_pyo3(pyo3_instrument) → FuturesContract
Return legacy Cython futures contract instrument converted from the given pyo3 Rust object.
- Parameters: pyo3_instrument (nautilus_pyo3.FuturesContract) – The pyo3 Rust futures contract instrument to convert from.
- Return type: FuturesContract
classmethod fully_qualified_name(cls) → str
Return the fully qualified name for the Data class.
- Return type: str
get_base_currency(self) → Currency
Return the instruments base currency (if applicable).
- Return type:
Currency or
None
get_settlement_currency(self) → Currency
Return the currency used to settle a trade of the instrument.
- Standard linear instruments = quote_currency
- Inverse instruments = base_currency
- Quanto instruments = settlement_currency
- Return type: Currency
id
The instrument ID.
- Returns: InstrumentId
info
The raw info for the instrument.
- Returns: dict[str, object]
instrument_class
The class of the instrument.
- Returns: InstrumentClass
is_inverse
If the quantity is expressed in quote currency.
- Returns: Currency
classmethod is_signal(cls, unicode name=u'') → bool
Determine if the current class is a signal type, optionally checking for a specific signal name.
- Parameters: name (str , optional) – The specific signal name to check. If name not provided or if an empty string is passed, the method checks whether the class name indicates a general signal type. If name is provided, the method checks if the class name corresponds to that specific signal.
- Returns: True if the class name matches the signal type or the specific signal name, otherwise False.
- Return type: bool
lot_size
The rounded lot unit size (standard/board) for the instrument.
- Returns:
Quantity or
None
make_price(self, value) → Price
Return a new price from the given value using the instruments price precision.
- Parameters: value (integer , float , str or Decimal) – The value of the price.
- Return type: Price
make_qty(self, value) → Quantity
Return a new quantity from the given value using the instruments size precision.
- Parameters: value (integer , float , str or Decimal) – The value of the quantity.
- Return type: Quantity
- Raises: ValueError – If a non zero value is rounded to zero due to the instruments size increment or size precision.
maker_fee
The fee rate for liquidity makers as a percentage of order value (where 1.0 is 100%).
- Returns: Decimal
margin_init
The initial (order) margin rate for the instrument.
- Returns: Decimal
margin_maint
The maintenance (position) margin rate for the instrument.
- Returns: Decimal
max_notional
The maximum notional order value for the instrument.
- Returns:
Money or
None
max_price
The maximum printable price for the instrument.
- Returns:
Price or
None
max_quantity
The maximum order quantity for the instrument.
- Returns:
Quantity or
None
min_notional
The minimum notional order value for the instrument.
- Returns:
Money or
None
min_price
The minimum printable price for the instrument.
- Returns:
Price or
None
min_quantity
The minimum order quantity for the instrument.
- Returns:
Quantity or
None
multiplier
The contract multiplier for the instrument (determines tick value).
- Returns: Quantity
next_ask_price(self, double value, int num_ticks=0) → Price
Return the price n ask ticks away from value.
If a given price is between two ticks, n=0 will find the nearest ask tick.
- Parameters:
- value (double) – The reference value.
- num_ticks (int , default 0) – The number of ticks to move.
- Return type: Price
- Raises: ValueError – If a tick scheme is not initialized.
next_bid_price(self, double value, int num_ticks=0) → Price
Return the price n bid ticks away from value.
If a given price is between two ticks, n=0 will find the nearest bid tick.
- Parameters:
- value (double) – The reference value.
- num_ticks (int , default 0) – The number of ticks to move.
- Return type: Price
- Raises: ValueError – If a tick scheme is not initialized.
notional_value(self, Quantity quantity, Price price, bool use_quote_for_inverse=False) → Money
Calculate the notional value.
Result will be in quote currency for standard instruments, or base currency for inverse instruments.
- Parameters:
- Return type: Money
price_increment
The minimum price increment or tick size for the instrument.
- Returns: Price
price_precision
The price precision of the instrument.
- Returns: int
quote_currency
The quote currency for the instrument.
- Returns: Currency
raw_symbol
The raw/local/native symbol for the instrument, assigned by the venue.
- Returns: Symbol
size_increment
The minimum size increment for the instrument.
- Returns: Quantity
size_precision
The size precision of the instrument.
- Returns: int
symbol
Return the instruments ticker symbol.
- Return type: Symbol
taker_fee
The fee rate for liquidity takers as a percentage of order value (where 1.0 is 100%).
- Returns: Decimal
tick_scheme_name
The tick scheme name.
- Returns:
str or
None
static to_dict(FuturesContract obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
ts_event
UNIX timestamp (nanoseconds) when the data event occurred.
- Returns: uint64_t
ts_init
UNIX timestamp (nanoseconds) when the object was initialized.
- Returns: uint64_t
underlying
The underlying asset for the contract.
- Returns: str
venue
Return the instruments trading venue.
- Return type: Venue
class OptionsContract
Bases: Instrument
OptionsContract(InstrumentId instrument_id, Symbol raw_symbol, AssetClass asset_class, Currency currency, int price_precision, Price price_increment, Quantity multiplier, Quantity lot_size, unicode underlying, OptionKind option_kind, Price strike_price, uint64_t activation_ns, uint64_t expiration_ns, uint64_t ts_event, uint64_t ts_init, unicode exchange=None, dict info=None)
Represents a generic options contract instrument.
- Parameters:
- instrument_id (InstrumentId) – The instrument ID.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- asset_class (AssetClass) – The options contract asset class.
- currency (Currency) – The options contract currency.
- price_precision (int) – The price decimal precision.
- price_increment (Price) – The minimum price increment (tick size).
- multiplier (Quantity) – The option multiplier.
- lot_size (Quantity) – The rounded lot unit size (standard/board).
- underlying (str) – The underlying asset.
- option_kind (OptionKind) – The kind of option (PUT | CALL).
- strike_price (Price) – The option strike price.
- activation_ns (uint64_t) – UNIX timestamp (nanoseconds) for contract activation.
- expiration_ns (uint64_t) – UNIX timestamp (nanoseconds) for contract expiration.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- exchange (str , optional) – The exchange ISO 10383 Market Identifier Code (MIC) where the instrument trades.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If multiplier is not positive (> 0).
- ValueError – If price_precision is negative (< 0).
- ValueError – If tick_size is not positive (> 0).
- ValueError – If lot_size is not positive (> 0).
activation_ns
UNIX timestamp (nanoseconds) for contract activation.
- Returns: unit64_t
activation_utc
pd.Timestamp
Return the contract activation timestamp (UTC).
- Returns: tz-aware UTC.
- Return type: pd.Timestamp
- Type: OptionsContract.activation_utc
asset_class
The asset class of the instrument.
- Returns: AssetClass
static base_from_dict(dict values) → Instrument
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: Instrument
static base_to_dict(Instrument obj)
Return a dictionary representation of this object.
- Return type: dict[str, object]
calculate_base_quantity(self, Quantity quantity, Price last_px) → Quantity
Calculate the base asset quantity from the given quote asset quantity and last price.
- Parameters:
- Return type: Quantity
exchange
The exchange ISO 10383 Market Identifier Code (MIC) where the instrument trades.
- Returns:
str or
None
expiration_ns
UNIX timestamp (nanoseconds) for contract expiration.
- Returns: unit64_t
expiration_utc
pd.Timestamp
Return the contract expriation timestamp (UTC).
- Returns: tz-aware UTC.
- Return type: pd.Timestamp
- Type: OptionsContract.expiration_utc
static from_dict(dict values) → OptionsContract
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: OptionsContract
static from_pyo3(pyo3_instrument) → OptionsContract
Return legacy Cython options contract instrument converted from the given pyo3 Rust object.
- Parameters: pyo3_instrument (nautilus_pyo3.OptionsContract) – The pyo3 Rust options contract instrument to convert from.
- Return type: OptionsContract
classmethod fully_qualified_name(cls) → str
Return the fully qualified name for the Data class.
- Return type: str
get_base_currency(self) → Currency
Return the instruments base currency (if applicable).
- Return type:
Currency or
None
get_settlement_currency(self) → Currency
Return the currency used to settle a trade of the instrument.
- Standard linear instruments = quote_currency
- Inverse instruments = base_currency
- Quanto instruments = settlement_currency
- Return type: Currency
id
The instrument ID.
- Returns: InstrumentId
info
The raw info for the instrument.
- Returns: dict[str, object]
instrument_class
The class of the instrument.
- Returns: InstrumentClass
is_inverse
If the quantity is expressed in quote currency.
- Returns: Currency
classmethod is_signal(cls, unicode name=u'') → bool
Determine if the current class is a signal type, optionally checking for a specific signal name.
- Parameters: name (str , optional) – The specific signal name to check. If name not provided or if an empty string is passed, the method checks whether the class name indicates a general signal type. If name is provided, the method checks if the class name corresponds to that specific signal.
- Returns: True if the class name matches the signal type or the specific signal name, otherwise False.
- Return type: bool
lot_size
The rounded lot unit size (standard/board) for the instrument.
- Returns:
Quantity or
None
make_price(self, value) → Price
Return a new price from the given value using the instruments price precision.
- Parameters: value (integer , float , str or Decimal) – The value of the price.
- Return type: Price
make_qty(self, value) → Quantity
Return a new quantity from the given value using the instruments size precision.
- Parameters: value (integer , float , str or Decimal) – The value of the quantity.
- Return type: Quantity
- Raises: ValueError – If a non zero value is rounded to zero due to the instruments size increment or size precision.
maker_fee
The fee rate for liquidity makers as a percentage of order value (where 1.0 is 100%).
- Returns: Decimal
margin_init
The initial (order) margin rate for the instrument.
- Returns: Decimal
margin_maint
The maintenance (position) margin rate for the instrument.
- Returns: Decimal
max_notional
The maximum notional order value for the instrument.
- Returns:
Money or
None
max_price
The maximum printable price for the instrument.
- Returns:
Price or
None
max_quantity
The maximum order quantity for the instrument.
- Returns:
Quantity or
None
min_notional
The minimum notional order value for the instrument.
- Returns:
Money or
None
min_price
The minimum printable price for the instrument.
- Returns:
Price or
None
min_quantity
The minimum order quantity for the instrument.
- Returns:
Quantity or
None
multiplier
The contract multiplier for the instrument (determines tick value).
- Returns: Quantity
next_ask_price(self, double value, int num_ticks=0) → Price
Return the price n ask ticks away from value.
If a given price is between two ticks, n=0 will find the nearest ask tick.
- Parameters:
- value (double) – The reference value.
- num_ticks (int , default 0) – The number of ticks to move.
- Return type: Price
- Raises: ValueError – If a tick scheme is not initialized.
next_bid_price(self, double value, int num_ticks=0) → Price
Return the price n bid ticks away from value.
If a given price is between two ticks, n=0 will find the nearest bid tick.
- Parameters:
- value (double) – The reference value.
- num_ticks (int , default 0) – The number of ticks to move.
- Return type: Price
- Raises: ValueError – If a tick scheme is not initialized.
notional_value(self, Quantity quantity, Price price, bool use_quote_for_inverse=False) → Money
Calculate the notional value.
Result will be in quote currency for standard instruments, or base currency for inverse instruments.
- Parameters:
- Return type: Money
option_kind
The option kind (PUT | CALL) for the contract.
- Returns: OptionKind
price_increment
The minimum price increment or tick size for the instrument.
- Returns: Price
price_precision
The price precision of the instrument.
- Returns: int
quote_currency
The quote currency for the instrument.
- Returns: Currency
raw_symbol
The raw/local/native symbol for the instrument, assigned by the venue.
- Returns: Symbol
size_increment
The minimum size increment for the instrument.
- Returns: Quantity
size_precision
The size precision of the instrument.
- Returns: int
strike_price
The strike price for the contract.
- Returns: Price
symbol
Return the instruments ticker symbol.
- Return type: Symbol
taker_fee
The fee rate for liquidity takers as a percentage of order value (where 1.0 is 100%).
- Returns: Decimal
tick_scheme_name
The tick scheme name.
- Returns:
str or
None
static to_dict(OptionsContract obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
ts_event
UNIX timestamp (nanoseconds) when the data event occurred.
- Returns: uint64_t
ts_init
UNIX timestamp (nanoseconds) when the object was initialized.
- Returns: uint64_t
underlying
The underlying asset for the contract.
- Returns: str
venue
Return the instruments trading venue.
- Return type: Venue
class SyntheticInstrument
Bases: Data
SyntheticInstrument(Symbol symbol, uint8_t price_precision, list components, unicode formula, uint64_t ts_event, uint64_t ts_init)
Represents a synthetic instrument with prices derived from component instruments using a formula.
The id for the synthetic will become {symbol}.{SYNTH}.
- Parameters:
- symbol (Symbol) – The symbol for the synethic instrument.
- price_precision (uint8_t) – The price precision for the synthetic instrument.
- components (list [InstrumentId ]) – The component instruments for the synthetic instrument.
- formula (str) – The derivation formula for the synthetic instrument.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- Raises:
- ValueError – If price_precision is greater than 9.
- OverflowError – If price_precision is negative (< 0).
- ValueError – If the components list does not contain at least 2 instrument IDs.
- ValueError – If the formula is not a valid string.
- ValueError – If the formula is not a valid expression.
WARNING
All component instruments should already be defined and exist in the cache prior to defining a new synthetic instrument.
calculate(self, list inputs) → Price
Calculate the price of the synthetic instrument from the given inputs.
- Parameters: inputs (list *[*double ])
- Return type: Price
- Raises:
- ValueError – If inputs is empty, contains a NaN value, or length is different from components count.
- RuntimeError – If an internal error occurs when calculating the price.
change_formula(self, unicode formula) → void
Change the internal derivation formula for the synthetic instrument.
- Parameters: formula (str) – The derivation formula to change to.
- Raises:
- ValueError – If the formula is not a valid string.
- ValueError – If the formula is not a valid expression.
components
list[InstrumentId]
Return the components of the synthetic instrument.
- Return type: list[InstrumentId]
- Type: SyntheticInstrument.components
formula
str
Return the synthetic instrument internal derivation formula.
- Return type: str
- Type: SyntheticInstrument.formula
static from_dict(dict values) → SyntheticInstrument
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: SyntheticInstrument
classmethod fully_qualified_name(cls) → str
Return the fully qualified name for the Data class.
- Return type: str
id
The instrument ID.
- Returns: InstrumentId
classmethod is_signal(cls, unicode name=u'') → bool
Determine if the current class is a signal type, optionally checking for a specific signal name.
- Parameters: name (str , optional) – The specific signal name to check. If name not provided or if an empty string is passed, the method checks whether the class name indicates a general signal type. If name is provided, the method checks if the class name corresponds to that specific signal.
- Returns: True if the class name matches the signal type or the specific signal name, otherwise False.
- Return type: bool
price_increment
Price
Return the minimum price increment (tick size) for the synthetic instrument.
- Return type: Price
- Type: SyntheticInstrument.price_increment
price_precision
int
Return the precision for the synthetic instrument.
- Return type: int
- Type: SyntheticInstrument.price_precision
static to_dict(SyntheticInstrument obj) → dict[str, object]
Return a dictionary representation of this object.
- Return type: dict[str, object]
ts_event
int
UNIX timestamp (nanoseconds) when the data event occurred.
- Return type: int
- Type: SyntheticInstrument.ts_event
ts_init
int
UNIX timestamp (nanoseconds) when the object was initialized.
- Return type: int
- Type: SyntheticInstrument.ts_init
class Instrument
Bases: Data
Instrument(InstrumentId instrument_id, Symbol raw_symbol, AssetClass asset_class, InstrumentClass instrument_class, Currency quote_currency, bool is_inverse, int price_precision, int size_precision, Quantity size_increment, Quantity multiplier, margin_init: Decimal, margin_maint: Decimal, maker_fee: Decimal, taker_fee: Decimal, uint64_t ts_event, uint64_t ts_init, Price price_increment: Price | None = None, Quantity lot_size: Quantity | None = None, Quantity max_quantity: Quantity | None = None, Quantity min_quantity: Quantity | None = None, Money max_notional: Money | None = None, Money min_notional: Money | None = None, Price max_price: Price | None = None, Price min_price: Price | None = None, unicode tick_scheme_name=None, dict info=None)
The base class for all instruments.
Represents a tradable instrument. This class can be used to define an instrument, or act as a parent class for more specific instruments.
- Parameters:
- instrument_id (InstrumentId) – The instrument ID for the instrument.
- raw_symbol (Symbol) – The raw/local/native symbol for the instrument, assigned by the venue.
- asset_class (AssetClass) – The instrument asset class.
- instrument_class (InstrumentClass) – The instrument class.
- quote_currency (Currency) – The quote currency.
- is_inverse (bool) – If the instrument costing is inverse (quantity expressed in quote currency units).
- price_precision (int) – The price decimal precision.
- size_precision (int) – The trading size decimal precision.
- size_increment (Price) – The minimum size increment.
- multiplier (Decimal) – The contract value multiplier (determines tick value).
- lot_size (Quantity , optional) – The rounded lot unit size (standard/board).
- margin_init (Decimal) – The initial (order) margin requirement in percentage of order value.
- margin_maint (Decimal) – The maintenance (position) margin in percentage of position value.
- maker_fee (Decimal) – The fee rate for liquidity makers as a percentage of order value (where 1.0 is 100%).
- taker_fee (Decimal) – The fee rate for liquidity takers as a percentage of order value (where 1.0 is 100%).
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the data event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
- price_increment (Price , optional) – The minimum price increment (tick size).
- max_quantity (Quantity , optional) – The maximum allowable order quantity.
- min_quantity (Quantity , optional) – The minimum allowable order quantity.
- max_notional (Money , optional) – The maximum allowable order notional value.
- min_notional (Money , optional) – The minimum allowable order notional value.
- max_price (Price , optional) – The maximum allowable quoted price.
- min_price (Price , optional) – The minimum allowable quoted price.
- tick_scheme_name (str , optional) – The name of the tick scheme.
- info (dict *[*str , object ] , optional) – The additional instrument information.
- Raises:
- ValueError – If tick_scheme_name is not a valid string.
- ValueError – If price_precision is negative (< 0).
- ValueError – If size_precision is negative (< 0).
- ValueError – If price_increment is not positive (> 0).
- ValueError – If size_increment is not positive (> 0).
- ValueError – If price_precision is not equal to price_increment.precision.
- ValueError – If size_increment is not equal to size_increment.precision.
- ValueError – If multiplier is not positive (> 0).
- ValueError – If lot size is not positive (> 0).
- ValueError – If max_quantity is not positive (> 0).
- ValueError – If min_quantity is negative (< 0).
- ValueError – If max_notional is not positive (> 0).
- ValueError – If min_notional is negative (< 0).
- ValueError – If max_price is not positive (> 0).
- ValueError – If min_price is negative (< 0).
asset_class
The asset class of the instrument.
- Returns: AssetClass
static base_from_dict(dict values) → Instrument
Return an instrument from the given initialization values.
- Parameters: values (dict *[*str , object ]) – The values to initialize the instrument with.
- Return type: Instrument
static base_to_dict(Instrument obj)
Return a dictionary representation of this object.
- Return type: dict[str, object]
calculate_base_quantity(self, Quantity quantity, Price last_px) → Quantity
Calculate the base asset quantity from the given quote asset quantity and last price.
- Parameters:
- Return type: Quantity
classmethod fully_qualified_name(cls) → str
Return the fully qualified name for the Data class.
- Return type: str
get_base_currency(self) → Currency
Return the instruments base currency (if applicable).
- Return type:
Currency or
None
get_settlement_currency(self) → Currency
Return the currency used to settle a trade of the instrument.
- Standard linear instruments = quote_currency
- Inverse instruments = base_currency
- Quanto instruments = settlement_currency
- Return type: Currency
id
The instrument ID.
- Returns: InstrumentId
info
The raw info for the instrument.
- Returns: dict[str, object]
instrument_class
The class of the instrument.
- Returns: InstrumentClass
is_inverse
If the quantity is expressed in quote currency.
- Returns: Currency
classmethod is_signal(cls, unicode name=u'') → bool
Determine if the current class is a signal type, optionally checking for a specific signal name.
- Parameters: name (str , optional) – The specific signal name to check. If name not provided or if an empty string is passed, the method checks whether the class name indicates a general signal type. If name is provided, the method checks if the class name corresponds to that specific signal.
- Returns: True if the class name matches the signal type or the specific signal name, otherwise False.
- Return type: bool
lot_size
The rounded lot unit size (standard/board) for the instrument.
- Returns:
Quantity or
None
make_price(self, value) → Price
Return a new price from the given value using the instruments price precision.
- Parameters: value (integer , float , str or Decimal) – The value of the price.
- Return type: Price
make_qty(self, value) → Quantity
Return a new quantity from the given value using the instruments size precision.
- Parameters: value (integer , float , str or Decimal) – The value of the quantity.
- Return type: Quantity
- Raises: ValueError – If a non zero value is rounded to zero due to the instruments size increment or size precision.
maker_fee
The fee rate for liquidity makers as a percentage of order value (where 1.0 is 100%).
- Returns: Decimal
margin_init
The initial (order) margin rate for the instrument.
- Returns: Decimal
margin_maint
The maintenance (position) margin rate for the instrument.
- Returns: Decimal
max_notional
The maximum notional order value for the instrument.
- Returns:
Money or
None
max_price
The maximum printable price for the instrument.
- Returns:
Price or
None
max_quantity
The maximum order quantity for the instrument.
- Returns:
Quantity or
None
min_notional
The minimum notional order value for the instrument.
- Returns:
Money or
None
min_price
The minimum printable price for the instrument.
- Returns:
Price or
None
min_quantity
The minimum order quantity for the instrument.
- Returns:
Quantity or
None
multiplier
The contract multiplier for the instrument (determines tick value).
- Returns: Quantity
next_ask_price(self, double value, int num_ticks=0) → Price
Return the price n ask ticks away from value.
If a given price is between two ticks, n=0 will find the nearest ask tick.
- Parameters:
- value (double) – The reference value.
- num_ticks (int , default 0) – The number of ticks to move.
- Return type: Price
- Raises: ValueError – If a tick scheme is not initialized.
next_bid_price(self, double value, int num_ticks=0) → Price
Return the price n bid ticks away from value.
If a given price is between two ticks, n=0 will find the nearest bid tick.
- Parameters:
- value (double) – The reference value.
- num_ticks (int , default 0) – The number of ticks to move.
- Return type: Price
- Raises: ValueError – If a tick scheme is not initialized.
notional_value(self, Quantity quantity, Price price, bool use_quote_for_inverse=False) → Money
Calculate the notional value.
Result will be in quote currency for standard instruments, or base currency for inverse instruments.
- Parameters:
- Return type: Money
price_increment
The minimum price increment or tick size for the instrument.
- Returns: Price
price_precision
The price precision of the instrument.
- Returns: int
quote_currency
The quote currency for the instrument.
- Returns: Currency
raw_symbol
The raw/local/native symbol for the instrument, assigned by the venue.
- Returns: Symbol
size_increment
The minimum size increment for the instrument.
- Returns: Quantity
size_precision
The size precision of the instrument.
- Returns: int
symbol
Return the instruments ticker symbol.
- Return type: Symbol
taker_fee
The fee rate for liquidity takers as a percentage of order value (where 1.0 is 100%).
- Returns: Decimal
tick_scheme_name
The tick scheme name.
- Returns:
str or
None
ts_event
UNIX timestamp (nanoseconds) when the data event occurred.
- Returns: uint64_t
ts_init
UNIX timestamp (nanoseconds) when the object was initialized.
- Returns: uint64_t
venue
Return the instruments trading venue.
- Return type: Venue