init

2023-12-12 00:15:38 +09:00
parent 6b22132b43
commit fbfab6d236
7 changed files with 550 additions and 359 deletions
--- a/HTS_etf.py
+++ b/HTS_etf.py
@@ -1,6 +1,5 @@
 import time
-import os
-import sqlite3
+import pandas as pd
 from datetime import datetime

 from hts.HTS import HTS
@@ -11,11 +10,14 @@ from stock.util.LabelChecker import LabelChecker
 from stock.util.TelegramBot import TelegramBot
 from stock.analysis.StockStatus import StockStatus

-from hts.BuySellChecker_122630 import BuySellChecker_122630
-from hts.BuySellChecker_233740 import BuySellChecker_233740
-from hts.BuySellChecker_251340 import BuySellChecker_251340
-from hts.BuySellChecker_252670 import BuySellChecker_252670
+from stock.analysis.Common import Common
+from stock.analysis.Stochastic import Stochastic
+from stock.analysis.RSI import RSI
+from stock.analysis.MACD import MACD
+from stock.analysis.IchimokuCloud import IchimokuCloud
+from statsmodels.tsa.seasonal import seasonal_decompose

+from hts.BuySellChecker import BuySellChecker

 class HTS_etf(HTS):
    RESOURCE_PATH = None
@@ -25,10 +27,16 @@ class HTS_etf(HTS):
    buy_count = None
    orderChecker = None
    buySellChecker = None
-    labelChecker = None
    bot = None
    stockStatus = None

+    common = None
+    stochastic = None
+    rsi = None
+    macd = None
+    ichimokuCloud = None
+
+
    def __init__(self, RESOURCE_PATH, stock_code, stock_name, SELL_GAP):
        super().__init__(RESOURCE_PATH)

@@ -42,19 +50,19 @@ class HTS_etf(HTS):
        self.bot = TelegramBot()
        self.stockStatus = StockStatus(RESOURCE_PATH)

-        self.buySellChecker = None
-        if stock_code == '122630':
-            self.buySellChecker = BuySellChecker_122630()
-        elif stock_code == '233740':
-            self.buySellChecker = BuySellChecker_233740()
-        elif stock_code == '251340':
-            self.buySellChecker = BuySellChecker_251340()
-        elif stock_code == '252670':
-            self.buySellChecker = BuySellChecker_252670()
+        self.common = Common()
+        self.stochastic = Stochastic()
+        self.rsi = RSI()
+        self.macd = MACD()
+        self.ichimokuCloud = IchimokuCloud()

+        self.buySellChecker = BuySellChecker()

        return

+    def getBallance(self):
+        return
+
    def sellStocks(self, stock_code=None, bs_sell_price=None):
        check = False
        jangoDic = self.requstJango()
@@ -64,19 +72,19 @@ class HTS_etf(HTS):
                    if code == "A" + stock_code:
                        if bs_sell_price is not None:
                            if jangoDic[code]['매도가능'] > 0:
-                                if jangoDic[code]['평가손익'] < -1.5 or 3 < jangoDic[code]['평가손익'] or self.SELL_GAP < jangoDic[code]['평가금액']-jangoDic[code]['매입금액']:
+                                if jangoDic[code]['평가손익'] < -1.0 or 2 < jangoDic[code]['평가손익'] or self.SELL_GAP < jangoDic[code]['평가금액']-jangoDic[code]['매입금액']:
                                    # 1.5% 손해 혹은 2% 이상 시 수익 매도
                                    self.requestOrder(OrderType.sell, code[1:], jangoDic[code]['매도가능'], bs_sell_price)
                                    check = True
                        else:
                            if jangoDic[code]['매도가능'] > 0:
-                                if jangoDic[code]['평가손익'] < -1.5 or 3 < jangoDic[code]['평가손익'] or self.SELL_GAP < jangoDic[code]['평가금액']-jangoDic[code]['매입금액']:
+                                if jangoDic[code]['평가손익'] < -1.0 or 2 < jangoDic[code]['평가손익'] or self.SELL_GAP < jangoDic[code]['평가금액']-jangoDic[code]['매입금액']:
                                    # 1.5% 손해 혹은 2% 이상 시 수익 매도
                                    self.requestOrder(OrderType.sell, code[1:], jangoDic[code]['매도가능'], jangoDic[code]['현재가'])
                                    check = True
                else:
                    if jangoDic[code]['매도가능'] > 0:
-                        if jangoDic[code]['평가손익'] < -1.5 or 3 < jangoDic[code]['평가손익'] or self.SELL_GAP < jangoDic[code]['평가금액']-jangoDic[code]['매입금액']:
+                        if jangoDic[code]['평가손익'] < -1.0 or 2 < jangoDic[code]['평가손익'] or self.SELL_GAP < jangoDic[code]['평가금액']-jangoDic[code]['매입금액']:
                            # 1.5% 손해 혹은 2% 이상 시 수익 매도
                            self.requestOrder(OrderType.sell, code[1:], jangoDic[code]['매도가능'], jangoDic[code]['현재가'])
                            check = True
@@ -105,6 +113,188 @@ class HTS_etf(HTS):
                            return orderNum, log_time.strftime('%Y%m%d %H%M%S'), jangoDic[code]['매도가능'], sell_price
        return orderNum, None, None, None

+    def analyze(self, result):
+        # 기본 캔들 정보
+        open = result["open"]
+        close = result["close"]
+        high = result["high"]
+        low = result["low"]
+        volume = result["vol"]
+
+        if "volume_down" in result:
+            volume_down = result["volume_down"]
+        if "volume_up" in result:
+            volume_up = result["volume_up"]
+        if "volume_updown_diff" in result:
+            volume_updown_diff = result["volume_updown_diff"]
+
+        # 이동 평균
+        close_df = pd.DataFrame(close)
+        avg5_list = close_df.rolling(window=5).mean().fillna(close[0]).values.tolist()
+        avg5 = [item[0] for item in avg5_list]
+        avg20_list = close_df.rolling(window=20).mean().fillna(close[0]).values.tolist()
+        avg20 = [item[0] for item in avg20_list]
+        avg30_list = close_df.rolling(window=30).mean().fillna(close[0]).values.tolist()
+        avg30 = [item[0] for item in avg30_list]
+        avg60_list = close_df.rolling(window=60).mean().fillna(close[0]).values.tolist()
+        avg60 = [item[0] for item in avg60_list]
+        avg120_list = close_df.rolling(window=120).mean().fillna(close[0]).values.tolist()
+        avg120 = [item[0] for item in avg120_list]
+        avg240_list = close_df.rolling(window=240).mean().fillna(close[0]).values.tolist()
+        avg240 = [item[0] for item in avg240_list]
+        avg480_list = close_df.rolling(window=480).mean().fillna(close[0]).values.tolist()
+        avg480 = [item[0] for item in avg480_list]
+        avg1500_list = close_df.rolling(window=1500).mean().fillna(close[0]).values.tolist()
+        avg1500 = [item[0] for item in avg1500_list]
+
+        size = int(len(close) / 8)
+        pos = round(size / 2)
+        close_temp = close + [close[-1]] * pos
+        decomposition_results = seasonal_decompose(close_temp, model='multiplicative', period=size)
+        trend = decomposition_results.trend[:-pos]
+        trend_df = pd.DataFrame(trend).fillna(close[0])
+        trend_avg_list = trend_df.rolling(window=20).mean().values.tolist()
+        trend_avg = [item[0] for item in trend_avg_list]
+
+        open_df = pd.DataFrame(close)
+        disparity_avg5_list = (open_df / close_df.rolling(window=5).mean()).values.tolist()
+        disparity_avg5 = [item[0] for item in disparity_avg5_list]
+        disparity_avg20_list = (open_df / close_df.rolling(window=20).mean()).values.tolist()
+        disparity_avg20 = [item[0] for item in disparity_avg20_list]
+        disparity_avg30_list = (open_df / close_df.rolling(window=30).mean()).values.tolist()
+        disparity_avg30 = [item[0] for item in disparity_avg30_list]
+        disparity_avg60_list = (open_df / close_df.rolling(window=60).mean()).values.tolist()
+        disparity_avg60 = [item[0] for item in disparity_avg60_list]
+        disparity_avg120_list = (open_df / close_df.rolling(window=120).mean()).values.tolist()
+        disparity_avg120 = [item[0] for item in disparity_avg120_list]
+        disparity_avg240_list = (open_df / close_df.rolling(window=240).mean()).values.tolist()
+        disparity_avg240 = [item[0] for item in disparity_avg240_list]
+        disparity_avg480_list = (open_df / close_df.rolling(window=480).mean()).values.tolist()
+        disparity_avg480 = [item[0] for item in disparity_avg480_list]
+        disparity_avg1500_list = (open_df / close_df.rolling(window=1500).mean()).values.tolist()
+        disparity_avg1500 = [item[0] for item in disparity_avg1500_list]
+
+        # 볼린져 밴드
+        df = pd.DataFrame(close)
+        max20 = df.rolling(window=20).mean()
+        stddev20 = df.rolling(window=20).std()
+        upper_df = max20 + (stddev20 * 2)  # 상단 볼린저 밴드
+        lower_df = max20 - (stddev20 * 2)  # 하단 볼린저 밴드
+        middle_df = (upper_df + lower_df) / 2
+        upper_limit_df = upper_df - (upper_df - lower_df) * 0.1
+        lower_limit_df = (upper_df - lower_df) * 0.15 + lower_df
+
+        upper, lower, middle, upper_limit, lower_limit = [], [], [], [], []
+        for i in range(len(upper_df)):
+            if i < 10:
+                upper.append(upper_df.values[0][0])
+                lower.append(lower_df.values[0][0])
+                middle.append(middle_df.values[0][0])
+                upper_limit.append(upper_limit_df.values[0][0])
+                lower_limit.append(lower_limit_df.values[0][0])
+            else:
+                upper.append(upper_df.values[i][0])
+                lower.append(lower_df.values[i][0])
+                middle.append(middle_df.values[i][0])
+                upper_limit.append(upper_limit_df.values[i][0])
+                lower_limit.append(lower_limit_df.values[i][0])
+
+        upper, lower = [], []
+        for i in range(len(upper_df)):
+            if i < 10:
+                upper.append(upper_df.values[0][0])
+                lower.append(lower_df.values[0][0])
+            else:
+                upper.append(upper_df.values[i][0])
+                lower.append(lower_df.values[i][0])
+
+        point_temp = result["time"]
+        STOCK = []
+        if "volume_up" in result and "volume_updown_diff" in result:
+            for i in range(len(open)):
+                STOCK.append({'volume': volume[i], 'volume_down': volume_down[i], 'volume_up': volume_up[i], 'volume_updown_diff': volume_updown_diff[i], 'close': close[i], 'open': open[i], 'high': high[i], 'low': low[i],
+                              'avg5': avg5[i], 'avg20': avg20[i], 'avg60': avg60[i], 'avg120': avg120[i], 'avg240': avg240[i], 'avg480': avg480[i], 'avg1500': avg1500[i]})
+        else:
+            for i in range(len(open)):
+                STOCK.append({'volume': volume[i], 'close': close[i], 'open': open[i], 'high': high[i], 'low': low[i],
+                              'avg5': avg5[i], 'avg20': avg20[i], 'avg60': avg60[i], 'avg120': avg120[i], 'avg240': avg240[i], 'avg480': avg480[i], 'avg1500': avg1500[i]})
+
+        # stochastic
+        stochastic_df = self.stochastic.apply(STOCK, n=30, m=5, t=5)
+        fast_k = stochastic_df['fast_k'].values.tolist()
+        slow_k = stochastic_df['slow_k'].values.tolist()
+        slow_d = stochastic_df['slow_d'].values.tolist()
+
+        # macd
+        #macd_df = self.macd.apply(STOCK, short=12, long=26, t=9)
+        macd_df = self.macd.apply(STOCK, short=5, long=20, t=5)
+        macd = macd_df['macd'].values.tolist()
+        macds = macd_df['macds'].values.tolist()
+        macdo = macd_df['macdo'].values.tolist()
+
+        # rsi
+        rsi_df = self.rsi.apply(STOCK, period=30, window=5)
+        rsi = rsi_df['rsi'].values.tolist()
+        rsis = rsi_df['rsis'].values.tolist()
+
+        # ichimokuCloud
+        ichimokuCloud_df = self.ichimokuCloud.apply(STOCK, c=9, b=26, l=52)
+        ichimokuCloud_df = ichimokuCloud_df[:len(ichimokuCloud_df) - 51]
+        changeLine = ichimokuCloud_df['changeLine'].values.tolist()
+        baseLine = ichimokuCloud_df['baseLine'].values.tolist()
+        laggingSpan = ichimokuCloud_df['laggingSpan'].values.tolist()
+        leadingSpan1 = ichimokuCloud_df['leadingSpan1'].values.tolist()
+        leadingSpan2 = ichimokuCloud_df['leadingSpan2'].values.tolist()
+
+        # 결과
+        if "volume_up" in result and "volume_updown_diff" in result:
+            temp = {
+                "ymd": point_temp,
+                "open": open, "high": high, "low": low, "close": close, "volume": volume, "volume_down": volume_down,
+                "volume_up": volume_up, "volume_updown_diff": volume_updown_diff,
+                "trend": trend, "trend_avg": trend_avg,
+                "avg5": avg5, "avg20": avg20, "avg60": avg60, "avg120": avg120, "avg240": avg240, "avg480": avg480,
+                "avg1500": avg1500,
+                "disparity_avg5": disparity_avg5, "disparity_avg20": disparity_avg20,
+                "disparity_avg30": disparity_avg30, "disparity_avg60": disparity_avg60,
+                "disparity_avg120": disparity_avg120, "disparity_avg240": disparity_avg240,
+                "disparity_avg480": disparity_avg480, "disparity_avg1500": disparity_avg1500,
+                "upper": upper, "lower": lower, 'middle': middle, 'upper_limit': upper_limit,
+                'lower_limit': lower_limit,
+                "macd": macd, "macds": macds, "macdo": macdo,
+                "fast_k": fast_k, "slow_k": slow_k, "slow_d": slow_d,
+                "rsi": rsi, "rsis": rsis,
+                "changeLine": changeLine, "baseLine": baseLine, "laggingSpan": laggingSpan,
+                "leadingSpan1": leadingSpan1, "leadingSpan2": leadingSpan2,
+            }
+        else:
+            temp = {
+                "ymd": point_temp,
+                "open": open, "high": high, "low": low, "close": close, "volume": volume,
+                "trend": trend, "trend_avg": trend_avg,
+                "avg5": avg5, "avg20": avg20, "avg60": avg60, "avg120": avg120, "avg240": avg240, "avg480": avg480,
+                "avg1500": avg1500,
+                "disparity_avg5": disparity_avg5, "disparity_avg20": disparity_avg20,
+                "disparity_avg30": disparity_avg30, "disparity_avg60": disparity_avg60,
+                "disparity_avg120": disparity_avg120, "disparity_avg240": disparity_avg240,
+                "disparity_avg480": disparity_avg480, "disparity_avg1500": disparity_avg1500,
+                "upper": upper, "lower": lower, 'middle': middle, 'upper_limit': upper_limit,
+                'lower_limit': lower_limit,
+                "macd": macd, "macds": macds, "macdo": macdo,
+                "fast_k": fast_k, "slow_k": slow_k, "slow_d": slow_d,
+                "rsi": rsi, "rsis": rsis,
+                "changeLine": changeLine, "baseLine": baseLine, "laggingSpan": laggingSpan,
+                "leadingSpan1": leadingSpan1, "leadingSpan2": leadingSpan2,
+            }
+
+        data = pd.DataFrame(temp)
+        df_final_time = pd.DatetimeIndex(point_temp)
+        data.index = df_final_time
+
+        data = data.fillna(-1)
+        return data
+
+
    def makeTickData(self, data, mins=30):
        result = {"check": set(),
                  "time": [],
@@ -127,30 +317,63 @@ class HTS_etf(HTS):

        return result

+    def makeTickData1(self, data, mins=5):
+        result = {
+            "ymd": [],
+            "open": [], "close": [], "high": [], "low": [], "volume": [], "volume_up": [], "volume_down": [], "volume_updown_diff": []
+        }

-    def getLIMITInfo(self, stock_code, ymd, dbfile_name="stock.db"):
-        conn = sqlite3.connect(os.path.join(self.RESOURCE_PATH, dbfile_name))
-        cursor = conn.cursor()
+        for i in range(mins, len(data['ymd'])+1):
+            result["ymd"].append(data['ymd'][i-1])

-        cursor.execute('select ymd, open, close, high, low, volume from stock where code=? order by ymd desc limit ?',
-                       (stock_code, 100,))
-        db_result = cursor.fetchall()
-        cursor.close()
-        conn.close()
+            result["open"].append(data['open'][i-mins])
+            result["close"].append(data['close'][i-1])

-        match = False
-        LIMIT_PRICE = []
-        for i, rows in enumerate(db_result):
-            if rows[0].replace('.', '') == ymd:
-                match = True
-            if match:
-                LIMIT_PRICE.append(rows[2])
+            result["high"].append(max(data['high'][i - mins: i]))
+            result["low"].append(min(data['low'][i - mins: i]))
+            result["volume"].append(sum(data['volume'][i - mins: i]))

-        return {'LOW_PRICE': sum(LIMIT_PRICE[:20]) / len(LIMIT_PRICE[:20])}
+            up = [data['volume'][i - mins + c] for c in range(len(data['volume'][i - mins: i])) if data['open'][i - mins + c] < data['close'][i - mins + c]]
+            down = [data['volume'][i - mins + c] for c in range(len(data['volume'][i - mins: i])) if data['close'][i - mins + c] < data['open'][i - mins + c]]
+            result["volume_up"].append(sum(up))
+            result["volume_down"].append(sum(down))
+            result["volume_updown_diff"].append(sum(up) - sum(down))

+        return result

-    def buyRealTime(self, today, analyzed_day=1000, logFp=None, MAX_PRICE=30000):
-        INFO = self.getLIMITInfo(self.stock_code, today)
+    def makeTickData2(self, data, mins=5):
+        result = {
+            "ymd": [],
+            "open": [], "close": [], "high": [], "low": [], "volume": [], "volume_up": [], "volume_down": [], "volume_updown_diff": []
+        }
+
+        for i in range(mins, len(data['ymd'])+1, mins):
+            result["ymd"].append(data['ymd'][i-1])
+
+            result["open"].append(data['open'][i-mins])
+            result["close"].append(data['close'][i-1])
+
+            result["high"].append(max(data['high'][i - mins: i]))
+            result["low"].append(min(data['low'][i - mins: i]))
+            result["volume"].append(data['volume'][i-1])
+            if data['open'][i-1] < data['close'][i-1]:
+                result["volume_up"].append(data['volume'][i-1])
+                result["volume_down"].append(0)
+            elif data['close'][i-1] < data['open'][i-1]:
+                result["volume_down"].append(-1*data['volume'][i-1])
+                result["volume_up"].append(0)
+            else:
+                result["volume_up"].append(0)
+                result["volume_down"].append(0)
+
+            up = [data['volume'][i - mins + c] for c in range(len(data['volume'][i - mins: i])) if data['close'][i - mins + c] < data['open'][i - mins + c]]
+            down = [data['volume'][i - mins + c] for c in range(len(data['volume'][i - mins: i])) if data['close'][i - mins + c] < data['open'][i - mins + c]]
+            result["volume_updown_diff"].append(sum(up) - sum(down))
+
+        return result
+
+    def buyRealTime(self, today, MAX_PRICE=30000):
+        BUY_LIST = {'buy_count': 0, 'buy_avg': 0, 'buy_list': []}

        print("START...")
        THIS_TIME = datetime.now()
@@ -160,69 +383,72 @@ class HTS_etf(HTS):
        while datetime.strptime(today + " 063000", '%Y%m%d %H%M%S') < THIS_TIME < datetime.strptime(today + " 153100",'%Y%m%d %H%M%S'):
            if datetime.strptime(today + " 090000", '%Y%m%d %H%M%S') < THIS_TIME  < datetime.strptime(today + " 090100", '%Y%m%d %H%M%S'):
                self.bot.sendMsg("START... {} ({}) SLOW_K: {}".format(self.stock_code, self.stock_name, MAX_PRICE))
-                logFp.write("START {} ({}) SLOW_K: {}\n".format(self.stock_code, self.stock_name, MAX_PRICE))

            if datetime.strptime(today + " 090000", '%Y%m%d %H%M%S') < THIS_TIME < datetime.strptime(today + " 151500", '%Y%m%d %H%M%S'):

                # 매도를 체크한다.
-                self.sellStocks(self.stock_code)
+                check = self.sellStocks(self.stock_code)
+
+                buy_avg = self.getBallance(self.stock_code)
+                if check or buy_avg == 0:
+                    BUY_LIST['buy_avg'] = 0
+                    BUY_LIST['buy_count'] = 0
+                    BUY_LIST['buy_list'].clear()

                time.sleep(0.1)

                try:
                    # 데이터를 가지고 온다.
-                    result = self.getRealTime(self.stock_code, today, LAST_DATA)
+                    result_m1 = self.getRealTime(self.stock_code, today, LAST_DATA)
                except:
                    print("#ERROR:", self.stock_code)
                    continue

-                data = self.buySellChecker.analyze(result)
-                data.drop(data.index[:len(data) - analyzed_day], inplace=True)
+                result_tic_m1 = self.makeTickData1(result_m1, mins=1)
+                data = self.buySellChecker.analyze(result_tic_m1)
+                result_tic_m30 = self.makeTickData2(result_tic_m1, mins=30)
+                data_signal = self.buySellChecker.analyze(result_tic_m30)
+
+                #data.drop(data.index[:len(data) - analyzed_day], inplace=True)

                # 사야 할 시점과 팔아야 할 시점을 체크한다.
-                bsLine = self.buySellChecker.checkTransaction(self.stock_code, data, INFO, isRealTime=True)
-                bs_buy_price = bsLine['buy'][0]
-                bs_buy_weight = bsLine['buy_weight'][0]
-                bs_sell_price = bsLine['sell'][0]
+                bsLine1 = self.buySellChecker.checkTransaction1(self.stock_code, MAX_PRICE, data, data_signal, BUY_LIST, isRealTime=True)
+
+                if 'sell_price' in bsLine1:
+                    sell_price = bsLine1['sell_price'][-1]
+                    if 0 < sell_price:
+                        profit_rate = 1.002
+                        if buy_avg * profit_rate < data['close'][-1]:
+                            check = self.sellStocks(self.stock_code, sell_price)
+                            if check:
+                                self.orderChecker.sell(datetime.today().strftime('%Y%m%d'), self.stock_code)
+                                BUY_LIST['buy_avg'] = 0
+                                BUY_LIST['buy_count'] = 0
+                                BUY_LIST['buy_list'].clear()
+                                self.bot.sendMsg( "Profit {:.2f}, {} ({})".format(amount * (profit_rate - 1), self.stock_code, self.stock_name))
+
+                if 'buy_price' in bsLine1:
+                    buy_price = bsLine1['buy_price'][-1]
+                    buy_count = bsLine1['buy_count'][-1]
+                    if buy_price > 0:
+                        # 매수를 요청 한다.
+                        amount = buy_price * buy_count
+                        orderNum = self.requestOrder(OrderType.buy, self.stock_code, buy_count, buy_price)
+                        self.orderChecker.buy(today, "A" + self.stock_code, buy_count, buy_price, orderNum)
+
+                        self.orderChecker.buy(datetime.today().strftime('%Y%m%d'), self.stock_code, buy_count, buy_price)
+                        self.bot.post(self.stock_code, self.stock_name, "[BUY] ", buy_price, buy_count, data['rsi'][-1], -1)

                # 미체결 기록을 가져와서 10분 이상 된 매수 주문을 취소 한다.
-                ORDER_LIST = self.requestOrderList()
-                orderListToCancel = self.orderChecker.cancel(today, "A" + self.stock_code, ORDER_LIST, mins=10)
-                if len(orderListToCancel) > 0:
-                    self.cancelOrderList(orderListToCancel)
+                #ORDER_LIST = self.requestOrderList()
+                #orderListToCancel = self.orderChecker.cancel(today, "A" + self.stock_code, ORDER_LIST, mins=10)
+                #if len(orderListToCancel) > 0:
+                #    self.cancelOrderList(orderListToCancel)

-                if bs_buy_price > 1000:
-
-                    #if not self.orderChecker.exist(today, "A" + self.stock_code, hours=9):
-                    buy_count = int(MAX_PRICE / bs_buy_price)
-
-                    if buy_count > 0:
-                        # 매수를 주문한다.
-                        orderNum = self.requestOrder(OrderType.buy, self.stock_code, buy_count, bs_buy_price)
-                        self.orderChecker.buy(today, "A" + self.stock_code, buy_count, bs_buy_price, orderNum)
-
-                        # 로그 출력
-                        print("BUY", THIS_TIME.strftime('%Y%m%d %H%M%S'), orderNum, self.stock_code, bs_buy_price, buy_count)
-                        logFp.write("{} BUY {} {} {}\n".format(THIS_TIME.strftime('%Y%m%d %H%M%S'), self.stock_code, bs_buy_price, buy_count))
-
-                if bs_sell_price > 1000:
-                    check = self.sellStocks(self.stock_code, bs_sell_price)
-
-                    if check:
-                        # 로그 출력
-                        print("SELL", THIS_TIME.strftime('%Y%m%d %H%M%S'), self.stock_code, self.stock_name, bs_sell_price)
-                        logFp.write("{} SELL {} {} {}\n".format(THIS_TIME.strftime('%Y%m%d %H%M%S'), self.stock_code, bs_buy_price, bs_sell_price))
-
-                # 로그 출력
-                print("TIMECHECK: %s, code: %s, buy: %d, sell: %d, open: %d, close: %d, high: %d, low: %d, macd: %.2f" %
-                      (str(THIS_TIME), self.stock_code, bs_buy_price, bs_sell_price, data["open"][len(data["open"])-1], data["close"][len(data["close"])-1], data["high"][len(data["high"])-1], data["low"][len(data["low"])-1], data["macd"][len(data["macd"])-1]))
-                logFp.write("TIMECHECK: %s, code: %s, buy: %d, sell: %d, open: %d, close: %d, high: %d, low: %d, macd: %.2f\n" %
-                      (str(THIS_TIME), self.stock_code, bs_buy_price, bs_sell_price, data["open"][len(data["open"])-1], data["close"][len(data["close"])-1], data["high"][len(data["high"])-1], data["low"][len(data["low"])-1], data["macd"][len(data["macd"])-1]))

                if (int(THIS_TIME.strftime("%M")) % 50 == 0 or int(THIS_TIME.strftime("%M")) % 20 == 0):
                    self.bot.alarm_live(self.stock_code, self.stock_name, data["close"][len(data["close"])-1], data["macd"][len(data["macd"])-1])

-            logFp.flush()
            time.sleep(60)
            THIS_TIME = datetime.now()