Config

Backtest

parse_filters_expr(s: str | None)

Parse a pyarrow.dataset filter expression from a string.

>>> parse_filters_expr('field("Currency") == "CHF"')
<pyarrow.dataset.Expression (Currency == "CHF")>

>>> parse_filters_expr("print('hello')")

>>> parse_filters_expr("None")

class BacktestVenueConfig

Bases: NautilusConfig

Represents a venue configuration for one specific backtest engine.

• Parameters:
  • name (str) – The name of the venue.
  • oms_type (str) – The order management system type for the exchange. If HEDGING will generate new position IDs.
  • account_type (str) – The account type for the exchange.
  • starting_balances (list [Money | str ]) – The starting account balances (specify one for a single asset account).
  • base_currency (Currency | str , optional) – The account base currency for the exchange. Use None for multi-currency accounts.
  • default_leverage (float , optional) – The account default leverage (for margin accounts).
  • leverages (dict *[*str , float ] , optional) – The instrument specific leverage configuration (for margin accounts).
  • book_type (str) – The default order book type.
  • routing (bool , default False) – If multi-venue routing should be enabled for the execution client.
  • frozen_account (bool , default False) – If the account for this exchange is frozen (balances will not change).
  • reject_stop_orders (bool , default True) – If stop orders are rejected on submission if trigger price is in the market.
  • support_gtd_orders (bool , default True) – If orders with GTD time in force will be supported by the venue.
  • support_contingent_orders (bool , default True) – If contingent orders will be supported/respected by the venue. If False, then it’s expected the strategy will be managing any contingent orders.
  • use_position_ids (bool , default True) – If venue position IDs will be generated on order fills.
  • use_random_ids (bool , default False) – If all venue generated identifiers will be random UUID4’s.
  • use_reduce_only (bool , default True) – If the reduce_only execution instruction on orders will be honored.
  • bar_execution (bool , default True) – If bars should be processed by the matching engine(s) (and move the market).
  • bar_adaptive_high_low_ordering (bool , default False) – Determines whether the processing order of bar prices is adaptive based on a heuristic. This setting is only relevant when bar_execution is True. If False, bar prices are always processed in the fixed order: Open, High, Low, Close. If True, the processing order adapts with the heuristic:
    • If High is closer to Open than Low then the processing order is Open, High, Low, Close.
    • If Low is closer to Open than High then the processing order is Open, Low, High, Close.
  • trade_execution (bool , default False) – If trades should be processed by the matching engine(s) (and move the market).
  • modules (list [ImportableActorConfig ] , optional) – The simulation modules for the venue.
  • fill_model (ImportableFillModelConfig , optional) – The fill model for the venue.
  • latency_model (ImportableLatencyModelConfig , optional) – The latency model for the venue.
  • fee_model (ImportableFeeModelConfig , optional) – The fee model for the venue.

name : str

oms_type : str

account_type : str

starting_balances : list[str]

base_currency : str | None

default_leverage : float

leverages : dict[str, float] | None

book_type : str

routing : bool

frozen_account : bool

reject_stop_orders : bool

support_gtd_orders : bool

support_contingent_orders : bool

use_position_ids : bool

use_random_ids : bool

use_reduce_only : bool

bar_execution : bool

bar_adaptive_high_low_ordering : bool

trade_execution : bool

modules : list[ImportableActorConfig] | None

fill_model : ImportableFillModelConfig | None

latency_model : ImportableLatencyModelConfig | None

fee_model : ImportableFeeModelConfig | None

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class BacktestDataConfig

Bases: NautilusConfig

Represents the data configuration for one specific backtest run.

• Parameters:
  • catalog_path (str) – The path to the data catalog.
  • data_cls (str) – The data type for the configuration.
  • catalog_fs_protocol (str , optional) – The fsspec filesystem protocol for the catalog.
  • catalog_fs_storage_options (dict , optional) – The fsspec storage options.
  • instrument_id (InstrumentId | str , optional) – The instrument ID for the data configuration.
  • start_time (str or int , optional) – The start time for the data configuration. Can be an ISO 8601 format datetime string, or UNIX nanoseconds integer.
  • end_time (str or int , optional) – The end time for the data configuration. Can be an ISO 8601 format datetime string, or UNIX nanoseconds integer.
  • filter_expr (str , optional) – The additional filter expressions for the data catalog query.
  • client_id (str , optional) – The client ID for the data configuration.
  • metadata (dict or callable , optional) – The metadata for the data catalog query.
  • bar_spec (BarSpecification | str , optional) – The bar specification for the data catalog query.
  • instrument_ids (list [InstrumentId | str ] , optional) – The instrument IDs for the data catalog query. Can be used if instrument_id is not specified. If bar_spec is specified an equivalent list of bar_types will be constructed.
  • bar_types (list [BarType | str ] , optional) – The bar types for the data catalog query. Can be used if instrument_id is not specified.

catalog_path : str

data_cls : str

catalog_fs_protocol : str | None

catalog_fs_storage_options : dict | None

instrument_id : InstrumentId | None

start_time : str | int | None

end_time : str | int | None

filter_expr : str | None

client_id : str | None

metadata : dict | Any | None

bar_spec : str | None

instrument_ids : list[str] | None

bar_types : list[str] | None

property data_type : type

Return a type for the specified data_cls for the configuration.

• Return type: type

property query : dict[str, Any]

Return a catalog query object for the configuration.

• Return type: dict[str, Any]

property start_time_nanos : int

Return the data configuration start time in UNIX nanoseconds.

Will be zero if no start_time was specified.

• Return type: int

property end_time_nanos : int

Return the data configuration end time in UNIX nanoseconds.

Will be sys.maxsize if no end_time was specified.

• Return type: int

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class BacktestEngineConfig

Bases: NautilusKernelConfig

Configuration for BacktestEngine instances.

• Parameters:
  • trader_id (TraderId) – The trader ID for the node (must be a name and ID tag separated by a hyphen).
  • log_level (str , default "INFO") – The stdout log level for the node.
  • loop_debug (bool , default False) – If the asyncio event loop should be in debug mode.
  • cache (CacheConfig , optional) – The cache configuration.
  • data_engine (DataEngineConfig , optional) – The live data engine configuration.
  • risk_engine (RiskEngineConfig , optional) – The live risk engine configuration.
  • exec_engine (ExecEngineConfig , optional) – The live execution engine configuration.
  • streaming (StreamingConfig , optional) – The configuration for streaming to feather files.
  • strategies (list [ImportableStrategyConfig ]) – The strategy configurations for the kernel.
  • actors (list [ImportableActorConfig ]) – The actor configurations for the kernel.
  • exec_algorithms (list [ImportableExecAlgorithmConfig ]) – The execution algorithm configurations for the kernel.
  • controller (ImportableControllerConfig , optional) – The trader controller for the kernel.
  • load_state (bool , default True) – If trading strategy state should be loaded from the database on start.
  • save_state (bool , default True) – If trading strategy state should be saved to the database on stop.
  • bypass_logging (bool , default False) – If logging should be bypassed.
  • run_analysis (bool , default True) – If post backtest performance analysis should be run.

environment : Environment

trader_id : TraderId

data_engine : DataEngineConfig

risk_engine : RiskEngineConfig

exec_engine : ExecEngineConfig

run_analysis : bool

actors : list[ImportableActorConfig]

cache : CacheConfig | None

catalogs : list[DataCatalogConfig]

controller : ImportableControllerConfig | None

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

emulator : OrderEmulatorConfig | None

exec_algorithms : list[ImportableExecAlgorithmConfig]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

instance_id : UUID4 | None

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

load_state : bool

logging : LoggingConfig | None

loop_debug : bool

message_bus : MessageBusConfig | None

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

portfolio : PortfolioConfig | None

save_state : bool

strategies : list[ImportableStrategyConfig]

streaming : StreamingConfig | None

timeout_connection : PositiveFloat

timeout_disconnection : PositiveFloat

timeout_portfolio : PositiveFloat

timeout_post_stop : PositiveFloat

timeout_reconciliation : PositiveFloat

timeout_shutdown : PositiveFloat

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class BacktestRunConfig

Bases: NautilusConfig

Represents the configuration for one specific backtest run.

This includes a backtest engine with its actors and strategies, with the external inputs of venues and data.

• Parameters:
  • venues (list [BacktestVenueConfig ]) – The venue configurations for the backtest run.
  • data (list [BacktestDataConfig ]) – The data configurations for the backtest run.
  • engine (BacktestEngineConfig) – The backtest engine configuration (the core system kernel).
  • chunk_size (int , optional) – The number of data points to process in each chunk during streaming mode. If None, the backtest will run without streaming, loading all data at once.
  • raise_exception (bool , default False) – If exceptions during an engine build or run should be raised to interrupt the nodes process.
  • dispose_on_completion (bool , default True) – If the backtest engine should be disposed on completion of the run. If True, then will drop data and all state. If False, then will only drop data.
  • start (datetime or str or int , optional) – The start datetime (UTC) for the backtest run. If None engine runs from the start of the data.
  • end (datetime or str or int , optional) – The end datetime (UTC) for the backtest run. If None engine runs to the end of the data.
  • data_clients (dict *[*str , type [LiveDataClientConfig ] ] , optional) – The data clients configuration for the backtest run.

venues : list[BacktestVenueConfig]

data : list[BacktestDataConfig]

engine : BacktestEngineConfig | None

chunk_size : int | None

raise_exception : bool

dispose_on_completion : bool

start : str | int | None

end : str | int | None

data_clients : dict[str, type[LiveDataClientConfig]] | None

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class SimulationModuleConfig

Bases: ActorConfig

Configuration for SimulationModule instances.

component_id : ComponentId | None

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

log_commands : bool

log_events : bool

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class FillModelConfig

Bases: NautilusConfig

Configuration for FillModel instances.

• Parameters:
  • prob_fill_on_limit (float , default 1.0) – The probability of limit order filling if the market rests on its price.
  • prob_fill_on_stop (float , default 1.0) – The probability of stop orders filling if the market rests on its price.
  • prob_slippage (float , default 0.0) – The probability of order fill prices slipping by one tick.
  • random_seed (int , optional) – The random seed (if None then no random seed).

prob_fill_on_limit : float

prob_fill_on_stop : float

prob_slippage : float

random_seed : int | None

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class ImportableFillModelConfig

Bases: NautilusConfig

Configuration for a fill model instance.

• Parameters:
  • fill_model_path (str) – The fully qualified name of the fill model class.
  • config_path (str) – The fully qualified name of the config class.
  • config (dict *[*str , Any ]) – The fill model configuration.

fill_model_path : str

config_path : str

config : dict[str, Any]

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class FillModelFactory

Bases: object

Provides fill model creation from importable configurations.

static create(config: ImportableFillModelConfig)

Create a fill model from the given configuration.

• Parameters: config (ImportableFillModelConfig) – The configuration for the building step.
• Return type: FillModel
• Raises: TypeError – If config is not of type ImportableFillModelConfig.

class LatencyModelConfig

Bases: NautilusConfig

Configuration for LatencyModel instances.

• Parameters:
  • base_latency_nanos (int , default 1_000_000_000) – The base latency (nanoseconds) for the model.
  • insert_latency_nanos (int , default 0) – The order insert latency (nanoseconds) for the model.
  • update_latency_nanos (int , default 0) – The order update latency (nanoseconds) for the model.
  • cancel_latency_nanos (int , default 0) – The order cancel latency (nanoseconds) for the model.

base_latency_nanos : Annotated[int, msgspec.Meta(ge=0)]

insert_latency_nanos : Annotated[int, msgspec.Meta(ge=0)]

update_latency_nanos : Annotated[int, msgspec.Meta(ge=0)]

cancel_latency_nanos : Annotated[int, msgspec.Meta(ge=0)]

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class ImportableLatencyModelConfig

Bases: NautilusConfig

Configuration for a latency model instance.

• Parameters:
  • latency_model_path (str) – The fully qualified name of the latency model class.
  • config_path (str) – The fully qualified name of the config class.
  • config (dict *[*str , Any ]) – The latency model configuration.

latency_model_path : str

config_path : str

config : dict[str, Any]

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class LatencyModelFactory

Bases: object

Provides latency model creation from importable configurations.

static create(config: ImportableLatencyModelConfig)

Create a latency model from the given configuration.

• Parameters: config (ImportableLatencyModelConfig) – The configuration for the building step.
• Return type: LatencyModel
• Raises: TypeError – If config is not of type ImportableLatencyModelConfig.

class FeeModelConfig

Bases: NautilusConfig

Base configuration for FeeModel instances.

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class MakerTakerFeeModelConfig

Bases: FeeModelConfig

Configuration for MakerTakerFeeModel instances.

This fee model uses the maker/taker fees defined on the instrument.

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class FixedFeeModelConfig

Bases: FeeModelConfig

Configuration for FixedFeeModel instances.

• Parameters:
  • commission (Money | str) – The fixed commission amount for trades.
  • charge_commission_once (bool , default True) – Whether to charge the commission once per order or per fill.

commission : str

charge_commission_once : bool

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class PerContractFeeModelConfig

Bases: FeeModelConfig

Configuration for PerContractFeeModel instances.

• Parameters: commission (Money | str) – The commission amount per contract.

commission : str

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class ImportableFeeModelConfig

Bases: NautilusConfig

Configuration for a fee model instance.

• Parameters:
  • fee_model_path (str) – The fully qualified name of the fee model class.
  • config_path (str) – The fully qualified name of the config class.
  • config (dict *[*str , Any ]) – The fee model configuration.

fee_model_path : str

config_path : str

config : dict[str, Any]

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class FeeModelFactory

Bases: object

Provides fee model creation from importable configurations.

static create(config: ImportableFeeModelConfig)

Create a fee model from the given configuration.

• Parameters: config (ImportableFeeModelConfig) – The configuration for the building step.
• Return type: FeeModel
• Raises: TypeError – If config is not of type ImportableFeeModelConfig.

class FXRolloverInterestConfig

Bases: SimulationModuleConfig

Provides an FX rollover interest simulation module.

• Parameters: rate_data (pd.DataFrame) – The interest rate data for the internal rollover interest calculator.

rate_data : pd.DataFrame

component_id : ComponentId | None

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

log_commands : bool

log_events : bool

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

Cache

class CacheConfig

Bases: NautilusConfig

Configuration for Cache instances.

• Parameters:
  • database (DatabaseConfig , optional) – The configuration for the cache backing database.
  • encoding (str , {'msgpack' , 'json'} , default 'msgpack') – The encoding for database operations, controls the type of serializer used.
  • timestamps_as_iso8601 – If timestamps should be persisted as ISO 8601 strings. If False then will persit as UNIX nanoseconds.
  • False (default) – If timestamps should be persisted as ISO 8601 strings. If False then will persit as UNIX nanoseconds.
  • buffer_interval_ms (PositiveInt , optional) – The buffer interval (milliseconds) between pipelined/batched transactions. The recommended range if using buffered pipeling is [10, 1000] milliseconds, with a good compromise being 100 milliseconds.
  • use_trader_prefix (bool , default True) – If a ‘trader-’ prefix is used for keys.
  • use_instance_id (bool , default False) – If the traders instance ID is used for keys.
  • flush_on_start (bool , default False) – If database should be flushed on start.
  • drop_instruments_on_reset (bool , default True) – If instruments data should be dropped from the caches memory on reset.
  • tick_capacity (PositiveInt , default 10_000) – The maximum length for internal tick dequeues.
  • bar_capacity (PositiveInt , default 10_000) – The maximum length for internal bar dequeues.

database : DatabaseConfig | None

encoding : str

timestamps_as_iso8601 : bool

buffer_interval_ms : Annotated[int, msgspec.Meta(gt=0)] | None

use_trader_prefix : bool

use_instance_id : bool

flush_on_start : bool

drop_instruments_on_reset : bool

tick_capacity : Annotated[int, msgspec.Meta(gt=0)]

bar_capacity : Annotated[int, msgspec.Meta(gt=0)]

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

Common

exception InvalidConfiguration

Bases: RuntimeError

Raised when there is a violation of a configuration condition, making it invalid.

add_note(object,)

Exception.add_note(note) – add a note to the exception

args

with_traceback(object,)

Exception.with_traceback(tb) – set self._traceback_ to tb and return self.

resolve_path(path: str) → type

resolve_config_path(path: str) → type[NautilusConfig]

nautilus_schema_hook(type_: type[Any]) → dict[str, Any]

msgspec_encoding_hook(obj: Any) → Any

msgspec_decoding_hook(obj_type: type, obj: Any) → Any

register_config_encoding(type_: type, encoder: Callable) → None

register_config_decoding(type_: type, decoder: Callable) → None

tokenize_config(obj: NautilusConfig) → str

class NautilusConfig

Bases: Struct

The base class for all Nautilus configuration objects.

property id : str

Return the hashed identifier for the configuration.

• Return type: str

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class DatabaseConfig

Bases: NautilusConfig

Configuration for database connections.

• Parameters:
  • type (str , {'redis'} , default 'redis') – The database type.
  • host (str , optional) – The database host address. If None then should use the typical default.
  • port (int , optional) – The database port. If None then should use the typical default.
  • username (str , optional) – The account username for the database connection.
  • password (str , optional) – The account password for the database connection. If a value is provided then it will be redacted in the string repr for this object.
  • ssl (bool , default False) – If socket should use an SSL (TLS encryption) enabled connection.
  • timeout (int , default 20) – The timeout (seconds) to wait for a new connection.

type : str

host : str | None

port : int | None

username : str | None

password : str | None

ssl : bool

timeout : int | None

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class MessageBusConfig

Bases: NautilusConfig

Configuration for MessageBus instances.

• Parameters:
  • database (DatabaseConfig , optional) – The configuration for the message bus backing database.
  • encoding (str , {'msgpack' , 'json'} , default 'msgpack') – The encoding for database operations, controls the type of serializer used.
  • timestamps_as_iso8601 – If timestamps should be persisted as ISO 8601 strings. If False then will persit as UNIX nanoseconds.
  • False (default) – If timestamps should be persisted as ISO 8601 strings. If False then will persit as UNIX nanoseconds.
  • buffer_interval_ms (PositiveInt , optional) – The buffer interval (milliseconds) between pipelined/batched transactions. The recommended range if using buffered pipeling is [10, 1000] milliseconds, with a good compromise being 100 milliseconds.
  • autotrim_mins (int , optional) – The lookback window in minutes for automatic stream trimming. The actual window may extend up to one minute beyond the specified value since streams are trimmed at most once every minute. Note that this feature requires Redis version 6.2 or higher; otherwise it will result in a command syntax error.
  • use_trader_prefix (bool , default True) – If a ‘trader-’ prefix is used for stream names.
  • use_trader_id (bool , default True) – If the traders ID is used for stream names.
  • use_instance_id (bool , default False) – If the traders instance ID is used for stream names.
  • streams_prefix (str , default 'stream') – The prefix for externally published stream names (must have a database config). If use_trader_id and use_instance_id are both false, then it becomes possible for many traders to be configured to write to the same streams.
  • stream_per_topic (bool , default True) – If True, messages will be written to separate streams per topic. If False, all messages will be written to the same stream.
  • external_streams (list *[*str ] , optional) – The external stream keys the node will listen to for publishing deserialized message payloads on the internal message bus.
  • types_filter (list *[*type ] , optional) – A list of serializable types not to publish externally.
  • heartbeat_interval_secs (PositiveInt , optional) – The heartbeat interval (seconds) to use for trading node health.

database : DatabaseConfig | None

encoding : str

timestamps_as_iso8601 : bool

buffer_interval_ms : Annotated[int, msgspec.Meta(gt=0)] | None

autotrim_mins : int | None

use_trader_prefix : bool

use_trader_id : bool

use_instance_id : bool

streams_prefix : str

stream_per_topic : bool

external_streams : list[str] | None

types_filter : list[type] | None

heartbeat_interval_secs : Annotated[int, msgspec.Meta(gt=0)] | None

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class InstrumentProviderConfig

Bases: NautilusConfig

Configuration for InstrumentProvider instances.

• Parameters:
  • load_all (bool , default False) – If all venue instruments should be loaded on start.
  • load_ids (frozenset [InstrumentId ] , optional) – The list of instrument IDs to be loaded on start (if load_all is False).
  • filters (frozendict or dict *[*str , Any ] , optional) – The venue specific instrument loading filters to apply.
  • filter_callable (str , optional) – A fully qualified path to a callable that takes a single argument, instrument and returns a bool, indicating whether the instrument should be loaded
  • log_warnings (bool , default True) – If parser warnings should be logged.

load_all : bool

load_ids : frozenset[InstrumentId] | None

filters : dict[str, Any] | None

filter_callable : str | None

log_warnings : bool

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class OrderEmulatorConfig

Bases: NautilusConfig

Configuration for OrderEmulator instances.

• Parameters: debug (bool , default False) – If debug mode is active (will provide extra debug logging).

debug : bool

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class ActorConfig

Bases: NautilusConfig

The base model for all actor configurations.

• Parameters:
  • component_id (ComponentId , optional) – The component ID. If None then the identifier will be taken from type(self)._name_.
  • log_events (bool , default True) – If events should be logged by the actor. If False, then only warning events and above are logged.
  • log_commands (bool , default True) – If commands should be logged by the actor.

component_id : ComponentId | None

log_events : bool

log_commands : bool

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class ImportableActorConfig

Bases: NautilusConfig

Configuration for an actor instance.

• Parameters:
  • actor_path (str) – The fully qualified name of the Actor class.
  • config_path (str) – The fully qualified name of the Actor Config class.
  • config (dict) – The actor configuration.

actor_path : str

config_path : str

config : dict

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class ActorFactory

Bases: object

Provides actor creation from importable configurations.

static create(config: ImportableActorConfig)

Create an actor from the given configuration.

• Parameters: config (ImportableActorConfig) – The configuration for the building step.
• Return type: Actor
• Raises: TypeError – If config is not of type ImportableActorConfig.

class LoggingConfig

Bases: NautilusConfig

Configuration for standard output and file logging for a NautilusKernel instance.

• Parameters:
  • log_level (str , default "INFO") – The minimum log level to write to stdout. Will always write ERROR level logs to stderr (unless bypass_logging is True).
  • log_level_file (str , optional) – The minimum log level to write to a log file. If None then no file logging will occur.
  • log_directory (str , optional) – The path to the log file directory. If None then will write to the current working directory.
  • log_file_name (str , optional) – The custom log file name (will use a ‘.log’ suffix for plain text or ‘.json’ for JSON). This will override automatic naming, and no daily file rotation will occur.
  • log_file_format (str { 'JSON' } , optional) – The log file format. If None (default) then will log in plain text.
  • log_file_max_size (PositiveInt , optional) – The maximum size of log files in bytes before rotation occurs.
  • log_file_max_backup_count (NonNegativeInt , default 5) – The maximum number of backup log files to keep when rotating.
  • log_colors (bool , default True) – If ANSI codes should be used to produce colored log lines.
  • log_component_levels (dict *[*str , LogLevel ]) – The additional per component log level filters, where keys are component IDs (e.g. actor/strategy IDs) and values are log levels.
  • bypass_logging (bool , default False) – If all logging should be bypassed.
  • print_config (bool , default False) – If the core logging configuration should be printed to stdout at initialization.
  • use_pyo3 (bool , default False) – If the logging subsystem should be initialized via pyo3, this isn’t recommended for backtesting as the performance is much lower but can be useful for seeing logs originating from Rust.
  • clear_log_file (bool , default False) – If the log file name should be cleared before being used (e.g. for testing). Only applies if log_file_name is not None.

log_level : str

log_level_file : str | None

log_directory : str | None

log_file_name : str | None

log_file_format : str | None

log_file_max_size : Annotated[int, msgspec.Meta(gt=0)] | None

log_file_max_backup_count : Annotated[int, msgspec.Meta(ge=0)]

log_colors : bool

log_component_levels : dict[str, str] | None

bypass_logging : bool

print_config : bool

use_pyo3 : bool

clear_log_file : bool

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class ImportableFactoryConfig

Bases: NautilusConfig

Represents an importable (JSON) factory config.

path : str

create()

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class ImportableConfig

Bases: NautilusConfig

Represents an importable configuration (typically live data client or live execution client).

path : str

config : dict

factory : ImportableFactoryConfig | None

static is_importable(data: dict) → bool

create()

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

Data

class DataEngineConfig

Bases: NautilusConfig

Configuration for DataEngine instances.

• Parameters:
  • time_bars_interval_type (str , default 'left-open') – Determines the type of interval used for time aggregation.
    • ‘left-open’: start time is excluded and end time is included (default).
    • ‘right-open’: start time is included and end time is excluded.
  • time_bars_timestamp_on_close (bool , default True) – If time bar aggregators will timestamp ts_event on bar close. If False, then will timestamp on bar open.
  • time_bars_skip_first_non_full_bar (bool , default False) – If time bar aggregators will skip emitting a bar if the aggregation starts mid-interval.
  • time_bars_build_with_no_updates (bool , default True) – If time bar aggregators will build and emit bars with no new market updates.
  • time_bars_origin_offset (dict [BarAggregation , pd.Timedelta | pd.DateOffset ] , optional) – A dictionary mapping time bar aggregations to their origin time offsets.
  • time_bars_build_delay (int , default 0) – The time delay (microseconds) before building and emitting a composite bar type. 15 microseconds can be useful in a backtest context, when aggregating internal bars from internal bars several times so all messages are processed before a timer triggers.
  • validate_data_sequence (bool , default False) – If data objects timestamp sequencing will be validated and handled.
  • buffer_deltas (bool , default False) – If order book deltas should be buffered until the F_LAST flag is set for a delta.
  • external_clients (list [ClientId ] , optional) – The client IDs declared for external stream processing. The data engine will not attempt to send data commands to these client IDs.
  • debug (bool , default False) – If debug mode is active (will provide extra debug logging).

time_bars_interval_type : str

time_bars_timestamp_on_close : bool

time_bars_skip_first_non_full_bar : bool

time_bars_build_with_no_updates : bool

time_bars_origin_offset : dict | None

time_bars_build_delay : int

validate_data_sequence : bool

buffer_deltas : bool

external_clients : list[ClientId] | None

debug : bool

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

Execution

class ExecEngineConfig

Bases: NautilusConfig

Configuration for ExecutionEngine instances.

• Parameters:
  • load_cache (bool , default True) – If the cache should be loaded on initialization.
  • manage_own_order_books (bool , default False) – If the execution engine should maintain own/user order books based on commands and events.
  • snapshot_orders (bool , default False) – If order state snapshot lists are persisted to a backing database. Snapshots will be taken at every order state update (when events are applied).
  • snapshot_positions (bool , default False) – If position state snapshot lists are persisted to a backing database. Snapshots will be taken at position opened, changed and closed (when events are applied). To include the unrealized PnL in the snapshot then quotes for the positions instrument must be available in the cache.
  • snapshot_positions_interval_secs (PositiveFloat , optional) – The interval (seconds) at which additional position state snapshots are persisted to a backing database. If None then no additional snapshots will be taken. To include unrealized PnL in these snapshots, quotes for the position’s instrument must be available in the cache.
  • debug (bool , default False) – If debug mode is active (will provide extra debug logging).

load_cache : bool

manage_own_order_books : bool

snapshot_orders : bool

snapshot_positions : bool

snapshot_positions_interval_secs : Annotated[float, msgspec.Meta(gt=0.0)] | None

debug : bool

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class ExecAlgorithmConfig

Bases: NautilusConfig

The base model for all execution algorithm configurations.

• Parameters:
  • exec_algorithm_id (ExecAlgorithmId , optional) – The unique ID for the execution algorithm. If not None then will become the execution algorithm ID.
  • log_events (bool , default True) – If events should be logged by the execution algorithm. If False, then only warning events and above are logged.
  • log_commands (bool , default True) – If commands should be logged by the execution algorithm.

exec_algorithm_id : ExecAlgorithmId | None

log_events : bool

log_commands : bool

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class ImportableExecAlgorithmConfig

Bases: NautilusConfig

Configuration for an execution algorithm instance.

• Parameters:
  • exec_algorithm_path (str) – The fully qualified name of the execution algorithm class.
  • config_path (str) – The fully qualified name of the config class.
  • config (dict *[*str , Any ]) – The execution algorithm configuration.

exec_algorithm_path : str

config_path : str

config : dict[str, Any]

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class ExecAlgorithmFactory

Bases: object

Provides execution algorithm creation from importable configurations.

static create(config: ImportableExecAlgorithmConfig)

Create an execution algorithm from the given configuration.

• Parameters: config (ImportableExecAlgorithmConfig) – The configuration for the building step.
• Return type: ExecAlgorithm
• Raises: TypeError – If config is not of type ImportableExecAlgorithmConfig.

Live

class LiveDataEngineConfig

Bases: DataEngineConfig

Configuration for LiveDataEngine instances.

• Parameters:
  • qsize (PositiveInt , default 100_000) – The queue size for the engines internal queue buffers.
  • graceful_shutdown_on_exception (bool , default False) – If the system should perform a graceful shutdown when an unexpected exception occurs during message queue processing (does not include user actor/strategy exceptions).

qsize : PositiveInt

graceful_shutdown_on_exception : bool

buffer_deltas : bool

debug : bool

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

external_clients : list[ClientId] | None

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

time_bars_build_delay : int

time_bars_build_with_no_updates : bool

time_bars_interval_type : str

time_bars_origin_offset : dict | None

time_bars_skip_first_non_full_bar : bool

time_bars_timestamp_on_close : bool

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

validate_data_sequence : bool

class LiveRiskEngineConfig

Bases: RiskEngineConfig

Configuration for LiveRiskEngine instances.

• Parameters:
  • qsize (PositiveInt , default 100_000) – The queue size for the engines internal queue buffers.
  • graceful_shutdown_on_exception (bool , default False) – If the system should perform a graceful shutdown when an unexpected exception occurs during message queue processing (does not include user actor/strategy exceptions).

qsize : Annotated[int, msgspec.Meta(gt=0)]

graceful_shutdown_on_exception : bool

bypass : bool

debug : bool

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

max_notional_per_order : dict[str, int]

max_order_modify_rate : str

max_order_submit_rate : str

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class LiveExecEngineConfig

Bases: ExecEngineConfig

Configuration for LiveExecEngine instances.

The purpose of the in-flight order check is for live reconciliation, events emitted from the venue may have been lost at some point - leaving an order in an intermediate state, the check can recover these events via status reports.

• Parameters:
  • reconciliation (bool , default True) – If reconciliation is active at start-up.
  • reconciliation_lookback_mins (NonNegativeInt , optional) – The maximum lookback minutes to reconcile state for. If None or 0 then will use the maximum lookback available from the venues.
  • filter_unclaimed_external_orders (bool , default False) – If unclaimed order events with an EXTERNAL strategy ID should be filtered/dropped.
  • filter_position_reports (bool , default False) – If position status reports are filtered from reconciliation. This may be applicable when other nodes are trading the same instrument(s), on the same account - which could cause conflicts in position status.
  • generate_missing_orders (bool , default True) – If MARKET order events will be generated during reconciliation to align discrepancies between internal and external positions.
  • inflight_check_interval_ms (NonNegativeInt , default 2_000) – The interval (milliseconds) between checking whether in-flight orders have exceeded their time-in-flight threshold. This should not be set less than the inflight_check_threshold_ms.
  • inflight_check_threshold_ms (NonNegativeInt , default 5_000) – The threshold (milliseconds) beyond which an in-flight orders status is checked with the venue. As a rule of thumb, you shouldn’t consider reducing this setting unless you are colocated with the venue (to avoid the potential for race conditions).
  • inflight_check_retries (NonNegativeInt , default 5) – The number of retry attempts the engine will make to verify the status of an in-flight order with the venue, should the initial attempt fail.
  • own_books_audit_interval_secs (NonNegativeFloat , optional) – The interval (seconds) between auditing all own books against public order books. The audit will ensure all order statuses are in sync and that no closed orders remain in an own book. Logs all failures as errors.
  • open_check_interval_secs (PositiveFloat , optional) – The interval (seconds) between checks for open orders at the venue. If there is a discrepancy then an order status report is generated and reconciled. A recommended setting is between 5-10 seconds, consider API rate limits and the additional request weights. If no value is specified then the open order checking task is not started.
  • open_check_open_only (bool , default True) – If True, the check_open_orders requests only currently open orders from the venue. If False, it requests the entire order history, which can be a heavy API call. This parameter only applies if the check_open_orders task is running.
  • purge_closed_orders_interval_mins (PositiveInt , optional) – The interval (minutes) between purging closed orders from the in-memory cache, will not purge from the database. If None, closed orders will not be automatically purged. A recommended setting is 10-15 minutes for HFT.
  • purge_closed_orders_buffer_mins (NonNegativeInt , optional) – The time buffer (minutes) from when an order was closed before it can be purged. Only orders closed for at least this amount of time will be purged. A recommended setting is 60 minutes for HFT.
  • purge_closed_positions_interval_mins (PositiveInt , optional) – The interval (minutes) between purging closed positions from the in-memory cache, will not purge from the database. If None, closed positions will not be automatically purged. A recommended setting is 10-15 minutes for HFT.
  • purge_closed_positions_buffer_mins (NonNegativeInt , optional) – The time buffer (minutes) from when a position was closed before it can be purged. Only positions closed for at least this amount of time will be purged. A recommended setting is 60 minutes for HFT.
  • purge_account_events_interval_mins (PositiveInt , optional) – The interval (minutes) between purging account events from the in-memory cache, will not purge from the database. If None, closed orders will not be automatically purged. A recommended setting is 10-15 minutes for HFT.
  • purge_account_events_lookback_mins (NonNegativeInt , optional) – The time buffer (minutes) from when an account event occurred before it can be purged. Only events outside the lookback window will be purged. A recommended setting is 60 minutes for HFT.
  • purge_from_database (bool , default False) – If purging operations will also delete from the backing database, in addition to the in-memory cache.
  • qsize (PositiveInt , default 100_000) – The queue size for the engines internal queue buffers.
  • graceful_shutdown_on_exception (bool , default False) – If the system should perform a graceful shutdown when an unexpected exception occurs during message queue processing (does not include user actor/strategy exceptions).

reconciliation : bool

reconciliation_lookback_mins : Annotated[int, msgspec.Meta(ge=0)] | None

filter_unclaimed_external_orders : bool

filter_position_reports : bool

generate_missing_orders : bool

inflight_check_interval_ms : Annotated[int, msgspec.Meta(ge=0)]

inflight_check_threshold_ms : Annotated[int, msgspec.Meta(ge=0)]

inflight_check_retries : Annotated[int, msgspec.Meta(ge=0)]

own_books_audit_interval_secs : Annotated[float, msgspec.Meta(gt=0.0)] | None

open_check_interval_secs : Annotated[float, msgspec.Meta(gt=0.0)] | None

open_check_open_only : bool

purge_closed_orders_interval_mins : Annotated[int, msgspec.Meta(gt=0)] | None

purge_closed_orders_buffer_mins : Annotated[int, msgspec.Meta(ge=0)] | None

purge_closed_positions_interval_mins : Annotated[int, msgspec.Meta(gt=0)] | None

purge_closed_positions_buffer_mins : Annotated[int, msgspec.Meta(ge=0)] | None

purge_account_events_interval_mins : Annotated[int, msgspec.Meta(gt=0)] | None

purge_account_events_lookback_mins : Annotated[int, msgspec.Meta(ge=0)] | None

purge_from_database : bool

qsize : Annotated[int, msgspec.Meta(gt=0)]

graceful_shutdown_on_exception : bool

debug : bool

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

load_cache : bool

manage_own_order_books : bool

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

snapshot_orders : bool

snapshot_positions : bool

snapshot_positions_interval_secs : Annotated[float, msgspec.Meta(gt=0.0)] | None

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class RoutingConfig

Bases: NautilusConfig

Configuration for live client message routing.

• Parameters:
  • default (bool) – If the client should be registered as the default routing client (when a specific venue routing cannot be found).
  • venues (list *[*str ] , optional) – The venues to register for routing.

default : bool

venues : frozenset[str] | None

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class LiveDataClientConfig

Bases: NautilusConfig

Configuration for LiveDataClient instances.

• Parameters:
  • handle_revised_bars (bool) – If DataClient will emit bar updates when a new bar opens.
  • instrument_provider (InstrumentProviderConfig) – The clients instrument provider configuration.
  • routing (RoutingConfig) – The clients message routing config.

handle_revised_bars : bool

instrument_provider : InstrumentProviderConfig

routing : RoutingConfig

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class LiveExecClientConfig

Bases: NautilusConfig

Configuration for LiveExecutionClient instances.

• Parameters:
  • instrument_provider (InstrumentProviderConfig) – The clients instrument provider configuration.
  • routing (RoutingConfig) – The clients message routing config.

instrument_provider : InstrumentProviderConfig

routing : RoutingConfig

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class ControllerConfig

Bases: ActorConfig

The base model for all controller configurations.

component_id : ComponentId | None

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

log_commands : bool

log_events : bool

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class ControllerFactory

Bases: object

Provides controller creation from importable configurations.

static create(config: ImportableControllerConfig, trader)

class TradingNodeConfig

Bases: NautilusKernelConfig

Configuration for TradingNode instances.

• Parameters:
  • trader_id (TraderId , default "TRADER-001") – The trader ID for the node (must be a name and ID tag separated by a hyphen).
  • cache (CacheConfig , optional) – The cache configuration.
  • data_engine (LiveDataEngineConfig , optional) – The live data engine configuration.
  • risk_engine (LiveRiskEngineConfig , optional) – The live risk engine configuration.
  • exec_engine (LiveExecEngineConfig , optional) – The live execution engine configuration.
  • data_clients (dict *[*str , ImportableConfig | LiveDataClientConfig ] , optional) – The data client configurations.
  • exec_clients (dict *[*str , ImportableConfig | LiveExecClientConfig ] , optional) – The execution client configurations.

environment : Environment

trader_id : TraderId

data_engine : LiveDataEngineConfig

risk_engine : LiveRiskEngineConfig

exec_engine : LiveExecEngineConfig

data_clients : dict[str, LiveDataClientConfig]

exec_clients : dict[str, LiveExecClientConfig]

actors : list[ImportableActorConfig]

cache : CacheConfig | None

catalogs : list[DataCatalogConfig]

controller : ImportableControllerConfig | None

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

emulator : OrderEmulatorConfig | None

exec_algorithms : list[ImportableExecAlgorithmConfig]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

instance_id : UUID4 | None

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

load_state : bool

logging : LoggingConfig | None

loop_debug : bool

message_bus : MessageBusConfig | None

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

portfolio : PortfolioConfig | None

save_state : bool

strategies : list[ImportableStrategyConfig]

streaming : StreamingConfig | None

timeout_connection : PositiveFloat

timeout_disconnection : PositiveFloat

timeout_portfolio : PositiveFloat

timeout_post_stop : PositiveFloat

timeout_reconciliation : PositiveFloat

timeout_shutdown : PositiveFloat

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

Persistence

class StreamingConfig

Bases: NautilusConfig

Configuration for streaming live or backtest runs to the catalog in feather format.

• Parameters:
  • catalog_path (str) – The path to the data catalog.
  • fs_protocol (str , optional) – The fsspec filesystem protocol for the catalog.
  • fs_storage_options (dict , optional) – The fsspec storage options.
  • flush_interval_ms (int , optional) – The flush interval (milliseconds) for writing chunks.
  • replace_existing (bool , default False) – If any existing feather files should be replaced.
  • include_types (list *[*type ] , optional) – A list of Arrow serializable types to write. If this is specified then only the included types will be written.
  • rotation_mode (RotationMode , default RotationMode.NO_ROTATION) – The mode for file rotation.
  • max_file_size (int , default 1GB) – The maximum file size in bytes before rotation (for SIZE mode).
  • rotation_interval (pd.Timedelta , optional) – The time interval for file rotation (for INTERVAL mode and SCHEDULED_DATES mode).
  • rotation_time (time , default 00:00) – The time of day for file rotation (for SCHEDULED_DATES mode).
  • rotation_timezone (str , default 'UTC') – The timezone for rotation calculations (for SCHEDULED_DATES mode).

catalog_path : str

fs_protocol : str | None

fs_storage_options : dict | None

flush_interval_ms : int | None

replace_existing : bool

include_types : list[type] | None

rotation_mode : RotationMode

max_file_size : int

rotation_interval : Timedelta | None

rotation_time : time

rotation_timezone : str

property fs

as_catalog()

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class DataCatalogConfig

Bases: NautilusConfig

Configuration for a data catalog.

• Parameters:
  • path (str) – The path to the data catalog.
  • fs_protocol (str , optional) – The fsspec file system protocol for the data catalog.
  • fs_storage_options (dict , optional) – The fsspec storage options for the data catalog.

path : str

fs_protocol : str | None

fs_storage_options : dict | None

name : str | None

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

Risk

class RiskEngineConfig

Bases: NautilusConfig

Configuration for RiskEngine instances.

• Parameters:
  • bypass (bool , default False) – If True, then will bypass all pre-trade risk checks and rate limits (will still check for duplicate IDs).
  • max_order_submit_rate (str , default 100/00:00:01) – The maximum rate of submit order commands per timedelta.
  • max_order_modify_rate (str , default 100/00:00:01) – The maximum rate of modify order commands per timedelta.
  • max_notional_per_order (dict *[*str , int ] , default empty dict) – The maximum notional value of an order per instrument ID. The value should be a valid decimal format.
  • debug (bool , default False) – If debug mode is active (will provide extra debug logging).

bypass : bool

max_order_submit_rate : str

max_order_modify_rate : str

max_notional_per_order : dict[str, int]

debug : bool

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

System

class NautilusKernelConfig

Bases: NautilusConfig

Configuration for a NautilusKernel core system instance.

• Parameters:
  • environment (Environment { BACKTEST, SANDBOX, LIVE }) – The kernel environment context.
  • trader_id (TraderId) – The trader ID for the kernel (must be a name and ID tag separated by a hyphen).
  • instance_id (UUID4 , optional) – The unique instance identifier for the kernel.
  • cache (CacheConfig , optional) – The cache configuration.
  • message_bus (MessageBusConfig , optional) – The message bus configuration.
  • data_engine (DataEngineConfig , optional) – The data engine configuration.
  • risk_engine (RiskEngineConfig , optional) – The risk engine configuration.
  • exec_engine (ExecEngineConfig , optional) – The execution engine configuration.
  • portfolio (PortfolioConfig , optional) – The portfolio configuration.
  • emulator (OrderEmulatorConfig , optional) – The order emulator configuration.
  • streaming (StreamingConfig , optional) – The configuration for streaming to feather files.
  • catalogs (list [DataCatalogConfig ] , optional) – The list of data catalog configurations.
  • actors (list [ImportableActorConfig ]) – The actor configurations for the kernel.
  • strategies (list [ImportableStrategyConfig ]) – The strategy configurations for the kernel.
  • exec_algorithms (list [ImportableExecAlgorithmConfig ]) – The execution algorithm configurations for the kernel.
  • controller (ImportableControllerConfig , optional) – The trader controller for the kernel.
  • load_state (bool , default True) – If trading strategy state should be loaded from the database on start.
  • save_state (bool , default True) – If trading strategy state should be saved to the database on stop.
  • loop_debug (bool , default False) – If the asyncio event loop should be in debug mode.
  • logging (LoggingConfig , optional) – The logging configuration for the kernel.
  • timeout_connection (PositiveFloat , default 60) – The timeout (seconds) for all clients to connect and initialize.
  • timeout_reconciliation (PositiveFloat , default 30) – The timeout (seconds) for execution state to reconcile.
  • timeout_portfolio (PositiveFloat , default 10) – The timeout (seconds) for portfolio to initialize margins and unrealized PnLs.
  • timeout_disconnection (PositiveFloat , default 10) – The timeout (seconds) for all engine clients to disconnect.
  • timeout_post_stop (PositiveFloat , default 10) – The timeout (seconds) after stopping the node to await residual events before final shutdown.
  • timeout_shutdown (PositiveFloat , default 5) – The timeout (seconds) to await pending tasks cancellation during shutdown.

environment : Environment

trader_id : TraderId

instance_id : UUID4 | None

cache : CacheConfig | None

message_bus : MessageBusConfig | None

data_engine : DataEngineConfig | None

risk_engine : RiskEngineConfig | None

exec_engine : ExecEngineConfig | None

portfolio : PortfolioConfig | None

emulator : OrderEmulatorConfig | None

streaming : StreamingConfig | None

catalogs : list[DataCatalogConfig]

actors : list[ImportableActorConfig]

strategies : list[ImportableStrategyConfig]

exec_algorithms : list[ImportableExecAlgorithmConfig]

controller : ImportableControllerConfig | None

load_state : bool

save_state : bool

loop_debug : bool

logging : LoggingConfig | None

timeout_connection : Annotated[float, msgspec.Meta(gt=0.0)]

timeout_reconciliation : Annotated[float, msgspec.Meta(gt=0.0)]

timeout_portfolio : Annotated[float, msgspec.Meta(gt=0.0)]

timeout_disconnection : Annotated[float, msgspec.Meta(gt=0.0)]

timeout_post_stop : Annotated[float, msgspec.Meta(gt=0.0)]

timeout_shutdown : Annotated[float, msgspec.Meta(gt=0.0)]

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

Trading

class StrategyConfig

Bases: NautilusConfig

The base model for all trading strategy configurations.

• Parameters:
  • strategy_id (StrategyId , optional) – The unique ID for the strategy. Will become the strategy ID if not None.
  • order_id_tag (str , optional) – The unique order ID tag for the strategy. Must be unique amongst all running strategies for a particular trader ID.
  • use_uuid_client_order_ids (bool , default False) – If UUID4’s should be used for client order ID values.
  • oms_type (OmsType , optional) – The order management system type for the strategy. This will determine how the ExecutionEngine handles position IDs.
  • external_order_claims (list [InstrumentId ] , optional) – The external order claim instrument IDs. External orders for matching instrument IDs will be associated with (claimed by) the strategy.
  • manage_contingent_orders (bool , default False) – If OUO and OCO open contingent orders should be managed automatically by the strategy. Any emulated orders which are active local will be managed by the OrderEmulator instead.
  • manage_gtd_expiry (bool , default False) – If all order GTD time in force expirations should be managed by the strategy. If True, then will ensure open orders have their GTD timers re-activated on start.
  • log_events (bool , default True) – If events should be logged by the strategy. If False, then only warning events and above are logged.
  • log_commands (bool , default True) – If commands should be logged by the strategy.

strategy_id : StrategyId | None

order_id_tag : str | None

use_uuid_client_order_ids : bool

oms_type : str | None

external_order_claims : list[InstrumentId] | None

manage_contingent_orders : bool

manage_gtd_expiry : bool

log_events : bool

log_commands : bool

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class ImportableStrategyConfig

Bases: NautilusConfig

Configuration for a trading strategy instance.

• Parameters:
  • strategy_path (str) – The fully qualified name of the strategy class.
  • config_path (str) – The fully qualified name of the config class.
  • config (dict *[*str , Any ]) – The strategy configuration.

strategy_path : str

config_path : str

config : dict[str, Any]

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool

class StrategyFactory

Bases: object

Provides strategy creation from importable configurations.

static create(config: ImportableStrategyConfig)

Create a trading strategy from the given configuration.

• Parameters: config (ImportableStrategyConfig) – The configuration for the building step.
• Return type: Strategy
• Raises: TypeError – If config is not of type ImportableStrategyConfig.

class ImportableControllerConfig

Bases: NautilusConfig

Configuration for a controller instance.

• Parameters:
  • controller_path (str) – The fully qualified name of the controller class.
  • config_path (str) – The fully qualified name of the config class.
  • config (dict *[*str , Any ]) – The controller configuration.

controller_path : str

config_path : str

config : dict

dict() → dict[str, Any]

Return a dictionary representation of the configuration.

• Return type: dict[str, Any]

classmethod fully_qualified_name() → str

Return the fully qualified name for the NautilusConfig class.

• Return type: str

property id : str

Return the hashed identifier for the configuration.

• Return type: str

json() → bytes

Return serialized JSON encoded bytes.

• Return type: bytes

json_primitives() → dict[str, Any]

Return a dictionary representation of the configuration with JSON primitive types as values.

• Return type: dict[str, Any]

classmethod json_schema() → dict[str, Any]

Generate a JSON schema for this configuration class.

• Return type: dict[str, Any]

classmethod parse(raw: bytes | str) → Any

Return a decoded object of the given cls.

• Parameters:
  • cls (type) – The type to decode to.
  • raw (bytes or str) – The raw bytes or JSON string to decode.
• Return type: Any

validate() → bool

Return whether the configuration can be represented as valid JSON.

• Return type: bool