Version: nightly

Data

class Bar

Bases: Data

Bar(BarType bar_type, Price open, Price high, Price low, Price close, Quantity volume, uint64_t ts_event, uint64_t ts_init, bool is_revision=False) -> None

Represents an aggregated bar.

Parameters:
- bar_type (BarType) – The bar type for this bar.
- open (Price) – The bars open price.
- high (Price) – The bars high price.
- low (Price) – The bars low price.
- close (Price) – The bars close price.
- volume (Quantity) – The bars volume.
- 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.
- is_revision (bool , default False) – If this bar is a revision of a previous bar with the same ts_event.
Raises:
- ValueError – If high is not >= low.
- ValueError – If high is not >= close.
- ValueError – If low is not <= close.

bar_type

BarType

Return the bar type of bar.

Return type: BarType
Type: Bar.bar_type

close

Price

Return the close price of the bar.

Return type: Price
Type: Bar.close

static from_dict(dict values) → Bar

Return a bar parsed from the given values.

Parameters: values (dict *[*str , object ]) – The values for initialization.
Return type: Bar

static from_pyo3(pyo3_bar) → Bar

Return a legacy Cython bar converted from the given pyo3 Rust object.

Parameters: pyo3_bar (nautilus_pyo3.Bar) – The pyo3 Rust bar to convert from.
Return type: Bar

static from_pyo3_list(list pyo3_bars) → list[Bar]

Return legacy Cython bars converted from the given pyo3 Rust objects.

Parameters: pyo3_bars (list *[*nautilus_pyo3.Bar ]) – The pyo3 Rust bars to convert from.
Return type: list[Bar]

static from_raw(BarType bar_type, PriceRaw open, PriceRaw high, PriceRaw low, PriceRaw close, uint8_t price_prec, QuantityRaw volume, uint8_t size_prec, uint64_t ts_event, uint64_t ts_init) → Bar

static from_raw_arrays_to_list(BarType bar_type, uint8_t price_prec, uint8_t size_prec, double[:] opens, double[:] highs, double[:] lows, double[:] closes, double[:] volumes, uint64_t[:] ts_events, uint64_t[:] ts_inits) → list[Bar]

classmethod fully_qualified_name(cls) → str

Return the fully qualified name for the Data class.

Return type: str

high

Price

Return the high price of the bar.

Return type: Price
Type: Bar.high

is_revision

If this bar is a revision for a previous bar with the same ts_event.

Returns: bool

classmethod is_signal(cls, str name='') → 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

is_single_price(self) → bool

If the OHLC are all equal to a single price.

Return type: bool

low

Price

Return the low price of the bar.

Return type: Price
Type: Bar.low

open

Price

Return the open price of the bar.

Return type: Price
Type: Bar.open

static to_dict(Bar obj)

Return a dictionary representation of this object.

Return type: dict[str, object]

to_pyo3(self) → nautilus_pyo3.Bar

Return a pyo3 object from this legacy Cython instance.

Return type: nautilus_pyo3.Bar

static to_pyo3_list(list bars) → list[nautilus_pyo3.Bar]

Return pyo3 Rust bars converted from the given legacy Cython objects.

Parameters: bars (list [Bar ]) – The legacy Cython bars to convert from.
Return type: list[nautilus_pyo3.Bar]

ts_event

int

UNIX timestamp (nanoseconds) when the data event occurred.

Return type: int
Type: Bar.ts_event

ts_init

int

UNIX timestamp (nanoseconds) when the object was initialized.

Return type: int
Type: Bar.ts_init

volume

Quantity

Return the volume of the bar.

Return type: Quantity
Type: Bar.volume

class BarAggregation

Bases: IntFlag

conjugate()

Returns self, the complex conjugate of any int.

bit_length()

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length=1, byteorder='big', , signed=False)

Return an array of bytes representing an integer.

length : Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes. Default is length 1.

byteorder : The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.

signed : Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

classmethod from_bytes(bytes, byteorder='big', , signed=False)

Return the integer represented by the given array of bytes.

bytes : Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.

signed : Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()

Return a pair of integers, whose ratio is equal to the original int.

The ratio is in lowest terms and has a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

is_integer()

Returns True. Exists for duck type compatibility with float.is_integer.

real

the real part of a complex number

imag

the imaginary part of a complex number

numerator

the numerator of a rational number in lowest terms

denominator

the denominator of a rational number in lowest terms

TICK = 1

TICK_IMBALANCE = 2

TICK_RUNS = 3

VOLUME = 4

VOLUME_IMBALANCE = 5

VOLUME_RUNS = 6

VALUE = 7

VALUE_IMBALANCE = 8

VALUE_RUNS = 9

MILLISECOND = 10

SECOND = 11

MINUTE = 12

HOUR = 13

DAY = 14

WEEK = 15

MONTH = 16

YEAR = 17

class BarIntervalType

Bases: IntFlag

conjugate()

Returns self, the complex conjugate of any int.

bit_length()

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

bit_count()

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

to_bytes(length=1, byteorder='big', , signed=False)

Return an array of bytes representing an integer.

length : Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes. Default is length 1.

signed : Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

classmethod from_bytes(bytes, byteorder='big', , signed=False)

Return the integer represented by the given array of bytes.

signed : Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()

Return a pair of integers, whose ratio is equal to the original int.

The ratio is in lowest terms and has a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

is_integer()

Returns True. Exists for duck type compatibility with float.is_integer.

real

the real part of a complex number

imag

the imaginary part of a complex number

numerator

the numerator of a rational number in lowest terms

denominator

the denominator of a rational number in lowest terms

LEFT_OPEN = 0

RIGHT_OPEN = 1

class BarSpecification

Bases: object

BarSpecification(int step, BarAggregation aggregation, PriceType price_type) -> None

Represents a bar aggregation specification that defines how market data should be aggregated into bars (candlesticks).

A bar specification consists of three main components:

Step: The quantity or interval for aggregation (e.g., 5 for 5-minute bars)
Aggregation: The method/rule for aggregation (time, tick, volume, value, etc.)
Price Type: Which price to use for aggregation (BID, ASK, MID, LAST)

Bar specifications are used to define different types of bars:

Time-based bars: Aggregate data over fixed time intervals

Examples: 1-MINUTE-LAST, 5-MINUTE-MID, 1-HOUR-BID

Tick-based bars: Aggregate data after a certain number of ticks

Examples: 100-TICK-LAST, 1000-TICK-MID

Volume-based bars: Aggregate data after a certain volume threshold

Examples: 1000-VOLUME-LAST, 10000-VOLUME-MID

Value-based bars: Aggregate data after a certain dollar value threshold

Examples: 100000-VALUE-LAST, 1000000-VALUE-MID

Information-based bars: Advanced aggregation based on information flow

Examples: 1000-VALUE_IMBALANCE-MID, 500-VALUE_RUNS-LAST

The specification determines:

What triggers bar creation (aggregation method)
How often bars are created (step size)
Which price level to use for OHLCV calculation (price type)

Parameters:
- step (int) – The step size for bar aggregation. Must be positive.
  - For time bars: interval in time units (1=1min, 5=5min, etc.)
  - For tick bars: number of ticks per bar
  - For volume/value bars: threshold amount
- aggregation (BarAggregation) – The aggregation method (MINUTE, TICK, VOLUME, VALUE, etc.)
- price_type (PriceType) – The price type to use (BID, ASK, MID, LAST)
Raises: ValueError – If step is not valid or if invalid aggregation/price_type combinations

aggregation

BarAggregation

Return the aggregation for the specification.

Return type: BarAggregation
Type: BarSpecification.aggregation

static check_information_aggregated(BarAggregation aggregation)

Check if the given aggregation is an information-based aggregation type.

Information-based aggregation creates bars based on market microstructure patterns and sequential runs of similar market events. These bars capture information flow and market efficiency patterns by detecting sequences of directionally similar price movements or trading activity.

Information-based aggregation types include:

TICK_RUNS: Bars created when runs of tick price movements occur
VOLUME_RUNS: Bars created when runs of volume patterns occur
VALUE_RUNS: Bars created when runs of value patterns occur

Runs are sequences of consecutive events with the same directional property (e.g., consecutive upticks or downticks). This aggregation method is useful for analyzing market microstructure, information flow, and detecting patterns in high-frequency trading activity.

This differs from time-based aggregation (fixed intervals) and threshold-based aggregation (activity levels), focusing instead on sequential patterns and information content of market events.

Parameters: aggregation (BarAggregation) – The aggregation type to check.
Returns: True if the aggregation is information-based, else False.
Return type: bool

static check_threshold_aggregated(BarAggregation aggregation)

Check if the given aggregation is a threshold-based aggregation type.

Threshold-based aggregation creates bars when accumulated market activity reaches predefined thresholds, providing activity-driven sampling rather than time-driven sampling. These bars capture market dynamics based on actual trading patterns and volumes.

Threshold-based aggregation types include:

TICK: Bars created after N ticks (price changes)
TICK_IMBALANCE: Bars created when tick imbalance reaches threshold
VOLUME: Bars created after N units of volume are traded
VOLUME_IMBALANCE: Bars created when volume imbalance reaches threshold
VALUE: Bars created after N units of notional value are traded
VALUE_IMBALANCE: Bars created when value imbalance reaches threshold

This differs from time-based aggregation which creates bars at fixed time intervals, and information-based aggregation which creates bars based on market microstructure patterns and runs.

Parameters: aggregation (BarAggregation) – The aggregation type to check.
Returns: True if the aggregation is threshold-based, else False.
Return type: bool

static check_time_aggregated(BarAggregation aggregation)

Check if the given aggregation is a time-based aggregation type.

Time-based aggregation creates bars at fixed time intervals, where each bar represents market data for a specific time period. These bars are emitted when the time interval expires, regardless of trading activity level.

Time-based aggregation types include:

MILLISECOND: Bars created every N milliseconds
SECOND: Bars created every N seconds
MINUTE: Bars created every N minutes
HOUR: Bars created every N hours
DAY: Bars created every N days (calendar days)
WEEK: Bars created every N weeks (calendar weeks)
MONTH: Bars created every N months (calendar months)
YEAR: Bars created every N years (calendar years)

This is distinct from threshold-based aggregation (TICK, VOLUME, VALUE) which creates bars when activity thresholds are reached, and information-based aggregation (RUNS) which creates bars based on market microstructure patterns.

Parameters: aggregation (BarAggregation) – The aggregation type to check.
Returns: True if the aggregation is time-based, else False.
Return type: bool

static from_str(str value) → BarSpecification

Return a bar specification parsed from the given string.

Parameters: value (str) – The bar specification string to parse.
Return type: BarSpecification
Raises: ValueError – If value is not a valid string.

static from_timedelta(timedelta duration, PriceType price_type) → BarSpecification

Return a bar specification parsed from the given timedelta and price_type.

Parameters:
- duration (timedelta) – The bar specification timedelta to parse.
- price_type (PriceType) – The bar specification price_type.
Return type: BarSpecification
Raises: ValueError – If duration is not rounded step of aggregation.

get_interval_ns(self) → uint64_t

Return the interval length in nanoseconds for time-based bar specifications.

Converts the bar specification’s time interval to nanoseconds based on its aggregation type and step size. This method is used for time calculations and (TODO: bar alignment).

Returns: The interval length in nanoseconds.
Return type: uint64_t
Raises: ValueError – If the aggregation is MONTH or YEAR (since months and years have variable lengths 28-31 days or 365-366 days, making fixed nanosecond conversion impossible). If the aggregation is not a time-based aggregation.

is_information_aggregated(self) → bool

Return a value indicating whether the aggregation method is information-driven.

Information-based aggregation creates bars based on market microstructure patterns and sequential runs of similar market events. This aggregation method captures information flow, market efficiency patterns, and the sequential nature of trading activity by detecting directional runs.

Information-based aggregation types supported:

TICK_RUNS: Bars based on runs of directional tick movements (upticks/downticks)
VOLUME_RUNS: Bars based on runs of volume patterns and clustering
VALUE_RUNS: Bars based on runs of notional value patterns

A “run” is a sequence of consecutive market events with the same directional or categorical property. For example, a tick run might be 5 consecutive upticks followed by 3 consecutive downticks.

Information-based bars are ideal for:

Market microstructure analysis and information flow studies
Detecting patterns in high-frequency trading and market efficiency
Analyzing sequential dependencies in market data
Capturing information content rather than just time or activity levels
Studying market maker behavior and order flow dynamics

This differs from time-based aggregation (fixed time intervals) and threshold-based aggregation (activity levels), focusing instead on the sequential information content and patterns within market events.

Returns: True if the aggregation method is information-based, else False.
Return type: bool

is_threshold_aggregated(self) → bool

Return a value indicating whether the aggregation method is threshold-based.

Threshold-based aggregation types trigger bar creation when cumulative activity reaches predefined levels, making them ideal for volume and value-driven analysis rather than time-based intervals.

Threshold-Based Aggregation Types

Activity threshold types supported:

TICK: Bars based on tick count thresholds (every N ticks)
VOLUME: Bars based on volume thresholds (every N units traded)
VALUE: Bars based on notional value thresholds (every N dollars/currency traded)

Imbalance threshold types supported:

TICK_IMBALANCE: Bars based on cumulative tick flow imbalances
VOLUME_IMBALANCE: Bars based on cumulative volume imbalances
VALUE_IMBALANCE: Bars based on cumulative value flow imbalances

Threshold-based bars are ideal for:

Volume and activity-based analysis independent of time
Capturing market activity during varying trading intensities
Equal-activity sampling for statistical analysis
Risk management based on position sizing and exposure levels
Algorithmic trading strategies sensitive to market participation

This differs from time-based aggregation (fixed time intervals) and information-based aggregation (information content patterns), focusing instead on measurable activity and participation thresholds.

Returns: True if the aggregation method is threshold-based, else False.
Return type: bool

is_time_aggregated(self) → bool

Return a value indicating whether the aggregation method is time-driven.

Time-based aggregation creates bars at fixed time intervals based on calendar or clock time, providing consistent temporal sampling of market data. Each bar covers a specific time period regardless of trading activity level.

Time-based aggregation types supported:

MILLISECOND: Fixed millisecond intervals (high-frequency sampling)
SECOND: Fixed second intervals (short-term patterns)
MINUTE: Fixed minute intervals (most common for retail trading)
HOUR: Fixed hour intervals (intraday analysis)
DAY: Fixed daily intervals (daily charts, longer-term analysis)
WEEK: Fixed weekly intervals (weekly patterns, medium-term trends)
MONTH: Fixed monthly intervals (long-term analysis, seasonal patterns)
YEAR: Fixed yearly intervals (annual trends, long-term investment)

Time-based bars are ideal for:

Regular time-series analysis and charting
Consistent temporal sampling across different market conditions
Traditional technical analysis and pattern recognition
Comparing market behavior across fixed time periods

This differs from threshold aggregation (volume/tick-based) which creates bars when activity levels are reached, and information aggregation which creates bars based on market microstructure patterns.

Returns: True if the aggregation method is time-based, else False.
Return type: bool

price_type

PriceType

Return the price type for the specification.

Return type: PriceType
Type: BarSpecification.price_type

step

int

Return the step size for the specification.

Return type: int
Type: BarSpecification.step

timedelta

pd.Timedelta

Return the timedelta for the specification.

Return type: pandas.Timedelta
Raises: ValueError – If aggregation is not a time aggregation, or is``MONTH`` (which is ambiguous).
Type: BarSpecification.timedelta

class BarType

Bases: object

BarType(InstrumentId instrument_id, BarSpecification bar_spec, AggregationSource aggregation_source=AggregationSource.EXTERNAL) -> None

Represents a bar type including the instrument ID, bar specification and aggregation source.

Parameters:
- instrument_id (InstrumentId) – The bar type’s instrument ID.
- bar_spec (BarSpecification) – The bar type’s specification.
- aggregation_source (AggregationSource , default EXTERNAL) – The bar type aggregation source. If INTERNAL the DataEngine will subscribe to the necessary ticks and aggregate bars accordingly. Else if EXTERNAL then bars will be subscribed to directly from the venue / data provider.

aggregation_source

AggregationSource

Return the aggregation source for the bar type.

Return type: AggregationSource
Type: BarType.aggregation_source

composite(self) → BarType

static from_str(str value) → BarType

Return a bar type parsed from the given string.

Parameters: value (str) – The bar type string to parse.
Return type: BarType
Raises: ValueError – If value is not a valid string.

instrument_id

InstrumentId

Return the instrument ID for the bar type.

Return type: InstrumentId
Type: BarType.instrument_id

is_composite(self) → bool

Return a value indicating whether the bar type corresponds to BarType::Composite in Rust.

Return type: bool

is_externally_aggregated(self) → bool

Return a value indicating whether the bar aggregation source is EXTERNAL.

Return type: bool

is_internally_aggregated(self) → bool

Return a value indicating whether the bar aggregation source is INTERNAL.

Return type: bool

is_standard(self) → bool

Return a value indicating whether the bar type corresponds to BarType::Standard in Rust.

Return type: bool

static new_composite(InstrumentId instrument_id, BarSpecification bar_spec, AggregationSource aggregation_source, int composite_step, BarAggregation composite_aggregation, AggregationSource composite_aggregation_source) → BarType

spec

BarSpecification

Return the specification for the bar type.

Return type: BarSpecification
Type: BarType.spec

standard(self) → BarType

class BookOrder

Bases: object

BookOrder(OrderSide side, Price price, Quantity size, uint64_t order_id) -> None

Represents an order in a book.

Parameters:
- side (OrderSide {BUY, SELL}) – The order side.
- price (Price) – The order price.
- size (Quantity) – The order size.
- order_id (uint64_t) – The order ID.

exposure(self) → double

Return the total exposure for this order (price * size).

Return type: double

static from_dict(dict values) → BookOrder

Return an order from the given dict values.

Parameters: values (dict *[*str , object ]) – The values for initialization.
Return type: BookOrder

static from_raw(OrderSide side, PriceRaw price_raw, uint8_t price_prec, QuantityRaw size_raw, uint8_t size_prec, uint64_t order_id) → BookOrder

Return an book order from the given raw values.

Parameters:
- side (OrderSide {BUY, SELL}) – The order side.
- price_raw (int) – The order raw price (as a scaled fixed-point integer).
- price_prec (uint8_t) – The order price precision.
- size_raw (int) – The order raw size (as a scaled fixed-point integer).
- size_prec (uint8_t) – The order size precision.
- order_id (uint64_t) – The order ID.
Return type: BookOrder

order_id

uint64_t

Return the book orders side.

Return type: uint64_t
Type: BookOrder.order_id

price

Price

Return the book orders price.

Return type: Price
Type: BookOrder.price

side

OrderSide

Return the book orders side.

Return type: OrderSide
Type: BookOrder.side

signed_size(self) → double

Return the signed size of the order (negative for SELL).

Return type: double

size

Quantity

Return the book orders size.

Return type: Quantity
Type: BookOrder.size

static to_dict(BookOrder obj)

Return a dictionary representation of this object.

Return type: dict[str, object]

class CustomData

Bases: Data

CustomData(DataType data_type, Data data) -> None

Provides a wrapper for custom data which includes data type information.

Parameters:
- data_type (DataType) – The data type.
- data (Data) – The data object to wrap.

data

The data.

Returns: Data

data_type

The data type.

Returns: DataType

classmethod fully_qualified_name(cls) → str

Return the fully qualified name for the Data class.

Return type: str

classmethod is_signal(cls, str name='') → 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

ts_event

int

UNIX timestamp (nanoseconds) when the data event occurred.

Return type: int
Type: CustomData.ts_event

ts_init

int

UNIX timestamp (nanoseconds) when the object was initialized.

Return type: int
Type: CustomData.ts_init

class DataType

Bases: object

DataType(type type, dict metadata=None) -> None

Represents a data type including metadata.

Parameters:
- type (type) – The Data type of the data.
- metadata (dict) – The data types metadata.
Raises:
- ValueError – If type is not either a subclass of Data or meets the Data contract.
- TypeError – If metadata contains a key or value which is not hashable.

WARNING

This class may be used as a key in hash maps throughout the system, thus the key and value contents of metadata must themselves be hashable.

metadata

The data types metadata.

Returns: dict[str, object]

topic

The data types topic string.

Returns: str

type

The Data type of the data.

Returns: type

class FundingRateUpdate

Bases: Data

FundingRateUpdate(InstrumentId instrument_id, rate, uint64_t ts_event, uint64_t ts_init, next_funding_ns=None) -> None

Represents a funding rate update for a perpetual swap instrument.

Parameters:
- instrument_id (InstrumentId) – The instrument ID for the funding rate.
- rate (Decimal) – The current funding rate.
- next_funding_ns (int , optional) – UNIX timestamp (nanoseconds) of the next funding payment (if available).
- ts_event (int) – UNIX timestamp (nanoseconds) when the update occurred.
- ts_init (int) – UNIX timestamp (nanoseconds) when the data object was initialized.

static from_dict(dict values) → FundingRateUpdate

Return a funding rate update from the given dict values.

Parameters: values (dict *[*str , object ]) – The values for initialization.
Return type: FundingRateUpdate

static from_pyo3(pyo3_funding_rate) → FundingRateUpdate

Return a legacy Cython funding rate update converted from the given pyo3 Rust object.

Parameters: pyo3_funding_rate (nautilus_pyo3.FundingRateUpdate) – The pyo3 Rust funding rate update to convert from.
Return type: FundingRateUpdate

static from_pyo3_list(list pyo3_funding_rates) → list[FundingRateUpdate]

Return legacy Cython funding rate updates converted from the given pyo3 Rust objects.

Parameters: pyo3_funding_rates (list *[*nautilus_pyo3.FundingRateUpdate ]) – The pyo3 Rust funding rate updates to convert from.
Return type: list[FundingRateUpdate]

classmethod fully_qualified_name(cls) → str

Return the fully qualified name for the Data class.

Return type: str

instrument_id

The instrument ID for the funding rate.

Returns: InstrumentId

classmethod is_signal(cls, str name='') → 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

next_funding_ns

UNIX timestamp (nanoseconds) of the next funding payment (if available, otherwise zero).

Returns: int or None

rate

The current funding rate.

Returns: Decimal

static to_dict(FundingRateUpdate 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: FundingRateUpdate.ts_event

ts_init

int

UNIX timestamp (nanoseconds) when the object was initialized.

Return type: int
Type: FundingRateUpdate.ts_init

class IndexPriceUpdate

Bases: Data

IndexPriceUpdate(InstrumentId instrument_id, Price value, uint64_t ts_event, uint64_t ts_init) -> None

Represents an index price update.

Parameters:
- instrument_id (InstrumentId) – The instrument ID for the index price.
- value (Price) – The index price.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the update occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.

static from_dict(dict values) → IndexPriceUpdate

Return an index price from the given dict values.

Parameters: values (dict *[*str , object ]) – The values for initialization.
Return type: IndexPriceUpdate

static from_pyo3(pyo3_index_price) → IndexPriceUpdate

Return a legacy Cython index price converted from the given pyo3 Rust object.

Parameters: pyo3_trade (nautilus_pyo3.IndexPriceUpdate) – The pyo3 Rust index price to convert from.
Return type: IndexPriceUpdate

static from_pyo3_list(list pyo3_index_prices) → list[IndexPriceUpdate]

Return legacy Cython index prices converted from the given pyo3 Rust objects.

Parameters: pyo3_index_prices (list *[*nautilus_pyo3.IndexPriceUpdate ]) – The pyo3 Rust index prices to convert from.
Return type: list[IndexPriceUpdate]

classmethod fully_qualified_name(cls) → str

Return the fully qualified name for the Data class.

Return type: str

instrument_id

InstrumentId

Return the instrument ID.

Return type: InstrumentId
Type: IndexPriceUpdate.instrument_id

classmethod is_signal(cls, str name='') → 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

static to_dict(IndexPriceUpdate obj)

Return a dictionary representation of this object.

Return type: dict[str, object]

to_pyo3(self) → nautilus_pyo3.IndexPriceUpdate

Return a pyo3 object from this legacy Cython instance.

Return type: nautilus_pyo3.IndexPriceUpdate

static to_pyo3_list(list index_prices) → list[nautilus_pyo3.IndexPriceUpdate]

Return pyo3 Rust index prices converted from the given legacy Cython objects.

Parameters: mark_prices (list [IndexPriceUpdate ]) – The legacy Cython Rust index prices to convert from.
Return type: list[nautilus_pyo3.IndexPriceUpdate]

ts_event

int

UNIX timestamp (nanoseconds) when the data event occurred.

Return type: int
Type: IndexPriceUpdate.ts_event

ts_init

int

UNIX timestamp (nanoseconds) when the object was initialized.

Return type: int
Type: IndexPriceUpdate.ts_init

value

Price

The mark price.

Return type: Price
Type: IndexPriceUpdate.value

class InstrumentClose

Bases: Data

InstrumentClose(InstrumentId instrument_id, Price close_price, InstrumentCloseType close_type, uint64_t ts_event, uint64_t ts_init) -> None

Represents an instrument close at a venue.

Parameters:
- instrument_id (InstrumentId) – The instrument ID.
- close_price (Price) – The closing price for the instrument.
- close_type (InstrumentCloseType) – The type of closing price.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the close price event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the object was initialized.

close_price

The instrument close price.

Returns: Price

close_type

The instrument close type.

Returns: InstrumentCloseType

static from_dict(dict values) → InstrumentClose

Return an instrument close price event from the given dict values.

Parameters: values (dict *[*str , object ]) – The values for initialization.
Return type: InstrumentClose

static from_pyo3(pyo3_close) → InstrumentClose

Return a legacy Cython instrument close converted from the given pyo3 Rust object.

Parameters: pyo3_close (nautilus_pyo3InstrumentClose.) – The pyo3 Rust instrument close to convert from.
Return type: InstrumentClose

static from_pyo3_list(list pyo3_closes) → list[InstrumentClose]

Return legacy Cython instrument closes converted from the given pyo3 Rust objects.

Parameters: pyo3_closes (list *[*nautilus_pyo3.InstrumentClose ]) – The pyo3 Rust instrument closes to convert from.
Return type: list[InstrumentClose]

classmethod fully_qualified_name(cls) → str

Return the fully qualified name for the Data class.

Return type: str

instrument_id

The event instrument ID.

Returns: InstrumentId

classmethod is_signal(cls, str name='') → 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

static to_dict(InstrumentClose obj)

Return a dictionary representation of this object.

Return type: dict[str, object]

to_pyo3(self) → nautilus_pyo3.InstrumentClose

Return a pyo3 object from this legacy Cython instance.

Return type: nautilus_pyo3.InstrumentClose

static to_pyo3_list(list closes) → list[nautilus_pyo3.InstrumentClose]

Return pyo3 Rust index prices converted from the given legacy Cython objects.

Parameters: closes (list [InstrumentClose ]) – The legacy Cython Rust instrument closes to convert from.
Return type: list[nautilus_pyo3.InstrumentClose]

ts_event

UNIX timestamp (nanoseconds) when the data event occurred.

Returns: uint64_t

ts_init

UNIX timestamp (nanoseconds) when the instance was created.

Returns: uint64_t

class InstrumentStatus

Bases: Data

InstrumentStatus(InstrumentId instrument_id, MarketStatusAction action, uint64_t ts_event, uint64_t ts_init, str reason=None, str trading_event=None, is_trading: bool | None = None, is_quoting: bool | None = None, is_short_sell_restricted: bool | None = None) -> None

Represents an event that indicates a change in an instrument market status.

Parameters:
- instrument_id (InstrumentId) – The instrument ID for the status change.
- action (MarketStatusAction) – The instrument market status action.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the status event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the object was initialized.
- reason (str , optional) – Additional details about the cause of the status change.
- trading_event (str , optional) – Further information about the status change (if provided).
- is_trading (bool , optional) – The state of trading in the instrument.
- is_quoting (bool , optional) – The state of quoting in the instrument.
- is_short_sell_restricted (bool , optional) – The state of short sell restrictions for the instrument (if applicable).

action

The instrument market status action.

Returns: MarketStatusAction

static from_dict(dict values) → InstrumentStatus

Return an instrument status update from the given dict values.

Parameters: values (dict *[*str , object ]) – The values for initialization.
Return type: InstrumentStatus

static from_pyo3(pyo3_status) → InstrumentStatus

Return a legacy Cython quote tick converted from the given pyo3 Rust object.

Parameters: pyo3_status (nautilus_pyo3.InstrumentStatus) – The pyo3 Rust instrument status to convert from.
Return type: InstrumentStatus

static from_pyo3_list(list pyo3_status_list) → list[QuoteTick]

Return legacy Cython instrument status converted from the given pyo3 Rust objects.

Parameters: pyo3_status_list (list *[*nautilus_pyo3.InstrumentStatus ]) – The pyo3 Rust instrument status list to convert from.
Return type: list[InstrumentStatus]

classmethod fully_qualified_name(cls) → str

Return the fully qualified name for the Data class.

Return type: str

instrument_id

The instrument ID.

Returns: InstrumentId

is_quoting

bool | None

Return the state of quoting in the instrument (if known).

Return type: bool or None
Type: InstrumentStatus.is_quoting

is_short_sell_restricted

bool | None

Return the state of short sell restrictions for the instrument (if known and applicable).

Return type: bool or None
Type: InstrumentStatus.is_short_sell_restricted

classmethod is_signal(cls, str name='') → 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

is_trading

bool | None

Return the state of trading in the instrument (if known).

Return type: bool or None
Type: InstrumentStatus.is_trading

reason

Additional details about the cause of the status change.

Returns: str or None

static to_dict(InstrumentStatus obj)

Return a dictionary representation of this object.

Return type: dict[str, object]

to_pyo3(self) → nautilus_pyo3.InstrumentStatus

Return a pyo3 object from this legacy Cython instance.

Return type: nautilus_pyo3.InstrumentStatus

trading_event

Further information about the status change (if provided).

Returns: str or None

ts_event

UNIX timestamp (nanoseconds) when the data event occurred.

Returns: uint64_t

ts_init

UNIX timestamp (nanoseconds) when the instance was created.

Returns: uint64_t

class MarkPriceUpdate

Bases: Data

MarkPriceUpdate(InstrumentId instrument_id, Price value, uint64_t ts_event, uint64_t ts_init) -> None

Represents a mark price update.

Parameters:
- instrument_id (InstrumentId) – The instrument ID for the mark price.
- value (Price) – The mark price.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the update occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.

static from_dict(dict values) → MarkPriceUpdate

Return a mark price from the given dict values.

Parameters: values (dict *[*str , object ]) – The values for initialization.
Return type: MarkPriceUpdate

static from_pyo3(pyo3_mark_price) → MarkPriceUpdate

Return a legacy Cython mark price converted from the given pyo3 Rust object.

Parameters: pyo3_trade (nautilus_pyo3.MarkPriceUpdate) – The pyo3 Rust mark price to convert from.
Return type: MarkPriceUpdate

static from_pyo3_list(list pyo3_mark_prices) → list[MarkPriceUpdate]

Return legacy Cython trades converted from the given pyo3 Rust objects.

Parameters: pyo3_mark_prices (list *[*nautilus_pyo3.MarkPriceUpdate ]) – The pyo3 Rust mark prices to convert from.
Return type: list[MarkPriceUpdate]

classmethod fully_qualified_name(cls) → str

Return the fully qualified name for the Data class.

Return type: str

instrument_id

InstrumentId

Return the instrument ID.

Return type: InstrumentId
Type: MarkPriceUpdate.instrument_id

classmethod is_signal(cls, str name='') → 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

static to_dict(MarkPriceUpdate obj)

Return a dictionary representation of this object.

Return type: dict[str, object]

to_pyo3(self) → nautilus_pyo3.MarkPriceUpdate

Return a pyo3 object from this legacy Cython instance.

Return type: nautilus_pyo3.MarkPriceUpdate

static to_pyo3_list(list mark_prices) → list[nautilus_pyo3.MarkPriceUpdate]

Return pyo3 Rust mark prices converted from the given legacy Cython objects.

Parameters: mark_prices (list [MarkPriceUpdate ]) – The legacy Cython Rust mark prices to convert from.
Return type: list[nautilus_pyo3.MarkPriceUpdate]

ts_event

int

UNIX timestamp (nanoseconds) when the data event occurred.

Return type: int
Type: MarkPriceUpdate.ts_event

ts_init

int

UNIX timestamp (nanoseconds) when the object was initialized.

Return type: int
Type: MarkPriceUpdate.ts_init

value

Price

The mark price.

Return type: Price
Type: MarkPriceUpdate.value

class OrderBookDelta

Bases: Data

OrderBookDelta(InstrumentId instrument_id, BookAction action, BookOrder order: BookOrder | None, uint8_t flags, uint64_t sequence, uint64_t ts_event, uint64_t ts_init) -> None

Represents a single update/difference on an OrderBook.

Parameters:
- instrument_id (InstrumentId) – The instrument ID for the book.
- action (BookAction {ADD, UPDATE, DELETE, CLEAR}) – The order book delta action.
- order (BookOrder or None) – The book order for the delta.
- flags (uint8_t) – The record flags bit field, indicating event end and data information. A value of zero indicates no flags.
- sequence (uint64_t) – The unique sequence number for the update. If no sequence number provided in the source data then use a value of zero.
- 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 action is ADD or UPDATE and order.size is not positive (> 0).

action

BookAction

Return the deltas book action {ADD, UPDATE, DELETE, CLEAR}

Return type: BookAction
Type: OrderBookDelta.action

static capsule_from_list(list items)

static clear(InstrumentId instrument_id, uint64_t sequence, uint64_t ts_event, uint64_t ts_init)

Return an order book delta which acts as an initial CLEAR.

Return type: OrderBookDelta

flags

uint8_t

Return the flags for the delta.

Return type: uint8_t
Type: OrderBookDelta.flags

static from_dict(dict values) → OrderBookDelta

Return an order book delta from the given dict values.

Parameters: values (dict *[*str , object ]) – The values for initialization.
Return type: OrderBookDelta

static from_pyo3(pyo3_delta) → OrderBookDelta

Return a legacy Cython order book delta converted from the given pyo3 Rust object.

Parameters: pyo3_delta (nautilus_pyo3.OrderBookDelta) – The pyo3 Rust order book delta to convert from.
Return type: OrderBookDelta

static from_pyo3_list(list pyo3_deltas) → list[OrderBookDelta]

Return legacy Cython order book deltas converted from the given pyo3 Rust objects.

Parameters: pyo3_deltas (list *[*nautilus_pyo3.OrderBookDelta ]) – The pyo3 Rust order book deltas to convert from.
Return type: list[OrderBookDelta]

static from_raw(InstrumentId instrument_id, BookAction action, OrderSide side, PriceRaw price_raw, uint8_t price_prec, QuantityRaw size_raw, uint8_t size_prec, uint64_t order_id, uint8_t flags, uint64_t sequence, uint64_t ts_event, uint64_t ts_init) → OrderBookDelta

Return an order book delta from the given raw values.

Parameters:
- instrument_id (InstrumentId) – The trade instrument ID.
- action (BookAction {ADD, UPDATE, DELETE, CLEAR}) – The order book delta action.
- side (OrderSide {BUY, SELL}) – The order side.
- price_raw (int) – The order raw price (as a scaled fixed-point integer).
- price_prec (uint8_t) – The order price precision.
- size_raw (int) – The order raw size (as a scaled fixed-point integer).
- size_prec (uint8_t) – The order size precision.
- order_id (uint64_t) – The order ID.
- flags (uint8_t) – The record flags bit field, indicating event end and data information. A value of zero indicates no flags.
- sequence (uint64_t) – The unique sequence number for the update. If no sequence number provided in the source data then use a value of zero.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the tick event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
Return type: OrderBookDelta

classmethod fully_qualified_name(cls) → str

Return the fully qualified name for the Data class.

Return type: str

instrument_id

InstrumentId

Return the deltas book instrument ID.

Return type: InstrumentId
Type: OrderBookDelta.instrument_id

is_add

BookAction

If the deltas book action is an ADD.

Return type: bool
Type: OrderBookDelta.is_add

is_clear

BookAction

If the deltas book action is a CLEAR.

Return type: bool
Type: OrderBookDelta.is_clear

is_delete

BookAction

If the deltas book action is a DELETE.

Return type: bool
Type: OrderBookDelta.is_delete

classmethod is_signal(cls, str name='') → 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

is_update

BookAction

If the deltas book action is an UPDATE.

Return type: bool
Type: OrderBookDelta.is_update

static list_from_capsule(capsule) → list[OrderBookDelta]

order

BookOrder | None

Return the deltas book order for the action.

Return type: BookOrder
Type: OrderBookDelta.order

sequence

uint64_t

Return the sequence number for the delta.

Return type: uint64_t
Type: OrderBookDelta.sequence

static to_dict(OrderBookDelta obj)

Return a dictionary representation of this object.

Return type: dict[str, object]

static to_pyo3_list(list deltas) → list[nautilus_pyo3.OrderBookDelta]

Return pyo3 Rust order book deltas converted from the given legacy Cython objects.

Parameters: pyo3_deltas (list [OrderBookDelta ]) – The pyo3 Rust order book deltas to convert from.
Return type: list[nautilus_pyo3.OrderBookDelta]

ts_event

int

UNIX timestamp (nanoseconds) when the data event occurred.

Return type: int
Type: OrderBookDelta.ts_event

ts_init

int

UNIX timestamp (nanoseconds) when the object was initialized.

Return type: int
Type: OrderBookDelta.ts_init

class OrderBookDeltas

Bases: Data

OrderBookDeltas(InstrumentId instrument_id, list deltas) -> None

Represents a batch of OrderBookDelta updates for an OrderBook.

Parameters:
- instrument_id (InstrumentId) – The instrument ID for the book.
- deltas (list [OrderBookDelta ]) – The batch of order book changes.
Raises: ValueError – If deltas is an empty list.

static batch(list data: list[OrderBookDelta]) → list[OrderBookDeltas]

Groups the given list of OrderBookDelta records into batches, creating OrderBookDeltas objects when an F_LAST flag is encountered.

The method iterates through the data list and appends each OrderBookDelta to the current batch. When an F_LAST flag is found, it indicates the end of a batch. The batch is then appended to the list of completed batches and a new batch is started.

Return type: list[OrderBookDeltas]
Raises:
- ValueError – If data is empty.
- TypeError – If data is not a list of OrderBookDelta.

WARNING

UserWarning : If there are remaining deltas in the final batch after the last F_LAST flag.

deltas

list[OrderBookDelta]

Return the contained deltas.

Return type: list[OrderBookDeltas]
Type: OrderBookDeltas.deltas

flags

uint8_t

Return the flags for the last delta.

Return type: uint8_t
Type: OrderBookDeltas.flags

static from_dict(dict values) → OrderBookDeltas

Return order book deltas from the given dict values.

Parameters: values (dict *[*str , object ]) – The values for initialization.
Return type: OrderBookDeltas

classmethod fully_qualified_name(cls) → str

Return the fully qualified name for the Data class.

Return type: str

instrument_id

InstrumentId

Return the deltas book instrument ID.

Return type: InstrumentId
Type: OrderBookDeltas.instrument_id

classmethod is_signal(cls, str name='') → 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

is_snapshot

bool

If the deltas is a snapshot.

Return type: bool
Type: OrderBookDeltas.is_snapshot

sequence

uint64_t

Return the sequence number for the last delta.

Return type: uint64_t
Type: OrderBookDeltas.sequence

to_capsule(self)

static to_dict(OrderBookDeltas obj)

Return a dictionary representation of this object.

Return type: dict[str, object]

to_pyo3(self)

Return a pyo3 object from this legacy Cython instance.

Return type: nautilus_pyo3.OrderBookDeltas

ts_event

int

UNIX timestamp (nanoseconds) when the data event occurred.

Return type: int
Type: OrderBookDeltas.ts_event

ts_init

int

UNIX timestamp (nanoseconds) when the object was initialized.

Return type: int
Type: OrderBookDeltas.ts_init

class OrderBookDepth10

Bases: Data

OrderBookDepth10(InstrumentId instrument_id, list bids, list asks, list bid_counts, list ask_counts, uint8_t flags, uint64_t sequence, uint64_t ts_event, uint64_t ts_init) -> None

Represents a self-contained order book update with a fixed depth of 10 levels per side.

Parameters:
- instrument_id (InstrumentId) – The instrument ID for the book.
- bids (list [BookOrder ]) – The bid side orders for the update.
- asks (list [BookOrder ]) – The ask side orders for the update.
- bid_counts (list *[*uint32_t ]) – The count of bid orders per level for the update. Can be zeros if data not available.
- ask_counts (list *[*uint32_t ]) – The count of ask orders per level for the update. Can be zeros if data not available.
- flags (uint8_t) – The record flags bit field, indicating event end and data information. A value of zero indicates no flags.
- sequence (uint64_t) – The unique sequence number for the update. If no sequence number provided in the source data then use a value of zero.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the tick event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
Raises:
- ValueError – If bids, asks, bid_counts, ask_counts lengths are greater than 10.
- ValueError – If bids, asks, bid_counts, ask_counts lengths are not equal.

ask_counts

list[uint32_t]

Return the count of ask orders level for the update.

Return type: list[uint32_t]
Type: OrderBookDepth10.ask_counts

asks

list[BookOrder]

Return the ask orders for the update.

Return type: list[BookOrder]
Type: OrderBookDepth10.asks

bid_counts

list[uint32_t]

Return the count of bid orders per level for the update.

Return type: list[uint32_t]
Type: OrderBookDepth10.bid_counts

bids

list[BookOrder]

Return the bid orders for the update.

Return type: list[BookOrder]
Type: OrderBookDepth10.bids

static capsule_from_list(list items)

flags

uint8_t

Return the flags for the depth update.

Return type: uint8_t
Type: OrderBookDepth10.flags

static from_dict(dict values) → OrderBookDepth10

Return order book depth from the given dict values.

Parameters: values (dict *[*str , object ]) – The values for initialization.
Return type: OrderBookDepth10

static from_pyo3(pyo3_depth) → OrderBookDepth10

Return a legacy Cython order book depth converted from the given pyo3 Rust object.

Parameters: pyo3_depth (nautilus_pyo3.OrderBookDepth10) – The pyo3 Rust order book depth to convert from.
Return type: OrderBookDepth10

static from_pyo3_list(pyo3_depths) → list[OrderBookDepth10]

Return legacy Cython order book depths converted from the given pyo3 Rust objects.

Parameters: pyo3_depths (nautilus_pyo3.OrderBookDepth10) – The pyo3 Rust order book depths to convert from.
Return type: list[OrderBookDepth10]

classmethod fully_qualified_name(cls) → str

Return the fully qualified name for the Data class.

Return type: str

instrument_id

InstrumentId

Return the depth updates book instrument ID.

Return type: InstrumentId
Type: OrderBookDepth10.instrument_id

classmethod is_signal(cls, str name='') → 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

static list_from_capsule(capsule) → list[OrderBookDepth10]

sequence

uint64_t

Return the sequence number for the depth update.

Return type: uint64_t
Type: OrderBookDepth10.sequence

static to_dict(OrderBookDepth10 obj)

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: OrderBookDepth10.ts_event

ts_init

int

UNIX timestamp (nanoseconds) when the object was initialized.

Return type: int
Type: OrderBookDepth10.ts_init

class QuoteTick

Bases: Data

QuoteTick(InstrumentId instrument_id, Price bid_price, Price ask_price, Quantity bid_size, Quantity ask_size, uint64_t ts_event, uint64_t ts_init) -> None

Represents a single quote tick in a market.

Contains information about the best top-of-book bid and ask.

Parameters:
- instrument_id (InstrumentId) – The quotes instrument ID.
- bid_price (Price) – The top-of-book bid price.
- ask_price (Price) – The top-of-book ask price.
- bid_size (Quantity) – The top-of-book bid size.
- ask_size (Quantity) – The top-of-book ask size.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the tick event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
Raises:
- ValueError – If bid.precision != ask.precision.
- ValueError – If bid_size.precision != ask_size.precision.

ask_price

Price

Return the top-of-book ask price.

Return type: Price
Type: QuoteTick.ask_price

ask_size

Quantity

Return the top-of-book ask size.

Return type: Quantity
Type: QuoteTick.ask_size

bid_price

Price

Return the top-of-book bid price.

Return type: Price
Type: QuoteTick.bid_price

bid_size

Quantity

Return the top-of-book bid size.

Return type: Quantity
Type: QuoteTick.bid_size

static capsule_from_list(list items)

extract_price(self, PriceType price_type) → Price

Extract the price for the given price type.

Parameters: price_type (PriceType) – The price type to extract.
Return type: Price

extract_size(self, PriceType price_type) → Quantity

Extract the size for the given price type.

Parameters: price_type (PriceType) – The price type to extract.
Return type: Quantity

static from_dict(dict values) → QuoteTick

Return a quote tick parsed from the given values.

Parameters: values (dict *[*str , object ]) – The values for initialization.
Return type: QuoteTick

static from_pyo3(pyo3_quote) → QuoteTick

Return a legacy Cython quote tick converted from the given pyo3 Rust object.

Parameters: pyo3_quote (nautilus_pyo3.QuoteTick) – The pyo3 Rust quote tick to convert from.
Return type: QuoteTick

static from_pyo3_list(list pyo3_quotes) → list[QuoteTick]

Return legacy Cython quotes converted from the given pyo3 Rust objects.

Parameters: pyo3_quotes (list *[*nautilus_pyo3.QuoteTick ]) – The pyo3 Rust quotes to convert from.
Return type: list[QuoteTick]

static from_raw(InstrumentId instrument_id, PriceRaw bid_price_raw, PriceRaw ask_price_raw, uint8_t bid_price_prec, uint8_t ask_price_prec, QuantityRaw bid_size_raw, QuantityRaw ask_size_raw, uint8_t bid_size_prec, uint8_t ask_size_prec, uint64_t ts_event, uint64_t ts_init) → QuoteTick

Return a quote tick from the given raw values.

Parameters:
- instrument_id (InstrumentId) – The quotes instrument ID.
- bid_price_raw (int) – The raw top-of-book bid price (as a scaled fixed-point integer).
- ask_price_raw (int) – The raw top-of-book ask price (as a scaled fixed-point integer).
- bid_price_prec (uint8_t) – The bid price precision.
- ask_price_prec (uint8_t) – The ask price precision.
- bid_size_raw (int) – The raw top-of-book bid size (as a scaled fixed-point integer).
- ask_size_raw (int) – The raw top-of-book ask size (as a scaled fixed-point integer).
- bid_size_prec (uint8_t) – The bid size precision.
- ask_size_prec (uint8_t) – The ask size precision.
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the tick event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
Return type: QuoteTick
Raises:
- ValueError – If bid_price_prec != ask_price_prec.
- ValueError – If bid_size_prec != ask_size_prec.

static from_raw_arrays_to_list(InstrumentId instrument_id: InstrumentId, int price_prec: int, int size_prec: int, bid_prices_raw: np.ndarray, ask_prices_raw: np.ndarray, bid_sizes_raw: np.ndarray, ask_sizes_raw: np.ndarray, ts_events: np.ndarray, ts_inits: np.ndarray) → list[QuoteTick]

classmethod fully_qualified_name(cls) → str

Return the fully qualified name for the Data class.

Return type: str

instrument_id

InstrumentId

Return the tick instrument ID.

Return type: InstrumentId
Type: QuoteTick.instrument_id

classmethod is_signal(cls, str name='') → 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

static list_from_capsule(capsule) → list[QuoteTick]

static to_dict(QuoteTick obj)

Return a dictionary representation of this object.

Return type: dict[str, object]

to_pyo3(self) → nautilus_pyo3.QuoteTick

Return a pyo3 object from this legacy Cython instance.

Return type: nautilus_pyo3.QuoteTick

static to_pyo3_list(list quotes) → list[nautilus_pyo3.QuoteTick]

Return pyo3 Rust quotes converted from the given legacy Cython objects.

Parameters: quotes (list [QuoteTick ]) – The legacy Cython quotes to convert from.
Return type: list[nautilus_pyo3.QuoteTick]

ts_event

int

UNIX timestamp (nanoseconds) when the data event occurred.

Return type: int
Type: QuoteTick.ts_event

ts_init

int

UNIX timestamp (nanoseconds) when the object was initialized.

Return type: int
Type: QuoteTick.ts_init

class TradeTick

Bases: Data

TradeTick(InstrumentId instrument_id, Price price, Quantity size, AggressorSide aggressor_side, TradeId trade_id, uint64_t ts_event, uint64_t ts_init) -> None

Represents a single trade tick in a market.

Contains information about a single unique trade which matched buyer and seller counterparties.

Parameters:
- instrument_id (InstrumentId) – The trade instrument ID.
- price (Price) – The traded price.
- size (Quantity) – The traded size.
- aggressor_side (AggressorSide) – The trade aggressor side.
- trade_id (TradeId) – The trade match ID (assigned by the venue).
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the tick event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
Raises:
- ValueError – If trade_id is not a valid string.
- ValueError – If size is not positive (> 0).

aggressor_side

AggressorSide

Return the ticks aggressor side.

Return type: AggressorSide
Type: TradeTick.aggressor_side

static capsule_from_list(items)

static from_dict(dict values) → TradeTick

Return a trade tick from the given dict values.

Parameters: values (dict *[*str , object ]) – The values for initialization.
Return type: TradeTick

static from_pyo3(pyo3_trade) → TradeTick

Return a legacy Cython trade tick converted from the given pyo3 Rust object.

Parameters: pyo3_trade (nautilus_pyo3.TradeTick) – The pyo3 Rust trade tick to convert from.
Return type: TradeTick

static from_pyo3_list(list pyo3_trades) → list[TradeTick]

Return legacy Cython trades converted from the given pyo3 Rust objects.

Parameters: pyo3_trades (list *[*nautilus_pyo3.TradeTick ]) – The pyo3 Rust trades to convert from.
Return type: list[TradeTick]

static from_raw(InstrumentId instrument_id, PriceRaw price_raw, uint8_t price_prec, QuantityRaw size_raw, uint8_t size_prec, AggressorSide aggressor_side, TradeId trade_id, uint64_t ts_event, uint64_t ts_init) → TradeTick

Return a trade tick from the given raw values.

Parameters:
- instrument_id (InstrumentId) – The trade instrument ID.
- price_raw (int) – The traded raw price (as a scaled fixed-point integer).
- price_prec (uint8_t) – The traded price precision.
- size_raw (int) – The traded raw size (as a scaled fixed-point integer).
- size_prec (uint8_t) – The traded size precision.
- aggressor_side (AggressorSide) – The trade aggressor side.
- trade_id (TradeId) – The trade match ID (assigned by the venue).
- ts_event (uint64_t) – UNIX timestamp (nanoseconds) when the tick event occurred.
- ts_init (uint64_t) – UNIX timestamp (nanoseconds) when the data object was initialized.
Return type: TradeTick

static from_raw_arrays_to_list(InstrumentId instrument_id, uint8_t price_prec, uint8_t size_prec, double[:] prices_raw, double[:] sizes_raw, uint8_t[:] aggressor_sides, list trade_ids, uint64_t[:] ts_events, uint64_t[:] ts_inits) → list[TradeTick]

classmethod fully_qualified_name(cls) → str

Return the fully qualified name for the Data class.

Return type: str

instrument_id

InstrumentId

Return the ticks instrument ID.

Return type: InstrumentId
Type: TradeTick.instrument_id

classmethod is_signal(cls, str name='') → 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

static list_from_capsule(capsule) → list[TradeTick]

price

Price

Return the ticks price.

Return type: Price
Type: TradeTick.price

size

Quantity

Return the ticks size.

Return type: Quantity
Type: TradeTick.size

static to_dict(TradeTick obj)

Return a dictionary representation of this object.

Return type: dict[str, object]

to_pyo3(self) → nautilus_pyo3.TradeTick

Return a pyo3 object from this legacy Cython instance.

Return type: nautilus_pyo3.TradeTick

static to_pyo3_list(list trades) → list[nautilus_pyo3.TradeTick]

Return pyo3 Rust trades converted from the given legacy Cython objects.

Parameters: ticks (list [TradeTick ]) – The legacy Cython Rust trades to convert from.
Return type: list[nautilus_pyo3.TradeTick]

trade_id

InstrumentId

Return the ticks trade match ID.

Return type: Price
Type: TradeTick.trade_id

ts_event

int

UNIX timestamp (nanoseconds) when the data event occurred.

Return type: int
Type: TradeTick.ts_event

ts_init

int

UNIX timestamp (nanoseconds) when the object was initialized.

Return type: int
Type: TradeTick.ts_init

class Bar​

bar_type​

close​

static from_dict(dict values) → Bar​

static from_pyo3(pyo3_bar) → Bar​

static from_pyo3_list(list pyo3_bars) → list[Bar]​

static from_raw(BarType bar_type, PriceRaw open, PriceRaw high, PriceRaw low, PriceRaw close, uint8_t price_prec, QuantityRaw volume, uint8_t size_prec, uint64_t ts_event, uint64_t ts_init) → Bar​

static from_raw_arrays_to_list(BarType bar_type, uint8_t price_prec, uint8_t size_prec, double[:] opens, double[:] highs, double[:] lows, double[:] closes, double[:] volumes, uint64_t[:] ts_events, uint64_t[:] ts_inits) → list[Bar]​

classmethod fully_qualified_name(cls) → str​

high​

is_revision​

classmethod is_signal(cls, str name='') → bool​

is_single_price(self) → bool​

low​

open​

static to_dict(Bar obj)​

to_pyo3(self) → nautilus_pyo3.Bar​

static to_pyo3_list(list bars) → list[nautilus_pyo3.Bar]​

ts_event​

ts_init​

volume​

class BarAggregation​

conjugate()​

bit_length()​

bit_count()​

to_bytes(length=1, byteorder='big', , signed=False)​

classmethod from_bytes(bytes, byteorder='big', , signed=False)​

as_integer_ratio()​

is_integer()​

real​

imag​

numerator​

denominator​

TICK = 1​

TICK_IMBALANCE = 2​

TICK_RUNS = 3​

VOLUME = 4​

VOLUME_IMBALANCE = 5​

VOLUME_RUNS = 6​

VALUE = 7​

VALUE_IMBALANCE = 8​

VALUE_RUNS = 9​

MILLISECOND = 10​

SECOND = 11​

MINUTE = 12​

HOUR = 13​

DAY = 14​

WEEK = 15​

MONTH = 16​

YEAR = 17​

class BarIntervalType​

conjugate()​

bit_length()​

bit_count()​

to_bytes(length=1, byteorder='big', , signed=False)​

classmethod from_bytes(bytes, byteorder='big', , signed=False)​

as_integer_ratio()​

is_integer()​

real​

imag​

numerator​

denominator​

LEFT_OPEN = 0​

RIGHT_OPEN = 1​

class BarSpecification​

aggregation​

static check_information_aggregated(BarAggregation aggregation)​

static check_threshold_aggregated(BarAggregation aggregation)​

static check_time_aggregated(BarAggregation aggregation)​

static from_str(str value) → BarSpecification​

static from_timedelta(timedelta duration, PriceType price_type) → BarSpecification​

get_interval_ns(self) → uint64_t​

is_information_aggregated(self) → bool​

SEE ALSO​

is_threshold_aggregated(self) → bool​

SEE ALSO​

is_time_aggregated(self) → bool​

SEE ALSO​

price_type​

step​

class Bar

bar_type

close

static from_dict(dict values) → Bar

static from_pyo3(pyo3_bar) → Bar

static from_pyo3_list(list pyo3_bars) → list[Bar]

static from_raw(BarType bar_type, PriceRaw open, PriceRaw high, PriceRaw low, PriceRaw close, uint8_t price_prec, QuantityRaw volume, uint8_t size_prec, uint64_t ts_event, uint64_t ts_init) → Bar

static from_raw_arrays_to_list(BarType bar_type, uint8_t price_prec, uint8_t size_prec, double[:] opens, double[:] highs, double[:] lows, double[:] closes, double[:] volumes, uint64_t[:] ts_events, uint64_t[:] ts_inits) → list[Bar]

classmethod fully_qualified_name(cls) → str

high

is_revision

classmethod is_signal(cls, str name='') → bool

is_single_price(self) → bool

low

open

static to_dict(Bar obj)

to_pyo3(self) → nautilus_pyo3.Bar

static to_pyo3_list(list bars) → list[nautilus_pyo3.Bar]

ts_event

ts_init

volume

class BarAggregation

conjugate()

bit_length()

bit_count()

to_bytes(length=1, byteorder='big', , signed=False)

classmethod from_bytes(bytes, byteorder='big', , signed=False)

as_integer_ratio()

is_integer()

real

imag

numerator

denominator

TICK = 1

TICK_IMBALANCE = 2

TICK_RUNS = 3

VOLUME = 4

VOLUME_IMBALANCE = 5

VOLUME_RUNS = 6

VALUE = 7

VALUE_IMBALANCE = 8

VALUE_RUNS = 9

MILLISECOND = 10

SECOND = 11

MINUTE = 12

HOUR = 13

DAY = 14

WEEK = 15

MONTH = 16

YEAR = 17

class BarIntervalType

conjugate()

bit_length()

bit_count()

to_bytes(length=1, byteorder='big', , signed=False)

classmethod from_bytes(bytes, byteorder='big', , signed=False)

as_integer_ratio()

is_integer()

real

imag

numerator

denominator

LEFT_OPEN = 0

RIGHT_OPEN = 1

class BarSpecification

aggregation

static check_information_aggregated(BarAggregation aggregation)

static check_threshold_aggregated(BarAggregation aggregation)

static check_time_aggregated(BarAggregation aggregation)

static from_str(str value) → BarSpecification

static from_timedelta(timedelta duration, PriceType price_type) → BarSpecification

get_interval_ns(self) → uint64_t

is_information_aggregated(self) → bool

SEE ALSO

is_threshold_aggregated(self) → bool

SEE ALSO

is_time_aggregated(self) → bool

SEE ALSO

price_type

step