def __configure_default(self, behaviour_config): """Configures and returns the default behaviour class. Args: behaviour_config (dict): A dictionary of configuration values pertaining to the behaviour. Returns: DefaultBehaviour: A class of functionality for the default behaviour. """ exchange_interface = ExchangeInterface(self.config.exchanges) strategy_analyzer = StrategyAnalyzer() notifier = Notifier(self.config.notifiers) behaviour = DefaultBehaviour( behaviour_config, exchange_interface, strategy_analyzer, notifier ) return behaviour
def run_from_config(config_ff, threadID): # Load settings and create the config object config = Configuration(config_ff) settings = config.settings # Set up logger logs.configure_logging(settings['log_level'], settings['log_mode']) logger = structlog.get_logger() logger.info(" %s", threadID) # Configure and run configured behaviour. exchange_interface = ExchangeInterface(config.exchanges) notifier = Notifier(config.notifiers, config) behaviour = Behaviour(config, exchange_interface, notifier) while True: if settings['run_on_start']: start = time.time() behaviour.run(settings['market_pairs'], settings['output_mode']) end = time.time() dif = end - start wait_for = settings['update_interval'] - int(dif) logger.info("Sleeping for %s seconds", wait_for) time.sleep(wait_for) else: logger.info("Run on start not enabled waiting for %s seconds", settings['wait_and_run']) time.sleep(settings['wait_and_run'])
def __configure_simple_bot(self, behaviour_config): """Configures and returns the bot behaviour class. Args: behaviour_config (dict): A dictionary of configuration values pertaining to the behaviour. Returns: SimpleBotBehaviour: A class of functionality for the rsi bot behaviour. """ exchange_interface = ExchangeInterface(self.config.exchanges) strategy_analyzer = StrategyAnalyzer() notifier = Notifier(self.config.notifiers) db_handler = DatabaseHandler(self.config.database) behaviour = SimpleBotBehaviour( behaviour_config, exchange_interface, strategy_analyzer, notifier, db_handler ) return behaviour
def main(): """Initializes the application """ # Load settings and create the config object config = Configuration() settings = config.settings # Set up logger logs.configure_logging(settings['log_level'], settings['log_mode']) logger = structlog.get_logger() # Configure and run configured behaviour. exchange_interface = ExchangeInterface(config.exchanges) if settings['market_pairs']: market_pairs = settings['market_pairs'] logger.info("Found configured markets: %s", market_pairs) market_data = exchange_interface.get_exchange_markets( markets=market_pairs) else: logger.info("No configured markets, using all available on exchange.") market_data = exchange_interface.get_exchange_markets() # notifier = Notifier(config.notifiers, market_data) thread_list = [] for exchange in market_data: num = 1 for chunk in split_market_data(market_data[exchange]): market_data_chunk = dict() market_data_chunk[exchange] = { key: market_data[exchange][key] for key in chunk } notifier = Notifier(config.notifiers, config.indicators, market_data_chunk) behaviour = Behaviour(config, exchange_interface, notifier) workerName = "Worker-{}".format(num) worker = AnalysisWorker(workerName, behaviour, notifier, market_data_chunk, settings, logger) thread_list.append(worker) worker.daemon = True worker.start() time.sleep(60) num += 1 logger.info('All workers are running!') for worker in thread_list: worker.join()
def configure_rsi_bot(self, behaviour_config): exchange_interface = ExchangeInterface( self.config.fetch_exchange_config()) strategy_analyzer = StrategyAnalyzer(exchange_interface) notifier = Notifier(self.config.fetch_notifier_config()) db_handler = DatabaseHandler(self.config.fetch_database_config()) behaviour = RSIBot(behaviour_config, exchange_interface, strategy_analyzer, notifier, db_handler) return behaviour
def configure_default(self, behaviour_config): exchange_interface = ExchangeInterface( self.config.fetch_exchange_config()) strategy_analyzer = StrategyAnalyzer(exchange_interface) notifier = Notifier(self.config.fetch_notifier_config()) behaviour = DefaultBehaviour(behaviour_config, exchange_interface, strategy_analyzer, notifier) return behaviour
def main(): # Load settings and create the config object secrets = {} if os.path.isfile('secrets.json'): secrets = json.load(open('secrets.json')) config = json.load(open('default-config.json')) config.update(secrets) config['settings']['market_pairs'] = os.environ.get('MARKET_PAIRS', config['settings']['market_pairs']) config['settings']['loglevel'] = os.environ.get('LOGLEVEL', config['settings']['loglevel']) config['settings']['app_mode'] = os.environ.get('APP_MODE', config['settings']['app_mode']) config['exchanges']['bittrex']['required']['key'] = os.environ.get('BITTREX_KEY', config['exchanges']['bittrex']['required']['key']) config['exchanges']['bittrex']['required']['secret'] = os.environ.get('BITTREX_SECRET', config['exchanges']['bittrex']['required']['secret']) config['notifiers']['twilio']['required']['key'] = os.environ.get('TWILIO_KEY', config['notifiers']['twilio']['required']['key']) config['notifiers']['twilio']['required']['secret'] = os.environ.get('TWILIO_SECRET', config['notifiers']['twilio']['required']['secret']) config['notifiers']['twilio']['required']['sender_number'] = os.environ.get('TWILIO_SENDER_NUMBER', config['notifiers']['twilio']['required']['sender_number']) config['notifiers']['twilio']['required']['receiver_number'] = os.environ.get('TWILIO_RECEIVER_NUMBER', config['notifiers']['twilio']['required']['receiver_number']) config['notifiers']['gmail']['required']['username'] = os.environ.get('GMAIL_USERNAME', config['notifiers']['gmail']['required']['username']) config['notifiers']['gmail']['required']['password'] = os.environ.get('GMAIL_PASSWORD', config['notifiers']['gmail']['required']['password']) config['notifiers']['gmail']['required']['destination_emails'] = os.environ.get('GMAIL_DESTINATION_EMAILS', config['notifiers']['gmail']['required']['destination_emails']) # Set up logger logs.configure_logging(config['settings']['loglevel'], config['settings']['app_mode']) logger = structlog.get_logger() exchange_interface = ExchangeInterface(config) strategy_analyzer = StrategyAnalyzer(config) notifier = Notifier(config) # The coin pairs coin_pairs = [] if config['settings']['market_pairs']: coin_pairs = config['settings']['market_pairs'].translate(str.maketrans('', '', whitespace)).split(",") else: user_markets = exchange_interface.get_user_markets() for user_market in user_markets['info']: if 'BTC' in user_market['Currency']: continue market_pair = user_market['Currency'] + '/BTC' coin_pairs.append(market_pair) logger.debug(coin_pairs) while True: get_signal(coin_pairs, strategy_analyzer, notifier)
def __configure_reporter(self, behaviour_config): """Configures and returns the reporter behaviour class. Args: behaviour_config (dict): A dictionary of configuration values pertaining to the behaviour. Returns: ReporterBehaviour: A class of functionality for the reporter behaviour. """ exchange_interface = ExchangeInterface(self.config.exchanges) notifier = Notifier(self.config.notifiers) db_handler = DatabaseHandler(self.config.database) behaviour = ReporterBehaviour(behaviour_config, exchange_interface, notifier, db_handler) return behaviour
def main(): """Initializes the application """ # Load settings and create the config object config = Configuration() settings = config.settings # Set up logger logs.configure_logging(settings['log_level'], settings['log_mode']) logger = structlog.get_logger() # Configure and run configured behaviour. exchange_interface = ExchangeInterface(config.exchanges) notifier = Notifier(config.notifiers) behaviour = Behaviour(config, exchange_interface, notifier) while True: behaviour.run(settings['market_pairs'], settings['output_mode']) logger.info("Sleeping for %s seconds", settings['update_interval']) time.sleep(settings['update_interval'])
def main(): # Load settings and create the config object config = conf.Configuration() settings = config.fetch_settings() exchange_config = config.fetch_exchange_config() notifier_config = config.fetch_notifier_config() behaviour_config = config.fetch_behaviour_config() # Set up logger logs.configure_logging(settings['loglevel'], settings['app_mode']) exchange_interface = ExchangeInterface(exchange_config) strategy_analyzer = StrategyAnalyzer(exchange_interface) notifier = Notifier(notifier_config) behaviour_manager = Behaviour(behaviour_config) behaviour = behaviour_manager.get_behaviour(settings['selected_task']) behaviour.run(settings['symbol_pairs'], settings['update_interval'], exchange_interface, strategy_analyzer, notifier)
def __configure_rsi_bot(self, behaviour_config): """Configures and returns the rsi bot behaviour class. Args: behaviour_config (dict): A dictionary of configuration values pertaining to the behaviour. Returns: RSIBot: A class of functionality for the rsi bot behaviour. """ exchange_interface = ExchangeInterface( self.config.get_exchange_config()) strategy_analyzer = StrategyAnalyzer(exchange_interface) notifier = Notifier(self.config.get_notifier_config()) db_handler = DatabaseHandler(self.config.get_database_config()) behaviour = RSIBot(behaviour_config, exchange_interface, strategy_analyzer, notifier, db_handler) return behaviour
def main(): with open("app/config.yml", 'r') as stream: data_loaded = yaml.load(stream) exchangeInterface = ExchangeInterface(data_loaded['exchanges']) exchange = list(data_loaded['exchanges'].keys())[0] market_pair = data_loaded['settings']['market_pairs'][0] interval = data_loaded['settings']['update_interval'] max_periods = data_loaded['settings']['backtest_periods'] ohlcv = exchangeInterface.get_historical_data(exchange, market_pair, interval, max_periods) first = CDL_Test(ohlcv) cdl_list = list(map(lambda x: eval('talib.' + x), cdl)) params_list = {'trailing_window': [10, 15], 'indicator': cdl_list} #result = first.run_algorithm(params_list) best_sharpe, params = first.optim_algo(params_list) first.optim_grid.sort_values(by='sharpe', ascending=False) result = first.run_algorithm(params) pf.create_full_tear_sheet(result.returns)
def load_exchange(exchange): global config, market_data, fibonacci, new_results try: single_config = dict() single_config[exchange] = config.exchanges[exchange] single_exchange_interface = ExchangeInterface(single_config) single_market_data = dict() single_market_data[exchange] = market_data[exchange] behaviour = Behaviour(config, single_exchange_interface) new_result = behaviour.run(exchange, single_market_data, fibonacci, config.settings['output_mode']) new_results[exchange] = new_result[exchange] return True except Exception as exc: logger.info('Exception while processing exchange: %s', exchange) #logger.info('%s', exc) raise exc
# Load settings and create the config object config = Configuration() settings = config.settings # Set up logger logs.configure_logging(settings['log_level'], settings['log_mode']) logger = structlog.get_logger() update_interval = ceil(settings['update_interval'] / 60) logger.info('udate interval %d ', update_interval) config_indicators = config.indicators # Configure and run configured behaviour. exchange_interface = ExchangeInterface(config.exchanges) if settings['market_pairs']: market_pairs = settings['market_pairs'] logger.info("Found configured markets: %s", market_pairs) market_data = exchange_interface.get_exchange_markets(markets=market_pairs) else: logger.info("No configured markets, using all available on exchange.") market_data = exchange_interface.get_exchange_markets() #Dict to save user defined fibonacci levels fibonacci = None #Global Telegram Bot Updater updater = None
def main(): with open("app/config.yml", 'r') as stream: data_loaded = yaml.load(stream) exchangeInterface = ExchangeInterface(data_loaded['exchanges']) exchange = list(data_loaded['exchanges'].keys())[0] market_pair = data_loaded['settings']['market_pairs'][0] interval = data_loaded['settings']['update_interval'] strategies = data_loaded['strategies'] engine = database.engine conn = engine.connect() params = cdl_back_test(exchangeInterface,exchange,market_pair,interval,data_loaded,max_periods=1000,pre_trained=True) database.reset_db() # get historical & live data for the strategies datafeed.start_ticker(exchangeInterface, exchange, market_pair, interval=interval) # start all the strategies strategy_result = start_strategy(exchange, market_pair, interval,strategies) ##################### ### RISK MANAGEMENT ##################### # Position control # let's conjure up a position book fake_position_data = pd.DataFrame({ 'exchange': 'gdax', 'symbol': 'BTC/USD', 'position': 'long', 'amount': 0.1, 'price': 3600}, index=range(1)) # TODO: use config file to list all the exchanges, market pair and update interval # that we need to pull for position control ohlcv_new = datafeed.get_latest_data_from_db(exchange, market_pair, interval) # Look at the collected market data s = db.select([database.OHLCV]) result = conn.execute(s) data = result.fetchall() df = pd.DataFrame(data) df.columns = result.keys() order_book_raw = exchangeInterface.get_order_book('gdax', 'BTC/USD') # purge orders - tbc from logics.risk_management import position_control position_control_simple = position_control.Position_Control(fake_position_data, ohlcv_new, 0.2, 0.2) # produce sell signals only rm_result = position_control_simple.control() # Order execution from logics.risk_management import order_control def order_execution(exchangeInterface, exchange, market_pair, position_book, order_book, orderType='market', ): if (strategy_result['sell'][0] or rm_result['sell'][0]): free_balance = exchangeInterface.get_free_balance(exchange) position = \ position_book.loc[(position_book.exchange == exchange) & (position_book.symbol == market_pair)]['position'][ 0] order_control_simple = order_control.Order_Control(exchange, market_pair, free_balance, position, position_book, order_book) return order_control_simple.simple_control() exec_price, exec_size = order_execution(exchangeInterface, exchange, market_pair, fake_position_data, order_book_raw) ###### ACTUAL ORDER EXECUTION # exchangeInterface.create_order(exchange,market_pair,'limit','buy',exec_size,exec_price) def start_strategy(exchange, market_pair, interval): buy = [] sell = [] def log_result(result): # This is called whenever start_strategy_ returns a result # result_list is modified only by the main process, not the pool workers. buy.append(result['buy']) sell.append(result['sell']) pool = Pool() for key, val in strategies.items(): Backtest_Optim = globals()[val['backtest_optim']] # extract the strategy assert interval == val['interval'], "strategy is not optimized for the given interval" params = {'trailing_window': val['trailing_window'], 'indicator': getattr(talib, val['indicator'])} pool.apply_async(start_strategy_, args=(exchange, market_pair, Backtest_Optim, params, interval), callback=log_result) pool.close() pool.join() return {'buy': buy, 'sell': sell} start_strategy(exchange, market_pair, interval) order_info = exchangeInterface.exchanges['gdax'].fetch_orders('BTC/USD')[0] def log_trade(exchangeInterface, exchange, orderID): """ :param exchangeInterface: :param exchange: :param market_pair: :param orderID: :return: True if the trade is logged, False otherwise """ status = None timeout = tm.time() + 120 while status != 'filled' and tm.time() < timeout: status = exchangeInterface.get_order_info(exchange, orderID)['status'] tm.sleep(exchange.rateLimit / 1000) if status == 'filled': info = exchangeInterface.get_order_info(exchange, orderID)['info'] with database.lock: ins = database.TradeBook.insert().values(info) conn.execute(ins) return True else: return False orderID = exchangeInterface.create_order()[0]['id'] log_trade(exchangeInterface, exchange, orderID)
def main(): # Load settings and create the config object secrets = {} if os.path.isfile('secrets.json'): secrets = json.load(open('secrets.json')) config = json.load(open('default-config.json')) config.update(secrets) config['settings']['market_pairs'] = os.environ.get( 'MARKET_PAIRS', config['settings']['market_pairs']) config['settings']['loglevel'] = os.environ.get('LOGLEVEL', logging.INFO) config['exchanges']['bittrex']['required']['key'] = os.environ.get( 'BITTREX_KEY', config['exchanges']['bittrex']['required']['key']) config['exchanges']['bittrex']['required']['secret'] = os.environ.get( 'BITTREX_SECRET', config['exchanges']['bittrex']['required']['secret']) config['notifiers']['twilio']['required']['key'] = os.environ.get( 'TWILIO_KEY', config['notifiers']['twilio']['required']['key']) config['notifiers']['twilio']['required']['secret'] = os.environ.get( 'TWILIO_SECRET', config['notifiers']['twilio']['required']['secret']) config['notifiers']['twilio']['required'][ 'sender_number'] = os.environ.get( 'TWILIO_SENDER_NUMBER', config['notifiers']['twilio']['required']['sender_number']) config['notifiers']['twilio']['required'][ 'receiver_number'] = os.environ.get( 'TWILIO_RECEIVER_NUMBER', config['notifiers']['twilio']['required']['receiver_number']) config['notifiers']['gmail']['required']['username'] = os.environ.get( 'GMAIL_USERNAME', config['notifiers']['gmail']['required']['username']) config['notifiers']['gmail']['required']['password'] = os.environ.get( 'GMAIL_PASSWORD', config['notifiers']['gmail']['required']['password']) config['notifiers']['gmail']['required'][ 'destination_emails'] = os.environ.get( 'GMAIL_DESTINATION_EMAILS', config['notifiers']['gmail']['required']['destination_emails']) # Set up logger LOGGER = logging.getLogger(__name__) LOGGER.setLevel(config['settings']['loglevel']) LOG_FORMAT = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') LOG_HANDLE = logging.StreamHandler() LOG_HANDLE.setLevel(logging.DEBUG) LOG_HANDLE.setFormatter(LOG_FORMAT) LOGGER.addHandler(LOG_HANDLE) exchange_interface = ExchangeInterface(config) strategy_analyzer = StrategyAnalyzer(config) notifier = Notifier(config) # The coin pairs coin_pairs = [] if config['settings']['market_pairs']: coin_pairs = config['settings']['market_pairs'].translate( str.maketrans('', '', whitespace)).split(",") else: user_markets = exchange_interface.get_user_markets() for user_market in user_markets['info']: if 'BTC' in user_market['Currency']: continue market_pair = user_market['Currency'] + '/BTC' coin_pairs.append(market_pair) LOGGER.debug(coin_pairs) while True: get_signal(coin_pairs, strategy_analyzer, notifier)
def __init__(self, config): self.exchange_aggregator = ExchangeInterface(config) self.logger = structlog.get_logger()