How to invest and trade in crypto currencies with Tradingview, Cryptohopper and Binance

import json, config, math, concurrent.futures, threading, logging, sqlite3
import numpy as np
import datetime
from flask import Flask, request, jsonify, render_template
from binance.client import Client
from binance.enums import *

app = Flask(__name__)

app.jinja_env.auto_reload = True

thread_local = threading.local()
client = Client(config.API_KEY, config.API_SECRET)


stable_coin = 'USDT'

filename_reserved_currencies = "reserved.txt"
f = open(filename_reserved_currencies, "r")
reserved_currencies = f.readline().rstrip().split(',')
reserved_currencies_with_usdt = [s + stable_coin for s in reserved_currencies]

reserved_currencies = reserved_currencies + reserved_currencies_with_usdt


logging.basicConfig(filename='binance.log', level=logging.INFO, format='%(asctime)s - %(levelname)s: %(message)s', datefmt='%Y-%m-%d %H:%M:%S %p')
#logging.info('Reserved currencies')
#logging.info(reserved_currencies)

def truncate(number, digits) -> float:
    stepper = 10.0 ** digits
    return math.trunc(stepper * number) / stepper

def sell_all(with_reserved=False):
    info = client.get_account()

    assets = []
    values = []

    for index in range(len(info['balances'])):
        if float(info['balances'][index]['free'])>0.0:
            for key in info['balances'][index]:
                if key == 'asset':
                    assets.append(info['balances'][index][key])
                if key == 'free':
                    values.append(info['balances'][index][key])

    data = json.loads(request.data)

    logging.info(data['ticker'])
    logging.info(data['strategy']['order_action'].upper())
    logging.info(data['strategy']['order_contracts'])

    if data['passphrase'] != config.WEBHOOK_PASSPHRASE:
        resp = {"code": "error","message": "Nice try, invalid passphrase"}
        return jsonify(resp)

    if data['ticker'] != "PANIC_BUTTON":
        resp = {"code": "error","message": "no panic"}
        return jsonify(resp)

    #my_file = open("coins_list", "r")
    coins_list = assets

    converted_list = []

    logging.info('Reserved currencies')
    logging.info(reserved_currencies)

    if with_reserved:
        for element in coins_list:
            logging.info(element.strip())
            #converted_list.append(element.strip())
    else:
        for element in coins_list:
            if element != stable_coin and element != 'BNB' and element != 'BNB'+stable_coin and element != 'SHIB' and element != 'SHIB'+stable_coin and element not in reserved_currencies:
                logging.info(element.strip())
                converted_list.append(element.strip())

    order_response_text = ""
    order_response_all = 1
    for i in converted_list:

        data['ticker'] = i

        side = 'SELL'

        logging.info(i)
        this_asset = i + stable_coin
        info_symbol = client.get_symbol_info(this_asset)
        #logging.info(info_symbol)
        #baseAssetPrecision = int(info_symbol['baseAssetPrecision'])
        #logging.info(baseAssetPrecision)
        my_qty = float(client.get_asset_balance(asset=i)['free'])
        OrderSize = my_qty
        if OrderSize >= 0.01 :
            OrderSize = truncate(OrderSize,2)
            logging.info('OrderSize >= 0.01')
            logging.info(OrderSize)
        else :
            logging.info('OrderSize < 0.01')
            logging.info(OrderSize)

        logging.info(OrderSize)
        quantity = OrderSize
        symbol = data['ticker']
        order_type=ORDER_TYPE_MARKET

        logging.info(f"sending order {order_type} - {side} {quantity} {symbol}")

        #order_response = 0
        order_response = order(side, quantity, this_asset)
        order_response_all = order_response_all and order_response
        #logging.info(order_response)

        if order_response:
            order_response_text = f"order {order_type} - {side} {quantity} {symbol} succeded"
            logging.info(order_response_text)
        else:
            order_response_text = f"order {order_type} - {side} {quantity} {symbol} failed"
            logging.info(order_response_text)
            quantity = truncate(quantity,0)
            logging.info('new quontity truncate 0')
            logging.info(quantity)
            order_response2 = order(side, quantity, this_asset)
            logging.info(order_response2)

        logging.info('***')
        
    return order_response_all



def topup_bnb(min_balance: float, topup: float):
    ''' Top up BNB balance if it drops below minimum specified balance '''
    bnb_balance = client.get_asset_balance(asset='BNB')
    bnb_balance = float(bnb_balance['free'])

    logging.info('bnb_balance: %s', str(bnb_balance))
    logging.info('bnb_min_balance: %s', str(min_balance))

    if bnb_balance < min_balance:
        logging.info('bnb_balance < bnb_min_balance')
        qty = round(topup - bnb_balance, 5)
        print(qty)
        logging.info('ordering %s of BNB'+stable_coin, qty)
        order = client.order_market_buy(symbol='BNB'+stable_coin, quantity=qty)
        return order
    return False


def get_symbol_ticker(couple):
    price = client.get_symbol_ticker(symbol=couple)
    return price

def get_total_balance():

    info = client.get_account()

    assets = []
    values = []
    usdt_value = 0.0
    for index in range(len(info['balances'])):
        if float(info['balances'][index]['free'])>0.0:
            for key in info['balances'][index]:
                if key == 'asset':
                    assets.append(info['balances'][index][key])
                if key == 'free':
                    values.append(info['balances'][index][key])
                    if info['balances'][index]['asset'] == stable_coin:
                        usdt_value = info['balances'][index][key]


    token_usdt = []  # Dict to hold pair price in stable_coin
    token_pairs = []  # List to hold different token pairs



    # Creating token pairs and saving into a list
    with concurrent.futures.ThreadPoolExecutor(max_workers=200) as executor:
        for token in assets:
            #logging.info(token)
            if token != stable_coin:
                couple=token + stable_coin
                try:
                    price = executor.submit(get_symbol_ticker, couple)
                    #logging.info(couple)
                    #logging.info('couple price: %s', str(price.result()))
                    token_usdt.append(price.result())
                    token_pairs.append(couple)
                except Exception as e:
                    token_usdt.append({'symbol': couple, 'price': '-1'})
                    token_pairs.append(couple)
                    pass
            else:
                token_usdt.append(0)
   #else:
            #    token_usdt.append(0)
            #    token_pairs.append(stable_coin)
    total = total_amount_usdt(assets,values,token_usdt,token_pairs)
    total_without_reserved = total_amount_without_reserved_usdt(assets,values,token_usdt,token_pairs)
    n_currencies = 0
    this_currency_amount = 0.0
    total_amount = 0.0
    for i, token in enumerate(assets):
        if token in reserved_currencies:
            total_amount = total_amount
        elif token != stable_coin:
            this_currency_amount = float(values[i]) * float(token_usdt[i]['price'])
            if this_currency_amount > 15.0:
                n_currencies = n_currencies + 1

    return total_without_reserved, total, usdt_value, n_currencies

def total_amount_without_reserved_usdt(assets, values, token_usdt, token_pairs):

    total_amount = 0

    for i, token in enumerate(assets):
        if token in reserved_currencies:
            total_amount = total_amount
        elif token != stable_coin:
            if float(token_usdt[i]['price'])> 0.0:
                total_amount += float(values[i]) * float(token_usdt[i]['price'])
        else:
            total_amount += float(values[i]) * 1
    return total_amount

def total_amount_usdt(assets, values, token_usdt, token_pairs):
    total_amount = 0

    #logging.info('enumerate assets = %s elements', str(len(assets)))
    #logging.info('enumerate token_usdt = %s elements', str(len(token_usdt)))
    #logging.info('enumerate values = %s elements', str(len(values)))
    if len(assets)>1:
        logging.info('len_assets: %s', str(len(assets)))
        for i, token in enumerate(assets):
            #logging.info('value = %s', str(values[i]))
            #logging.info('price = %s', str(float(token_usdt[i]['price'])))
            #logging.info('------')
            
            if token != stable_coin:
                if float(token_usdt[i]['price'])> 0.0:
                    total_amount += float(values[i]) * float(token_usdt[i]['price'])
            else:
                total_amount += float(values[i]) * 1
    else:
        logging.info('binance server respond with insufficient coins: %s', str(len(assets)))
    return total_amount

def total_amount_btc(assets, values, token_usdt):
    """
    Function to calculate total portfolio value in BTC
    :param assets: Assets list
    :param values: Assets quantity
    :param token_usdt: Token pair price dict
    :return: total value in BTC
    """
    total_amount = 0
    for i, token in enumerate(assets):
        if token != 'BTC' and token != stable_coin:
            total_amount += float(values[i]) \
                            * float(token_usdt[token + stable_coin]) \
                            / float(token_usdt['BTC'+stable_coin])
        if token == 'BTC':
            total_amount += float(values[i]) * 1
        else:
            total_amount += float(values[i]) \
                            / float(token_usdt['BTC'+stable_coin])
    return total_amount


def assets_usdt(assets, values, token_usdt):
    """
    Function to convert all assets into equivalent stable_coin value
    :param assets: Assets list
    :param values: Assets quantity
    :param token_usdt: Token pair price dict
    :return: list of asset values in stable_coin
    """
    assets_in_usdt = []
    for i, token in enumerate(assets):
        if token != stable_coin:
            assets_in_usdt.append(
                float(values[i]) * float(token_usdt[token + stable_coin])
            )
        else:
            assets_in_usdt.append(float(values[i]) * 1)
    return assets_in_usdt

def order(side, quantity, symbol, order_type=ORDER_TYPE_MARKET, balance = 0.0):
    try:
        logging.info('ENTERING IN ORDER')
        binance_asset=symbol.replace(stable_coin,'')
        binance_asset=binance_asset.replace('USD','')
        OrderSize = quantity
        stepSize = 0

        #topup_bnb(1,1.1)
        logging.info(side)

        if side == "SELL" :
            logging.info('ENTERING IN SELL')
            OrderSize= quantity
            logging.info(symbol)
            logging.info(OrderSize)

            if binance_asset == "BNB" :
                OrderSize = OrderSize * 0.0
            #quantity=quantity-(quantity*0.0016)

        if side == "BUY" :
            logging.info('ENTERING IN BUY')
            logging.info(f"TRYING TO BUY {symbol}")
            if balance == 0.0 :
                total_balance_without_reserved, total_balance, usdt_value, n_currencies = get_total_balance()
            else :
                total_balance_without_reserved = float(balance)
                total_balance = float(balance)

            logging.info(f"{stable_coin} available: {total_balance_without_reserved}")
            total_balance_without_reserved = float(total_balance_without_reserved)
            amount = total_balance_without_reserved*0.0046

            logging.info(f"{stable_coin} available per coin: {amount}")
            
            maxAmount = 22.0
            minAmount = 20.0

            if amount > maxAmount :
                logging.info(f"{stable_coin} amount too big for me ({maxAmount}) per coin")
                amount = maxAmount
                logging.info(f"{stable_coin} amount resetted to ({amount})")
            if amount < minAmount :
                logging.info(f"{stable_coin} amount too small for me ({minAmount}) per coin")
                amount = minAmount
                logging.info(f"{stable_coin} amount resetted to ({amount})")
            symbolusdt=symbol+stable_coin
            info = client.get_symbol_info(symbolusdt)
            

            #print(info)
            baseAssetPrecision = int(info['baseAssetPrecision'])

            minQty = truncate(float(info['filters'][2]['minQty']),baseAssetPrecision)
            logging.info(f"minQty = {minQty}")
            minNotional = truncate(float(info['filters'][3]['minNotional']),baseAssetPrecision)
            logging.info(f"minNotional = {minNotional}")
            stepSize = float(info['filters'][2]['stepSize'])
            logging.info(f"stepSize = {stepSize}")

            logStepSize = abs(math.log10(stepSize))
            logging.info(f"logStepSize = {logStepSize}")

            price = float(client.get_symbol_ticker(symbol=symbolusdt)['price'])
            logging.info(f"price of {symbol}: {price}")

            MinimumOrderSize = truncate(float(round(minNotional / price,0)),logStepSize)

            OrderSize = truncate(float(round(amount/price,0)),logStepSize)
            
            logging.info(f"quantity of {symbol} to buy: {OrderSize}")

            logging.info(f"minQuantity to by of {symbol}: {minQty}")
            logging.info(f"minNotional to by of {symbol}: {minNotional}")

            if OrderSize < MinimumOrderSize :
                logging.info(f"Quantity {OrderSize} considered insufficient")
                OrderSize = MinimumOrderSize
                logging.info(f"Quantity resetted to {OrderSize}")

            stepSize10 = stepSize * 10
            logging.info(f"adding stepSize10 = {stepSize10} to orderSize = {OrderSize} for boh!")

            OrderSize = OrderSize + stepSize10

        
        logging.info(f"sending now order {order_type} - {side} {OrderSize} {symbol}")
        symbolusdt=symbol+stable_coin
        order = client.create_order(symbol=symbolusdt, side=side, type=order_type, quantity=OrderSize)
    except Exception as e:
        logging.info("an exception occured - {}".format(e))
        return False

    return order

def exp_moving_avarage(x,n):
    weights = np.exp(np.linspace(-1.,0.,n))
    weights /= weights.sum()

    ema = np.convolve(x, weights)[:len(x)]
    ema[:n] = ema[n]

    return ema

@app.route('/', methods=['POST','GET'])
def welcome():
    return render_template('result.html')

@app.route('/rebuy_all', methods=['POST'])
def rebuy_all():
    
    currencies_set = request.args.get('set')
    currencies_set_file = 'all_currencies_set.txt'

    if(currencies_set == '200') :
        currencies_set_file = 'all_currencies_first_120.txt'

    data = json.loads(request.data)
    resp = {"code": "error","message": "Wrong message"}

    if data['passphrase'] != config.WEBHOOK_PASSPHRASE :
        resp = {"code": "error","message": "Nice try, invalid passphrase"}
        

    side = data['strategy']['order_action'].upper()
    

    if side == 'REBUY_ALL' :
        f = open(currencies_set_file, "r")
        all_currencies_array = f.readline().rstrip().split(',')
        all_currencies_array.reverse()
        total_balance_without_reserved, total_balance, usdt_value, n_currencies = get_total_balance()
        total_balance_without_reserved = float(total_balance_without_reserved)

        for token in all_currencies_array:
            logging.info('token to be buyed: %s',token)
            order_response = order('BUY', 0.0, token,ORDER_TYPE_MARKET, total_balance_without_reserved)

            if not order_response :
                logging.info('token not buyed: %s',token)

            logging.info('-------------')

            resp = {"code": "success","message": "order executed"}
            
 
    return jsonify(resp)

@app.route('/webhook', methods=['POST'])
def webhook():
    #print(request.data)
    data = json.loads(request.data)
    
    if data['passphrase'] != config.WEBHOOK_PASSPHRASE:
        resp = {"code": "error","message": "Nice try, invalid passphrase"}
        return jsonify(resp)

    print(data['ticker'])
    print(data['bar'])

    side = data['strategy']['order_action'].upper()
    quantity = data['strategy']['order_contracts']
    symbol = data['ticker']

    print(symbol)

    order_response = order(side, quantity, symbol)

    print(order_response)

    resp = {}
    if order_response:
        resp = {"code": "success","message": "order executed"}
    else:
        print("order failed")
        resp = {"code": "error","message": "order failed"}

    return jsonify(resp)

@app.route('/panic_button', methods=['POST'])
def panic_button():
    order_response_all=sell_all()
    resp = {}
    if order_response_all:
        resp = {"code": "success","message": order_response_text}
    else:
        print("order failed")
        resp = {"code": "error","message": order_response_text}

    return jsonify(resp)

@app.route('/check_balance_ten_percent', methods=['POST'])
def check_balance_ten_percent():

    f = open(filename_reserved_currencies, "r")
    reserved_currencies = f.readline().rstrip().split(',')
    reserved_currencies_with_usdt = [s + stable_coin for s in reserved_currencies]

    reserved_currencies = reserved_currencies + reserved_currencies_with_usdt

    logging.info('Reserved currencies:')
    logging.info(reserved_currencies)

    #open and read the file after the appending:
    #logging.info('reading ten_percent.txt and ten_percent_actual.txt')
    
    filename = "ten_percent.txt"
    filename_actual = "ten_percent_actual.txt"
    
    f = open(filename, "r")
    initial_balance=float(f.read())
    
    f_actual = open(filename_actual, "r")
    initial_balance_actual = float(f_actual.read())
    #logging.info(initial_balance_actual)
    #logging.info('initial_balance without reserved: $ %s',str(initial_balance))
    total_balance_without_reserved, total_balance, usdt_value, n_currencies = get_total_balance()
    usdt_value = float(usdt_value)
    n_currencies = float(n_currencies)
    total_balance =float(total_balance)
    total_balance_without_reserved = float(total_balance_without_reserved)
    rounded_total_balance = round(total_balance,4)
    rounded_initial_balance_actual = round(initial_balance_actual,4)
    logging.info('total_balance: $ %s - $ %s ($ %s)',str(rounded_total_balance),str(rounded_initial_balance_actual),str(round(rounded_total_balance - rounded_initial_balance_actual,4)))

    logging.info('total_balance without reserved: $ %s - $ %s ($ %s)',str(round(total_balance_without_reserved,4)),str(round(initial_balance,4)),str(round(total_balance_without_reserved-initial_balance,4)))
    #percent_for_total_balance = float(100*(total_balance - initial_balance)/initial_balance)
    percent_for_total_balance_without_reserved = float(100*(total_balance_without_reserved - initial_balance)/initial_balance)
    #logging.info('current percent of total balance: %s',str(percent_for_total_balance))
    logging.info('current percent of total balance without reserved: %s%%',str(round(percent_for_total_balance_without_reserved,4)))

    filename_perc_for_panic = "percentage_for_panic.txt"
    f = open(filename_perc_for_panic, "r")
    percentage_for_panic=float(f.read())
    logging.info('percentage for panic: %s%%',str(percentage_for_panic))

    filename_perc_for_panic_negative = "percentage_for_panic_negative.txt"
    f = open(filename_perc_for_panic_negative, "r")
    percentage_for_panic_negative=float(f.read())
    logging.info('percentage for panic negative: %s%%',str(percentage_for_panic_negative))
    ct = datetime.datetime.now()
    date_time = ct.strftime("%Y-%m-%d %H:%M:%S")
    result = render_template('index_sum.html',timestamp=date_time, reserved_currencies=reserved_currencies, initial_balance_without_reserved=initial_balance, total_balance = str(rounded_total_balance), total_balance_without_reserved = str(round(total_balance_without_reserved,4)), current_percentage = str(round(percent_for_total_balance_without_reserved,4)), percentage_for_panic= str(percentage_for_panic), percentage_for_panic_negative=str(percentage_for_panic_negative), difference = str(round(total_balance_without_reserved - initial_balance,4)), initial_balance_actual = str(rounded_initial_balance_actual), difference_actual= str(round(rounded_total_balance - rounded_initial_balance_actual,4)))
    with open('templates/result.html', 'w') as f:
        f.write(result)

    if percent_for_total_balance_without_reserved >= percentage_for_panic :
        logging.info('Selling all for profit')
        result = sell_all()
        logging.info('sell_all:')
        logging.info('result')
        #topup_bnb(0.5, 0.5)
        f = open(filename, "w")
        logging.info('Writing new total balance into %s', filename)
        f.write(str(truncate(total_balance_without_reserved, 0)))
        f.close()
        logging.info('new initial_balance written into %s', filename)

    if percent_for_total_balance_without_reserved < percentage_for_panic_negative :
        logging.info('Selling all for stop loss')
        result = sell_all()
        logging.info('sell_all:')
        logging.info('result')
        #topup_bnb(0.5, 0.5)
        f = open(filename, "w")
        logging.info('Writing new total balance into %s', filename)
        f.write(str(truncate(total_balance_without_reserved, 0)))
        f.close()
        logging.info('new initial_balance written into %s', filename)

    if total_balance >= 25000.0 :
        logging.info('Selling all for 25000 profit')
        result = sell_all(True)
        f = open(filename, "w")
        logging.info('Writing new total balance into %s', filename)
        f.write(str(truncate(total_balance, 0)))
        f.close()
        logging.info('new initial_balance written into %s', filename)

    total_invested_without_reserved = total_balance_without_reserved - usdt_value
    percentage_invested = total_invested_without_reserved / total_balance_without_reserved * 100
    #logging.info('total_balance_without_reserved %s', total_balance_without_reserved)
    #logging.info('usdt_value %s', usdt_value)
    #logging.info('total_invested_without_reserved %s', total_invested_without_reserved)
    #logging.info('percentage_invested %s', percentage_invested)
    if n_currencies>0:
        percentage_per_currency = percentage_invested / n_currencies
    #logging.info('n_currencies %s', n_currencies)
    #logging.info('percentage_per_currency %s', percentage_per_currency)
        
    # if percent < 0.0 :
    #     logging.info('with negative percentage downgrade initial_balance to new value of: %s', str(total_balance))
    #     f = open(filename, "w")
    #     f.write(str(truncate(total_balance, 0)))
    #     f.close()
    #     logging.info('new initial_balance written into %s', filename)

    logging.info('-----------------')
    resp = {"code": "success","message": percent_for_total_balance_without_reserved} 
    return jsonify(resp)

package binanceServerFlask;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.charset.StandardCharsets;


import com.google.gson.JsonObject;
import com.google.gson.JsonParser;




public class Test {
	private static HttpURLConnection con;
	
	public static void main(String[] args) {
		
		var url = "http://[YOUR_RASPBERRY_IP_ADDRESS IN YOUR LAN]:5000/check_balance_ten_percent";
 		var urlParameters = "passphrase=[YOUR WEBHOOK PASS PHRASE IN PYTHON SCRIPT]&ticker=PANIC_BUTTON";
 		byte[] postData = urlParameters.getBytes(StandardCharsets.UTF_8);

 		try {
			var myurl = new URL(url);
			con = (HttpURLConnection) myurl.openConnection();

			con.setDoOutput(true);
			con.setRequestMethod("POST");
			con.setRequestProperty("Content-Type", "application/json; utf-8");
			//con.setRequestProperty("User-Agent", "Java client");
			con.setDoOutput(true);

			/*try (var wr = new DataOutputStream(con.getOutputStream())) {

			    wr.write(postData);
			}*/
            
			String jsonInputString = "{\n"
					+ "	\"passphrase\": \"[WEBHOOK_PASSPHRASE (the same used in the app.py script)]\",\n"
					+ "	\"time\": \"2021-02-14T18:24:01Z\",\n"
					+ "	\"exchange\": \"BINANCE\",\n"
					+ "	\"ticker\": \"PANIC_BUTTON\",\n"
					+ "	\"bar\": {\n"
					+ "		\"time\": \"2021-02-14T18:24:00Z\",\n"
					+ "		\"open\": 0.05551,\n"
					+ "		\"high\": 0.05551,\n"
					+ "		\"low\": 0.05551,\n"
					+ "		\"close\": 0.05551,\n"
					+ "		\"volume\": 194777.80114775\n"
					+ "	},\n"
					+ "	\"strategy\": {\n"
					+ "		\"position_size\": 10000,\n"
					+ "		\"order_action\": \"SELL\",\n"
					+ "		\"order_contracts\": 1382,\n"
					+ "		\"order_price\": 0.07651,\n"
					+ "		\"order_id\": \"door\",\n"
					+ "		\"market_position\": \"long\",\n"
					+ "		\"market_position_size\": 10000,\n"
					+ "		\"prev_market_position\": \"flat\",\n"
					+ "		\"prev_market_position_size\": 0\n"
					+ "	}\n"
					+ "}";
            
            try(OutputStream os = con.getOutputStream()) {
                byte[] input = jsonInputString.getBytes("utf-8");
                os.write(input, 0, input.length);			
            }
            
            
            StringBuilder content;

            try (var br = new BufferedReader(
                    new InputStreamReader(con.getInputStream()))) {

                String line;
                content = new StringBuilder();

                while ((line = br.readLine()) != null) {
                    content.append(line);
                    content.append(System.lineSeparator());
                }
            }

            System.out.println(content.toString());

            JsonObject jsonObjectAlt = JsonParser.parseString(content.toString()).getAsJsonObject();
            
            System.out.println(jsonObjectAlt.get("message"));
            
        } catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {

            con.disconnect();
        }

	}

}