def setUp(self):
# Fixture Setup
clock = TestClock()
logger = TestLogger(clock)
self.trader_id = TraderId("TESTER", "000")
self.strategy = TradingStrategy(order_id_tag="001")
self.strategy.register_trader(
TraderId("TESTER", "000"),
clock,
logger,
)
config = {
'host': 'localhost',
'port': 6379,
}
self.database = RedisExecutionDatabase(
trader_id=self.trader_id,
logger=logger,
command_serializer=MsgPackCommandSerializer(),
event_serializer=MsgPackEventSerializer(),
config=config,
)
self.test_redis = redis.Redis(host="localhost", port=6379, db=0)
def setUp(self):
# Fixture Setup
clock = TestClock()
logger = TestLogger()
self.trader_id = TraderId('TESTER', '000')
self.strategy = EmptyStrategy(order_id_tag='001')
self.strategy.change_clock(clock)
self.strategy.change_logger(logger)
self.database = RedisExecutionDatabase(
trader_id=self.trader_id,
host='localhost',
port=6379,
command_serializer=MsgPackCommandSerializer(),
event_serializer=MsgPackEventSerializer(),
logger=logger)
self.test_redis = redis.Redis(host='localhost', port=6379, db=0)
def setup(self):
# Fixture Setup
self.clock = TestClock()
self.logger = Logger(self.clock)
self.trader_id = TraderId("TESTER-000")
self.strategy = TradingStrategy(order_id_tag="001")
self.strategy.register_trader(self.trader_id, self.clock, self.logger)
config = {
"host": "localhost",
"port": 6379,
}
self.database = RedisCacheDatabase(
trader_id=self.trader_id,
logger=self.logger,
instrument_serializer=MsgPackInstrumentSerializer(),
command_serializer=MsgPackCommandSerializer(),
event_serializer=MsgPackEventSerializer(),
config=config,
)
self.test_redis = redis.Redis(host="localhost", port=6379, db=0)
def __init__(
self,
strategies: List[TradingStrategy],
config: Dict[str, object],
):
"""
Initialize a new instance of the TradingNode class.
Parameters
----------
strategies : list[TradingStrategy]
The list of strategies to run on the trading node.
config : dict[str, object]
The configuration for the trading node.
Raises
------
ValueError
If strategies is None or empty.
ValueError
If config is None or empty.
"""
PyCondition.not_none(strategies, "strategies")
PyCondition.not_none(config, "config")
PyCondition.not_empty(strategies, "strategies")
PyCondition.not_empty(config, "config")
# Extract configs
config_trader = config.get("trader", {})
config_log = config.get("logging", {})
config_exec_db = config.get("exec_database", {})
config_strategy = config.get("strategy", {})
config_adapters = config.get("adapters", {})
self._uuid_factory = UUIDFactory()
self._loop = asyncio.get_event_loop()
self._executor = concurrent.futures.ThreadPoolExecutor()
self._loop.set_default_executor(self._executor)
self._clock = LiveClock(loop=self._loop)
self.created_time = self._clock.utc_now()
self._is_running = False
# Uncomment for debugging
# self._loop.set_debug(True)
# Setup identifiers
self.trader_id = TraderId(
name=config_trader["name"],
tag=config_trader["id_tag"],
)
# Setup logging
self._logger = LiveLogger(
clock=self._clock,
name=self.trader_id.value,
level_console=LogLevelParser.from_str_py(config_log.get("log_level_console")),
level_file=LogLevelParser.from_str_py(config_log.get("log_level_file")),
level_store=LogLevelParser.from_str_py(config_log.get("log_level_store")),
run_in_process=config_log.get("run_in_process", True), # Run logger in a separate process
log_thread=config_log.get("log_thread_id", False),
log_to_file=config_log.get("log_to_file", False),
log_file_path=config_log.get("log_file_path", ""),
)
self._log = LoggerAdapter(component_name=self.__class__.__name__, logger=self._logger)
self._log_header()
self._log.info("Building...")
self._setup_loop() # Requires the logger to be initialized
self.portfolio = Portfolio(
clock=self._clock,
logger=self._logger,
)
self._data_engine = LiveDataEngine(
loop=self._loop,
portfolio=self.portfolio,
clock=self._clock,
logger=self._logger,
config={"qsize": 10000},
)
self.portfolio.register_cache(self._data_engine.cache)
self.analyzer = PerformanceAnalyzer()
if config_exec_db["type"] == "redis":
exec_db = RedisExecutionDatabase(
trader_id=self.trader_id,
logger=self._logger,
command_serializer=MsgPackCommandSerializer(),
event_serializer=MsgPackEventSerializer(),
config={
"host": config_exec_db["host"],
"port": config_exec_db["port"],
}
)
else:
exec_db = BypassExecutionDatabase(
trader_id=self.trader_id,
logger=self._logger,
)
self._exec_engine = LiveExecutionEngine(
loop=self._loop,
database=exec_db,
portfolio=self.portfolio,
clock=self._clock,
logger=self._logger,
config={"qsize": 10000},
)
self._exec_engine.load_cache()
self._setup_adapters(config_adapters, self._logger)
self.trader = Trader(
trader_id=self.trader_id,
strategies=strategies,
portfolio=self.portfolio,
data_engine=self._data_engine,
exec_engine=self._exec_engine,
clock=self._clock,
logger=self._logger,
)
self._check_residuals_delay = config_trader.get("check_residuals_delay", 5.0)
self._load_strategy_state = config_strategy.get("load_state", True)
self._save_strategy_state = config_strategy.get("save_state", True)
if self._load_strategy_state:
self.trader.load()
self._log.info("state=INITIALIZED.")
self.time_to_initialize = self._clock.delta(self.created_time)
self._log.info(f"Initialized in {self.time_to_initialize.total_seconds():.3f}s.")
def __init__(
self,
strategies: List[TradingStrategy],
config: Dict[str, object],
):
"""
Initialize a new instance of the TradingNode class.
Parameters
----------
strategies : list[TradingStrategy]
The list of strategies to run on the trading node.
config : dict[str, object]
The configuration for the trading node.
"""
if strategies is None:
strategies = []
config_trader = config.get("trader", {})
config_log = config.get("logging", {})
config_exec_db = config.get("exec_database", {})
config_strategy = config.get("strategy", {})
config_data_clients = config.get("data_clients", {})
config_exec_clients = config.get("exec_clients", {})
self._clock = LiveClock()
self._uuid_factory = UUIDFactory()
self._loop = asyncio.get_event_loop()
self._executor = concurrent.futures.ThreadPoolExecutor()
self._loop.set_default_executor(self._executor)
self._loop.set_debug(False) # TODO: Development
self._is_running = False
# Setup identifiers
self.trader_id = TraderId(
name=config_trader["name"],
tag=config_trader["id_tag"],
)
# Setup logging
logger = LiveLogger(
clock=self._clock,
name=self.trader_id.value,
level_console=LogLevelParser.from_str_py(
config_log.get("log_level_console")),
level_file=LogLevelParser.from_str_py(
config_log.get("log_level_file")),
level_store=LogLevelParser.from_str_py(
config_log.get("log_level_store")),
log_thread=config_log.get("log_thread_id", True),
log_to_file=config_log.get("log_to_file", False),
log_file_path=config_log.get("log_file_path", ""),
)
self._log = LoggerAdapter(component_name=self.__class__.__name__,
logger=logger)
self._log_header()
self._log.info("Building...")
self.portfolio = Portfolio(
clock=self._clock,
logger=logger,
)
self._data_engine = LiveDataEngine(
loop=self._loop,
portfolio=self.portfolio,
clock=self._clock,
logger=logger,
)
self.portfolio.register_cache(self._data_engine.cache)
self.analyzer = PerformanceAnalyzer()
if config_exec_db["type"] == "redis":
exec_db = RedisExecutionDatabase(
trader_id=self.trader_id,
logger=logger,
command_serializer=MsgPackCommandSerializer(),
event_serializer=MsgPackEventSerializer(),
config={
"host": config_exec_db["host"],
"port": config_exec_db["port"],
})
else:
exec_db = BypassExecutionDatabase(
trader_id=self.trader_id,
logger=logger,
)
self._exec_engine = LiveExecutionEngine(
loop=self._loop,
database=exec_db,
portfolio=self.portfolio,
clock=self._clock,
logger=logger,
)
self._exec_engine.load_cache()
self._setup_data_clients(config_data_clients, logger)
self._setup_exec_clients(config_exec_clients, logger)
self.trader = Trader(
trader_id=self.trader_id,
strategies=strategies,
data_engine=self._data_engine,
exec_engine=self._exec_engine,
clock=self._clock,
logger=logger,
)
self._check_residuals_delay = 2.0 # Hard coded delay (refactor)
self._load_strategy_state = config_strategy.get("load_state", True)
self._save_strategy_state = config_strategy.get("save_state", True)
if self._load_strategy_state:
self.trader.load()
self._setup_loop()
self._log.info("state=INITIALIZED.")
def setUp(self):
# Fixture Setup
self.account_id = TestStubs.account_id()
self.serializer = MsgPackEventSerializer()
def __init__(
self,
strategies: List[TradingStrategy],
config: Dict[str, object],
):
"""
Initialize a new instance of the TradingNode class.
Parameters
----------
strategies : list[TradingStrategy]
The list of strategies to run on the trading node.
config : dict[str, object]
The configuration for the trading node.
Raises
------
ValueError
If strategies is None or empty.
ValueError
If config is None or empty.
"""
PyCondition.not_none(strategies, "strategies")
PyCondition.not_none(config, "config")
PyCondition.not_empty(strategies, "strategies")
PyCondition.not_empty(config, "config")
self._config = config
# Extract configs
config_trader = config.get("trader", {})
config_system = config.get("system", {})
config_log = config.get("logging", {})
config_exec_db = config.get("exec_database", {})
config_risk = config.get("risk", {})
config_strategy = config.get("strategy", {})
# System config
self._connection_timeout = config_system.get("connection_timeout", 5.0)
self._disconnection_timeout = config_system.get(
"disconnection_timeout", 5.0)
self._check_residuals_delay = config_system.get(
"check_residuals_delay", 5.0)
self._load_strategy_state = config_strategy.get("load_state", True)
self._save_strategy_state = config_strategy.get("save_state", True)
# Setup loop
self._loop = asyncio.get_event_loop()
self._executor = concurrent.futures.ThreadPoolExecutor()
self._loop.set_default_executor(self._executor)
self._loop.set_debug(config_system.get("loop_debug", False))
# Components
self._clock = LiveClock(loop=self._loop)
self._uuid_factory = UUIDFactory()
self.system_id = self._uuid_factory.generate()
self.created_time = self._clock.utc_now()
self._is_running = False
# Setup identifiers
self.trader_id = TraderId(
name=config_trader["name"],
tag=config_trader["id_tag"],
)
# Setup logging
level_stdout = LogLevelParser.from_str_py(
config_log.get("level_stdout"))
self._logger = LiveLogger(
loop=self._loop,
clock=self._clock,
trader_id=self.trader_id,
system_id=self.system_id,
level_stdout=level_stdout,
)
self._log = LoggerAdapter(
component=self.__class__.__name__,
logger=self._logger,
)
self._log_header()
self._log.info("Building...")
if platform.system() != "Windows":
# Requires the logger to be initialized
# Windows does not support signal handling
# https://stackoverflow.com/questions/45987985/asyncio-loops-add-signal-handler-in-windows
self._setup_loop()
# Build platform
# ----------------------------------------------------------------------
self.portfolio = Portfolio(
clock=self._clock,
logger=self._logger,
)
self._data_engine = LiveDataEngine(
loop=self._loop,
portfolio=self.portfolio,
clock=self._clock,
logger=self._logger,
config={"qsize": 10000},
)
self.portfolio.register_cache(self._data_engine.cache)
self.analyzer = PerformanceAnalyzer()
if config_exec_db["type"] == "redis":
exec_db = RedisExecutionDatabase(
trader_id=self.trader_id,
logger=self._logger,
command_serializer=MsgPackCommandSerializer(),
event_serializer=MsgPackEventSerializer(),
config={
"host": config_exec_db["host"],
"port": config_exec_db["port"],
},
)
else:
exec_db = BypassExecutionDatabase(
trader_id=self.trader_id,
logger=self._logger,
)
self._exec_engine = LiveExecutionEngine(
loop=self._loop,
database=exec_db,
portfolio=self.portfolio,
clock=self._clock,
logger=self._logger,
config={"qsize": 10000},
)
self._risk_engine = LiveRiskEngine(
loop=self._loop,
exec_engine=self._exec_engine,
portfolio=self.portfolio,
clock=self._clock,
logger=self._logger,
config=config_risk,
)
self._exec_engine.load_cache()
self._exec_engine.register_risk_engine(self._risk_engine)
self.trader = Trader(
trader_id=self.trader_id,
strategies=strategies,
portfolio=self.portfolio,
data_engine=self._data_engine,
exec_engine=self._exec_engine,
risk_engine=self._risk_engine,
clock=self._clock,
logger=self._logger,
)
if self._load_strategy_state:
self.trader.load()
self._builder = TradingNodeBuilder(
data_engine=self._data_engine,
exec_engine=self._exec_engine,
risk_engine=self._risk_engine,
clock=self._clock,
logger=self._logger,
log=self._log,
)
self._log.info("state=INITIALIZED.")
self.time_to_initialize = self._clock.delta(self.created_time)
self._log.info(
f"Initialized in {self.time_to_initialize.total_seconds():.3f}s.")
self._is_built = False
def setUp(self):
# Fixture Setup
trader_id = TraderId('TESTER', '000')
account_id = TestStubs.account_id()
clock = LiveClock()
guid_factory = LiveGuidFactory()
logger = LiveLogger()
self.command_server = MessageServer(
server_id=ServerId("CommandServer-001"),
recv_port=TEST_COMMANDS_REQ_PORT,
send_port=TEST_COMMANDS_REP_PORT,
header_serializer=MsgPackDictionarySerializer(),
request_serializer=MsgPackRequestSerializer(),
response_serializer=MsgPackResponseSerializer(),
compressor=CompressorBypass(),
encryption=EncryptionSettings(),
clock=clock,
guid_factory=guid_factory,
logger=LoggerAdapter('CommandServer', logger))
self.command_serializer = MsgPackCommandSerializer()
self.command_server_sink = []
self.command_server.register_handler(MessageType.COMMAND, self.command_handler)
self.command_server.start()
time.sleep(0.1)
self.portfolio = Portfolio(
currency=Currency.USD,
clock=clock,
guid_factory=guid_factory,
logger=logger)
self.analyzer = PerformanceAnalyzer()
self.exec_db = InMemoryExecutionDatabase(
trader_id=trader_id,
logger=logger)
self.exec_engine = LiveExecutionEngine(
trader_id=trader_id,
account_id=account_id,
database=self.exec_db,
portfolio=self.portfolio,
clock=clock,
guid_factory=guid_factory,
logger=logger)
self.exec_engine.handle_event(TestStubs.account_event())
self.exec_client = LiveExecClient(
exec_engine=self.exec_engine,
host=LOCALHOST,
command_req_port=TEST_COMMANDS_REQ_PORT,
command_res_port=TEST_COMMANDS_REP_PORT,
event_pub_port=TEST_EVENTS_PUB_PORT,
compressor=CompressorBypass(),
encryption=EncryptionSettings(),
command_serializer=MsgPackCommandSerializer(),
header_serializer=MsgPackDictionarySerializer(),
request_serializer=MsgPackRequestSerializer(),
response_serializer=MsgPackResponseSerializer(),
event_serializer=MsgPackEventSerializer(),
clock=clock,
guid_factory=guid_factory,
logger=logger)
self.exec_engine.register_client(self.exec_client)
self.exec_client.connect()
time.sleep(0.1)
self.bar_type = TestStubs.bartype_audusd_1min_bid()
self.strategy = TestStrategy1(self.bar_type, id_tag_strategy='001')
self.strategy.change_logger(logger)
self.exec_engine.register_strategy(self.strategy)