def index_remove_coin(self, coin): if (coin.upper() == "BTC"): logger.warn("You cannot remove BTC from your index.") return indexedCoin = DatabaseManager.get_index_coin_model(coin.upper()) btcCoin = DatabaseManager.get_index_coin_model('BTC') percentageToAdd = indexedCoin.DesiredPercentage if self.coin_supported_check(coin.upper()): if DatabaseManager.delete_index_coin_model(coin.upper()): # Add percentage back to BTC model DatabaseManager.update_index_coin_model( btcCoin.Ticker, btcCoin.DesiredPercentage + percentageToAdd, btcCoin.DistanceFromTarget, btcCoin.Locked) logger.info("Coin " + coin.upper() + " removed from index") else: # Already Exist logger.warn("Coin not in index") else: logger.warn("Coin not supported")
def calculate_amounts(self, coin_above_threshold, coin_below_threshold, percentage_btc_amount): """Calculate the amounts necessary to buy and sell.""" rebalance_special_ticker = coin_above_threshold + "/BTC" if coin_above_threshold == "BTC": rebalance_special_ticker = "BTC/USDT" rebalance_coin_ticker_model = DatabaseManager.get_ticker_model( rebalance_special_ticker) eligible_coin_ticker_model = DatabaseManager.get_ticker_model( coin_below_threshold + "/BTC") amount_to_sell = 0.0 amount_to_buy = 0.0 if coin_above_threshold == "BTC": amount_to_sell = percentage_btc_amount else: btc_val = rebalance_coin_ticker_model.BTCVal if btc_val is not None and btc_val > 0: amount_to_sell = percentage_btc_amount / btc_val if coin_below_threshold == "BTC": amount_to_buy = percentage_btc_amount else: btc_val = eligible_coin_ticker_model.BTCVal if btc_val is not None and btc_val > 0: amount_to_buy = percentage_btc_amount / btc_val return {"rebalance": amount_to_sell, "eligible": amount_to_buy}
def perform_algo_task(): balanceManager = BalanceManager() coinsAboveThreshold = {} coinsEligibleForIncrease = {} em = ExchangeManager() indexInfo = DatabaseManager.get_index_info_model() try: if indexInfo.Active == True: percentage_btc_amount = indexInfo.TotalBTCVal*(indexInfo.BalanceThreshold/100) logger.debug("Percentage_to_btc_amount: " + str(percentage_btc_amount)) if percentage_btc_amount <= CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT: logger.debug("Current BTC Threshold Value To Low - " + str(percentage_btc_amount)) else: # Generate our winners/losers list for indexedCoin in DatabaseManager.get_all_index_coin_models(): if indexedCoin.DistanceFromTarget >= indexInfo.BalanceThreshold: coinsAboveThreshold[indexedCoin.Ticker] = indexedCoin.DistanceFromTarget elif abs(indexedCoin.DistanceFromTarget) >= indexInfo.BalanceThreshold: coinsEligibleForIncrease[indexedCoin.Ticker] = indexedCoin.DistanceFromTarget # Sort our tables coinsAboveThreshold = Util.tuple_list_to_dict(sorted(coinsAboveThreshold.items(), key=lambda pair: pair[1], reverse=True)) coinsEligibleForIncrease = Util.tuple_list_to_dict(sorted(coinsEligibleForIncrease.items(), key=lambda pair: pair[1], reverse=True)) balanceManager.rebalance_coins(coinsAboveThreshold, coinsEligibleForIncrease, percentage_btc_amount, app) except Exception as e: logger.exception(e)
def handle_coin(self, coin_above_threshold, coin_below_threshold, percentage_btc_amount, celery_app): """Handle buying and selling these coins.""" logger.debug("Handling sell/buy for %s and %s", coin_above_threshold, coin_below_threshold) coin_balance = DatabaseManager.get_coin_balance_model( coin_above_threshold) amounts = self.calculate_amounts(coin_above_threshold, coin_below_threshold, percentage_btc_amount) amount_to_sell = amounts["rebalance"] amount_to_buy = amounts["eligible"] if coin_balance.TotalCoins >= amount_to_sell: if self.check_markets(coin_above_threshold, coin_below_threshold): DatabaseManager.create_coin_lock_model(coin_above_threshold) DatabaseManager.create_coin_lock_model(coin_below_threshold) logger.info("Performing Rebalance %s %s - %s %s", coin_above_threshold.upper(), amount_to_sell, coin_below_threshold.upper(), amount_to_buy) celery_app.send_task('Tasks.perform_rebalance_task', args=[ coin_above_threshold.upper(), amount_to_sell, coin_below_threshold.upper(), amount_to_buy ]) else: logger.error("Failed to sell coins - we do not have enough of %s", coin_above_threshold)
def index_equal_weight(self): """Set portfolio to equal weight""" totalPercentage = 0 totalLockedPercentage = 0.0 totalUnlockedPercentage = 100 totalUnlockedCoinsCount = 0 averagePercentage = 0 indexedCoins = DatabaseManager.get_all_index_coin_models() for inCoins in indexedCoins: if inCoins.Locked == True: totalLockedPercentage = totalLockedPercentage + inCoins.DesiredPercentage else: totalUnlockedCoinsCount = totalUnlockedCoinsCount + 1 totalPercentage = totalPercentage + totalLockedPercentage totalUnlockedPercentage = totalUnlockedPercentage - totalLockedPercentage averagePercentage = round( totalUnlockedPercentage / totalUnlockedCoinsCount, 2) logger.info("Setting default allocation to " + str(averagePercentage)) for inCoins in indexedCoins: if inCoins.Locked == False: totalPercentage = totalPercentage + averagePercentage if totalPercentage + averagePercentage > 100: desiredPercentage = 100 - totalPercentage else: desiredPercentage = averagePercentage DatabaseManager.update_index_coin_model( inCoins.Ticker, float(desiredPercentage), 0.0, False)
def handle_trade(self, coin, amount, is_over, celery_app): """Send the appropriate celery message based on buy/sell.""" string_ticker = coin if coin == "BTC": string_ticker += "/USDT" else: string_ticker += "/BTC" if self.em.check_min_buy(amount, string_ticker): ticker = self.em.get_ticker(string_ticker) single_coin_cost = ticker["last"] num_coins = round(amount / single_coin_cost, 8) DatabaseManager.create_coin_lock_model(coin) DatabaseManager.create_wallet_trade_lock_model(coin) if is_over is True: logger.debug("selling %s", coin) celery_app.send_task('Tasks.perform_sell_task', args=[coin.upper(), num_coins]) else: logger.debug("buying %s", coin) celery_app.send_task('Tasks.perform_buy_task', args=[coin.upper(), num_coins]) else: logger.debug("purchase %s does not meet market minimum")
def index_stop_command(self): indexInfo = DatabaseManager.get_index_info_model() DatabaseManager.update_index_info_model(False, indexInfo.TotalBTCVal, indexInfo.TotalUSDVal, indexInfo.BalanceThreshold, indexInfo.OrderTimeout, indexInfo.OrderRetryAmount, indexInfo.RebalanceTickSetting) logger.info("Index Management Stopped.")
def __init__(self): self._client = discord.Client(heartbeat_timeout=60, guild_subscriptions=False, fetch_offline_members=False) self._databaseManager = DatabaseManager(self) self._cacheManager = CacheManager(self) self._commandsManager = CommandsManager(self) self._statisticsManager = StatisticsManager(self) self._teamupManager = TeamupManager(self, config.bot["teamup_dev_token"]) self._calendarsManager = CalendarsManager(self) print("✓ Bot initialized")
def index_remove_coin(self, coin): if self.coin_supported_check(coin.upper()): if DatabaseManager.delete_index_coin_model(coin.upper()): DatabaseManager.delete_realized_gain_model(coin.upper()) logger.info("Coin " + coin.upper() + " removed from index") else: # Already Exist logger.warn("Coin not in index") else: logger.warn("Coin not supported")
def increment_rebalance_tick_task(): indexInfo = DatabaseManager.get_index_info_model() if indexInfo.Active == True: rebalanceTick = DatabaseManager.get_rebalance_tick_model() if rebalanceTick.TickCount >= indexInfo.RebalanceTickSetting: app.send_task('Tasks.perform_algo_task',args=[]) else: DatabaseManager.update_rebalance_tick_model(rebalanceTick.TickCount + 1)
def lock_unlock_coin(self, ticker, is_lock): coin = DatabaseManager.get_index_coin_model(ticker) if coin is None: logger.error( "%s is not currently in your index. Use index add functionality to add it.", ticker) return coin.Locked = is_lock DatabaseManager.update_index_coin_object(coin) logger.info("%s %s", ticker, "locked" if is_lock else "unlocked")
def index_rebalance_tick_update(self, tickcount): if isinstance(int(tickcount), (float, int, complex, long)): DatabaseManager.update_index_info_model( indexInfo.Active, indexInfo.TotalBTCVal, indexInfo.TotalUSDVal, indexInfo.TotalRealizedGain, indexInfo.TotalUnrealizedGain, round(float(percentage), 2), indexInfo.OrderTimeout, indexInfo.OrderRetryAmount, int(tickcount)) logger.info("Index rebalance time set to " + str(tickcount) + " minutes.") else: logger.warn("Tick count isn't a number")
def index_add_coin(self, coin, percentage=1.0, locked=False): lockCoin = False totalLockedPercentage = 0.0 totalUnlockedPercentage = 0.0 totalUnlockedCoinsCount = 0 indexInfo = DatabaseManager.get_index_info_model() indexedCoins = DatabaseManager.get_all_index_coin_models() if locked == "true" or locked == "True": lockCoin = True for inCoins in indexedCoins: if inCoins.Locked == True: totalLockedPercentage = totalLockedPercentage + inCoins.DesiredPercentage else: totalUnlockedPercentage = totalUnlockedPercentage + inCoins.DesiredPercentage totalUnlockedCoinsCount = totalUnlockedCoinsCount + 1 if totalUnlockedPercentage > float(percentage): if self.coin_supported_check(coin.upper()): percentageToRemove = float( percentage) / totalUnlockedCoinsCount for iCoin in indexedCoins: if iCoin.Locked != True: DatabaseManager.update_index_coin_model( iCoin.Ticker, iCoin.DesiredPercentage - percentageToRemove, iCoin.DistanceFromTarget, iCoin.Locked) if isinstance(float(percentage), (float, int, complex, int)): if DatabaseManager.create_index_coin_model( coin.upper(), float(percentage), 0.0, lockCoin): logger.info("Coin " + coin.upper() + " added to index") else: # Already Exist logger.warn("Coin already in index") else: logger.warn("Percentage isn't a number") else: logger.warn("Coin not supported") else: logger.warn("Not Enough Unlocked Percentage")
def get_ticker(key): fullTicker = key.Ticker + "/BTC" if key.Ticker == 'BTC': fullTicker = 'BTC/USDT' return DatabaseManager.get_ticker_model(fullTicker)
def index_rebalance_tick_update(self, tickcount): indexInfo = DatabaseManager.get_index_info_model() if isinstance(int(tickcount), (float, int, complex, int)): DatabaseManager.update_index_info_model(True, indexInfo.TotalBTCVal, indexInfo.TotalUSDVal, indexInfo.BalanceThreshold, indexInfo.OrderTimeout, indexInfo.OrderRetryAmount, int(tickcount)) logger.info("Index rebalance time set to " + str(tickcount) + " minutes.") else: logger.warn("Tick count isn't a number")
def supported_coins_task(): em = ExchangeManager() marketData = em.get_tickers() btcUsdValue = em.get_btc_usd_value() supportedCoins = em.get_supported_pairs(marketData) logger.debug("Starting Coins Update Task") # First We Update our Supported Market List for key in supportedCoins: sliced_pair = '' if key != 'BTC/USDT': sliced_pair = key[:-4] else: sliced_pair = 'BTC' DatabaseManager.create_supported_coin_model(sliced_pair) btcTickerVal = 0.0 usdTickerVal = 0.0 if key != 'BTC/USDT': btcTickerVal = marketData[key]['info']['Ask'] usdTickerVal = btcUsdValue * btcTickerVal else: btcTickerVal = 0.0 usdTickerVal = marketData[key]['info']['Ask'] if DatabaseManager.create_ticker_model(key, round(btcTickerVal, 8), round(usdTickerVal, 8), datetime.datetime.now()): #logger.debug("Created Ticker Model - " + key) pass else: if DatabaseManager.update_ticker_model(key, round(btcTickerVal, 8), round(usdTickerVal, 8), datetime.datetime.now()): #logger.debug("Updated Ticker Model - " + key) pass else: logger.error("Failed To Update Ticker Model - " + key) logger.info("Coins Update Task Completed")
def index_start_command(self): totalIndexPercentage = 0.0 indexInfo = DatabaseManager.get_index_info_model() indexCoins = DatabaseManager.get_all_index_coin_models() for coin in indexCoins: totalIndexPercentage = totalIndexPercentage + coin.DesiredPercentage if totalIndexPercentage == 100: for iCoin in indexCoins: if iCoin.Ticker != "BTC": coinTicker = DatabaseManager.get_ticker_model( iCoin.Ticker.upper() + "/BTC") sys.stdout.write(coinTicker) sys.stdout.write(iCoin.Ticker) sys.stdout.write('\n') percentage_btc_amount = (indexInfo.TotalBTCVal / 100) * iCoin.DesiredPercentage amountToBuy = percentage_btc_amount / coinTicker.BTCVal logger.debug("Percentage_to_btc_amount: " + str(percentage_btc_amount)) if percentage_btc_amount <= CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT: logger.debug("Current BTC Threshold Value To Low - " + str(percentage_btc_amount)) else: #buy app.send_task('Tasks.perform_buy_task', args=[iCoin.Ticker.upper(), amountToBuy]) DatabaseManager.update_index_info_model( True, indexInfo.TotalBTCVal, indexInfo.TotalUSDVal, indexInfo.TotalRealizedGain, indexInfo.TotalUnrealizedGain, indexInfo.BalanceThreshold, indexInfo.OrderTimeout, indexInfo.OrderRetryAmount, indexInfo.RebalanceTickSetting) else: logger.warn("Index is currently unbalanced please rebuild")
def check_locks(self, coin_above_threshold, coin_below_threshold): """Check the coins to make sure neither are currently locked.""" logger.debug("Checking locks for %s and %s", coin_above_threshold, coin_below_threshold) if DatabaseManager.get_coin_lock_model( coin_above_threshold) is not None: logger.debug("Current Avalible Coin Is Locked - %s", coin_above_threshold) return False if DatabaseManager.get_coin_lock_model( coin_below_threshold) is not None: logger.debug("Current Eligible Coin Is Locked - %s", coin_below_threshold) return False return True
def handle_coin(self, coin, is_over, celery_app): """Handle re-balancing an individual coin.""" if DatabaseManager.get_coin_lock_model( coin) is None and DatabaseManager.get_wallet_trade_lock_model( coin) is None: if not coin == "BTC": if not self.em.market_active(coin, "BTC"): logger.error("Market for %s/BTC offline", coin) return amount = self.calculate_amount(coin, is_over) if amount is None: return if not coin == "BTC": self.handle_trade(coin, amount, is_over, celery_app) else: logger.warning("Coin %s is locked and cannot be traded", coin)
def import_index(self): """Destructively create the index from a JSON file.""" coins = DatabaseManager.get_all_index_coin_models() for coin in coins: DatabaseManager.delete_index_coin_model(coin.Ticker) indexed_coins = "" with open("index.json", "r") as file_obj: indexed_coins = jsonpickle.decode(file_obj.read()) for coin in indexed_coins: coin.DesiredPercentage = coin.DesiredPercentage if coin.DesiredPercentage is not None else 1 coin.Locked = coin.Locked if coin.Locked is not None else False # logger.debug('adding %s with percentage %s', coin.Ticker, coin.DesiredPercentage) DatabaseManager.create_index_coin_model(coin.Ticker, coin.DesiredPercentage, 0, coin.Locked) logger.info("Index imported from index.json")
def index_threshold_update(self, percentage): if isinstance(float(percentage), (float, int, complex, int)): indexInfo = DatabaseManager.get_index_info_model() percentage_btc_amount = indexInfo.TotalBTCVal * ( float(percentage) / 100) if percentage_btc_amount <= CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT: logger.error("Desired BTC Threshold Value Too Low - " + str(percentage)) else: DatabaseManager.update_index_info_model( True, indexInfo.TotalBTCVal, indexInfo.TotalUSDVal, round(float(percentage), 2), indexInfo.OrderTimeout, indexInfo.OrderRetryAmount, indexInfo.RebalanceTickSetting) logger.info("Index threshold set to " + str(round(float(percentage), 2))) else: logger.warn("Percentage isn't a number")
def __call__(self, *args, **kwargs): """Init main loop for the application.""" self.database_manager = DatabaseManager() while True: clean_terminal() cprint(' Menu ', 'red') print("==================") cprint(' 1) Quel aliment souhaitez-vous remplacer ?', 'red') cprint(' 2) Retrouver mes aliments substitués.', 'red') reply_1 = self.ask_with_input( 'Choisir un numéro ' '(tapez "quit" pour quitter)' ' : ', 2, ('quit', )) if reply_1 == 'quit': break elif reply_1 == '1': while True: clean_terminal() cprint(' 1) Parcourir le rayon. ', 'red') cprint(' 2) Effectuer une recherche. ', 'red') reply_2 = self.ask_with_input( 'Choisir un numéro ' '(tapez "quit" pour quitter)' ' : ', 2, ('quit', )) if reply_2 == 'quit': break elif reply_2 == "1": self.get_store_department() elif reply_2 == "2": self.do_research() else: self.get_substitutable_products() self.database_manager.close()
def show_stats(self): indexInfo = IndexInfoModel.get(id=1) # Create the Index Table cointTableData = [[ 'Coin', 'Amount', 'BTC Val', 'USD Val', 'Desired %', 'Locked', 'Active %', 'U Gain %', 'R Gain %' ]] for coin in IndexedCoinModel.select(): coinBalance = CoinBalanceModel.get( CoinBalanceModel.Coin == coin.Ticker) realizedGainModel = DatabaseManager.get_realized_gain_model( coin.Ticker) newArray = [ coin.Ticker, coinBalance.TotalCoins, coinBalance.BTCBalance, round(coinBalance.USDBalance, 2), coin.DesiredPercentage, coin.Locked, coin.CurrentPercentage, coin.UnrealizedGain, realizedGainModel.RealizedGain, ] cointTableData.append(newArray) # Create the summary table summary_table_data = [[ 'Active', 'Index Count', 'BTC Val', 'USD Val', 'Unrealized Gain %', 'Realized Gain %' ]] summary_table_data.append([ True, len(IndexedCoinModel.select()), indexInfo.TotalBTCVal, indexInfo.TotalUSDVal, round(indexInfo.TotalUnrealizedGain, 2), round(indexInfo.TotalRealizedGain, 2) ]) coin_table = AsciiTable(cointTableData) summary_table = AsciiTable(summary_table_data) sys.stdout.write("\nCurrent Index Summary\n") sys.stdout.write(summary_table.table) sys.stdout.write("\nCurrent Index Table\n") sys.stdout.write(coin_table.table) sys.stdout.write('\n')
def index_gen_command(self): totalIndexPercentage = 0.0 indexInfo = DatabaseManager.get_index_info_model() indexCoins = DatabaseManager.get_all_index_coin_models() for iCoin in indexCoins: if iCoin.Ticker != "BTC": coinTicker = DatabaseManager.get_ticker_model( iCoin.Ticker.upper() + "/BTC") percentage_btc_amount = (indexInfo.TotalBTCVal / 100) * iCoin.DesiredPercentage amountToBuy = percentage_btc_amount / coinTicker.BTCVal logger.debug("Percentage_to_btc_amount: " + str(percentage_btc_amount)) if percentage_btc_amount <= CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT: logger.debug("Current BTC Threshold Value To Low - " + str(percentage_btc_amount)) else: #buy app.send_task('Tasks.perform_buy_task', args=[iCoin.Ticker.upper(), amountToBuy]) DatabaseManager.update_index_info_model(True, indexInfo.TotalBTCVal, indexInfo.TotalUSDVal, indexInfo.BalanceThreshold, indexInfo.OrderTimeout, indexInfo.OrderRetryAmount, indexInfo.RebalanceTickSetting)
def show_threshold(self): indexInfo = DatabaseManager.get_index_info_model() sys.stdout.write("\nCurrent Rebalance Threshold\n") summary_table_data = [[ "Active", "Balance Threshold", "Order Timeout", "Rebalance Tick Setting" ]] summary_table_data.append([ indexInfo.Active, indexInfo.BalanceThreshold, indexInfo.OrderTimeout, indexInfo.RebalanceTickSetting ]) summary_table = AsciiTable(summary_table_data) sys.stdout.write(summary_table.table) sys.stdout.write("\n")
def export_index(self): """Export the index to a JSON file.""" indexInfo = DatabaseManager.get_all_index_coin_models() indexJson = "[" coins = [] for coin in indexInfo: coins.append(jsonpickle.encode(coin)) indexJson += ",".join(coins) indexJson += "]" with open("index.json", "w") as file_object: file_object.write(indexJson) logger.info("Index exported to index.json")
from flask.blueprints import Blueprint from flask import render_template from flask import request from managers.DatabaseManager import DatabaseManager from extensions import db db_manager = DatabaseManager(db) addLecturer = Blueprint('addLecturer', __name__, template_folder='templates', static_folder='static') @addLecturer.route('/addLecturer') def index3(): return render_template('addLecturer.html') @addLecturer.route('/addLecturer', methods=['post', 'get']) def addLec(): if request.method == 'POST': last_name = request.form.get('last_name') name = request.form.get('name') surname = request.form.get('surname') if last_name and name and surname: message = "" db_manager.add_lecturer(name=name, last_name=last_name, surname=surname) else: message = "error!"
def calculate_amount(self, coin, is_over): """Figure out how much to buy/sell. Method should look up current value of each coin as trades fired previously could modify the balance. Includes minimum trade check. Returns None if amount doesn't meet trade threshold. """ index_info = DatabaseManager.get_index_info_model() coin_balance = DatabaseManager.get_coin_balance_model(coin) indexed_coin = DatabaseManager.get_index_coin_model(coin) amount = None off = indexed_coin.get_percent_from_coin_target( coin_balance, index_info.TotalBTCVal) logger.info( "coin off percentage is %s with current coin balance of %s", off, coin_balance.BTCBalance) if coin_balance.BTCBalance > 0: if is_over is True: logger.info( "Coin %s over threshold, calculating off percentage", coin) if off > 100: amount = round(coin_balance.BTCBalance * (1 / (off / 100)), 8) else: amount = round(coin_balance.BTCBalance * off / 100, 8) else: logger.info( "Coin %s under threshold, calculating off percentage", coin) amount = round( (coin_balance.BTCBalance / (1 - (abs(off) / 100))) - coin_balance.BTCBalance, 8) logger.info("Amount calculated as %s", amount) if amount == None or amount == 0: logger.info( "Zero amount detected for %s. Attemping to buy 2x the minimum order.", coin) pair_string = coin if pair_string == "BTC": pair_string += "/USDT" else: pair_string += "/BTC" min_buy = self.em.get_min_buy_btc(pair_string) if min_buy is not None: amount = round(min_buy * 2, 8) else: logger.info( "Zero amount of coin %s and market info cannot be found") amount = None if amount is not None: logger.info( "checking to see if amount %s is greater than trade threshold %s", amount, CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT) over_threshold = float(amount) >= float( CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT) if over_threshold is True: if is_over is False: logger.info("checking to see if %s is available in BTC", amount) balance_available = 0.0 btc_balance = DatabaseManager.get_coin_balance_model("BTC") btc_indexed_coin = DatabaseManager.get_index_coin_model( "BTC") btc_off = btc_indexed_coin.get_percent_from_coin_target( btc_balance, index_info.TotalBTCVal) if btc_off <= 0: return None balance_available = round( btc_balance.BTCBalance * (btc_off / 100), 8) logger.info("Available BTC balance %s", balance_available) if balance_available >= amount: return amount #See if 1x the threshold is available single_threshold_amount = round( amount / (index_info.BalanceThreshold / 100), 8) if not single_threshold_amount >= em.get_min_buy_btc( pair_string): single_threshold_amount = em.get_min_buy_btc( pair_string) * 2 if balance_available >= single_threshold_amount and float( single_threshold_amount) >= float( CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT): return single_threshold_amount else: amount = None logger.warning( "The amount to trade %s not available currently", amount) else: logger.info("selling %s %s to BTC/USDT", amount, coin) else: logger.warning("Coin %s amount %s not over trade threshold", coin, amount) amount = None return amount
def index_update_coin(self, coin, percentage, locked): lockCoin = False totalLockedPercentage = 0.0 totalUnlockedPercentage = 0.0 totalUnlockedCoinsCount = 0 indexInfo = DatabaseManager.get_index_info_model() indexedCoins = DatabaseManager.get_all_index_coin_models() indexedCoin = DatabaseManager.get_index_coin_model(coin.upper()) for inCoins in indexedCoins: if inCoins.Ticker != coin.upper(): if inCoins.Locked == True: totalLockedPercentage = totalLockedPercentage + inCoins.DesiredPercentage else: totalUnlockedPercentage = totalUnlockedPercentage + inCoins.DesiredPercentage totalUnlockedCoinsCount = totalUnlockedCoinsCount + 1 if len(indexedCoins) > 1: if totalUnlockedCoinsCount > 0: if locked == "true" or locked == "True": lockCoin = True percentage_btc_amount = indexInfo.TotalBTCVal * ( float(percentage) / 100) if percentage_btc_amount >= CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT: if float(percentage) > indexedCoin.DesiredPercentage: if totalUnlockedPercentage > float(percentage): if self.coin_supported_check(coin.upper()): percentageToAdd = 0.0 if totalUnlockedCoinsCount > 0: percentageToAdd = float( indexedCoin.DesiredPercentage - float(percentage) ) / totalUnlockedCoinsCount else: percentageToAdd = float( indexedCoin.DesiredPercentage - float(percentage)) for iCoin in indexedCoins: if iCoin.Ticker != coin.upper(): if iCoin.Locked != True: DatabaseManager.update_index_coin_model( iCoin.Ticker, iCoin.DesiredPercentage - percentageToAdd, iCoin.DistanceFromTarget, iCoin.Locked) if isinstance(float(percentage), (float, int, complex, long)): if DatabaseManager.update_index_coin_model( coin.upper(), float(percentage), 0.0, lockCoin): logger.info("Coin " + coin.upper() + " updated in index") else: # Already Exist logger.warn("Coin already in index") else: logger.warn("Percentage isn't a number") else: logger.warn("Coin not supported") else: logger.warn("Not Enough Unlocked Percentage") else: ## NEW BLOCK if self.coin_supported_check(coin.upper()): percentageToAdd = 0.0 if totalUnlockedCoinsCount > 0: percentageToAdd = float( indexedCoin.DesiredPercentage - float( percentage)) / totalUnlockedCoinsCount else: percentageToAdd = float( indexedCoin.DesiredPercentage - float(percentage)) for iCoin in indexedCoins: if iCoin.Ticker != coin.upper(): if iCoin.Locked != True: DatabaseManager.update_index_coin_model( iCoin.Ticker, iCoin.DesiredPercentage + percentageToAdd, iCoin.DistanceFromTarget, iCoin.Locked) if isinstance(float(percentage), (float, int, complex, int)): if DatabaseManager.update_index_coin_model( coin.upper(), float(percentage), 0.0, lockCoin): logger.info("Coin " + coin.upper() + " updated in index") else: # Already Exist logger.warn("Coin already in index") else: logger.warn("Percentage isn't a number") else: logger.warn("Coin not supported") else: logger.warn( "Specified percentage below current bittrex trade value" ) else: logger.warn( "Currently no unlocked coins to transfer free value") else: logger.warn( "Please add another coin to your index before updating a given coin" )
def index_add_coin(self, coin, percentage, locked): lockCoin = False totalLockedPercentage = 0.0 totalUnlockedPercentage = 0.0 totalUnlockedCoinsCount = 0 indexInfo = DatabaseManager.get_index_info_model() indexedCoins = DatabaseManager.get_all_index_coin_models() if locked == "true" or locked == "True": lockCoin = True percentage_btc_amount = indexInfo.TotalBTCVal * (float(percentage) / 100) if percentage_btc_amount >= CondexConfig.BITTREX_MIN_BTC_TRADE_AMOUNT: for inCoins in indexedCoins: if inCoins.Locked == True: totalLockedPercentage = totalLockedPercentage + inCoins.DesiredPercentage else: totalUnlockedPercentage = totalUnlockedPercentage + inCoins.DesiredPercentage totalUnlockedCoinsCount = totalUnlockedCoinsCount + 1 if totalUnlockedPercentage > float(percentage): if self.coin_supported_check(coin.upper()): percentageToRemove = float( percentage) / totalUnlockedCoinsCount for iCoin in indexedCoins: if iCoin.Locked != True: DatabaseManager.update_index_coin_model( iCoin.Ticker, iCoin.DesiredPercentage - percentageToRemove, iCoin.CurrentPercentage, iCoin.UnrealizedGain, iCoin.Locked) if isinstance(float(percentage), (float, int, complex, long)): if DatabaseManager.create_index_coin_model( coin.upper(), float(percentage), 0.0, 0.0, lockCoin): DatabaseManager.create_realized_gain_model( coin.upper(), 0.0) logger.info("Coin " + coin.upper() + " added to index") else: # Already Exist logger.warn("Coin already in index") else: logger.warn("Percentage isn't a number") else: logger.warn("Coin not supported") else: logger.warn("Not Enough Unlocked Percentage") else: logger.warn( "Specified percentage below current bittrex trade value")