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