Implementation:Nautechsystems Nautilus trader ImportableStrategyConfig Init

Field	Value
sources	https://github.com/nautechsystems/nautilus_trader, https://nautilustrader.io/docs/
domains	strategy-management, configuration-management, factory-pattern
last_updated	2026-02-10 12:00 GMT

Overview

Concrete tool for factory-based strategy instantiation from a serializable configuration provided by NautilusTrader.

Description

ImportableStrategyConfig is a frozen, immutable configuration dataclass that holds the three pieces of information needed to dynamically instantiate a trading strategy:

strategy_path -- the fully qualified Python path to the strategy class (e.g., "my_package.strategies:EMACrossStrategy").
config_path -- the fully qualified Python path to the strategy configuration class (e.g., "my_package.strategies:EMACrossStrategyConfig").
config -- a dictionary of raw configuration parameters that will be deserialized into the typed configuration class.

The companion StrategyFactory class consumes ImportableStrategyConfig instances via its static create() method, which:

Resolves the strategy class via resolve_path(config.strategy_path).
Resolves the config class via resolve_config_path(config.config_path).
Serializes the config dict to JSON using msgspec.
Parses the JSON into a typed config object via config_cls.parse(json).
Returns a new strategy instance: strategy_cls(config=typed_config).

This class is consumed by BacktestEngineConfig (via its strategies list) and ultimately by the BacktestNode to populate the trading system with strategies.

Usage

Import and instantiate ImportableStrategyConfig whenever you need to:

Declare a strategy in a backtest configuration file or script without directly importing the strategy class.
Compose multiple strategies in a BacktestEngineConfig.
Serialize a complete backtest configuration (including strategies) to JSON for storage or transfer.
Dynamically load user-defined strategies at runtime.

Code Reference

Source Location

nautilus_trader/trading/config.py, lines 103-120. The companion StrategyFactory is defined at lines 123-153.

Signature

class ImportableStrategyConfig(NautilusConfig, frozen=True):
    strategy_path: str
    config_path: str
    config: dict[str, Any]

Companion factory:

class StrategyFactory:
    @staticmethod
    def create(config: ImportableStrategyConfig) -> Strategy:
        strategy_cls = resolve_path(config.strategy_path)
        config_cls = resolve_config_path(config.config_path)
        json = msgspec.json.encode(config.config, enc_hook=msgspec_encoding_hook)
        config = config_cls.parse(json)
        return strategy_cls(config=config)

Import

from nautilus_trader.trading.config import ImportableStrategyConfig
from nautilus_trader.trading.config import StrategyFactory

I/O Contract

Inputs

Parameter	Type	Required	Default	Description
`strategy_path`	`str`	Yes	--	Fully qualified Python path to the strategy class (e.g., "module.submodule:ClassName")
`config_path`	`str`	Yes	--	Fully qualified Python path to the strategy config class
`config`	`dict[str, Any]`	Yes	--	Raw configuration parameters to deserialize into the config class

Outputs

Output	Type	Description
ImportableStrategyConfig instance	`ImportableStrategyConfig`	Frozen, immutable strategy specification. Consumed by `BacktestEngineConfig.strategies` list.
StrategyFactory.create() result	`Strategy`	A fully constructed and configured strategy instance, ready to be added to a trader.

Usage Examples

Declaring a single strategy:

from nautilus_trader.trading.config import ImportableStrategyConfig

strategy_config = ImportableStrategyConfig(
    strategy_path="nautilus_trader.examples.strategies.ema_cross:EMACross",
    config_path="nautilus_trader.examples.strategies.ema_cross:EMACrossConfig",
    config={
        "instrument_id": "EUR/USD.SIM",
        "bar_type": "EUR/USD.SIM-1-MINUTE-BID-INTERNAL",
        "fast_ema_period": 10,
        "slow_ema_period": 20,
        "trade_size": "1_000_000",
    },
)

Using with BacktestEngineConfig:

from nautilus_trader.backtest.engine import BacktestEngineConfig
from nautilus_trader.trading.config import ImportableStrategyConfig

strategy_config = ImportableStrategyConfig(
    strategy_path="my_strategies.momentum:MomentumStrategy",
    config_path="my_strategies.momentum:MomentumConfig",
    config={
        "instrument_id": "AAPL.XNAS",
        "lookback_period": 20,
        "entry_threshold": 0.02,
    },
)

engine_config = BacktestEngineConfig(
    strategies=[strategy_config],
)

Instantiating a strategy via the factory:

from nautilus_trader.trading.config import ImportableStrategyConfig
from nautilus_trader.trading.config import StrategyFactory

importable = ImportableStrategyConfig(
    strategy_path="my_strategies.mean_revert:MeanRevertStrategy",
    config_path="my_strategies.mean_revert:MeanRevertConfig",
    config={
        "instrument_id": "BTCUSDT-PERP.BINANCE",
        "lookback": 50,
        "z_threshold": 2.0,
    },
)

# Factory resolves paths, deserializes config, and returns a Strategy instance
strategy = StrategyFactory.create(importable)

Related Pages

Page Connections

Double-click a node to navigate. Hold to expand connections.

Principle

Implementation

Heuristic

Environment