def init_default():
config = load_test_config()
exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True)
exchange_inst = exchange_manager.get_exchange()
trader_inst = TraderSimulator(config, exchange_inst, 2)
order_inst = Order(trader_inst)
return config, order_inst, trader_inst, exchange_inst
def create_exchange_traders(self):
self.backtesting_enabled = Backtesting.enabled(self.config)
available_exchanges = ccxt.exchanges
for exchange_class_string in self.config[CONFIG_EXCHANGES]:
if exchange_class_string in available_exchanges:
exchange_type = getattr(ccxt, exchange_class_string)
# Backtesting Exchange
if self.backtesting_enabled:
exchange_manager = ExchangeManager(self.config,
exchange_type,
is_simulated=True)
else:
# True Exchange
exchange_manager = ExchangeManager(self.config,
exchange_type,
is_simulated=False)
exchange_inst = exchange_manager.get_exchange()
self.exchanges_list[exchange_inst.get_name()] = exchange_inst
# create trader instance for this exchange
exchange_trader = Trader(self.config, exchange_inst)
self.exchange_traders[
exchange_inst.get_name()] = exchange_trader
# create trader simulator instance for this exchange
exchange_trader_simulator = TraderSimulator(
self.config, exchange_inst)
self.exchange_trader_simulators[
exchange_inst.get_name()] = exchange_trader_simulator
else:
self.logger.error(
"{0} exchange not found".format(exchange_class_string))
async def _get_tools(event_loop):
symbol = "BTC/USDT"
exchange_traders = {}
exchange_traders2 = {}
config = load_test_config()
time_frame = TimeFrames.ONE_HOUR
AdvancedManager.create_class_list(config)
exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True)
await exchange_manager.initialize()
exchange_inst = exchange_manager.get_exchange()
global_price_updater = GlobalPriceUpdater(exchange_inst)
trader_inst = TraderSimulator(config, exchange_inst, 0.3)
trader_inst.stop_order_manager()
trader_inst2 = TraderSimulator(config, exchange_inst, 0.3)
trader_inst2.stop_order_manager()
crypto_currency_evaluator = CryptocurrencyEvaluator(config, "Bitcoin", [])
symbol_evaluator = SymbolEvaluator(config, symbol, crypto_currency_evaluator)
exchange_traders[exchange_inst.get_name()] = trader_inst
exchange_traders2[exchange_inst.get_name()] = trader_inst2
symbol_evaluator.set_trader_simulators(exchange_traders)
symbol_evaluator.set_traders(exchange_traders2)
symbol_evaluator.strategies_eval_lists[exchange_inst.get_name()] = \
EvaluatorCreator.create_strategies_eval_list(config)
trading_mode_inst = get_activated_trading_mode(config)(config, exchange_inst)
evaluator_task_manager = EvaluatorTaskManager(config, time_frame, global_price_updater,
symbol_evaluator, exchange_inst, trading_mode_inst, [],
event_loop)
trader_inst.portfolio.portfolio["USDT"] = {
Portfolio.TOTAL: 2000,
Portfolio.AVAILABLE: 2000
}
return evaluator_task_manager, time_frame, global_price_updater, symbol_evaluator, symbol
async def _get_tools():
symbol = "BTC/USDT"
exchange_traders = {}
exchange_traders2 = {}
config = load_test_config()
AdvancedManager.create_class_list(config)
exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True)
await exchange_manager.initialize()
exchange_inst = exchange_manager.get_exchange()
trader_inst = TraderSimulator(config, exchange_inst, 0.3)
await trader_inst.initialize()
trader_inst.stop_order_manager()
trader_inst2 = TraderSimulator(config, exchange_inst, 0.3)
await trader_inst2.initialize()
trader_inst2.stop_order_manager()
crypto_currency_evaluator = CryptocurrencyEvaluator(config, "Bitcoin", [])
symbol_evaluator = SymbolEvaluator(config, symbol,
crypto_currency_evaluator)
exchange_traders[exchange_inst.get_name()] = trader_inst
exchange_traders2[exchange_inst.get_name()] = trader_inst2
symbol_evaluator.set_trader_simulators(exchange_traders)
symbol_evaluator.set_traders(exchange_traders2)
symbol_evaluator.strategies_eval_lists[exchange_inst.get_name()] = \
EvaluatorCreator.create_strategies_eval_list(config)
trading_mode = DailyTradingMode(config, exchange_inst)
trading_mode.add_symbol_evaluator(symbol_evaluator)
final_evaluator = trading_mode.get_only_decider_key(symbol)
trader_inst.portfolio.portfolio["USDT"] = {
Portfolio.TOTAL: 2000,
Portfolio.AVAILABLE: 2000
}
return final_evaluator, trader_inst
def _get_tools():
symbol = "BTC/USDT"
exchange_traders = {}
exchange_traders2 = {}
config = load_test_config()
time_frame = TimeFrames.ONE_HOUR
AdvancedManager.create_class_list(config)
symbol_time_frame_updater_thread = SymbolTimeFramesDataUpdaterThread()
exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True)
exchange_inst = exchange_manager.get_exchange()
trader_inst = TraderSimulator(config, exchange_inst, 0.3)
trader_inst.stop_order_manager()
trader_inst2 = TraderSimulator(config, exchange_inst, 0.3)
trader_inst2.stop_order_manager()
crypto_currency_evaluator = CryptocurrencyEvaluator(config, "Bitcoin", [])
symbol_evaluator = SymbolEvaluator(config, symbol,
crypto_currency_evaluator)
exchange_traders[exchange_inst.get_name()] = trader_inst
exchange_traders2[exchange_inst.get_name()] = trader_inst2
symbol_evaluator.set_trader_simulators(exchange_traders)
symbol_evaluator.set_traders(exchange_traders2)
symbol_evaluator.strategies_eval_lists[exchange_inst.get_name(
)] = EvaluatorCreator.create_strategies_eval_list(config)
evaluator_thread_manager = EvaluatorThreadsManager(
config, time_frame, symbol_time_frame_updater_thread, symbol_evaluator,
exchange_inst, [])
trader_inst.portfolio.portfolio["USDT"] = {
Portfolio.TOTAL: 2000,
Portfolio.AVAILABLE: 2000
}
symbol_evaluator.add_evaluator_thread_manager(exchange_inst, time_frame,
evaluator_thread_manager)
return symbol_evaluator, exchange_inst, time_frame, evaluator_thread_manager
async def _get_tools():
config = load_test_config()
symbol = "BTC/USDT"
exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True)
await exchange_manager.initialize()
exchange_inst = exchange_manager.get_exchange()
trader_inst = TraderSimulator(config, exchange_inst, 0.3)
await trader_inst.portfolio.initialize()
trader_inst.stop_order_manager()
trader_inst.portfolio.portfolio["SUB"] = {
Portfolio.TOTAL: 0.000000000000000000005,
Portfolio.AVAILABLE: 0.000000000000000000005
}
trader_inst.portfolio.portfolio["BNB"] = {
Portfolio.TOTAL: 0.000000000000000000005,
Portfolio.AVAILABLE: 0.000000000000000000005
}
trader_inst.portfolio.portfolio["USDT"] = {
Portfolio.TOTAL: 2000,
Portfolio.AVAILABLE: 2000
}
trading_mode = MarketMakerTradingMode(config, exchange_inst)
return config, exchange_inst, trader_inst, symbol, trading_mode
def create_exchange_data_collectors(self):
available_exchanges = ccxt.exchanges
for exchange_class_string in self.config[CONFIG_EXCHANGES]:
if exchange_class_string in available_exchanges:
exchange_type = getattr(ccxt, exchange_class_string)
exchange_manager = ExchangeManager(self.config,
exchange_type,
is_simulated=False,
rest_only=True)
exchange_inst = exchange_manager.get_exchange()
exchange_data_collector = ExchangeDataCollector(
self.config, exchange_inst)
if not exchange_data_collector.get_symbols(
) or not exchange_data_collector.time_frames:
self.logger.warning(
"{0} exchange not started (not enough symbols or timeframes)"
.format(exchange_class_string))
else:
exchange_data_collector.start()
self.exchange_data_collectors_threads.append(
exchange_data_collector)
else:
self.logger.error(
"{0} exchange not found".format(exchange_class_string))
async def create_exchange_traders(self, ignore_config=False):
self.async_loop = asyncio.get_running_loop()
available_exchanges = ccxt.exchanges
for exchange_class_string in self.config[CONFIG_EXCHANGES]:
if exchange_class_string in available_exchanges:
exchange_type = getattr(ccxt, exchange_class_string)
# Backtesting Exchange
if self.backtesting_enabled:
exchange_manager = ExchangeManager(self.config,
exchange_type,
is_simulated=True)
else:
# Real Exchange
exchange_manager = ExchangeManager(
self.config,
exchange_type,
is_simulated=False,
ignore_config=ignore_config)
await exchange_manager.initialize()
exchange_inst = exchange_manager.get_exchange()
self.exchanges_list[exchange_inst.get_name()] = exchange_inst
self.global_updaters_by_exchange[exchange_inst.get_name(
)] = GlobalPriceUpdater(exchange_inst)
# create trader instance for this exchange
exchange_trader = Trader(self.config, exchange_inst)
await exchange_trader.initialize()
self.exchange_traders[
exchange_inst.get_name()] = exchange_trader
# create trader simulator instance for this exchange
exchange_trader_simulator = TraderSimulator(
self.config, exchange_inst)
await exchange_trader_simulator.initialize()
self.exchange_trader_simulators[
exchange_inst.get_name()] = exchange_trader_simulator
if not (exchange_trader_simulator.enabled(self.config)
or exchange_trader.enabled(self.config)):
self.logger.error(
f"No trader simulator nor real trader activated on {exchange_inst.get_name()}"
)
# create trading mode
try:
self.trading_mode = get_activated_trading_mode(
self.config)(self.config, exchange_inst)
self.exchange_trading_modes[
exchange_inst.get_name()] = self.trading_mode
self.logger.debug(
f"Using {self.trading_mode.get_name()} trading mode")
except RuntimeError as e:
self.logger.error(e.args[0])
raise e
else:
self.logger.error(
f"{exchange_class_string} exchange not found")
async def init_default():
config = load_test_config()
exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True)
await exchange_manager.initialize()
exchange_inst = exchange_manager.get_exchange()
trader_inst = Trader(config, exchange_inst, 1)
order_manager_inst = trader_inst.get_order_manager()
return config, exchange_inst, trader_inst, order_manager_inst
def init_default():
config = load_test_config()
exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True)
exchange_inst = exchange_manager.get_exchange()
trader_inst = TraderSimulator(config, exchange_inst, 1)
portfolio_inst = Portfolio(config, trader_inst)
trader_inst.stop_order_manager()
sub_portfolio_inst = SubPortfolio(config, trader_inst, portfolio_inst, TestSubPortfolio.DEFAULT_PERCENT)
return config, portfolio_inst, exchange_inst, trader_inst, sub_portfolio_inst
def init_default():
config = load_test_config()
exchange_manager = ExchangeManager(config,
ccxt.binance,
is_simulated=True)
exchange_inst = exchange_manager.get_exchange()
trader_inst = Trader(config, exchange_inst, 1)
trades_manager_inst = trader_inst.get_trades_manager()
return config, exchange_inst, trader_inst, trades_manager_inst
def __init__(self, config, data_file=None, symbols=None):
self.config = config
self.data_file = data_file if data_file else "tests/static/binance_BTC_USDT_20180428_121156.data"
self.symbols = symbols if symbols else ["BTC"]
exchange_manager = ExchangeManager(self.config, ccxt.binance, is_simulated=True)
self.exchange_simulator_inst = exchange_manager.get_exchange().get_exchange()
self.data_by_symbol_by_data_frame = None
self._init_data()
def init_default():
config = load_test_config()
config[CONFIG_BACKTESTING][CONFIG_ENABLED_OPTION] = True
exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True)
exchange_inst = exchange_manager.get_exchange()
exchange_simulator = exchange_inst.get_exchange()
exchange_simulator.init_candles_offset([TimeFrames.ONE_HOUR, TimeFrames.FOUR_HOURS, TimeFrames.ONE_DAY],
TestExchangeSimulator.DEFAULT_SYMBOL)
trader_inst = TraderSimulator(config, exchange_inst, 1)
return config, exchange_inst, exchange_simulator, trader_inst
def init_default():
config = load_test_config()
config[CONFIG_BACKTESTING][CONFIG_ENABLED_OPTION] = True
exchange_manager = ExchangeManager(config,
ccxt.binance,
is_simulated=True)
exchange_inst = exchange_manager.get_exchange()
exchange_simulator = exchange_inst.get_exchange()
trader_inst = TraderSimulator(config, exchange_inst, 1)
return config, exchange_inst, exchange_simulator, trader_inst
def _create_exchange_manager(self, exchange_type) -> ExchangeManager:
# Backtesting Exchange
if backtesting_enabled(self.octobot.get_config()):
return ExchangeManager(self.octobot.get_config(),
exchange_type,
is_simulated=True)
else:
# Real Exchange
return ExchangeManager(self.octobot.get_config(),
exchange_type,
ignore_config=self.ignore_config)
def execute_with_specific_target(self, exchange, symbol):
try:
exchange_type = getattr(ccxt, exchange)
exchange_manager = ExchangeManager(self.config, exchange_type, is_simulated=False, rest_only=True,
ignore_config=True)
exchange_inst = exchange_manager.get_exchange()
exchange_data_collector = ExchangeDataCollector(self.config, exchange_inst, symbol)
files = exchange_data_collector.load_available_data()
return files[0]
except Exception as e:
self.logger.exception(e)
raise e
async def init_default():
config = load_test_config()
exchange_manager = ExchangeManager(config,
ccxt.binance,
is_simulated=True)
await exchange_manager.initialize()
exchange_inst = exchange_manager.get_exchange()
trader_inst = TraderSimulator(config, exchange_inst, 1)
portfolio_inst = Portfolio(config, trader_inst)
await portfolio_inst.initialize()
trader_inst.stop_order_manager()
return config, portfolio_inst, exchange_inst, trader_inst
async def _get_tools(event_loop):
config = load_test_config()
symbol = "BTC/USDT"
exchange_traders = {}
exchange_traders2 = {}
time_frame = TimeFrames.FIVE_MINUTES
AdvancedManager.create_class_list(config)
exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True)
await exchange_manager.initialize()
exchange_inst = exchange_manager.get_exchange()
symbol_time_frame_updater_thread = GlobalPriceUpdater(exchange_inst)
trader_inst = TraderSimulator(config, exchange_inst, 0.3)
await trader_inst.initialize()
trader_inst.stop_order_manager()
trader_inst2 = TraderSimulator(config, exchange_inst, 0.3)
await trader_inst2.initialize()
trader_inst2.stop_order_manager()
trader_inst2.set_enabled(False)
trader_inst.portfolio.portfolio["SUB"] = {
Portfolio.TOTAL: 0.000000000000000000005,
Portfolio.AVAILABLE: 0.000000000000000000005
}
trader_inst.portfolio.portfolio["BNB"] = {
Portfolio.TOTAL: 0.000000000000000000005,
Portfolio.AVAILABLE: 0.000000000000000000005
}
trader_inst.portfolio.portfolio["USDT"] = {
Portfolio.TOTAL: 2000,
Portfolio.AVAILABLE: 2000
}
crypto_currency_evaluator = CryptocurrencyEvaluator(config, "Bitcoin", [])
symbol_evaluator = SymbolEvaluator(config, symbol,
crypto_currency_evaluator)
exchange_traders[exchange_inst.get_name()] = trader_inst
exchange_traders2[exchange_inst.get_name()] = trader_inst2
symbol_evaluator.set_trader_simulators(exchange_traders)
symbol_evaluator.set_traders(exchange_traders2)
trading_mode_inst = get_activated_trading_mode(config)(config,
exchange_inst)
_ = EvaluatorTaskManager(config, time_frame,
symbol_time_frame_updater_thread,
symbol_evaluator, exchange_inst,
trading_mode_inst, [], event_loop)
trading_mode = HighFrequencyMode(config, exchange_inst)
trading_mode.add_symbol_evaluator(symbol_evaluator)
decider = trading_mode.get_only_decider_key(symbol)
await decider.initialize()
return config, exchange_inst, trader_inst, symbol, trading_mode
async def _get_tools():
symbol = "BTC/USD"
exchange_traders = {}
exchange_traders2 = {}
config = load_test_config()
config[CONFIG_EVALUATOR]["FullMixedStrategiesEvaluator"] = False
config[CONFIG_EVALUATOR]["StaggeredStrategiesEvaluator"] = True
config[CONFIG_TRADING_TENTACLES]["DailyTradingMode"] = False
config[CONFIG_TRADING_TENTACLES]["StaggeredOrdersTradingMode"] = True
AdvancedManager.create_class_list(config)
exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True)
await exchange_manager.initialize()
exchange_inst = exchange_manager.get_exchange()
trader_inst = TraderSimulator(config, exchange_inst, 0.3)
await trader_inst.initialize()
trader_inst.stop_order_manager()
crypto_currency_evaluator = CryptocurrencyEvaluator(config, "Bitcoin", [])
symbol_evaluator = SymbolEvaluator(config, symbol,
crypto_currency_evaluator)
exchange_traders[exchange_inst.get_name()] = trader_inst
symbol_evaluator.set_trader_simulators(exchange_traders)
symbol_evaluator.set_traders(exchange_traders2)
symbol_evaluator.strategies_eval_lists[exchange_inst.get_name()] = \
EvaluatorCreator.create_strategies_eval_list(config)
trading_mode = StaggeredOrdersTradingMode(config, exchange_inst)
trading_mode.add_symbol_evaluator(symbol_evaluator)
final_evaluator = trading_mode.get_only_decider_key(symbol)
trader_inst.register_trading_mode(trading_mode)
staggered_strategy_evaluator = symbol_evaluator.strategies_eval_lists[
exchange_inst.get_name()][0]
trader_inst.portfolio.portfolio["USD"] = {
Portfolio.TOTAL: 1000,
Portfolio.AVAILABLE: 1000
}
trader_inst.portfolio.portfolio["BTC"] = {
Portfolio.TOTAL: 10,
Portfolio.AVAILABLE: 10
}
final_evaluator.lowest_buy = 1
final_evaluator.highest_sell = 10000
final_evaluator.operational_depth = 50
final_evaluator.spread = 0.06
final_evaluator.increment = 0.04
return final_evaluator, trader_inst, staggered_strategy_evaluator
async def init_default():
config = load_test_config()
config[CONFIG_TRADER][CONFIG_ENABLED_OPTION] = True
exchange_manager = ExchangeManager(config,
ccxt.binance,
is_simulated=True)
await exchange_manager.initialize()
exchange_inst = exchange_manager.get_exchange()
trader_real_inst = Trader(config, exchange_inst, 1)
trader_simulator_inst = TraderSimulator(config, exchange_inst, 1)
order_manager_inst = trader_real_inst.get_order_manager()
order_manager_simulator_inst = trader_simulator_inst.get_order_manager(
)
return config, exchange_inst, trader_real_inst, order_manager_inst, trader_simulator_inst, \
order_manager_simulator_inst
async def init_default():
config = load_test_config()
exchange_manager = ExchangeManager(config,
ccxt.binance,
is_simulated=True)
await exchange_manager.initialize()
return config, exchange_manager
def create_exchange_traders(self):
available_exchanges = ccxt.exchanges
for exchange_class_string in self.config[CONFIG_EXCHANGES]:
if exchange_class_string in available_exchanges:
exchange_type = getattr(ccxt, exchange_class_string)
# Backtesting Exchange
if self.backtesting_enabled:
exchange_manager = ExchangeManager(self.config,
exchange_type,
is_simulated=True)
else:
# Real Exchange
exchange_manager = ExchangeManager(self.config,
exchange_type,
is_simulated=False)
exchange_inst = exchange_manager.get_exchange()
self.exchanges_list[exchange_inst.get_name()] = exchange_inst
# create trader instance for this exchange
exchange_trader = Trader(self.config, exchange_inst)
self.exchange_traders[
exchange_inst.get_name()] = exchange_trader
# create trader simulator instance for this exchange
exchange_trader_simulator = TraderSimulator(
self.config, exchange_inst)
self.exchange_trader_simulators[
exchange_inst.get_name()] = exchange_trader_simulator
# create trading mode
try:
self.trading_mode = get_activated_trading_mode(
self.config)(self.config, exchange_inst)
self.exchange_trading_modes[
exchange_inst.get_name()] = self.trading_mode
self.logger.debug(
f"Using {self.trading_mode.get_name()} trading mode")
except RuntimeError as e:
self.logger.error(e.args[0])
raise e
else:
self.logger.error(
f"{exchange_class_string} exchange not found")
def _get_tools():
config = load_test_config()
symbol = "BTC/USDT"
exchange_traders = {}
exchange_traders2 = {}
time_frame = TimeFrames.FIVE_MINUTES
AdvancedManager.create_class_list(config)
symbol_time_frame_updater_thread = SymbolTimeFramesDataUpdaterThread()
exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True)
exchange_inst = exchange_manager.get_exchange()
trader_inst = TraderSimulator(config, exchange_inst, 0.3)
trader_inst.stop_order_manager()
trader_inst2 = TraderSimulator(config, exchange_inst, 0.3)
trader_inst2.stop_order_manager()
trader_inst2.set_enabled(False)
trader_inst.portfolio.portfolio["SUB"] = {
Portfolio.TOTAL: 0.000000000000000000005,
Portfolio.AVAILABLE: 0.000000000000000000005
}
trader_inst.portfolio.portfolio["BNB"] = {
Portfolio.TOTAL: 0.000000000000000000005,
Portfolio.AVAILABLE: 0.000000000000000000005
}
trader_inst.portfolio.portfolio["USDT"] = {
Portfolio.TOTAL: 2000,
Portfolio.AVAILABLE: 2000
}
crypto_currency_evaluator = CryptocurrencyEvaluator(config, "Bitcoin", [])
symbol_evaluator = SymbolEvaluator(config, symbol,
crypto_currency_evaluator)
exchange_traders[exchange_inst.get_name()] = trader_inst
exchange_traders2[exchange_inst.get_name()] = trader_inst2
symbol_evaluator.set_trader_simulators(exchange_traders)
symbol_evaluator.set_traders(exchange_traders2)
trading_mode_inst = OctoBot.get_trading_mode_class(config)(config,
exchange_inst)
_ = EvaluatorThreadsManager(config, time_frame,
symbol_time_frame_updater_thread,
symbol_evaluator, exchange_inst,
trading_mode_inst, [])
trading_mode = HighFrequencyMode(config, exchange_inst)
trading_mode.add_symbol_evaluator(symbol_evaluator)
return config, exchange_inst, trader_inst, symbol, trading_mode
def _get_tools():
config = load_test_config()
symbol = "BTC/USDT"
exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True)
exchange_inst = exchange_manager.get_exchange()
trader_inst = TraderSimulator(config, exchange_inst, 0.3)
trader_inst.stop_order_manager()
trader_inst.portfolio.portfolio["SUB"] = {
Portfolio.TOTAL: 0.000000000000000000005,
Portfolio.AVAILABLE: 0.000000000000000000005
}
trader_inst.portfolio.portfolio["BNB"] = {
Portfolio.TOTAL: 0.000000000000000000005,
Portfolio.AVAILABLE: 0.000000000000000000005
}
trader_inst.portfolio.portfolio["USDT"] = {
Portfolio.TOTAL: 2000,
Portfolio.AVAILABLE: 2000
}
return config, exchange_inst, trader_inst, symbol
class DataBank(Initializable):
def __init__(self, config, data_file=None, symbols=None):
super().__init__()
self.config = config
self.data_file = data_file if data_file else "tests/static/binance_BTC_USDT_20180428_121156.data"
self.symbols = symbols if symbols else ["BTC"]
self.exchange_manager = ExchangeManager(self.config,
ccxt.binance,
is_simulated=True)
self.exchange_simulator_inst = None
self.data_by_symbol_by_data_frame = None
async def initialize_impl(self):
await self.exchange_manager.initialize()
self.exchange_simulator_inst = self.exchange_manager.get_exchange(
).get_exchange()
self._init_data()
def get_all_data_for_all_available_time_frames_for_symbol(self, symbol):
return self.data_by_symbol_by_data_frame[symbol]
# works only with default data file
# not started, selling started, selling maxed, buying starting, max: back normal:
def get_rise_after_over_sold(self):
return np.concatenate((self._get_bank_time_frame_data(TimeFrames.FOUR_HOURS, 35, 61),
self._get_bank_time_frame_data(TimeFrames.FOUR_HOURS, 0, 49)), axis=1), \
35, 43, 46, 47
# works only with default data file
# not started, buying started, buying maxed, start dipping, super dip, max: back normal:
def get_dip_after_over_bought(self):
return self._get_bank_time_frame_data(TimeFrames.ONE_DAY, 0, 90), \
-18, -14, -10, -9, -2
# works only with default data file
# not started, started, heavy dump, very light dump, max: stopped dump:
def get_sudden_dump(self):
return self._get_bank_time_frame_data(TimeFrames.ONE_HOUR, 0, 46), \
-4, -3, -2, -1
# works only with default data file
# not started, started, heavy pump, max pump, change trend, dipping, max: dipped:
def get_sudden_pump(self):
return self._get_bank_time_frame_data(TimeFrames.HEIGHT_HOURS, 0, 83), \
71, 74, 76, 77, 78, 79
# works only with default data file
# long data_frame with flat then sudden big rise and then mostly flat for 120 values
# start move ending up in a rise, reaches flat trend, first micro up p1, first mirco up p2, micro down, micro up,
# micro down, micro up, micro down, back normal, micro down, back normal, micro down, back up, micro up, back down,
# back normal, micro down, back up, micro down, back up, micro down, back up
def get_overall_flat_trend(self):
return np.concatenate((self._get_bank_time_frame_data(TimeFrames.FIFTEEN_MINUTES, 6, 72)*0.9,
self._get_bank_time_frame_data(TimeFrames.HEIGHT_HOURS, 25, 43),
self._get_bank_time_frame_data(TimeFrames.FIFTEEN_MINUTES, 6, 72),
self._get_bank_time_frame_data(TimeFrames.FIFTEEN_MINUTES, 6, 72)), axis=1), \
67, 85, 87, 90, 95, 107, 116, 123, 138, 141, 151, 153, 161, 163, 173, 174, 175, 180, 183, 193, 198, 203, 207
def _get_bank_time_frame_data(self,
time_frame,
min_index=None,
max_index=None):
if max_index is None and min_index is None:
return self.data_by_symbol_by_data_frame[
self.symbols[0]][time_frame]
else:
min_i = min_index if min_index is not None else 0
max_i = max_index if max_index is not None else \
len(self.data_by_symbol_by_data_frame[self.symbols[0]][time_frame][0])-1
return self.reduce_data(
self.data_by_symbol_by_data_frame[self.symbols[0]][time_frame],
min_i, max_i)
def _init_data(self):
self.data_by_symbol_by_data_frame = {
symbol: self._get_symbol_data(symbol)
for symbol in self.symbols
}
def _get_symbol_data(self, symbol):
min_index = 0
max_index = min_index + 100
return {
time_frame:
self.exchange_simulator_inst.get_candles_exact(symbol,
time_frame,
min_index,
max_index,
return_list=False)
for time_frame in TimeFrames
if self.exchange_simulator_inst.has_data_for_time_frame(
symbol, time_frame.value)
}
@staticmethod
def reduce_data(time_frame_data, min_index, max_index):
symbol_prices = [None] * len(PriceIndexes)
symbol_prices[PriceIndexes.IND_PRICE_CLOSE.value] = \
time_frame_data[PriceIndexes.IND_PRICE_CLOSE.value][min_index:max_index]
symbol_prices[PriceIndexes.IND_PRICE_OPEN.value] = \
time_frame_data[PriceIndexes.IND_PRICE_OPEN.value][min_index:max_index]
symbol_prices[PriceIndexes.IND_PRICE_HIGH.value] = \
time_frame_data[PriceIndexes.IND_PRICE_HIGH.value][min_index:max_index]
symbol_prices[PriceIndexes.IND_PRICE_LOW.value] = \
time_frame_data[PriceIndexes.IND_PRICE_LOW.value][min_index:max_index]
symbol_prices[PriceIndexes.IND_PRICE_TIME.value] = \
time_frame_data[PriceIndexes.IND_PRICE_TIME.value][min_index:max_index]
symbol_prices[PriceIndexes.IND_PRICE_VOL.value] = \
time_frame_data[PriceIndexes.IND_PRICE_VOL.value][min_index:max_index]
return np.array(symbol_prices)
def init_default():
config = load_test_config()
exchange_manager = ExchangeManager(config, ccxt.binance, True)
binance_web_socket = BinanceWebSocketClient(config, exchange_manager)
return config, binance_web_socket