StartBot.py

# -*- coding: utf-8 -*-


# import websocket
import json
import pandas as pd
import pickle
import talib
from datetime import datetime
import numpy
import os
import asyncio
import aiofiles
# import websockets
import pprint
import websocket as wb
from apibutkib import BugKib
from pymongo import MongoClient
import datetime
import sys
from termcolor import colored
import numpy as np
from uuid import uuid4
import math
SOCKET = 'wss://api.bitkub.com/websocket-api/'
#Parameters of the RSI Strategy
pair = {
        'KUB':'market.trade.thb_kub'
        }
RSI_PERIOD = 14
RSI_OVERBOUGHT =70
RSI_OVERSOLD = 30
#Symbol of Ethereum
TRADE_SYMBOL = "ETHUSD"
#Quantity of ETH for a trade
TRADE_QUANTITY = 1
in_position = False
df = pd.DataFrame()
API_KEY = 'xxx'
API_SECRET = 'xxx'
HISTORY_PATH = os.path.join(os.getcwd(), "data_history")
WSS_URL = "wss://api.bitkub.com/websocket-api/"
DATA_STR = ""
Stop_Loss_at_Money = 4000
coinList = {'ZIL'}
excludeProfit = {'LUNA','IOST','ADA'}
excludeEmergency = {'LUNA','LUNA2','XLM','ZIL'}
# FTM SOL DOGE ZIL KUB BNB
# tradeLists = {'GT','GRT','MANA','ALPHA','SOL','GALA','SUSHI','NEAR','APE','ETH','JFIN','FTM','GF','MKR','BAND','GLM','SAND'}
bitkubFee = 0.0025
APIKEYBITKUB='APIKEY_BITKUB'
bitkub = BugKib(_apiKey=APIKEYBITKUB,_apisecret = b'APISECRET_BITKUB')

client = MongoClient('mongodbAddress',27017)
db = client.bitkub
trend_db = db.trends
subscribe_db = db.subscribe
stochrsi_db = db.stochrsis
macd_db = db.macds
profitDb = db.profits
botStopLossDb = db.botStopLoss
buyDb = db.buys
sellDb = db.sells
assetDb = db.assets
joblogDb = db.joblogs
cancleDb = db.cancleLogs
botActivateDb = db.botactivate
lineOrderToken = 'LINENOTIFYTOKEN'
# lineSignalToken = 'LINENOTIFYTOKEN'
lineSignalToken = 'LINENOTIFYTOKEN'
buyBtcRSI = 20
tradeLists = {'NEAR','KUB','ADA','DOGE'}
tradeOption = {
            'DEFAULT':{'Buy':50,'Sell':295,'MaxAmt':150,'firstInitial':50,'timeframe':'5','profitTotake':10,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-15},
            'GT':{'Buy':50,'Sell':295,'MaxAmt':150,'firstInitial':50,'timeframe':'5','profitTotake':10,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-15},
            'KUB':{'Buy':200,'Sell':295,'MaxAmt':600,'firstInitial':200,'timeframe':'5','profitTotake':10,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-15},
            'ADA':{'Buy':200,'Sell':295,'MaxAmt':600,'firstInitial':200,'timeframe':'5','profitTotake':10,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-15},
            'CHZ':{'Buy':250,'Sell':295,'MaxAmt':500,'firstInitial':250,'timeframe':'5','profitTotake':15,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-15},
            'GRT':{'Buy':250,'Sell':295,'MaxAmt':500,'firstInitial':250,'timeframe':'5','profitTotake':10,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-15},
            'MANA':{'Buy':50,'Sell':295,'MaxAmt':150,'firstInitial':50,'timeframe':'5','profitTotake':5,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-15},
            'BNB':{'Buy':50,'Sell':594,'MaxAmt':150,'firstInitial':100,'timeframe':'5','profitTotake':10,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-15},
            'ALPHA':{'Buy':50,'Sell':295,'MaxAmt':150,'firstInitial':50,'timeframe':'5','profitTotake':10,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-15},
            'SOL':{'Buy':50,'Sell':195,'MaxAmt':150,'firstInitial':50,'timeframe':'5','profitTotake':10,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-15},
            'GALA':{'Buy':50,'Sell':195,'MaxAmt':150,'firstInitial':50,'timeframe':'5','profitTotake':10,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-15},
            'SUSHI':{'Buy':50,'Sell':195,'MaxAmt':150,'firstInitial':50,'timeframe':'5','profitTotake':10,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-15},
            'BTC':{'Buy':50,'Sell':495,'MaxAmt':150,'firstInitial':200,'timeframe':'5','profitTotake':10,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-15},
            'NEAR':{'Buy':500,'Sell':495,'MaxAmt':1000,'firstInitial':500,'timeframe':'5','profitTotake':20,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-50},
            'APE':{'Buy':50,'Sell':495,'MaxAmt':150,'firstInitial':50,'timeframe':'5','profitTotake':10,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-15},
            'ETH':{'Buy':50,'Sell':495,'MaxAmt':150,'firstInitial':50,'timeframe':'5','profitTotake':10,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-15},
            'JFIN':{'Buy':50,'Sell':495,'MaxAmt':150,'firstInitial':50,'timeframe':'5','profitTotake':10,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-15},
            'FTM':{'Buy':50,'Sell':495,'MaxAmt':150,'firstInitial':50,'timeframe':'5','profitTotake':10,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-15},
            'DOGE':{'Buy':200,'Sell':495,'MaxAmt':2200,'firstInitial':200,'timeframe':'5','profitTotake':10,'tradeStyle':'stepProfit','stopLossWhenLossInTHB':-15},
            }
tradeStyleStep = {  # SYMBOL : {'RSI':'PERCENT TO SELL'}
                     'DEFAULT':{
                                  'Range':{'Min':30,'Max':40,'PercentToSell':20},
                                  'Range2':{'Min':40,'Max':50,'PercentToSell':30},
                                  'Range3':{'Min':50,'Max':60,'PercentToSell':40},
                                  'Range4':{'Min':60,'Max':70,'PercentToSell':50},
                                  'Range5':{'Min':70,'Max':80,'PercentToSell':60},
                                  'Range6':{'Min':80,'Max':90,'PercentToSell':80},
                                  'Range7':{'Min':90,'Max':100,'PercentToSell':99}
                         },
                          
                     'BTC':{
                             'Range':{'Min':30,'Max':40,'PercentToSell':20},
                             'Range2':{'Min':40,'Max':50,'PercentToSell':30},
                             'Range3':{'Min':50,'Max':60,'PercentToSell':40},
                             'Range4':{'Min':60,'Max':70,'PercentToSell':50},
                             'Range5':{'Min':70,'Max':80,'PercentToSell':60},
                             'Range6':{'Min':80,'Max':90,'PercentToSell':80},
                             'Range7':{'Min':90,'Max':100,'PercentToSell':99}
                         },
                     
                     'BNB':{
                             'Range':{'Min':30,'Max':40,'PercentToSell':20},
                             'Range2':{'Min':40,'Max':50,'PercentToSell':30},
                             'Range3':{'Min':50,'Max':60,'PercentToSell':40},
                             'Range4':{'Min':60,'Max':70,'PercentToSell':50},
                             'Range5':{'Min':70,'Max':80,'PercentToSell':60},
                             'Range6':{'Min':80,'Max':90,'PercentToSell':80},
                             'Range7':{'Min':90,'Max':100,'PercentToSell':99}
                         },
                     
                     'GT':{
                             'Range':{'Min':30,'Max':40,'PercentToSell':20},
                             'Range2':{'Min':40,'Max':50,'PercentToSell':30},
                             'Range3':{'Min':50,'Max':60,'PercentToSell':40},
                             'Range4':{'Min':60,'Max':70,'PercentToSell':50},
                             'Range5':{'Min':70,'Max':80,'PercentToSell':60},
                             'Range6':{'Min':80,'Max':90,'PercentToSell':80},
                             'Range7':{'Min':90,'Max':100,'PercentToSell':99}
                         },
                     'MANA':{
                             'Range':{'Min':30,'Max':40,'PercentToSell':20},
                             'Range2':{'Min':40,'Max':50,'PercentToSell':30},
                             'Range3':{'Min':50,'Max':60,'PercentToSell':40},
                             'Range4':{'Min':60,'Max':70,'PercentToSell':50},
                             'Range5':{'Min':70,'Max':80,'PercentToSell':60},
                             'Range6':{'Min':80,'Max':90,'PercentToSell':80},
                             'Range7':{'Min':90,'Max':100,'PercentToSell':99}
                         },
                     'ALPHA':{
                             'Range':{'Min':30,'Max':40,'PercentToSell':20},
                             'Range2':{'Min':40,'Max':50,'PercentToSell':30},
                             'Range3':{'Min':50,'Max':60,'PercentToSell':40},
                             'Range4':{'Min':60,'Max':70,'PercentToSell':50},
                             'Range5':{'Min':70,'Max':80,'PercentToSell':60},
                             'Range6':{'Min':80,'Max':90,'PercentToSell':80},
                             'Range7':{'Min':90,'Max':100,'PercentToSell':99}
                         },
                     'SOL':{
                             'Range':{'Min':30,'Max':40,'PercentToSell':20},
                             'Range2':{'Min':40,'Max':50,'PercentToSell':30},
                             'Range3':{'Min':50,'Max':60,'PercentToSell':40},
                             'Range4':{'Min':60,'Max':70,'PercentToSell':50},
                             'Range5':{'Min':70,'Max':80,'PercentToSell':60},
                             'Range6':{'Min':80,'Max':90,'PercentToSell':80},
                             'Range7':{'Min':90,'Max':100,'PercentToSell':99}
                         },
                     'GALA':{
                             'Range':{'Min':30,'Max':40,'PercentToSell':20},
                             'Range2':{'Min':40,'Max':50,'PercentToSell':30},
                             'Range3':{'Min':50,'Max':60,'PercentToSell':40},
                             'Range4':{'Min':60,'Max':70,'PercentToSell':50},
                             'Range5':{'Min':70,'Max':80,'PercentToSell':60},
                             'Range6':{'Min':80,'Max':90,'PercentToSell':80},
                             'Range7':{'Min':90,'Max':100,'PercentToSell':99}
                         },
                     'SUSHI':{
                             'Range':{'Min':30,'Max':40,'PercentToSell':20},
                             'Range2':{'Min':40,'Max':50,'PercentToSell':30},
                             'Range3':{'Min':50,'Max':60,'PercentToSell':40},
                             'Range4':{'Min':60,'Max':70,'PercentToSell':50},
                             'Range5':{'Min':70,'Max':80,'PercentToSell':60},
                             'Range6':{'Min':80,'Max':90,'PercentToSell':80},
                             'Range7':{'Min':90,'Max':100,'PercentToSell':99}
                         },
    }
# 'LUNA':{'Buy':200,'Sell':195,'MaxAmt':200,'firstInitial':194814},
# bitkub = BugKib(_apiKey='APIKEY_BITKUB' ,_apisecret = b'APISECRET_BITKUB')


def prepare_data_dir():
    print(f"checking history path ({HISTORY_PATH})")
    if not os.path.exists(HISTORY_PATH):
        os.mkdir(HISTORY_PATH)
        # print(f"history path is created")
        return
    # print(f"history path already exists")
    
def create_wss_url():
    global WSS_URL
    # symbols = [s for s in list(os.environ.get("CAPTURE_COIN", "").split(","))]
    stream_name = ",".join(
        [f"market.ticker.thb_{s.lower()}" for s in coinList])
    # print(stream_name)
    WSS_URL = f"{WSS_URL}{stream_name}"
    # print(WSS_URL)


#################################################### MAIN ####################################################
                        
if __name__ == "__main__":
    # prepare_data_dir()
    # create_wss_url()
    tb_name = datetime.datetime.now().strftime('%Y%m%d')
    assets = bitkub.get_assets()
    bal,aData = bitkub.get_balance_assets()
    cash =0
    orig_stdout = sys.stdout
    
    log_path = 'E:\\LogBot\\'
    if not os.path.exists(log_path):
        os.makedirs(log_path)
        
    f = open(log_path+'BotLogOut'+str(APIKEYBITKUB)+'_'+str(tb_name)+'.txt', 'a')
    sys.stdout = f
    print('Starting Bot Task :', datetime.datetime.now())
    
    try:
        botActivate = { "Instance": APIKEYBITKUB }
        botActivateDoc = botActivateDb.find_one(botActivate)
        Stop_Loss_at_Money = botActivateDoc['Stop_Loss_at_Money']
        tradeOptions_mongo = botActivateDoc['tradeOptions']
        tradeStyleSteps_mongo = botActivateDoc['tradeStyleSteps']
        tradeLists_mongo = botActivateDoc['tradeLists']
        lineOrderToken = botActivateDoc['lineOrderToken']
        lineSignalToken = botActivateDoc['lineSignalToken']
        buyBtcRSI = botActivateDoc['buyBtcRSI']
        # stopLossWhenLossInTHB = botActivateDoc['stopLossWhenLossInTHB']
        if(botActivateDoc['Activate']==False):
            logSave   = {
                    "CASH": bitkub.getMyMoney(),
                    "Asset": "BOT IS DEACTIVATE",
                    "Signal": "BOT IS DEACTIVATE",
                    "StochRSI": "BOT IS DEACTIVATE",
                    "AssetInTHB":"BOT IS DEACTIVATE",
                    "AvgBuyPrice":"BOT IS DEACTIVATE",
                    "CurrentPrice":"BOT IS DEACTIVATE",
                    "Available":"BOT IS DEACTIVATE",
                    "Reserved":"BOT IS DEACTIVATE",
                    "Profit":"BOT IS DEACTIVATE",
                    "ProfitGoal":"BOT IS DEACTIVATE",
                    "LastUpdate": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                }
            joblogDb[APIKEYBITKUB].insert_one(logSave)
            botActivateDb.update_one({'Instance': APIKEYBITKUB},
                       {'$set': {'Activate': False}
                        }
                       ,upsert=True
                       )
            bitkub.sendLine('Stop Loss บอทไม่ทำงาน เพราะตั้ง Stop Loss ไว้ที่ : ' + str(Stop_Loss_at_Money) + ' \n เงินคุณมี : '+ str(bitkub.getMyMoney()),token=lineOrderToken)
            sys.exit("BOT IS DEACTIVATE")
    except KeyError as e:
        exc_type, exc_obj, exc_tb = sys.exc_info()
        fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
        bitkub.sendLine('Exception  KeyError : ' + str(exc_type) + ' \n '+ str(fname) + '\n' + str(exc_tb.tb_lineno),token=lineOrderToken)
        botActivateDb.update_one(
            {'Instance': APIKEYBITKUB},
                    {
                        '$set': {
                            'tradeOptions': tradeOption,
                            'tradeStyleSteps':tradeStyleStep,
                            'tradeLists':list(tradeLists),
                            'lineOrderToken' : lineOrderToken,
                            'lineSignalToken' : lineSignalToken,
                            'buyBtcRSI' : float(buyBtcRSI)
                            }
                    },upsert=True
                    )
        botActivate = { "Instance": APIKEYBITKUB }
        botActivateDoc = botActivateDb.find_one(botActivate)
        tradeOptions_mongo = botActivateDoc['tradeOptions']
        tradeStyleSteps_mongo = botActivateDoc['tradeStyleSteps']
        tradeLists_mongo = botActivateDoc['tradeLists']
        lineOrderToken = botActivateDoc['lineOrderToken']
        lineSignalToken = botActivateDoc['lineSignalToken']
        buyBtcRSI = botActivateDoc['buyBtcRSI']
        # stopLossWhenLossInTHB = botActivateDoc['stopLossWhenLossInTHB']
    except Exception as e:
        exc_type, exc_obj, exc_tb = sys.exc_info()
        fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
        print(exc_type, fname, exc_tb.tb_lineno)
        bitkub.sendLine('Exception  : ' + str(exc_type) + ' \n '+ str(fname) + '\n' + str(exc_tb.tb_lineno),token=lineOrderToken)
        pass

    
    
    StopLossMai = bitkub.checkBalanceAndEmergencySell(StopLoss = Stop_Loss_at_Money , dictExclude = excludeEmergency , _token = lineOrderToken)
    
    # for signal in [bitkub.STOCHRSIsignal, bitkub.MACDsignal]:
    #     for stock in [x for x in df.columns if 'stock' in x]: 
    #         df['Close'] = df[stock]
    #         indicator = signal(df)
    #         for sig in indicator.keys():
    #             table.loc[sig, stock] = str(indicator[sig])[:4] 
    if(StopLossMai == True):
        print('In Remaining on Stop Loss No Running Bot')
        bitkub.sendLine('Stop Loss No Bot DeActivaed',token=lineOrderToken)
        logSave   = {
                "CASH": bitkub.getMyMoney(),
                "Asset": "StopLoss",
                "Signal": "StopLoss",
                "StochRSI": "StopLoss",
                "AssetInTHB":"StopLoss",
                "AvgBuyPrice":"StopLoss",
                "CurrentPrice":"StopLoss",
                "Available":"StopLoss",
                "Reserved":"StopLoss",
                "Profit":"StopLoss",
                "ProfitGoal":"StopLoss",
                "LastUpdate": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
            }
        joblogDb[APIKEYBITKUB].insert_one(logSave)
        botActivateDb.update_one({'Instance': APIKEYBITKUB},
                   {'$set': {'Activate': False}
                    }
                   ,upsert=True
                   )
    else:
        ablaaa = {}
        aOpenOrder= {}
        aOrderHistory = {}
        aDataFrame = {}
        aUrl={}
        alastBuyPrices = {}
        ##################################### ซื้อติดเป๋า 
        aData = aData['result']
        print('***************** BEGIN *******************')
        for trd in tradeLists_mongo:
            aAvailable = aData[trd]['available']
            aReserved = aData[trd]['reserved']
            valueNow = aAvailable + aReserved
            if(valueNow == 0):
                _pair = 'THB_'+trd
                _rat = bitkub.get_last_price(_pair)
                aOpenOrder[trd] = bitkub.getSymOpenOrder(_pair)
                aOpenOrderResult = aOpenOrder[trd]['result']
                if(len(aOpenOrderResult)>=1):
                    for resultOrder in aOpenOrderResult:
                        _sym=trd
                        _id=resultOrder['id']
                        _sd =resultOrder['side']
                        _hash=resultOrder['hash']
                        _rate=resultOrder['rate']
                        _amount=resultOrder['amount']
                        if(_sd == 'BUY'):
                            bitkub.cancelOpenOrder(_sym, _id, _sd,_hash,_rate,_amount,lineOrderToken)
                            cancleDbDataSave   = {
                                    "hash": _hash,
                                    "key": str(uuid4()),
                                    "Asset": _sym,
                                    "idOrder": _id,
                                    "Side":_sd,
                                    "Rate":_rate,
                                    "Amount":_amount,
                                    "LastUpdate": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                }
                            cancleDb[APIKEYBITKUB].insert_one(cancleDbDataSave)
                print('เงินพอซื้อ Init Market buy: ', trd)
                try:
                     aAmt = tradeOptions_mongo[trd]
                     
                except KeyError:
                     aAmt = tradeOptions_mongo['DEFAULT']
                     
                _firstInitial = aAmt['firstInitial']
                buyResponse = bitkub.buyMarket(_pair, _firstInitial, 0,lineOrderToken)
                try:
                    buyResponse = buyResponse['result']
                    buyDataSave   = {
                            "hash": str(buyResponse['hash']),
                            "key": str(uuid4()),
                            "Asset": trd,
                            "Signal": "NO INIT COIN",
                            "AssetInTHB":"NO INIT COIN",
                            "PreviousAvgBuyPrice":"NO INIT COIN",
                            "BuyPrice":_rat['last'],
                            "Available":"NO INIT COIN",
                            "Reserved":"NO INIT COIN",
                            "AmountToBuy":buyResponse['amt'],
                            "Type":buyResponse['typ'],
                            "Fee":buyResponse['fee'],
                            "CreditFee":buyResponse['cre'],
                            "AmountToReceive":buyResponse['rec'],
                            "timestamp":buyResponse['ts'],
                            "LastUpdate": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                        }
                    buyDb[APIKEYBITKUB].insert_one(buyDataSave)
                except KeyError:
                    
                    err = bitkub.errorCode[buyResponse['error']]
                    bitkub.sendLine('ซื้อ FirstInitial ไม่ได้ Error : ' + str(err),token=lineOrderToken)
              
                
        
        ##################################### ซื้อติดเป๋า 
        # print(table)
        # for ba in bal:
        for ba in bal:
            if(ba['symbol']=='THB' or ba['symbol']=='DON' or ba['symbol']=='LUNA2' or ba['symbol']=='TRX' ):
                if(ba['symbol']=='THB'):
                    cash = ba['available']
                pass
            else:
                # lastBuyPrices = {}
                symbol = ba['symbol']
                _pair = 'THB_'+symbol
                _rat = bitkub.get_last_price(_pair)
                _ratBTC = bitkub.get_last_price('THB_BTC')
                aOrderHistory[_pair] = bitkub.get_order_history(_pair)
                # lastBuyPrice = 0
                
                # for abc in aOrderHistory[_pair]:
                #     if(abc['side']=='buy'):
                #         lastBuyPrice=float(abc['rate'])
                #         break
                # lastBuyPrice = bitkub.getLastBuyAverage(symbol) #OLD
                # lastBuyPrice = bitkub.costBasisAveragePrice(symbol,timestamp=1655446223) # Time 17-06-2565 13.10 น
                lastBuyPrice = bitkub.costBasisAveragePrice(symbol,timestamp=1656670957) # Saturday, June 25, 2022 12:30:00 PM GMT+07:00 
                # try:
                #     lastBuyPrice = bitkub.costBasisAveragePrice(symbol,timestamp=1655446223)
                if(math.isnan(lastBuyPrice)):
                    lastBuyPrice = bitkub.getLastBuyAverage(symbol)
                #     print(symbol , " : lastBuyPrice ",lastBuyPrice)
                # except:
                #     lastBuyPrice = 0
                
                alastBuyPrices[symbol] = lastBuyPrice
                lastPrice = _rat
                Available = ba['available']
                # print(symbol,':', float(Available))
                Reserved = ba['reserved']
                
                try:
                     balance_value = Available *_rat['last']
                except TypeError:
                     continue
                 
                amountToSell = float((balance_value-2) / _rat['last'])
                amountToSell = round(amountToSell,8)
                signal =  []
                _timeframe='5'
                try:
                     aAmt = tradeOptions_mongo[symbol]
                     _timeframe = aAmt['timeframe']
                     stopLossWhenLossInTHB = aAmt['stopLossWhenLossInTHB']
                except KeyError:
                     aAmt = tradeOptions_mongo['DEFAULT']
                     _timeframe = aAmt['timeframe']
                     stopLossWhenLossInTHB = aAmt['stopLossWhenLossInTHB']
                
                
                # print('จำนวนเงินใน ', symbol , balance_value , 'บาท')
                # timeframe = ช่วงเวลาของกราฟที่จะดึงข้อมูล 1, 5, 15, 60, 240, 1D
                # MyDataFrame = bitkub.get_candle(symbol, timeframe=_timeframe)
                MyDataFrame ,aUrl[symbol]  = bitkub.get_candle(symbol, timeframe=_timeframe)
                aDataFrame[symbol] = MyDataFrame
                BTCDataFrame ,aUrl['BTC']  = bitkub.get_candle('BTC', timeframe='60')
                BTCDataFrame1D ,aUrl['BTC']  = bitkub.get_candle('BTC', timeframe='1D')
                # 'key': str(uuid4()),
                # "asset": symbol,
                # label_0 : macd_value,
                # label_1 : macd_hist,
                # label_2 : value_label,
                # label_3 : signal_label,
                # 'signal':signal,
                # 'key': str(uuid4()),
                # "asset": symbol,
                # "macd_value":{label_0 : macd_value},
                # "macd_hist":{label_1 : macd_hist},
                # "value_label":{label_2 : value_label},
                # "signal_label":{label_3 : signal_label},
                # 'signal':signal,
                # label_0 = f'MACD({fast}, {slow}, {signal}) value'
                # label_1 = f'MACD({fast}, {slow}, {signal}) hist'
                # label_2 = f'MACD({fast}, {slow}, {signal}) value signal'
                # label_3 = f'MACD({fast}, {slow}, {signal}) hist signal'
                try:
                    a = bitkub.STOCHRSIsignal(MyDataFrame,symbol)
                    BTCRSI = bitkub.STOCHRSIsignal(BTCDataFrame,'BTC')
                    BTCRSI1D = bitkub.STOCHRSIsignal(BTCDataFrame1D,'BTC')
                    aa = stochrsi_db[tb_name].insert_one(a)
                    aa = stochrsi_db[tb_name].insert_one(BTCRSI)
                except:
                    continue
                
                try:
                    b = bitkub.MACDsignal(MyDataFrame,symbol)
                    bb = macd_db[tb_name].insert_one(b)
                except:
                    continue
               
                textBTC =   'BTC' + '\n Timeframe : 1H \n```' + '\n STOCH RSI : ' + str(BTCRSI['STOCHRSIk']) + '\n ราคา : ' + str(_ratBTC['last']) + '฿ \n ส่งซิก : ' + BTCRSI['SignalDesc'] + '``` \n'
                textBTC1D =   'BTC' + '\n Timeframe : 1D \n```' + '\n STOCH RSI : ' + str(BTCRSI1D['STOCHRSIk']) + '\n ราคา : ' + str(_ratBTC['last']) + '฿ \n ส่งซิก : ' + BTCRSI1D['SignalDesc'] + '``` \n'
                text =  symbol + '\n Timeframe : '+ _timeframe +'m \n```' + '\n STOCH RSI : ' + str(a['STOCHRSIk']) + '\n ราคา : ' + str(_rat['last']) + '฿ \n ส่งซิก : ' + a['SignalDesc'] + '```'
                textMACD = f"\n``` MACD Value : {b['macd_value']['MACD(12, 26, 9) value']} \n MACD HIST Value: {b['macd_hist']['MACD(12, 26, 9) hist']} \n MACD Value Signal: {b['value_label']['MACD(12, 26, 9) value signal']} \n MACD Hist Signal  : {b['signal_label']['MACD(12, 26, 9) hist signal']} \n MACD Signal : {b['signal']} ```"
                print('\nDoing : ', symbol.strip() , ' RSI Signal : ' , a['signal'] , ' RSI : ' , a['STOCHRSIk'])
                # amountToSell = (balance_value-2) / _rat['last']
                # blaaa[symbol] = amountToSell
                _STOCHRSIk = a['STOCHRSIk']
                _BTC_STOCHRSIk = BTCRSI['STOCHRSIk']
                _signal = a['signal']
                if(a['signal'] != 'Hold'):
                    bitkub.sendLine(str(textBTC1D) + str(textBTC) + text + str(textMACD) , token = 'LINENOTIFYTOKEN')
                    print(str(textBTC) +str(text) + str(textMACD))
                if symbol in tradeLists_mongo:
                    print('กำลังทำงานในเหรียญ : ' , symbol)
                    buyResponse= {}
                    _firstInitial = aAmt['firstInitial']
                    aProfitTotake = aAmt['profitTotake']
                    _tradeStyle = aAmt['tradeStyle']
                    condition = {'cash':cash,'buymai':(balance_value-aAmt['Buy']),'amt/2':(aAmt['Buy']/2),'buy':aAmt['Buy'],'rat':_rat,'sell':amountToSell}
                    ablaaa[symbol] = {'Available':Available,'amountToSell':amountToSell,'Reserved':Reserved,'_rat':_rat,'balance_value':balance_value,'Action':condition}
                    aOpenOrder[symbol] = bitkub.getSymOpenOrder(_pair)
                    aOpenOrderResult = aOpenOrder[symbol]['result']
                    # ซื้ออออออออ
                    if (a['signal'] == 'Buy' and _BTC_STOCHRSIk < buyBtcRSI):
                        print('กำลังทำงานในเหรียญ : ' , symbol , ' ด้วยการซื้อ')
                        buyMai = balance_value
                        maxBuyAmt = (aAmt['MaxAmt'])
                        if(cash >= aAmt['Buy'] and balance_value <= maxBuyAmt):
                            if(len(aOpenOrderResult)>=1):
                                for resultOrder in aOpenOrderResult:
                                    _sym=symbol
                                    _id=resultOrder['id']
                                    _sd =resultOrder['side']
                                    _hash=resultOrder['hash']
                                    _rate=resultOrder['rate']
                                    _amount=resultOrder['amount']
                                    if(_sd == 'BUY'):
                                        print('กำลังทำงานในเหรียญ : ' , symbol , ' ยกเลิกออเดอร์เก่า')
                                        bitkub.cancelOpenOrder(_sym, _id, _sd,_hash,_rate,_amount,lineOrderToken)
                                        cancleDbDataSave   = {
                                                "hash": _hash,
                                                "key": str(uuid4()),
                                                "Asset": _sym,
                                                "idOrder": _id,
                                                "Side":_sd,
                                                "Rate":_rate,
                                                "Amount":_amount,
                                                "LastUpdate": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                            }
                                        cancleDb[APIKEYBITKUB].insert_one(cancleDbDataSave)
                            print('กำลังทำงานในเหรียญ : ' , symbol , ' เงินพอซื้อ')
                            if(balance_value <= maxBuyAmt):
                                amtChecked = maxBuyAmt - balance_value
                                amtToBuy = aAmt['Buy']
                                if(amtChecked>=amtToBuy):
                                    
                                    buyResponse = bitkub.buy(_pair, amtToBuy , _rat['last'],lineOrderToken)
                                    buyResponse = buyResponse['result']
                                    buyDataSave   = {
                                            "hash": str(buyResponse['hash']),
                                            "key": str(uuid4()),
                                            "Asset": symbol,
                                            "Signal": _signal,
                                            "AssetInTHB":balance_value,
                                            "PreviousAvgBuyPrice":lastBuyPrice,
                                            "BuyPrice":_rat['last'],
                                            "Available":Available,
                                            "Reserved":Reserved,
                                            "AmountToBuy":aAmt['Buy'],
                                            "Type":buyResponse['typ'],
                                            "Fee":buyResponse['fee'],
                                            "CreditFee":buyResponse['cre'],
                                            "AmountToReceive":buyResponse['rec'],
                                            "timestamp":buyResponse['ts'],
                                            "LastUpdate": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                        }
                                  
                                    buyDb[APIKEYBITKUB].insert_one(buyDataSave)
                                    print('กำลังทำงานในเหรียญ : ' , symbol , ' สั่งซื้อสำเร็จ')
                                else:
                                    if(amtChecked>=10):
                                        buyResponse = bitkub.buy(_pair, amtChecked , _rat['last'],lineOrderToken)
                                        buyResponse = buyResponse['result']
                                        buyDataSave   = {
                                                "hash": str(buyResponse['hash']),
                                                "key": str(uuid4()),
                                                "Asset": symbol,
                                                "Signal": _signal,
                                                "AssetInTHB":balance_value,
                                                "PreviousAvgBuyPrice":lastBuyPrice,
                                                "BuyPrice":_rat['last'],
                                                "Available":Available,
                                                "Reserved":Reserved,
                                                "AmountToBuy":aAmt['Buy'],
                                                "Type":buyResponse['typ'],
                                                "Fee":buyResponse['fee'],
                                                "CreditFee":buyResponse['cre'],
                                                "AmountToReceive":buyResponse['rec'],
                                                "timestamp":buyResponse['ts'],
                                                "LastUpdate": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                            }
                                      
                                        buyDb[APIKEYBITKUB].insert_one(buyDataSave)
                                        print('กำลังทำงานในเหรียญ : ' , symbol , ' สั่งซื้อสำเร็จ ด้วยเศษเงินที่เหลือ :' , amtChecked)
                                    else:
                                        print('กำลังทำงานในเหรียญ : ' , symbol , ' จำนวนสั่งซื้อ น้อยไป ไม่ถึง 10: ',_pair , ' Amount : ' ,amtChecked)
                                        
                                
                                print('กำลังทำงานในเหรียญ : ' , symbol , ' สั่งซื้อแล้ว')
                            else:
                                print('กำลังทำงานในเหรียญ : ' , symbol , ' มีแล้วรอขาย')
                              
                        else:
                            diff = maxBuyAmt - balance_value
                            if( balance_value > maxBuyAmt):
                                print('กำลังทำงานในเหรียญ : ' , symbol ,'มีเหรียญเยอะกว่าค่าสูงสุดอยู่แล้ว ไม่ซื้อจ๊ะ : ' , symbol)
                            elif(diff > aAmt['Buy']):
                                print('กำลังทำงานในเหรียญ : ' , symbol ,'มีเหรียญเยอะกว่าค่าสูงสุดอยู่แล้ว ไม่ซื้อจ๊ะ Diff > amtBuy : ' , symbol , ' diff:',diff,' amtBuy:',aAmt['Buy'])
                            else:
                                if(len(aOpenOrderResult)>=1):
                                    for resultOrder in aOpenOrderResult:
                                        _sym=symbol
                                        _id=resultOrder['id']
                                        _sd =resultOrder['side']
                                        _hash=resultOrder['hash']
                                        _rate=resultOrder['rate']
                                        _amount=resultOrder['amount']
                                        if(_sd == 'BUY'):
                                            bitkub.cancelOpenOrder(_sym, _id, _sd,_hash,_rate,_amount,lineOrderToken)
                                            cancleDbDataSave   = {
                                                    "hash": _hash,
                                                    "key": str(uuid4()),
                                                    "Asset": _sym,
                                                    "idOrder": _id,
                                                    "Side":_sd,
                                                    "Rate":_rate,
                                                    "Amount":_amount,
                                                    "LastUpdate": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                                }
                                            cancleDb[APIKEYBITKUB].insert_one(cancleDbDataSave)
                                if(cash>10):
                                    buyResponse = bitkub.buy(_pair, cash , _rat['last'],lineOrderToken)
                                    buyResponse = buyResponse['result']
                                    buyDataSave   = {
                                            "hash": str(buyResponse['hash']),
                                            "key": str(uuid4()),
                                            "Asset": symbol,
                                            "Signal": _signal,
                                            "AssetInTHB":balance_value,
                                            "PreviousAvgBuyPrice":lastBuyPrice,
                                            "BuyPrice":_rat['last'],
                                            "Available":Available,
                                            "Reserved":Reserved,
                                            "AmountToBuy":aAmt['Buy'],
                                            "Type":buyResponse['typ'],
                                            "Fee":buyResponse['fee'],
                                            "CreditFee":buyResponse['cre'],
                                            "AmountToReceive":buyResponse['rec'],
                                            "timestamp":buyResponse['ts'],
                                            "LastUpdate": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                        }
                                  
                                    buyDb[APIKEYBITKUB].insert_one(buyDataSave)
                                else:
                                    allX = {'Cash':cash,'aAmt[Buy]':aAmt['Buy'] ,'balance_value':balance_value,'maxBuyAmt':maxBuyAmt}
                                    print('กำลังทำงานในเหรียญ : ' , symbol ,'เงินน้อยไปซื้อไม่ได้ : ' , symbol ,' : ', allX) 
                                    bitkub.sendLine(f"เงินคุณไม่พอซื้อ {symbol} โปรดเติมกระสุน \n เงินคุณมี {cash} \n บอทจะซื้อ {aAmt['Buy']}", token=lineOrderToken)
                        
                         
                        
                        
                            # ขายยยยยยยยยยยยยย 
                    elif (a['signal'] == 'Sell'):
                        print('กำลังทำงานในเหรียญ : ' , symbol ,' ขาย') 
                        
                        profitMai = balance_value -  (Available*lastBuyPrice)
                        # TRADE STYLE
                        if(_tradeStyle == 'fixProfit'):
                            print('กำลังทำงานในเหรียญ : ' , symbol ,' ขาย แบบ fixProfit') 
                            # FIX RATE
                            if(profitMai>=float(aProfitTotake)): 
                                if(Available>=amountToSell and balance_value >= 10):
                                    if(len(aOpenOrderResult)>=1):
                                        for resultOrder in aOpenOrderResult:
                                            _sym=symbol
                                            _id=resultOrder['id']
                                            _sd =resultOrder['side']
                                            _hash=resultOrder['hash']
                                            _rate=resultOrder['rate']
                                            _amount=resultOrder['amount']
                                            if(_sd == 'SELL'):
                                                bitkub.cancelOpenOrder(_sym, _id, _sd,_hash,_rate,_amount,lineOrderToken)
                                                print('ยกเลิกออเดอร์ตั้งขายก่อนหน้า : ',symbol)
                                                cancleDbDataSave   = {
                                                        "hash": _hash,
                                                        "key": str(uuid4()),
                                                        "Asset": _sym,
                                                        "idOrder": _id,
                                                        "Side":_sd,
                                                        "Rate":_rate,
                                                        "Amount":_amount,
                                                        "LastUpdate": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                                    }
                                                cancleDb[APIKEYBITKUB].insert_one(cancleDbDataSave)
                                    bitkub.sell(_pair, amountToSell, _rat['last'],lineOrderToken)
                                    
                                    print('กำลังทำงานในเหรียญ : ' , symbol ,' ขาย แบบ fixProfit ตั้งขาย : ', _pair , ' Amt:', amountToSell,' Price:', _rat['last'] ) 
                                    bitkub.sendLine('ขายแบบ Fix Rate : '+symbol + 'STOCH RSI : ' + _STOCHRSIk + ' Sell : '+ amountToSell + '%'+ ' Price : ' +_rat['last'] + ' LastBuyPrice : ' + lastBuyPrice + ' Profit : '+profitMai , token=lineOrderToken)
                                else:
                                    print('กำลังทำงานในเหรียญ : ' , symbol ,' ต้องซื้อก่อนจะขาย ' ) 
                                    
                            #  IGNORE PROFIT Sell if RSI too High Don't Care Profit
                            if(aProfitTotake=='Ignore'): 
                                if(Available>=amountToSell and balance_value >= 10):
                                    if(len(aOpenOrderResult)>=1):
                                        for resultOrder in aOpenOrderResult:
                                            _sym=symbol
                                            _id=resultOrder['id']
                                            _sd =resultOrder['side']
                                            _hash=resultOrder['hash']
                                            _rate=resultOrder['rate']
                                            _amount=resultOrder['amount']
                                            if(_sd == 'SELL'):
                                                bitkub.cancelOpenOrder(_sym, _id, _sd,_hash,_rate,_amount,lineOrderToken)
                                                print('กำลังทำงานในเหรียญ : ' , symbol ,' ยกเลิกออเดอร์ตั้งขายก่อนหน้า งานขาย ' ) 
                                                
                                                cancleDbDataSave   = {
                                                        "hash": _hash,
                                                        "key": str(uuid4()),
                                                        "Asset": _sym,
                                                        "idOrder": _id,
                                                        "Side":_sd,
                                                        "Rate":_rate,
                                                        "Amount":_amount,
                                                        "LastUpdate": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                                    }
                                                cancleDb[APIKEYBITKUB].insert_one(cancleDbDataSave)
                                    bitkub.sell(_pair, amountToSell, _rat['last'],lineOrderToken)
                                    print('ตั้งขาย : ', _pair , ' Amt:', amountToSell,' Price:', _rat['last'] )
                                    bitkub.sendLine('ขายแบบไม่สนกำไร อิง RSI เป็นหลัก : '+symbol + 'STOCH RSI : ' + _STOCHRSIk + ' Sell : '+ amountToSell + '%'+ ' Price : ' +_rat['last'] + ' LastBuyPrice : ' + lastBuyPrice + ' Profit : '+profitMai , token=lineOrderToken)
                                    
                                else:
                                    print('ต้องซื้อก่อนจะขายออก แบบไม่สนใจกำไร : ',symbol)
                    
                   
                    if(_tradeStyle == 'stepProfit'):
                        print('กำลังทำงานในเหรียญ : ' , symbol ,' งานขายแบบ stepProfit ' ) 
                        try:
                            
                            AtradeStep = tradeStyleSteps_mongo[symbol]
                            
                        except KeyError:
                            AtradeStep = tradeStyleSteps_mongo['DEFAULT']
                            
                        for _range in AtradeStep:
                            _min = AtradeStep[_range]['Min']
                            _max = AtradeStep[_range]['Max']
                            _PercentToSell = AtradeStep[_range]['PercentToSell']
                            # print('_PercentToSell:',_PercentToSell)
                            amountToSell = (balance_value*_PercentToSell) / 100 
                            # print('amountToSell : (balance_value*_PercentToSell) / 100  : ' ,amountToSell)
                            amountToSell = round(amountToSell,15)
                            # print('amountToSell : round(amountToSell,10)  : ' ,amountToSell)
                            amountToSell = amountToSell / _rat['last']
                            # print('amountToSell : amountToSell / _rat["last"] : ' , ('%f' % amountToSell).rstrip('0').rstrip('.'))
                            cashRecieve =  amountToSell *  _rat['last']
                            a = ('%f' % amountToSell).rstrip('0').rstrip('.')
                            # print(a)
                            profitMai = (float(_rat['last'])*float(a)) - (float(a)*float(lastBuyPrice)) 
                            aFee = (cashRecieve*bitkubFee)
                            aProfitWithFee = profitMai - (aFee*2)
                            
                           
                            if(Available>=float(a) and balance_value >= 10 and cashRecieve >= 10 and float(a) >= 0.0001):
                                
                                # # DEBUG
                                # if(symbol =='BTC'):
                                #     abtc_STOCHRSIk = _STOCHRSIk
                                #     abtcbalance_value = balance_value
                                #     abtcAvailable = Available
                                #     abtclastBuyPrice = lastBuyPrice
                                #     abtcNowPrice =  _rat['last']
                                #     abtcProfit =  balance_value -  (Available*lastBuyPrice)
                                #     aBtc_min = AtradeStep[_range]['Min']
                                #     aBtc_max = AtradeStep[_range]['Max']
                                #     aBtc_PercentToSell = AtradeStep[_range]['PercentToSell']
                                #     aBtcamountToSell = (balance_value*_PercentToSell) / 100 
                                #     aBtcamountToSell = amountToSell / _rat['last']
                                #     aBtccashRecieve =  amountToSell *  _rat['last']
                                #     aBtca = ('%f' % amountToSell).rstrip('0').rstrip('.')
                                # # END
                                
                                if(_STOCHRSIk >= _min and _STOCHRSIk <= _max):
                                    print('********')
                                    print('Preparing to sell : ',symbol)
                                    print('StochRSI : ' , _STOCHRSIk)
                                    print('balance_value : ' , balance_value)
                                    print('lastBuyPrice : ' , lastBuyPrice)
                                    print('CurrentPrice : ' ,  _rat['last'])
                                    print('Available : ' , Available)
                                    print('Amount To Sell : ' , float(a))
                                    print('cashRecieve : ' , cashRecieve)
                                    print('aProfitWithFee : ' , aProfitWithFee)
                                    print('Profit without Fee : ' , profitMai)
                                    print('aProfitTotake : ' , aProfitTotake)
                                    print('_min : ' , _min)
                                    print('_max : ' , _max)
                                    print('_PercentToSell : ' , _PercentToSell)
                                    print('_PercentToSell : ' , float(a))
                                    print('Profit : ',aProfitWithFee , ' \n Fee : ' , aFee , '\n Profit - Fee Buy,Sell : ' , aProfitWithFee , '\n ******** ')
                                    
                                    # profitMai = (_rat['last']*a) - (a*lastBuyPrice)
                                    
                                    # profitMai = balance_value -  (Available*lastBuyPrice)
                                    
                                    
                                    if(aProfitWithFee >= float(aProfitTotake)):
                                        if(len(aOpenOrderResult)>=1):
                                            for resultOrder in aOpenOrderResult:
                                                _sym=symbol
                                                _id=resultOrder['id']
                                                _sd =resultOrder['side']
                                                _hash=resultOrder['hash']
                                                _rate=resultOrder['rate']
                                                _amount=resultOrder['amount']
                                                if(_sd == 'SELL'):
                                                    bitkub.cancelOpenOrder(_sym, _id, _sd,_hash,_rate,_amount,lineOrderToken)
                                                    remove = profitDb[APIKEYBITKUB].delete_one({"hash":_hash})
                                                    cancleDbDataSave   = {
                                                            "hash": _hash,
                                                            "key": str(uuid4()),
                                                            "Asset": _sym,
                                                            "idOrder": _id,
                                                            "Side":_sd,
                                                            "Rate":_rate,
                                                            "Amount":_amount,
                                                            "LastUpdate": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                                        }
                                                    cancleDb[APIKEYBITKUB].insert_one(cancleDbDataSave)
                                                    print('ยกเลิกออเดอร์ตั้งขายก่อนหน้า : ',symbol)
                                        # bitkub.sell(_pair,  a, _rat['last'],lineOrderToken)
                                        _textSellDescription = '\nขายแบบ STEP ขั้น RSI : '+ str(symbol) + '\nSTOCH RSI : ' + str(_STOCHRSIk) + '\nSell : '+ str(_PercentToSell) + '%' + '\nจำนวน : ' + str(a) + '\nราคาปัจจุบัน : ' + str(_rat['last']) + '\nราคาซื้อล่าสุด : ' + str(lastBuyPrice) + '\nกำไร : '+ str(profitMai)+'฿'
                                        sellResponse = bitkub.sell(_pair,  a, _rat['last'],lineOrderToken,_textSellDescription)
                                        sellResponse = sellResponse['result']
                                        profitDataSave   = {
                                                "hash": str(sellResponse['hash']),
                                                "key": str(uuid4()),
                                                "Asset": symbol,
                                                "Signal": _signal,
                                                "StochRSI": _STOCHRSIk,
                                                "AssetInTHB":balance_value,
                                                "AvgBuyPrice":lastBuyPrice,
                                                "SellPrice":_rat['last'],
                                                "Available":Available,
                                                "Amount":a,
                                                "PercentToSell" : _PercentToSell,
                                                "Reserved":Reserved,
                                                "Profit":profitMai,
                                                "ProfitGoal":aProfitTotake,
                                                "Description":_textSellDescription,
                                                "AmountToBuy":sellResponse['amt'],
                                                "Type":sellResponse['typ'],
                                                "Fee":sellResponse['fee'],
                                                "CreditFee":sellResponse['cre'],
                                                "AmountToReceive":sellResponse['rec'],
                                                "timestamp":sellResponse['ts'],
                                                "LastUpdate": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                            }
                                        # {
                                            #   "error": 0,
                                            #   "result": {
                                            #     "id": 1, // order id
                                            #     "hash": "fwQ6dnQWQPs4cbatF5Am2xCDP1J", // order hash
                                            #     "typ": "limit", // order type
                                            #     "amt": 1000, // spending amount
                                            #     "rat": 15000, // rate
                                            #     "fee": 2.5, // fee
                                            #     "cre": 2.5, // fee credit used
                                            #     "rec": 0.06666666, // amount to receive
                                            #     "ts": 1533834547 // timestamp
                                            #   }
                                            # }
                                        profitDb[APIKEYBITKUB].insert_one(profitDataSave)
                                        # print('ขายแบบ STEP ขั้น RSI : ',symbol , ' RSI : ' , _STOCHRSIk , ' Sell : ', _PercentToSell , '%', ' Price : ' ,_rat['last'] , ' LastBuyPrice : ' , lastBuyPrice , ' Profit : ',profitMai)
                                        print('ขายแบบ STEP ขั้น RSI : '+ str(symbol) + 'STOCH RSI : ' + str(_STOCHRSIk) + ' Sell : '+ str(_PercentToSell) + '%' + ' จำนวน : ' + str(a) + ' ราคาปัจจุบัน : ' + str(_rat['last']) + ' ซื้อล่าสุดราคา : ' + str(lastBuyPrice) + ' กำไร : '+ str(profitMai) )
                                    else:
                                        print('ขาดทุน ตาม Percent RSI ที่จะขาย : ' , aProfitWithFee)
                            
                        print('กำลังทำงาน ตรวจสอบ StopLoss:' , symbol , ' ขายทอดตลาด StopLoss')
                        # self,_pair,_amt,_rat,_token ,_txtOptional=''
                        _PercentToSell = 99
                        amountToSell = (balance_value*_PercentToSell) / 100 
                        amountToSell = round(amountToSell,15)
                        amountToSell = amountToSell / _rat['last']
                        cashRecieve =  amountToSell *  _rat['last']
                        a = ('%f' % amountToSell).rstrip('0').rstrip('.')
                        profitMai = (float(_rat['last'])*float(a)) - (float(a)*float(lastBuyPrice)) 
                        aFee = (cashRecieve*bitkubFee)
                        aProfitWithFee = profitMai - (aFee*2)
                        if(stopLossWhenLossInTHB>aProfitWithFee):
                            print('Sell Market When : StopLoss > Profit' , str(stopLossWhenLossInTHB) ,'>',str(aProfitWithFee))
                            print('Amount To Sell : ',str(a))
                            print('Cur Price : ',str( _rat['last']))
                            print('Last Buy Price : ',str( lastBuyPrice ))
                                  
                            sellResponse = bitkub.sellMarket(_pair,a, _rat['last'],lineOrderToken,'ขายทิ้ง Stop Loss ที่ขาดทุน :' + str(aProfitWithFee))
                            sellResponse = json.loads(sellResponse.text)
                            sellResponse = sellResponse['result']
                            botStopLossDbSave   = {
                                    "hash": str(sellResponse['hash']),
                                    "key": str(uuid4()),
                                    "Asset": symbol,
                                    "Signal": _signal,
                                    "StochRSI": _STOCHRSIk,
                                    "AssetInTHB":balance_value,
                                    "AvgBuyPrice":lastBuyPrice,
                                    "SellPrice":_rat['last'],
                                    "Available":Available,
                                    "Amount":a,
                                    "PercentToSell" : _PercentToSell,
                                    "Reserved":Reserved,
                                    "Profit":profitMai,
                                    "ProfitGoal":aProfitTotake,
                                    "Description":'ขายทิ้ง Stop Loss ที่ขาดทุน :' + str(aProfitWithFee),
                                    "AmountToBuy":sellResponse['amt'],
                                    "Type":sellResponse['typ'],
                                    "Fee":sellResponse['fee'],
                                    "CreditFee":sellResponse['cre'],
                                    "AmountToReceive":sellResponse['rec'],
                                    "timestamp":sellResponse['ts'],
                                    "LastUpdate": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                }
                            botStopLossDb[APIKEYBITKUB].insert_one(botStopLossDbSave)
                                        # bitkub.sendLine('ขายแบบ STEP ขั้น RSI : '+ str(symbol) + ' STOCH RSI : ' + str(_STOCHRSIk) + ' Sell : '+ str(_PercentToSell) + '%' + ' จำนวน : ' + str(a) + ' ราคาปัจจุบัน : ' + str(_rat['last']) + ' ซื้อล่าสุดราคา : ' + str(lastBuyPrice) + ' กำไร : '+ str(profitMai) ,token=lineOrderToken)
                    
                    
                    logSave   = {
                            "CASH": cash,
                            "Asset": symbol,
                            "Signal": _signal,
                            "StochRSI": _STOCHRSIk,
                            "AssetInTHB":balance_value,
                            "AvgBuyPrice":lastBuyPrice,
                            "CurrentPrice":_rat['last'],
                            "Available":Available,
                            "Reserved":Reserved,
                            "Profit":profitMai,
                            "ProfitGoal":aProfitTotake,
                            "LastUpdate": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                        }
                    joblogDb[APIKEYBITKUB].insert_one(logSave)
                    botActivateDb.update_one({'Instance': APIKEYBITKUB},
                               {'$set': {'Activate': True}
                                }
                               ,upsert=True
                               )
                    print('***************** END *******************')
                # else:
                #     pass
                #     print('Trade Option Not config TradeStyle')
                    
                        
                    
            # text =  '```' + symbol + ' : ' + a['SignalDesc'] + '```'
            # print('Doing : ', symbol , 'RSI Signal : ' , a['signal'] , '| MACD Signal : ',b['signal'])
            # if(a['signal'] != 'Hold'):
                # bitkub.sendLine(text,token = 'LINENOTIFYTOKEN')
    
    # for s in tradeLists:
        
    #     symbol = s
    #     signal =  []
    #     _pair = 'THB_'+symbol
    #     _amt = tradeAmt[symbol]
    #     if(s=='THB' or s=='DON'):
    #         pass
    #     else:
    #         MyDataFrame = bitkub.get_candle(symbol, timeframe='1')
    #         a = bitkub.STOCHRSIsignal(MyDataFrame,symbol)
    #         aa = stochrsi_db[tb_name].insert_one(a)
    #         # b = bitkub.MACDsignal(MyDataFrame,symbol)
    #         # bb = macd_db[tb_name].insert_one(b)
    #         _rat = bitkub.get_last_price(_pair)
    #         text =  symbol + '\n ```' + '\n RSI : ' + str(a['STOCHRSIk']) + '\n ราคา : ' + str(_rat['last']) + '฿ \n ส่งซิก : *' + a['SignalDesc'] + '*```'
    #         print('Doing : ', symbol , 'RSI Signal : ' , a['signal'] , ' RSI : ' , a['STOCHRSIk'])
    #         if(a['signal'] != 'Hold'):
    #             bitkub.sendLine(text,token = 'LINENOTIFYTOKEN')
    #             if (a['signal'] == 'Buy'):
    #                 print('ซื้อ ',_pair , )
    #                 _rat = bitkub.get_last_price(_pair)
    #                 bitkub.buy(_pair, _amt['Buy'], _rat['last'],'LINENOTIFYTOKEN')
                    
    #             elif (a['signal'] == 'Sell'):
    #                 MaxAmt
    #                 _rat = bitkub.get_last_price(_pair)
    #                 bitkub.sell(_pair, _amt['Sell'], _rat['last'],'LINENOTIFYTOKEN')
                
                
            # df = pd.DataFrame()
            # a = type(MyDataFrame)
            
            # for i in obj:
               
            # df[f'symbol_{i}'] = pd.Series(i, name = 'close').cumsum()
            
            
            # MyDataSeries = MyDataFrame.squeeze()
            # my_series = MyDataFrame['close'].squeeze()
            # table = pd.DataFrame()
            # MyDataFrame.plot(grid = True)
            
            # b = bitkub.MACDsignal(MyDataFrame)
            # aa = stochrsi_db[tb_name].insert_one(a)
            # macd_db[tb_name].insert_one(b)
            # for signal in [bitkub.STOCHRSIsignal, bitkub.MACDsignal]:
            #     for stock in [x for x in MyDataFrame.columns if 'stock' in x]: 
            #         MyDataFrame['close'] = MyDataFrame[stock]
            #         indicator = signal(MyDataFrame)
            #         for sig in indicator.keys():
            #             table.loc[sig, stock] = str(indicator[sig])[:4]
            # print(table)             
            # closed = obj['close']
            # open = obj['open']
            # high = obj['high']
            # low = obj['low']
            # volume = obj['volume']
            
            
            # signal=STOCHRSIsignal(obj)
            
            # print(f"closed: {closed}")
            # print(f"open: {open}")
            # short_k = talib.STOCHRSI(closed.to_numpy())
            # short_d = talib.STOCHRSI(closed.to_numpy(), timeperiod=14, fastk_period=3, fastd_period=3, fastd_matype=0)
            # long_k = talib.STOCHRSI(closed.to_numpy(), timeperiod=14, fastk_period=3, fastd_period=3, fastd_matype=0)
            # long_d = talib.STOCHRSI(closed.to_numpy(), timeperiod=14, fastk_period=3, fastd_period=3, fastd_matype=0)
                
   
    
    
    
    
    # print(assets)
    # i = 0
    # while i < len(assets):
    #     r = assets[i]
    #     id          = r['id']
    #     info        = r['info']
    #     asset      = r['symbol']
    #     gbal        = r['global']
    #     currency    = r['currency']
        
    #     # print(id,info,asset,gbal,currency)
    #     get_price = bitkub.get_last_price(gbal)
    #     current = 0
    #     if get_price:
    #         current = float(get_price['last'])

    #     # print(f"""Check Assets({colored(asset, 'blue')})\nValue: {colored(f'{current:,}', 'yellow')} per {colored(currency, 'blue')}\n{colored(''.rjust(60, '#'), 'yellow')}""")
    #     obj = bitkub.get_candle(asset, timeframe='1D')
    #     trend = bitkub.trand_ema(asset ,obj, fast_length=7, slow_length=45)
    #     # print(trend)
    #     trend_db[tb_name].insert_one(trend)
        
        
    #     # trend_db[tb_name].insert_one(trend)
        
        
    #     # ถ้า avg < 3 และ trend up
    #     if trend['avg'] < 3 and trend['trend'] == "UP":
    #         subscribe_db[tb_name].insert_one(trend)
        
    #     ### end
    #     print(f"\n{''.rjust(60, '-')}")
    #     i += 1
    # print('start : ',WSS_URL)
    # ws = wb.WebSocketApp(WSS_URL, on_open=on_open, on_close=on_close, on_error=on_error, on_message=on_message)
    # ws.run_forever()
    
    print("จบการทำงาน" , datetime.datetime.now())
    sys.stdout = orig_stdout
    f.close()
#################################################### MAIN ####################################################

# def on_message(ws, message):
#     global closed_prices
#     message = json.loads(message)
#     # print(message)
#     candle = message
#     print(candle['open'])
#     stream = candle['stream']
#     closed = candle['close']
#     open = candle['open']
#     high = candle['highestBid']
#     low = candle['lowestAskl']
#     volume = candle['quoteVolume']
#     last = candle['last']
#     lowestAsk = candle['lowestAsk']
#     lowestAskSize = candle['lowestAskSize']
#     highestBid = candle['highestBid']
#     highestBidSize = candle['highestBidSize']
#     change = candle['change']
#     percentChange = candle['percentChange']
#     baseVolume = candle['baseVolume']
#     quoteVolume = candle['quoteVolume']
#     isFrozen = candle['isFrozen']
#     high24hr = candle['high24hr']
#     low24hr = candle['low24hr']
#     open = candle['open']
#     close = candle['close']
    
#     # "stream": "market.ticker.thb_zil",
#     # "id": 12,
#     # "last": 1.7552,
#     # "lowestAsk": 1.7558,
#     # "lowestAskSize": 556.29657594,
#     # "highestBid": 1.7553,
#     # "highestBidSize": 2301.76038284,
#     # "change": 0.1022,
#     # "percentChange": 6.18,
#     # "baseVolume": 65030601.94591811,
#     # "quoteVolume": 110308290.45,
#     # "isFrozen": 0,
#     # "high24hr": 1.785,
#     # "low24hr": 1.6028,
#     # "open": 1.653,
#     # "close": 1.7552
    
#     is_candle_closed = candle['x']
    
#     if is_candle_closed:
#         closed = candle['c']
#         open = candle['o']
#         high = candle['h']
#         low = candle['l']
#         volume = candle['v']
#         print(f"closed: {closed}")
#         print(f"open: {open}")
#         closed_prices.append(float(closed))

#         if len(closed_prices) > RSI_PERIOD:
#             # closed_prices.pop(0)
#             all_rsi = talib.RSI(np.array(closed_prices), RSI_PERIOD)
#             pprint(f"all_rsi: {all_rsi}")
#             last_rsi = all_rsi[-1]
#             if last_rsi > RSI_OVERBOUGHT:
#                 if in_position:
#                     print("Overbought, sell!")
#                     success = order(SIDE_SELL, TRADE_SIZE, ORDER_TYPE_MARKET, TRADE_SYMBOL)
#                     if success:
#                         in_position = False

#                 else:
#                     print("overbought, but we dont have position")
#             elif last_rsi < RSI_OVERSOLD:
#                 if in_position:
#                     print("oversold but already in position")
#                 else:
#                     print("buy!")
#                     success = order(SIDE_BUY, TRADE_SIZE, ORDER_TYPE_MARKET, TRADE_SYMBOL)
#                     if success:
#                         in_position = True




def get_file_name():
    return os.path.join(HISTORY_PATH, f"{datetime.now().strftime('%Y-%m-%dT%H')}.txt")

def Stoch(close, high, low, smoothk, smoothd, n):
    lowestlow = pd.Series.rolling(low, window=n, center=False).min()
    highesthigh = pd.Series.rolling(high, window=n, center=False).max()
    K = pd.Series.rolling(
        100*((close-lowestlow)/(highesthigh-lowestlow)), window=smoothk).mean()
    D = pd.Series.rolling(K, window=smoothd).mean()
    return K, D

async def parse_socket_data(data):
    global DATA_STR
    lines = f"{DATA_STR}{data}".split("\n")
    print(lines)
    # async with aiofiles.open(get_file_name(), mode="a") as f:
    #     await f.writelines([f"{line}\n" for line in lines])
    #     f.close()
      
# async def collect_bitkub_history():
#     try:
#         async for websocket in websockets.connect(WSS_URL):
#             print('Connecting to websocket')
#             try:
#                 async for message in websocket:
#                     await parse_socket_data(message)
#             except:
#                 print('Websocket reading error')
#     except:
#        print('Cannot connect to websocket')
        
# mystochrsi = Stoch(df.rsi, df.rsi, df.rsi, settings.trade_rsi_k,
#                                settings.trade_rsi_d, settings.trade_rsi_stochastic)

# print(rsi)

def on_open(ws):
    # ws.send("{'event':'addChannel','channel':'ethusdt@kline_1m'}")
    print("connected ")


def on_close(ws):
    print("closed connection")


def on_error(ws, error):
    print(error)