def setup(self):
# Fixture Setup
self.clock = TestClock()
self.logger = Logger(self.clock)
self.trader_id = TestStubs.trader_id()
self.account_id = TestStubs.account_id()
self.msgbus = MessageBus(
trader_id=self.trader_id,
clock=self.clock,
logger=self.logger,
)
self.cache = TestStubs.cache()
self.portfolio = Portfolio(
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.data_engine = DataEngine(
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.data_engine.process(USDJPY_SIM)
self.exec_engine = ExecutionEngine(
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.exchange = SimulatedExchange(
venue=Venue("SIM"),
venue_type=VenueType.ECN,
oms_type=OMSType.HEDGING,
account_type=AccountType.MARGIN,
base_currency=USD,
starting_balances=[Money(1_000_000, USD)],
default_leverage=Decimal(50),
leverages={},
is_frozen_account=False,
cache=self.cache,
instruments=[USDJPY_SIM],
modules=[],
fill_model=FillModel(),
clock=self.clock,
logger=self.logger,
)
self.data_client = BacktestMarketDataClient(
client_id=ClientId("SIM"),
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.exec_client = BacktestExecClient(
exchange=self.exchange,
account_id=self.account_id,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.risk_engine = RiskEngine(
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
# Wire up components
self.data_engine.register_client(self.data_client)
self.exec_engine.register_client(self.exec_client)
self.trader = Trader(
trader_id=self.trader_id,
msgbus=self.msgbus,
cache=self.cache,
portfolio=self.portfolio,
data_engine=self.data_engine,
risk_engine=self.risk_engine,
exec_engine=self.exec_engine,
clock=self.clock,
logger=self.logger,
)
def symbol_xbtusd_bitmex() -> Symbol:
return Symbol("XBT/USD", Venue('BITMEX'))
def symbol_btcusd_binance() -> Symbol:
return Symbol("BTC/USD", Venue('BINANCE'))
from nautilus_trader.data.messages import DataRequest
from nautilus_trader.data.messages import DataResponse
from nautilus_trader.data.messages import Subscribe
from nautilus_trader.live.data_engine import LiveDataEngine
from nautilus_trader.model.data import Data
from nautilus_trader.model.data import DataType
from nautilus_trader.model.identifiers import ClientId
from nautilus_trader.model.identifiers import InstrumentId
from nautilus_trader.model.identifiers import Symbol
from nautilus_trader.model.identifiers import Venue
from nautilus_trader.model.tick import QuoteTick
from nautilus_trader.trading.portfolio import Portfolio
from tests.test_kit.providers import TestInstrumentProvider
from tests.test_kit.stubs import TestStubs
BITMEX = Venue("BITMEX")
BINANCE = Venue("BINANCE")
XBTUSD_BITMEX = TestInstrumentProvider.xbtusd_bitmex()
BTCUSDT_BINANCE = TestInstrumentProvider.btcusdt_binance()
ETHUSDT_BINANCE = TestInstrumentProvider.ethusdt_binance()
class LiveDataEngineTests(unittest.TestCase):
def setUp(self):
# Fixture Setup
self.clock = LiveClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(self.clock, level_stdout=LogLevel.DEBUG)
self.portfolio = Portfolio(
clock=self.clock,
from nautilus_trader.model.enums import OrderState
from nautilus_trader.model.identifiers import ExecutionId
from nautilus_trader.model.identifiers import PositionId
from nautilus_trader.model.identifiers import StrategyId
from nautilus_trader.model.identifiers import TraderId
from nautilus_trader.model.identifiers import Venue
from nautilus_trader.model.identifiers import VenueOrderId
from nautilus_trader.model.objects import Price
from nautilus_trader.model.objects import Quantity
from nautilus_trader.trading.portfolio import Portfolio
from nautilus_trader.trading.strategy import TradingStrategy
from tests.test_kit.mocks import MockLiveExecutionClient
from tests.test_kit.providers import TestInstrumentProvider
from tests.test_kit.stubs import TestStubs
SIM = Venue("SIM")
AUDUSD_SIM = TestInstrumentProvider.default_fx_ccy("AUD/USD")
GBPUSD_SIM = TestInstrumentProvider.default_fx_ccy("GBP/USD")
class TestLiveExecutionEngine:
def setup(self):
# Fixture Setup
self.clock = LiveClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(self.clock)
self.trader_id = TraderId("TESTER", "000")
self.account_id = TestStubs.account_id()
self.order_factory = OrderFactory(
def setUp(self):
# Fixture Setup
clock = TestClock()
logger = Logger(clock)
trader_id = TraderId("TESTER-000")
account_id = TestStubs.account_id()
self.cache = TestStubs.cache()
self.portfolio = Portfolio(
cache=self.cache,
clock=clock,
logger=logger,
)
self.data_engine = DataEngine(
portfolio=self.portfolio,
cache=self.cache,
clock=clock,
logger=logger,
config={"use_previous_close": False},
)
self.data_engine.process(USDJPY_SIM)
self.exec_engine = ExecutionEngine(
portfolio=self.portfolio,
cache=self.cache,
clock=clock,
logger=logger,
)
self.exchange = SimulatedExchange(
venue=Venue("SIM"),
venue_type=VenueType.ECN,
oms_type=OMSType.HEDGING,
account_type=AccountType.MARGIN,
base_currency=USD,
starting_balances=[Money(1_000_000, USD)],
is_frozen_account=False,
cache=self.exec_engine.cache,
instruments=[USDJPY_SIM],
modules=[],
fill_model=FillModel(),
clock=clock,
logger=logger,
)
self.data_client = BacktestMarketDataClient(
client_id=ClientId("SIM"),
engine=self.data_engine,
clock=clock,
logger=logger,
)
self.exec_client = BacktestExecClient(
exchange=self.exchange,
account_id=account_id,
account_type=AccountType.MARGIN,
base_currency=USD,
engine=self.exec_engine,
clock=clock,
logger=logger,
)
self.risk_engine = RiskEngine(
exec_engine=self.exec_engine,
portfolio=self.portfolio,
cache=self.cache,
clock=clock,
logger=logger,
)
# Wire up components
self.data_engine.register_client(self.data_client)
self.exec_engine.register_risk_engine(self.risk_engine)
self.exec_engine.register_client(self.exec_client)
strategies = [
TradingStrategy("001"),
TradingStrategy("002"),
]
self.trader = Trader(
trader_id=trader_id,
strategies=strategies,
portfolio=self.portfolio,
data_engine=self.data_engine,
risk_engine=self.risk_engine,
exec_engine=self.exec_engine,
clock=clock,
logger=logger,
)
# limitations under the License.
# -------------------------------------------------------------------------------------------------
import unittest
from nautilus_trader.core.message import Message
from nautilus_trader.core.message import MessageType
from nautilus_trader.core.uuid import uuid4
from nautilus_trader.model.commands import SubmitOrder
from nautilus_trader.model.identifiers import Symbol
from nautilus_trader.model.identifiers import Venue
from tests.test_kit.performance import PerformanceHarness
from tests.test_kit.stubs import UNIX_EPOCH
AUDUSD = Symbol("AUDUSD", Venue("IDEALPRO"))
MESSAGE = Message(MessageType.COMMAND, uuid4(), UNIX_EPOCH)
class Experiments:
@staticmethod
def built_in_arithmetic():
x = 1 + 1
return x
@staticmethod
def class_name():
x = "123".__class__.__name__
return x
from nautilus_trader.model.enums import AccountType
from nautilus_trader.model.enums import OMSType
from nautilus_trader.model.enums import OrderSide
from nautilus_trader.model.enums import OrderStatus
from nautilus_trader.model.identifiers import Venue
from nautilus_trader.model.objects import Money
from nautilus_trader.model.objects import Quantity
from nautilus_trader.msgbus.bus import MessageBus
from nautilus_trader.portfolio.portfolio import Portfolio
from nautilus_trader.risk.engine import RiskEngine
from tests.test_kit.mocks.strategies import MockStrategy
from tests.test_kit.stubs.component import TestComponentStubs
from tests.test_kit.stubs.data import TestDataStubs
from tests.test_kit.stubs.identifiers import TestIdStubs
FTX = Venue("FTX")
ETHUSD_FTX = TestInstrumentProvider.ethusd_ftx()
class TestSimulatedExchangeContingencyAdvancedOrders:
def setup(self):
# Fixture Setup
self.clock = TestClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(
clock=self.clock,
level_stdout=LogLevel.INFO,
)
self.trader_id = TestIdStubs.trader_id()
# -------------------------------------------------------------------------------------------------
# Copyright (C) 2015-2022 Nautech Systems Pty Ltd. All rights reserved.
# https://nautechsystems.io
#
# Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
# You may not use this file except in compliance with the License.
# You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# -------------------------------------------------------------------------------------------------
from nautilus_trader.model.identifiers import Venue
# It's recommended to have one constant for the venue
TEMPLATE_VENUE = Venue("TEMPLATE")
def setup(self):
# Fixture Setup
self.clock = TestClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(
clock=self.clock,
level_stdout=LogLevel.DEBUG,
)
self.trader_id = TestStubs.trader_id()
self.account_id = TestStubs.account_id()
self.msgbus = MessageBus(
trader_id=self.trader_id,
clock=self.clock,
logger=self.logger,
)
self.cache = TestStubs.cache()
self.portfolio = Portfolio(
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.data_engine = DataEngine(
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.exec_engine = ExecutionEngine(
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.risk_engine = RiskEngine(
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.exchange = SimulatedExchange(
venue=Venue("SIM"),
venue_type=VenueType.ECN,
oms_type=OMSType.HEDGING,
account_type=AccountType.MARGIN,
base_currency=USD,
starting_balances=[Money(1_000_000, USD)],
default_leverage=Decimal(50),
leverages={},
is_frozen_account=False,
cache=self.cache,
instruments=[USDJPY_SIM],
modules=[],
fill_model=FillModel(),
clock=self.clock,
logger=self.logger,
latency_model=LatencyModel(0),
)
self.data_client = BacktestMarketDataClient(
client_id=ClientId("SIM"),
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.exec_client = BacktestExecClient(
exchange=self.exchange,
account_id=self.account_id,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
# Wire up components
self.exchange.register_client(self.exec_client)
self.data_engine.register_client(self.data_client)
self.exec_engine.register_client(self.exec_client)
self.exchange.reset()
# Add instruments
self.data_engine.process(AUDUSD_SIM)
self.data_engine.process(GBPUSD_SIM)
self.data_engine.process(USDJPY_SIM)
self.cache.add_instrument(AUDUSD_SIM)
self.cache.add_instrument(GBPUSD_SIM)
self.cache.add_instrument(USDJPY_SIM)
self.exchange.process_tick(TestStubs.quote_tick_3decimal(
USDJPY_SIM.id)) # Prepare market
self.data_engine.start()
self.exec_engine.start()
# -------------------------------------------------------------------------------------------------
# Copyright (C) 2015-2022 Nautech Systems Pty Ltd. All rights reserved.
# https://nautechsystems.io
#
# Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
# You may not use this file except in compliance with the License.
# You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# -------------------------------------------------------------------------------------------------
from nautilus_trader.model.identifiers import Venue
BINANCE_VENUE = Venue("BINANCE")
from tests.test_kit.strategies import EMACross
# TODO: AtomicOrder with Market entry not working (needs peg)
# Requirements to run;
# - A Redis instance listening on the default port 6379
# - A NautilusData instance listening on the default ports
# - A NautilusExecutor instance listening on the default ports
BAR_SPEC_FX = BarSpecification(1, BarStructure.MINUTE, PriceType.BID)
BAR_SPEC_CFD = BarSpecification(5, BarStructure.MINUTE, PriceType.BID)
# BAR_SPEC_FX = BarSpecification(100, BarStructure.TICK, PriceType.BID)
# BAR_SPEC_CFD = BarSpecification(500, BarStructure.TICK, PriceType.BID)
symbols_fx = [
Symbol('AUD/USD', Venue('FXCM')),
Symbol('EUR/USD', Venue('FXCM')),
Symbol('GBP/USD', Venue('FXCM')),
Symbol('USD/JPY', Venue('FXCM')),
]
strategies_fx = []
for symbol in symbols_fx:
strategies_fx.append(
EMACross(symbol,
BAR_SPEC_FX,
risk_bp=10.0,
fast_ema=10,
slow_ema=20,
atr_period=20))
def default_fx_ccy(symbol: str, venue: Venue = None) -> CurrencySpot:
"""
Return a default FX currency pair instrument from the given instrument_id.
Parameters
----------
symbol : str
The currency pair symbol.
venue : Venue
The currency pair venue.
Returns
-------
CurrencySpot
Raises
------
ValueError
If `symbol` length is not in range [6, 7].
"""
if venue is None:
venue = Venue("SIM")
PyCondition.valid_string(symbol, "symbol")
PyCondition.in_range_int(len(symbol), 6, 7, "len(symbol)")
instrument_id = InstrumentId(
symbol=Symbol(symbol),
venue=venue,
)
base_currency = symbol[:3]
quote_currency = symbol[-3:]
# Check tick precision of quote currency
if quote_currency == "JPY":
price_precision = 3
else:
price_precision = 5
return CurrencySpot(
instrument_id=instrument_id,
local_symbol=Symbol(symbol),
base_currency=Currency.from_str(base_currency),
quote_currency=Currency.from_str(quote_currency),
price_precision=price_precision,
size_precision=0,
price_increment=Price(1 / 10**price_precision, price_precision),
size_increment=Quantity.from_int(1),
lot_size=Quantity.from_str("1000"),
max_quantity=Quantity.from_str("1e7"),
min_quantity=Quantity.from_str("1000"),
max_price=None,
min_price=None,
max_notional=Money(50000000.00, USD),
min_notional=Money(1000.00, USD),
margin_init=Decimal("0.03"),
margin_maint=Decimal("0.03"),
maker_fee=Decimal("0.00002"),
taker_fee=Decimal("0.00002"),
ts_event=0,
ts_init=0,
)
"api_key":
"BINANCE_API_KEY", # value is the environment variable key
"api_secret":
"BINANCE_API_SECRET", # value is the environment variable key
"sandbox_mode": False, # If clients use the testnet
},
},
}
# Instantiate your strategies to pass into the trading node. You could add
# custom options into the configuration file or even use another configuration
# file.
instrument_id = InstrumentId(
symbol=Symbol("ETH/USDT"),
venue=Venue("BINANCE"),
)
strategy = VolatilityMarketMaker(
instrument_id=instrument_id,
bar_spec=BarSpecification(1, BarAggregation.MINUTE, PriceType.LAST),
trade_size=Decimal("0.05"),
atr_period=20,
atr_multiple=1.0,
order_id_tag="001",
)
# Instantiate the node passing a list of strategies and configuration
node = TradingNode(strategies=[strategy], config=config)
# Stop and dispose of the node with SIGINT/CTRL+C
def setUp(self):
# Fixture Setup
self.clock = TestClock()
self.uuid_factory = TestUUIDFactory()
self.logger = TestLogger(self.clock)
self.portfolio = Portfolio(
clock=self.clock,
uuid_factory=self.uuid_factory,
logger=self.logger,
)
self.data_engine = DataEngine(
tick_capacity=1000,
bar_capacity=1000,
portfolio=self.portfolio,
clock=self.clock,
uuid_factory=self.uuid_factory,
logger=self.logger,
)
self.data_engine.set_use_previous_close(False)
self.analyzer = PerformanceAnalyzer()
trader_id = TraderId('TESTER', '000')
account_id = TestStubs.account_id()
self.exec_db = BypassExecutionDatabase(
trader_id=trader_id,
logger=self.logger,
)
self.exec_engine = ExecutionEngine(
database=self.exec_db,
portfolio=self.portfolio,
clock=self.clock,
uuid_factory=self.uuid_factory,
logger=self.logger,
)
usdjpy = InstrumentLoader.default_fx_ccy(TestStubs.symbol_usdjpy_fxcm())
self.market = SimulatedMarket(
venue=Venue("FXCM"),
oms_type=OMSType.HEDGING,
generate_position_ids=True,
exec_cache=self.exec_engine.cache,
instruments={usdjpy.symbol: usdjpy},
config=BacktestConfig(),
fill_model=FillModel(),
commission_model=GenericCommissionModel(),
clock=self.clock,
uuid_factory=TestUUIDFactory(),
logger=self.logger,
)
self.exec_client = BacktestExecClient(
market=self.market,
account_id=account_id,
engine=self.exec_engine,
logger=self.logger,
)
self.exec_engine.register_client(self.exec_client)
self.market.register_client(self.exec_client)
self.exec_engine.process(TestStubs.event_account_state())
self.market.process_tick(TestStubs.quote_tick_3decimal(usdjpy.symbol)) # Prepare market
self.strategy = TradingStrategy(order_id_tag="001")
self.strategy.register_trader(
trader_id=TraderId("TESTER", "000"),
clock=self.clock,
uuid_factory=self.uuid_factory,
logger=self.logger,
)
self.strategy.register_data_engine(self.data_engine)
self.strategy.register_execution_engine(self.exec_engine)
print("\n")
from nautilus_trader.model.enums import BarAggregation
from nautilus_trader.model.enums import PriceType
from nautilus_trader.model.identifiers import ClientId
from nautilus_trader.model.identifiers import InstrumentId
from nautilus_trader.model.identifiers import Symbol
from nautilus_trader.model.identifiers import TraderId
from nautilus_trader.model.identifiers import Venue
from nautilus_trader.model.tick import TradeTick
from nautilus_trader.trading.portfolio import Portfolio
from tests import TESTS_PACKAGE_ROOT
from tests.test_kit.mocks import ObjectStorer
from tests.test_kit.stubs import TestStubs
TEST_PATH = TESTS_PACKAGE_ROOT + "/integration_tests/adapters/ccxt/responses/"
BINANCE = Venue("BINANCE")
BTCUSDT = InstrumentId(Symbol("BTC/USDT"), BINANCE)
ETHUSDT = InstrumentId(Symbol("ETH/USDT"), BINANCE)
# Monkey patch magic mock
# This allows the stubbing of calls to coroutines
MagicMock.__await__ = lambda x: async_magic().__await__()
# Dummy method for above
async def async_magic():
return
class CCXTDataClientTests(unittest.TestCase):
def setUp(self):
from nautilus_trader.model.identifiers import StrategyId
from nautilus_trader.model.identifiers import TraderId
from nautilus_trader.model.identifiers import Venue
from nautilus_trader.model.objects import AccountBalance
from nautilus_trader.model.objects import Money
from nautilus_trader.model.objects import Price
from nautilus_trader.model.objects import Quantity
from nautilus_trader.model.position import Position
from nautilus_trader.model.tick import QuoteTick
from nautilus_trader.risk.engine import RiskEngine
from nautilus_trader.trading.portfolio import Portfolio
from nautilus_trader.trading.portfolio import PortfolioFacade
from tests.test_kit.providers import TestInstrumentProvider
from tests.test_kit.stubs import TestStubs
SIM = Venue("SIM")
BINANCE = Venue("BINANCE")
BITMEX = Venue("BITMEX")
AUDUSD_SIM = TestInstrumentProvider.default_fx_ccy("AUD/USD")
GBPUSD_SIM = TestInstrumentProvider.default_fx_ccy("GBP/USD")
USDJPY_SIM = TestInstrumentProvider.default_fx_ccy("USD/JPY")
BTCUSDT_BINANCE = TestInstrumentProvider.btcusdt_binance()
BTCUSD_BITMEX = TestInstrumentProvider.xbtusd_bitmex()
ETHUSD_BITMEX = TestInstrumentProvider.ethusd_bitmex()
class PortfolioFacadeTests(unittest.TestCase):
def test_account_raises_not_implemented_error(self):
# Arrange
portfolio = PortfolioFacade()
"data_client": True, # If a data client should be created
"exec_client": True, # If a exec client should be created
"api_token": "OANDA_API_TOKEN", # value is the environment variable key
"account_id": "OANDA_ACCOUNT_ID", # value is the environment variable key
},
},
}
# Instantiate your strategies to pass into the trading node. You could add
# custom options into the configuration file or even use another configuration
# file.
instrument1 = InstrumentId(
symbol=Symbol("AUD/USD"),
venue=Venue("OANDA"),
)
strategy1 = EMACross(
instrument_id=instrument1,
bar_spec=BarSpecification(1, BarAggregation.MINUTE, PriceType.MID),
fast_ema_period=10,
slow_ema_period=20,
trade_size=Decimal(10000),
order_id_tag="001",
)
# ------------------------------------------------------------------------------
instrument2 = InstrumentId(
symbol=Symbol("EUR/USD"),
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# -------------------------------------------------------------------------------------------------
import asyncio
import pytest
from nautilus_trader.common.providers import InstrumentProvider
from nautilus_trader.model.identifiers import Venue
from tests.test_kit.stubs import TestStubs
BITMEX = Venue("BITMEX")
AUDUSD = TestStubs.audusd_id()
class TestInstrumentProvider:
def setup(self):
# Fixture Setup
self.provider = InstrumentProvider()
def test_load_all_async_when_not_implemented_raises_exception(self):
# Fresh isolated loop testing pattern
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
async def run_test():
class TestBarType:
def test_bar_type_equality(self):
# Arrange
instrument_id1 = InstrumentId(Symbol("AUD/USD"), Venue("SIM"))
instrument_id2 = InstrumentId(Symbol("GBP/USD"), Venue("SIM"))
bar_spec = BarSpecification(1, BarAggregation.MINUTE, PriceType.BID)
bar_type1 = BarType(instrument_id1, bar_spec)
bar_type2 = BarType(instrument_id1, bar_spec)
bar_type3 = BarType(instrument_id2, bar_spec)
# Act
# Assert
assert bar_type1 == bar_type1
assert bar_type1 == bar_type2
assert bar_type1 != bar_type3
def test_bar_type_to_serializable_string(self):
# Arrange
instrument_id = InstrumentId(Symbol("AUD/USD"), Venue("IDEALPRO"))
bar_spec = BarSpecification(1, BarAggregation.MINUTE, PriceType.BID)
bar_type = BarType(instrument_id, bar_spec)
# Act
result = bar_type.to_serializable_str()
# Assert
assert "AUD/USD.IDEALPRO-1-MINUTE-BID" == result
def test_bar_type_hash_str_and_repr(self):
# Arrange
instrument_id = InstrumentId(Symbol("AUD/USD"), Venue("SIM"))
bar_spec = BarSpecification(1, BarAggregation.MINUTE, PriceType.BID)
bar_type = BarType(instrument_id, bar_spec)
# Act
# Assert
assert isinstance(hash(bar_type), int)
assert str(bar_type) == "AUD/USD.SIM-1-MINUTE-BID"
assert (
repr(bar_type)
== "BarType(AUD/USD.SIM-1-MINUTE-BID, internal_aggregation=True)"
)
@pytest.mark.parametrize(
"value",
["", "AUD/USD", "AUD/USD.IDEALPRO-1-MILLISECOND-BID"],
)
def test_from_str_given_various_invalid_strings_raises_value_error(self, value):
# Arrange
# Act
# Assert
with pytest.raises(ValueError):
BarType.from_serializable_str(value)
@pytest.mark.parametrize(
"value, expected",
[
[
"AUD/USD.IDEALPRO-1-MINUTE-BID",
BarType(
InstrumentId(Symbol("AUD/USD"), Venue("IDEALPRO")),
BarSpecification(1, BarAggregation.MINUTE, PriceType.BID),
),
], # noqa
[
"GBP/USD.SIM-1000-TICK-MID",
BarType(
InstrumentId(Symbol("GBP/USD"), Venue("SIM")),
BarSpecification(1000, BarAggregation.TICK, PriceType.MID),
),
], # noqa
[
"AAPL.NYSE-1-HOUR-MID",
BarType(
InstrumentId(Symbol("AAPL"), Venue("NYSE")),
BarSpecification(1, BarAggregation.HOUR, PriceType.MID),
),
], # noqa
[
"BTC/USDT.BINANCE-100-TICK-LAST",
BarType(
InstrumentId(Symbol("BTC/USDT"), Venue("BINANCE")),
BarSpecification(100, BarAggregation.TICK, PriceType.LAST),
),
],
], # noqa
)
def test_from_str_given_various_valid_string_returns_expected_specification(
self, value, expected
):
# Arrange
# Act
bar_type = BarType.from_serializable_str(value, internal_aggregation=True)
# Assert
assert expected == bar_type
from nautilus_trader.backtest.models import FillModel
from nautilus_trader.backtest.modules import FXRolloverInterestModule
from nautilus_trader.model.bar import BarSpecification
from nautilus_trader.model.currencies import USD
from nautilus_trader.model.enums import BarAggregation
from nautilus_trader.model.enums import OMSType
from nautilus_trader.model.enums import PriceType
from nautilus_trader.model.identifiers import Venue
from nautilus_trader.model.objects import Money
from tests.test_kit import PACKAGE_ROOT
from tests.test_kit.providers import TestDataProvider
from tests.test_kit.providers import TestInstrumentProvider
if __name__ == "__main__":
# Setup trading instruments
SIM = Venue("SIM")
GBPUSD = TestInstrumentProvider.default_fx_ccy("GBP/USD", SIM)
# Setup data container
data = BacktestDataContainer()
data.add_instrument(GBPUSD)
data.add_bars(
instrument_id=GBPUSD.id,
aggregation=BarAggregation.MINUTE,
price_type=PriceType.BID,
data=TestDataProvider.gbpusd_1min_bid(), # Stub data from the test kit
)
data.add_bars(
instrument_id=GBPUSD.id,
aggregation=BarAggregation.MINUTE,
price_type=PriceType.ASK,
"account_id":
"BINANCE_ACCOUNT_ID", # value is the environment variable key
"api_key":
"BINANCE_API_KEY", # value is the environment variable key
"api_secret":
"BINANCE_API_SECRET", # value is the environment variable key
"sandbox_mode": False, # If clients use the testnet
},
},
}
# Instantiate your strategies to pass into the trading node. You could add
# custom options into the configuration file or even use another configuration
# file.
strategy = VolatilityMarketMaker(
symbol=Symbol("ETH/USDT", Venue("BINANCE")),
bar_spec=BarSpecification(1, BarAggregation.MINUTE, PriceType.LAST),
trade_size=Decimal("0.05"),
atr_period=20,
atr_multiple=1.0,
order_id_tag="001",
)
# Instantiate the node passing a list of strategies and configuration
node = TradingNode(strategies=[strategy], config=config)
# Stop and dispose of the node with SIGINT/CTRL+C
if __name__ == "__main__":
try:
node.start()
finally:
def setUp(self):
# Fixture Setup
clock = TestClock()
logger = Logger(clock)
trader_id = TraderId("TESTER", "000")
account_id = TestStubs.account_id()
self.portfolio = Portfolio(
clock=clock,
logger=logger,
)
self.data_engine = DataEngine(
portfolio=self.portfolio,
clock=clock,
logger=logger,
config={"use_previous_close": False},
)
self.portfolio.register_cache(self.data_engine.cache)
self.analyzer = PerformanceAnalyzer()
self.exec_db = BypassExecutionDatabase(
trader_id=trader_id,
logger=logger,
)
self.exec_engine = ExecutionEngine(
database=self.exec_db,
portfolio=self.portfolio,
clock=clock,
logger=logger,
)
self.exchange = SimulatedExchange(
venue=Venue("SIM"),
oms_type=OMSType.HEDGING,
is_frozen_account=False,
starting_balances=[Money(1_000_000, USD)],
exec_cache=self.exec_engine.cache,
instruments=[USDJPY_SIM],
modules=[],
fill_model=FillModel(),
clock=clock,
logger=logger,
)
self.data_client = BacktestMarketDataClient(
instruments=[USDJPY_SIM],
client_id=ClientId("SIM"),
engine=self.data_engine,
clock=clock,
logger=logger,
)
self.data_engine.register_client(self.data_client)
self.exec_client = BacktestExecClient(
exchange=self.exchange,
account_id=account_id,
engine=self.exec_engine,
clock=clock,
logger=logger,
)
self.risk_engine = RiskEngine(
exec_engine=self.exec_engine,
portfolio=self.portfolio,
clock=clock,
logger=logger,
)
self.exec_engine.register_risk_engine(self.risk_engine)
self.exec_engine.register_client(self.exec_client)
strategies = [
TradingStrategy("001"),
TradingStrategy("002"),
]
self.trader = Trader(
trader_id=trader_id,
strategies=strategies,
portfolio=self.portfolio,
data_engine=self.data_engine,
exec_engine=self.exec_engine,
risk_engine=self.risk_engine,
clock=clock,
logger=logger,
)
"exec_client": True, # If a exec client should be created
"account_id":
"BITMEX_ACCOUNT_ID", # value is the environment variable key
"api_key":
"BITMEX_API_KEY", # value is the environment variable key
"api_secret":
"BITMEX_API_SECRET", # value is the environment variable key
},
},
}
# Instantiate your strategies to pass into the trading node. You could add
# custom options into the configuration file or even use another configuration
# file.
strategy1 = EMACross(
symbol=Symbol("ETH/USDT", Venue("BINANCE")),
bar_spec=BarSpecification(1, BarAggregation.MINUTE, PriceType.LAST),
trade_size=Decimal("0.02"),
fast_ema_period=10,
slow_ema_period=20,
order_id_tag="003",
)
strategy2 = EMACrossStopEntryTrail(
symbol=Symbol("BTC/USD", Venue("BITMEX")),
bar_spec=BarSpecification(1, BarAggregation.MINUTE, PriceType.LAST),
trade_size=Decimal("100"),
fast_ema_period=10,
slow_ema_period=20,
atr_period=20,
trail_atr_multiple=2.0,
"api_key":
"BITMEX_API_KEY", # value is the environment variable key
"api_secret":
"BITMEX_API_SECRET", # value is the environment variable key
"sandbox_mode": False, # If client uses the testnet
},
},
}
# Instantiate your strategies to pass into the trading node. You could add
# custom options into the configuration file or even use another configuration
# file.
instrument_id = InstrumentId(
symbol=Symbol("BTC/USD"),
venue=Venue("BITMEX"),
)
strategy = EMACross(
instrument_id=instrument_id,
bar_spec=BarSpecification(1, BarAggregation.MINUTE, PriceType.LAST),
fast_ema_period=10,
slow_ema_period=20,
trade_size=Decimal("10"),
order_id_tag="002",
)
# Instantiate the node passing a list of strategies and configuration
node = TradingNode(strategies=[strategy], config=config)
# Register your client factories with the node (can take user defined factories)
# -------------------------------------------------------------------------------------------------
import unittest
from nautilus_trader.common.clock import TestClock
from nautilus_trader.common.uuid import UUIDFactory
from nautilus_trader.data.messages import DataRequest
from nautilus_trader.data.messages import DataResponse
from nautilus_trader.data.messages import Subscribe
from nautilus_trader.model.data import DataType
from nautilus_trader.model.identifiers import InstrumentId
from nautilus_trader.model.identifiers import Symbol
from nautilus_trader.model.identifiers import Venue
from nautilus_trader.model.tick import QuoteTick
BINANCE = Venue("BINANCE")
IDEALPRO = Venue("IDEALPRO")
class DataMessageTests(unittest.TestCase):
def setUp(self):
# Fixture Setup
self.clock = TestClock()
self.uuid_factory = UUIDFactory()
def test_data_command_str_and_repr(self):
# Arrange
# Act
handler = [].append
command_id = self.uuid_factory.generate()
def symbol_ethusd_bitmex() -> Symbol:
return Symbol("ETH/USD", Venue('BITMEX'))
from nautilus_trader.model.identifiers import StrategyId
from nautilus_trader.model.identifiers import Symbol
from nautilus_trader.model.identifiers import TraderId
from nautilus_trader.model.identifiers import Venue
from nautilus_trader.model.objects import Price
from nautilus_trader.model.objects import Quantity
from nautilus_trader.model.position import Position
from nautilus_trader.model.tick import QuoteTick
from nautilus_trader.model.tick import TradeTick
from nautilus_trader.trading.commission import GenericCommissionModel
from nautilus_trader.trading.portfolio import Portfolio
from nautilus_trader.trading.strategy import TradingStrategy
from tests.test_kit.strategies import TestStrategy1
from tests.test_kit.stubs import TestStubs
USDJPY_FXCM = Symbol('USD/JPY', Venue('FXCM'))
AUDUSD_FXCM = Symbol('AUD/USD', Venue('FXCM'))
class TradingStrategyTests(unittest.TestCase):
def setUp(self):
# Fixture Setup
self.clock = TestClock()
self.uuid_factory = TestUUIDFactory()
self.logger = TestLogger(self.clock)
self.portfolio = Portfolio(
clock=self.clock,
uuid_factory=self.uuid_factory,
logger=self.logger,
def symbol_ethusdt_binance() -> Symbol:
return Symbol("ETH/USDT", Venue('BINANCE'))
def setup(self):
# Fixture Setup
self.clock = TestClock()
self.uuid_factory = UUIDFactory()
self.logger = Logger(
clock=self.clock,
level_stdout=LogLevel.DEBUG,
)
self.trader_id = TestIdStubs.trader_id()
self.account_id = TestIdStubs.account_id()
self.venue = Venue("SIM")
self.msgbus = MessageBus(
trader_id=self.trader_id,
clock=self.clock,
logger=self.logger,
)
self.cache = TestComponentStubs.cache()
self.portfolio = Portfolio(
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
config = ExecEngineConfig()
config.allow_cash_positions = True # Retain original behaviour for now
self.exec_engine = ExecutionEngine(
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
config=config,
)
self.risk_engine = RiskEngine(
portfolio=self.portfolio,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.exec_client = MockExecutionClient(
client_id=ClientId(self.venue.value),
venue=self.venue,
account_type=AccountType.MARGIN,
base_currency=USD,
msgbus=self.msgbus,
cache=self.cache,
clock=self.clock,
logger=self.logger,
)
self.portfolio.update_account(TestEventStubs.margin_account_state())
self.exec_engine.register_client(self.exec_client)
# Prepare data
self.cache.add_instrument(AUDUSD_SIM)
