Replies: 2 comments 3 replies
-
|
Hi @jeusdi This looks like a few issues in the strategy code rather than an engine bug:
To fix: remove the manual handle_bar calls from on_bar, and filter by bar type so only composite bars trigger your crossover logic. |
Beta Was this translation helpful? Give feedback.
3 replies
-
Changes AppliedThanks @cjdsellers for the guidance! I've implemented all the suggested fixes: 1. ✅ Removed double indicator update
2. ✅ Removed subscription to 1-minute source bars
3. ✅ Fixed bar type filteringDiscovered that composite bars (
Removed filtering entirely since we only subscribe to one bar type. Current StatusGood news: The strategy now processes bars correctly!
Bad news: The original The error occurs in Updated CodeStrategy Code#!/usr/bin/env python3
"""Dual Moving Average Crossover Strategy"""
from nautilus_trader.config import StrategyConfig
from nautilus_trader.core.message import Event
from nautilus_trader.indicators import SimpleMovingAverage
from nautilus_trader.model.data import Bar
from nautilus_trader.model.data import BarType
from nautilus_trader.model.enums import OrderSide
from nautilus_trader.model.events import PositionClosed
from nautilus_trader.model.identifiers import InstrumentId
from nautilus_trader.model.objects import Quantity
from nautilus_trader.trading.strategy import Strategy
class DualMAConfig(StrategyConfig):
"""Configuration for Dual Moving Average strategy."""
instrument_id: InstrumentId
bar_type: str
fast_period: int = 10
slow_period: int = 30
trade_size: int = 100_000
class DualMAStrategy(Strategy):
"""Dual Moving Average crossover strategy."""
def __init__(self, config: DualMAConfig):
super().__init__(config=config)
self.fast_sma = SimpleMovingAverage(period=config.fast_period)
self.slow_sma = Simpleerage(period=config.slow_period)
self.trade_size = Quantity.from_int(config.trade_size)
self.instrument_id = config.instrument_id
self.bar_type = config.bar_type
self.last_fast_above_slow: bool | None = None
self.pending_entry: OrderSide | None = None
self.bars_processed = 0
self.crossovers_detected = 0
def on_start(self):
"""Subscribe to data."""
bar_type_obj = BarType.from_str(self.bar_type)
self.bar_type_obj = bar_type_obj
# Register indicators - automatically calls handle_bar() when bars arrive
self.register_indicator_for_bars(bar_type_obj, self.fast_sma)
self.register_indicator_for_bars(bar_type_obj, self.slow_sma)
# Subscribe to 15-minute composite bars
self.subscribe_bars(bar_type_obj)
def on_stop(self):
"""Clean up."""
self.close_all_positions(self.instrument_id)
self.unsubscribe_bars(self.bar_type_obj)
def on_bar(self, bar: Bar):
"""
Process each bar.
NOTE: Composite bars (@) result in INTERNAL bar_type without @ suffix.
No filtering needed - we only subscribe to one bar type.
"""
self.bars_processed += 1
# Wait for indicators to initialize (updated automatically by register_indicator_for_bars)
if not (self.fast_sma.initialized and self.slow_sma.initialized):
return
self.check_crossover()
def on_event(self, event: Event):
"""Handle position events."""
if (
isinstance(event, PositionClosed)
and self.pending_entry
and event.instrument_id == self.instrument_id
):
self.enter(self.pending_entry)
self.pending_entry = None
def check_crossover(self):
"""Detect crossovers and generate signals."""
fast_value = self.fast_sma.value
slow_value = self.slow_sma.value
current_fast_above_slow = fast_value > slow_value
if self.last_fast_above_slow is None:
self.last_fast_above_slow = current_fast_above_slow
return
if self.last_fast_above_slow == current_fast_above_slow:
return
# Crossover detected
self.crossovers_detected += 1
self.last_fast_above_slow = current_fast_above_slow
signal = OrderSide.BUY if current_fast_above_slow else OrderSide.SELL
self.log.info(f"🔔 CROSSOVER DETECTED #{self.crossovers_detected}: {signal}")
open_positions = self.cache.positions_open(instrument_id=self.instrument_id)
if open_positions:
self.pending_entry = signal
self.close_all_positions(self.instrument_id)
else:
self.enter(signal)
def enter(self, side: OrderSide):
"""Enter a position with a market order."""
order = self.order_factory.market(
instrument_id=self.instrument_id,
order_side=side,
quantity=self.trade_size,
)
self.submit_order(order)
self.log.info(f"📤 Market order submitted: {side} {self.trade_size} @ MARKET")Backtest Configuration# Venue config
venue = BacktestVenueConfig(
name="SIM",
oms_type="NETTING",
account_type="MARGIN",
base_currency="USD",
starting_balances=["100_000 USD"],
bar_execution=True, # Fill market orders using bar OHLC data
)
# Data config - load 1-minute bars from catalog
data_config = BacktestDataConfig(
catalog_path=str(catalog_path),
data_cls="nautilus_trader.model.data:Bar",
bar_types=["EURUSD.SIM-1-MINUTE-MID-EXTERNAL"],
)
# Strategy config - subscribe to 15-minute composite bars
strategy_config = ImportableStrategyConfig(
strategy_path="strategies.dual_ma_strategy:DualMAStrategy",
config_path="strategies.dual_ma_strategy:DualMAConfig",
config={
"instrument_id": "EURUSD.SIM",
"bar_type": "EURUSD.SIM-15-MINUTE-MID-INTERNAL@1-MINUTE-EXTERNAL",
"fast_period": 10,
"slow_period": 30,
"trade_size": 100_000,
},
)Error TracebackQuestions
Environment
Any insights would be greatly appreciated! The strategy logic works perfectly now thanks to your guidance, but we're stuck on this order filling issue. |
Beta Was this translation helpful? Give feedback.
-
|
Hey @jeusdi Thanks, this is actually a bug in an error log related to a precision mismatch in your data, explained here. Will be fixed in the next release. Related: |
Beta Was this translation helpful? Give feedback.
-
|
Thanks for confirming this is related to precision! I've been investigating the code and think I've identified the root cause. The Precision MismatchLooking at the validation code in if order.leaves_qty._mem.precision != size_prec:
raise RuntimeError(
f"Invalid size precision for order leaves quantity {order.leaves_qty._mem.precision} "
f"when instrument size precision is {size_prec}. "
f"Check order quantity precision matches the {order.instrument_id} instrument"
)This check validates that the order quantity precision matches the instrument's
How the Instrument was DefinedThe instrument was created with Dukascopy Data Download ProcessThe data is downloaded from Dukascopy's free historical data API using 1-minute bar files (BID_candles_min_1.bi5). Example URL (November 6, 2025): Note: Dukascopy uses 0-indexed months (November = 10) To inspect the raw data manually: # Download file
curl -o /tmp/dukascopy_sample.bi5 "https://datafeed.dukascopy.com/datafeed/EURUSD/2025/10/06/BID_candles_min_1.bi5"
# Decompress and inspect (showing RAW float32 values from Dukascopy)
python3 << 'EOF'
import lzma, struct
data = lzma.decompress(open("/tmp/dukascopy_sample.bi5", "rb").read())
print(f"Records: {len(data) // 24}") # Should be 1440 (24 hours * 60 minutes)
# First 3 records - completely raw
for i in range(3):
chunk = data[i*24:(i+1)*24]
time_ms, open_p, close_p, low_p, high_p, volume = struct.unpack(">5if", chunk)
print(f"\nRecord {i+1}:")
print(f" OHLC: {open_p/100000:.5f} / {high_p/100000:.5f} / {low_p/100000:.5f} / {close_p/100000:.5f}")
print(f" Volume (raw float32): {volume}")
EOFSample output from real Dukascopy data (RAW float32 values): Important: These are raw float32 values from Dukascopy's binary format. The extra precision (e.g., Download and parsing code: def download_dukascopy_bars(symbol: str, year: int, month: int, day: int, hour: int) -> list:
"""
Download 1-minute bar data from Dukascopy for a specific day.
URL format: https://datafeed.dukascopy.com/datafeed/{SYMBOL}/{YEAR}/{MONTH-1}/{DAY}/BID_candles_min_1.bi5
"""
duka_symbol = symbol.replace("/", "") # EUR/USD -> EURUSD
duka_month = month - 1 # Dukascopy uses 0-indexed months
url = f"https://datafeed.dukascopy.com/datafeed/{duka_symbol}/{year:04d}/{duka_month:02d}/{day:02d}/BID_candles_min_1.bi5"
# Download and decompress LZMA-compressed data
with urlopen(req, timeout=30) as response:
compressed_data = response.read()
data = lzma.decompress(compressed_data)
# Parse binary format: 24 bytes per record
# Fields: time(int32), open(int32), close(int32), low(int32), high(int32), volume(float32)
bars = []
chunk_size = 24
for i in range(0, len(data), chunk_size):
chunk = data[i:i + chunk_size]
time_offset, open_price, close_price, low_price, high_price, volume = struct.unpack(">5if", chunk)
# Calculate timestamp (milliseconds from start of day)
dt = datetime(year, month, day, 0, 0, 0) + timedelta(milliseconds=time_offset)
# Convert prices (divide by 100000 for 5-digit pairs)
open_price = open_price / 100000.0
high_price = high_price / 100000.0
low_price = low_price / 100000.0
close_price = close_price / 100000.0
bars.append({
"timestamp": dt,
"open": open_price,
"high": high_price,
"low": low_price,
"close": close_price,
"volume": volume, # ⚠️ Raw volume from Dukascopy (e.g., 38.47, 95460.07)
})
return barsConverting to Nautilus Formatdef convert_to_nautilus_bars(df: pd.DataFrame, instrument) -> list:
"""Convert pandas DataFrame to Nautilus Bar objects."""
bars = []
bar_type = BarType.from_str(f"{instrument.id}-1-MINUTE-MID-EXTERNAL")
for timestamp, row in df.iterrows():
# Validate OHLC relationships
o, h, l, c = row['open'], row['high'], row['low'], row['close']
if not (l <= o <= h and l <= c <= h and l <= h):
continue # Skip invalid bars
bar = Bar(
bar_type=bar_type,
open=Price.from_str(f"{o:.5f}"),
high=Price.from_str(f"{h:.5f}"),
low=Price.from_str(f"{l:.5f}"),
close=Price.from_str(f"{c:.5f}"),
volume=Quantity.from_str(f"{row['volume']:.2f}"), # ⚠️ 2 decimal precision
ts_event=int(timestamp.timestamp() * 1_000_000_000),
ts_init=int(timestamp.timestamp() * 1_000_000_000),
)
bars.append(bar)
return barsInstrument Definitionfrom nautilus_trader.model.identifiers import InstrumentId, Symbol, Venue
from nautilus_trader.model.instruments import CurrencyPair
from nautilus_trader.model.objects import Currency, Price, Quantity
instrument = CurrencyPair(
instrument_id=InstrumentId(Symbol("EURUSD"), Venue("SIM")),
raw_symbol=Symbol("EURUSD"),
base_currency=Currency.from_str("EUR"),
quote_currency=Currency.from_str("USD"),
price_precision=5,
size_precision=2, # ⚠️ Set to match Dukascopy volume format
price_increment=Price.from_str("0.00001"),
size_increment=Quantity.from_str("0.01"),
lot_size=Quantity.from_str("1"),
max_quantity=Quantity.from_str("1000000"),
min_quantity=Quantity.from_str("0.01"),
max_price=Price.from_str("9.99999"),
min_price=Price.from_str("0.00001"),
ts_event=0,
ts_init=0,
)Catalog Creationfrom nautilus_trader.persistence.catalog import ParquetDataCatalog
catalog_path = Path.cwd() / "data" / "catalog"
catalog = ParquetDataCatalog(str(catalog_path))
# Write instrument definition
catalog.write_data([instrument])
# Write bar data (133,920 1-minute bars)
catalog.write_data(bars)Sample Dukascopy Volume DataThe raw Dukascopy data shows volumes with 2 decimal places: Key observation: The volumes vary widely (from ~38 to ~95,000), which suggests they might represent different things at different times, or there's a specific unit I'm not aware of. The QuestionWhat do these Dukascopy volume values actually represent? Scenario 1: Volumes are in lots (with decimals)
Scenario 2: Volumes are in units/currency
Proposed FixOnce I understand what the volume units represent, I can fix the precision mismatch by ensuring consistency: Option A (if lots with decimals): # Instrument: size_precision=2 ✅ (keep as-is)
# Order:
trade_size = Quantity.from_str("1.00") # 1 lot with 2 decimalsOption B (if units): # Instrument: adjust size_precision to match unit representation
# Order: adjust accordinglyQuestionCould you clarify what Dukascopy volume values represent? This will help me set the correct precision for both the instrument definition and order quantities. Thanks again for your help! 🙏 |
Beta Was this translation helpful? Give feedback.
-
|
@jeusdi your issue reporting is really good. It's easy to fix issues or help when there's no doubt on the code being executed. |
Beta Was this translation helpful? Give feedback.
0 replies
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Uh oh!
There was an error while loading. Please reload this page.
-
Summary
Market orders are successfully created and submitted during backtesting but never get filled. The orders reach
OrderSubmittedstate but never receiveOrderAcceptedorOrderFilledevents, resulting in 0 positions opened despite crossover signals being detected.Issue
I'm getting this erro rmessage:
Environment
Configuration
Venue Configuration
Data Configuration
Strategy Configuration
Instrument Definition
Order Creation Code
Observed Behavior
From the backtest logs:
After this, the backtest continues processing bars but:
OrderAcceptedeventOrderFilledeventOrderRejectedeventThe backtest completes successfully with:
Expected Behavior
With
bar_execution=True, market orders should be filled immediately using the current bar's OHLC data. The expected event flow should be:OrderInitialized✅ (happens)OrderSubmitted✅ (happens)OrderAccepted❌ (missing)OrderFilled❌ (missing)Questions
Is there additional configuration needed for bar execution mode?
FillModel?book_typeparameter relevant when usingbar_execution=True?Are composite bars (
@syntax) fully supported with bar execution?Does the
SimulatedExchangerequire specific setup for market order fills?Additional Context
OrderMatchingEngineupdates with OHLC values from barsSimulatedExchangeComplete Backtest Code
Main Backtest Script
Strategy Code
Questions
Is there additional configuration needed for bar execution mode?
FillModel?book_typeparameter relevant when usingbar_execution=True?Are composite bars (
@syntax) fully supported with bar execution?Does the
SimulatedExchangerequire specific setup for market order fills?Additional Context
OrderMatchingEngineupdates with OHLC values from barsSimulatedExchangeAny guidance would be greatly appreciated! Is this a configuration issue or potentially a bug?
Related searches I've done:
Thank you!
Beta Was this translation helpful? Give feedback.
All reactions