init

HTS_etf.py

@@ -13,8 +13,8 @@ from stock.util.LabelChecker import LabelChecker
 from stock.util.SlackBot import SlackBot
 from stock.analysis.StockStatus import StockStatus
 
-class HTS_etf (HTS):
 
+class HTS_etf(HTS):
     RESOURCE_PATH = None
     stock_code = None
     buy_count = None
@@ -56,11 +56,12 @@ class HTS_etf (HTS):
         if jangoDic and len(jangoDic.keys()) > 0:
             for code in jangoDic:
                 if stock_code is not None:
-                    if code == "A"+stock_code and bs_sell_price is not None:
+                    if code == "A" + stock_code and bs_sell_price is not None:
                         if jangoDic[code]['매도가능'] > 0:
                             if 2 < jangoDic[code]['평가손익']:
                                 self.requestOrder(OrderType.sell, code[1:], jangoDic[code]['매도가능'], bs_sell_price)
-                                self.slackBot.post_to_slack(code, jangoDic[code]['종목명'], "SELL", bs_sell_price, jangoDic[code]['매도가능'])
+                                self.slackBot.post_to_slack(code, jangoDic[code]['종목명'], "SELL", bs_sell_price,
+                                                            jangoDic[code]['매도가능'])
                                 check = True
                     else:
                         continue
@@ -70,11 +71,11 @@ class HTS_etf (HTS):
                             # 3% 이상 시 수익 매도
                             currentStock = self.currentStock(code[1:])
                             self.requestOrder(OrderType.sell, code[1:], jangoDic[code]['매도가능'], currentStock['close'])
-                            self.slackBot.post_to_slack(code, jangoDic[code]['종목명'], "SELL", currentStock['close'], jangoDic[code]['매도가능'])
+                            self.slackBot.post_to_slack(code, jangoDic[code]['종목명'], "SELL", currentStock['close'],
+                                                        jangoDic[code]['매도가능'])
                             check = True
         return check
 
-
     def getSellingPrice(self, log_time, stock_code, final_price, without_loss=False):
         # final_price와 diff를 받으면, 해당 가격으로 그냥 매도한다는 의미
         # final_price와 diff가 None이면 장부가와 final 중 max로 팔겠다는 의미
@@ -85,20 +86,20 @@ class HTS_etf (HTS):
             for code in jangoDic:
                 if jangoDic[code]['매도가능'] > 0:
                     if without_loss:
-                        if jangoDic[code]['장부가']*0.07 < jangoDic[code]['장부가'] - final_price:
+                        if jangoDic[code]['장부가'] * 0.07 < jangoDic[code]['장부가'] - final_price:
                             sell_price = jangoDic[code]['장부가']
                             if code == "A" + stock_code:
-                                orderNum = self.requestOrder(OrderType.sell, stock_code, jangoDic[code]['매도가능'], sell_price)
+                                orderNum = self.requestOrder(OrderType.sell, stock_code, jangoDic[code]['매도가능'],
+                                                             sell_price)
                                 return orderNum, log_time.strftime('%Y%m%d %H%M%S'), jangoDic[code]['매도가능'], sell_price
                     else:
                         max_price = max(jangoDic[code]['장부가'], final_price)
                         sell_price = (int(max_price) - int(max_price) % 5) + 5
-                        if code == "A"+stock_code:
+                        if code == "A" + stock_code:
                             orderNum = self.requestOrder(OrderType.sell, stock_code, jangoDic[code]['매도가능'], sell_price)
                             return orderNum, log_time.strftime('%Y%m%d %H%M%S'), jangoDic[code]['매도가능'], sell_price
         return orderNum, None, None, None
 
-
     def makeTickData(self, data, mins=30):
         result = {"check": set(),
                   "time": [],
@@ -109,12 +110,12 @@ class HTS_etf (HTS):
                   "vol": [],
                   "label": []}
 
-        for i in range(mins, len(data['time'])+1):
+        for i in range(mins, len(data['time']) + 1):
-            result["check"].add(data['time'][i-1])
+            result["check"].add(data['time'][i - 1])
-            result["time"].append(data['time'][i-1])
+            result["time"].append(data['time'][i - 1])
 
-            result["open"].append(data['open'][i-mins])
+            result["open"].append(data['open'][i - mins])
-            result["close"].append(data['close'][i-1])
+            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["vol"].append(sum(data['vol'][i - mins: i]))
@@ -124,7 +125,9 @@ class HTS_etf (HTS):
     def getSlowK(self, stock_code):
         slow_k, p_slow_k, slow_k_week, p_slow_k_week, slow_k_month, p_slow_k_month = -1, -1, -1, -1, -1, -1
 
-        self.cursor_stock.execute('select stochastic_slow_k, max(ymd) from stock_analysis where code=? group by 1 order by ymd desc',(stock_code,))
+        self.cursor_stock.execute(
+            'select stochastic_slow_k, max(ymd) from stock_analysis where code=? group by 1 order by ymd desc',
+            (stock_code,))
         items = self.cursor_stock.fetchall()
         if items is not None and len(items) > 1:
             for i, item in enumerate(items):
@@ -135,7 +138,9 @@ class HTS_etf (HTS):
                 else:
                     break
 
-        self.cursor_stock.execute('select stochastic_slow_k, max(ymd) from stock_analysis_weekly where code=? group by 1 order by ymd desc', (stock_code, ))
+        self.cursor_stock.execute(
+            'select stochastic_slow_k, max(ymd) from stock_analysis_weekly where code=? group by 1 order by ymd desc',
+            (stock_code,))
         items = self.cursor_stock.fetchall()
         if items is not None and len(items) > 1:
             for i, item in enumerate(items):
@@ -146,7 +151,9 @@ class HTS_etf (HTS):
                 else:
                     break
 
-        self.cursor_stock.execute('select stochastic_slow_k, max(ymd) from stock_analysis_monthly where code=? group by 1 order by ymd desc',(stock_code,))
+        self.cursor_stock.execute(
+            'select stochastic_slow_k, max(ymd) from stock_analysis_monthly where code=? group by 1 order by ymd desc',
+            (stock_code,))
         items = self.cursor_stock.fetchall()
         if items is not None and len(items) > 1:
             for i, item in enumerate(items):
@@ -158,7 +165,7 @@ class HTS_etf (HTS):
                     break
 
         if slow_k is None or p_slow_k is None:
-            slow_k , p_slow_k = -1, -1
+            slow_k, p_slow_k = -1, -1
         if slow_k_week is None or p_slow_k_week is None:
             slow_k_week, p_slow_k_week = -1, -1
         if slow_k_month is None or p_slow_k_month is None:
@@ -166,12 +173,13 @@ class HTS_etf (HTS):
 
         return slow_k, p_slow_k, slow_k_week, p_slow_k_week, slow_k_month, p_slow_k_month
 
-    def getBuyCount(self, stock_code, bs_buy_price, slow_k_kospi, p_slow_k_kospi, slow_k_week_kospi, p_slow_k_week_kospi, slow_k_month_kospi, p_slow_k_month_kospi):
+    def getBuyCount(self, stock_code, bs_buy_price, slow_k_kospi, p_slow_k_kospi, slow_k_week_kospi,
+                    p_slow_k_week_kospi, slow_k_month_kospi, p_slow_k_month_kospi):
 
         base_price = 10000
 
         # kospi 상태 파악
-        type_kospi = {'day':1, 'week':1, 'month':1}
+        type_kospi = {'day': 1, 'week': 1, 'month': 1}
         if slow_k_kospi < p_slow_k_kospi:
             if slow_k_kospi < 20: type_kospi['day'] = 4
             if 20 < slow_k_kospi < 30: type_kospi['day'] = 3
@@ -185,7 +193,7 @@ class HTS_etf (HTS):
             if 20 < slow_k_month_kospi < 30: type_kospi['month'] = 3
             if 30 < slow_k_month_kospi < 40: type_kospi['month'] = 2
 
-        type_stock = {'day':1, 'week':1, 'month':1}
+        type_stock = {'day': 1, 'week': 1, 'month': 1}
         slow_k, p_slow_k, slow_k_week, p_slow_k_week, slow_k_month, p_slow_k_month = self.getSlowK(stock_code)
         if slow_k < p_slow_k:
             if slow_k < 20: type_stock['day'] = 4
@@ -207,11 +215,15 @@ class HTS_etf (HTS):
         if stock_code == "252670":  # "KODEX 200선물인버스2X"
             base_price = 100000
 
-        max_price = math.log(type_kospi['day']*type_kospi['week']*type_kospi['month']*type_stock['day']*type_stock['week']*type_stock['month'], 1.3) * base_price
+        max_price = math.log(
+            type_kospi['day'] * type_kospi['week'] * type_kospi['month'] * type_stock['day'] * type_stock['week'] *
+            type_stock['month'], 1.3) * base_price
 
         if stock_code == "122630":  # "KODEX 레버리지"
             base_price = 100000
-            max_price_tmp = math.log(type_kospi['day'] * type_kospi['week'] * type_kospi['month'] * type_stock['day'] * type_stock['week'] * type_stock['month'], 1.3) * base_price
+            max_price_tmp = math.log(
+                type_kospi['day'] * type_kospi['week'] * type_kospi['month'] * type_stock['day'] * type_stock['week'] *
+                type_stock['month'], 1.3) * base_price
             max_price = max_price_tmp - max_price
 
         buy_count = int(math.floor(max_price / bs_buy_price))
@@ -220,18 +232,21 @@ class HTS_etf (HTS):
 
     def buyRealTime(self, today, stocks, analyzed_day=1000):
 
-        print ("START...")
+        print("START...")
         THIS_TIME = datetime.now()
 
-        slow_k_kospi, p_slow_k_kospi, slow_k_week_kospi, p_slow_k_week_kospi, slow_k_month_kospi, p_slow_k_month_kospi = self.getSlowK("^KS11")
+        slow_k_kospi, p_slow_k_kospi, slow_k_week_kospi, p_slow_k_week_kospi, slow_k_month_kospi, p_slow_k_month_kospi = self.getSlowK(
+            "^KS11")
 
         LAST_DATA = {}
         for stock in stocks:
             LAST_DATA[stock['stock_code']] = self.getLastData(stock['stock_code'], today)
 
-        while datetime.strptime(today + " 070000", '%Y%m%d %H%M%S') < THIS_TIME < datetime.strptime(today + " 153100", '%Y%m%d %H%M%S'):
+        while datetime.strptime(today + " 070000", '%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 + " 151500", '%Y%m%d %H%M%S'):
+            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()
@@ -240,7 +255,7 @@ class HTS_etf (HTS):
 
                     time.sleep(0.1)
 
-                    print("%5d: %8s, %-50s"%(idx, stock['stock_code'], stock['stock_name']))
+                    print("%5d: %8s, %-50s" % (idx, stock['stock_code'], stock['stock_name']))
 
                     try:
                         # 데이터를 가지고 온다.
@@ -282,35 +297,44 @@ class HTS_etf (HTS):
                     if bs_buy_price > 1000:
 
                         if not self.orderChecker.exist(today, "A" + stock['stock_code'], hours=9):
-                            buy_count = self.getBuyCount(stock['stock_code'], bs_buy_price, slow_k_kospi, p_slow_k_kospi, slow_k_week_kospi, p_slow_k_week_kospi, slow_k_month_kospi, p_slow_k_month_kospi)
+                            buy_count = self.getBuyCount(stock['stock_code'], bs_buy_price, slow_k_kospi,
+                                                         p_slow_k_kospi, slow_k_week_kospi, p_slow_k_week_kospi,
+                                                         slow_k_month_kospi, p_slow_k_month_kospi)
 
                             if buy_count > 0:
-
                                 # 매수를 주문한다.
-                                orderNum = self.requestOrder(OrderType.buy, stock['stock_code'], buy_count , bs_buy_price)
+                                orderNum = self.requestOrder(OrderType.buy, stock['stock_code'], buy_count,
-                                self.orderChecker.buy(today, "A" + stock['stock_code'], buy_count, bs_buy_price, orderNum)
+                                                             bs_buy_price)
+                                self.orderChecker.buy(today, "A" + stock['stock_code'], buy_count, bs_buy_price,
+                                                      orderNum)
 
                                 # slackbot에 메시지를 보냄
-                                self.slackBot.post_to_slack(stock['stock_code'], stock['stock_name'], "BUY", bsLine['buy'][len(bsLine['buy']) - 1], buy_count)
+                                self.slackBot.post_to_slack(stock['stock_code'], stock['stock_name'], "BUY",
+                                                            bsLine['buy'][len(bsLine['buy']) - 1], buy_count)
 
                                 # 로그 출력
-                                print("BUY", THIS_TIME.strftime('%Y%m%d %H%M%S'), orderNum, stock['stock_code'], stock['stock_name'], bs_buy_price, buy_count)
+                                print("BUY", THIS_TIME.strftime('%Y%m%d %H%M%S'), orderNum, stock['stock_code'],
+                                      stock['stock_name'], bs_buy_price, buy_count)
 
                     if bs_sell_price > 1000:
                         check = self.sellStocks(stock['stock_code'], bs_sell_price)
 
                         if check:
                             # slackbot에 메시지를 보냄
-                            self.slackBot.post_to_slack(stock['stock_code'], stock['stock_name'], "SELL", bs_sell_price, 'ALL')
+                            self.slackBot.post_to_slack(stock['stock_code'], stock['stock_name'], "SELL", bs_sell_price,
+                                                        'ALL')
 
                             # 로그 출력
-                            print("SELL", THIS_TIME.strftime('%Y%m%d %H%M%S'), stock['stock_code'], stock['stock_name'], bs_sell_price)
+                            print("SELL", THIS_TIME.strftime('%Y%m%d %H%M%S'), stock['stock_code'], stock['stock_name'],
-
+                                  bs_sell_price)
 
                     # 로그 출력
-                    print("TIMECHECK: %s, code: %s, name: %s, buy: %d, sell: %d, avg5: %.2f, avg30: %.2f, open: %d, high: %d, low: %d, slow_k: %.2f, slow_k_5: %.2f, slow_k_30: %.2f" %
+                    print(
-                          (str(THIS_TIME), stock['stock_code'], stock['stock_name'], bs_buy_price, bs_sell_price, data["avg5"][0], data["avg30"][0],
+                        "TIMECHECK: %s, code: %s, name: %s, buy: %d, sell: %d, avg5: %.2f, avg30: %.2f, open: %d, high: %d, low: %d, slow_k: %.2f, slow_k_5: %.2f, slow_k_30: %.2f" %
-                           data["open"][0], data["high"][0], data["low"][0], data["slow_k"][0], data_5["slow_k"][0], data_30["slow_k"][0]))
+                        (str(THIS_TIME), stock['stock_code'], stock['stock_name'], bs_buy_price, bs_sell_price,
+                         data["avg5"][0], data["avg30"][0],
+                         data["open"][0], data["high"][0], data["low"][0], data["slow_k"][0], data_5["slow_k"][0],
+                         data_30["slow_k"][0]))
 
                 """
                 elif datetime.strptime(today + " 151530", '%Y%m%d %H%M%S') < THIS_TIME < datetime.strptime(today + " 151600", '%Y%m%d %H%M%S'):
@@ -350,7 +374,6 @@ class HTS_etf (HTS):
 
 
 if __name__ == "__main__":
-
     today = datetime.today()
 
     PROJECT_HOME = os.getcwd()
@@ -418,4 +441,4 @@ if __name__ == "__main__":
 
     hts.disconnectStockDB()
     hts.disconnect()
-    print ("done...")
+    print("done...")

HTS_etf_long.py

@@ -0,0 +1,393 @@
+import time
+import os
+import math
+import sqlite3
+from datetime import datetime, timedelta
+
+from hts.HTS import HTS
+from hts.OrderType import OrderType
+
+from hts.BuySellChecker import BuySellChecker
+from hts.OrderChecker import OrderChecker
+from stock.util.LabelChecker import LabelChecker
+from stock.util.SlackBot import SlackBot
+from stock.analysis.StockStatus import StockStatus
+
+class HTS_etf (HTS):
+
+    RESOURCE_PATH = None
+    stock_code = None
+    buy_count = None
+    orderChecker = None
+    buySellChecker = None
+    labelChecker = None
+    slackBot = None
+    stockStatus = None
+
+    def __init__(self, RESOURCE_PATH):
+        super().__init__(RESOURCE_PATH)
+
+        self.RESOURCE_PATH = RESOURCE_PATH
+
+        self.orderChecker = OrderChecker(self.RESOURCE_PATH, "ETF")
+        self.buySellChecker = BuySellChecker()
+        self.labelChecker = LabelChecker(RESOURCE_PATH)
+        self.slackBot = SlackBot()
+        self.stockStatus = StockStatus(RESOURCE_PATH)
+
+        return
+
+    def connect2StockDB(self):
+
+        self.conn_stock = sqlite3.connect(os.path.join(self.RESOURCE_PATH, "stock.db"))
+        self.cursor_stock = self.conn_stock.cursor()
+
+        return
+
+    def disconnectStockDB(self):
+
+        self.cursor_stock.close()
+        self.conn_stock.close()
+        return
+
+    def sellStocks(self, stock_code=None, bs_sell_price=None):
+        check = False
+        jangoDic = self.requstJango()
+        if jangoDic and len(jangoDic.keys()) > 0:
+            for code in jangoDic:
+                if stock_code is not None:
+                    if code == "A"+stock_code and bs_sell_price is not None:
+                        if jangoDic[code]['매도가능'] > 0:
+                            if 2 < jangoDic[code]['평가손익']:
+                                self.requestOrder(OrderType.sell, code[1:], jangoDic[code]['매도가능'], bs_sell_price)
+                                self.slackBot.post_to_slack(code, jangoDic[code]['종목명'], "SELL", bs_sell_price, jangoDic[code]['매도가능'])
+                                check = True
+                    else:
+                        continue
+                else:
+                    if jangoDic[code]['매도가능'] > 0:
+                        if 3 < jangoDic[code]['평가손익']:
+                            # 3% 이상 시 수익 매도
+                            currentStock = self.currentStock(code[1:])
+                            self.requestOrder(OrderType.sell, code[1:], jangoDic[code]['매도가능'], currentStock['close'])
+                            self.slackBot.post_to_slack(code, jangoDic[code]['종목명'], "SELL", currentStock['close'], jangoDic[code]['매도가능'])
+                            check = True
+        return check
+
+
+    def getSellingPrice(self, log_time, stock_code, final_price, without_loss=False):
+        # final_price와 diff를 받으면, 해당 가격으로 그냥 매도한다는 의미
+        # final_price와 diff가 None이면 장부가와 final 중 max로 팔겠다는 의미
+        # final_price가 0이고 diff가 None이면 장부가로 팔겠다는 의미임
+        orderNum = None
+        jangoDic = self.requstJango()
+        if jangoDic and len(jangoDic.keys()) > 0:
+            for code in jangoDic:
+                if jangoDic[code]['매도가능'] > 0:
+                    if without_loss:
+                        if jangoDic[code]['장부가']*0.07 < jangoDic[code]['장부가'] - final_price:
+                            sell_price = jangoDic[code]['장부가']
+                            if code == "A" + stock_code:
+                                orderNum = self.requestOrder(OrderType.sell, stock_code, jangoDic[code]['매도가능'], sell_price)
+                                return orderNum, log_time.strftime('%Y%m%d %H%M%S'), jangoDic[code]['매도가능'], sell_price
+                    else:
+                        max_price = max(jangoDic[code]['장부가'], final_price)
+                        sell_price = (int(max_price) - int(max_price) % 5) + 5
+                        if code == "A"+stock_code:
+                            orderNum = self.requestOrder(OrderType.sell, stock_code, jangoDic[code]['매도가능'], sell_price)
+                            return orderNum, log_time.strftime('%Y%m%d %H%M%S'), jangoDic[code]['매도가능'], sell_price
+        return orderNum, None, None, None
+
+
+    def makeTickData(self, data, mins=30):
+        result = {"check": set(),
+                  "time": [],
+                  "open": [],
+                  "close": [],
+                  "high": [],
+                  "low": [],
+                  "vol": [],
+                  "label": []}
+
+        for i in range(mins, len(data['time'])+1):
+            result["check"].add(data['time'][i-1])
+            result["time"].append(data['time'][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["vol"].append(sum(data['vol'][i - mins: i]))
+
+        return result
+
+    def getStockType(self, stock_code, short=False):
+        slow_k, p_slow_k, slow_k_week, p_slow_k_week, slow_k_month, p_slow_k_month = -1, -1, -1, -1, -1, -1
+
+        self.cursor_stock.execute('select stochastic_slow_k, max(ymd) from stock_analysis where code=? group by 1 order by ymd desc',(stock_code,))
+        items = self.cursor_stock.fetchall()
+        if items is not None and len(items) > 1:
+            for i, item in enumerate(items):
+                if i == 0:
+                    slow_k = item[0]
+                elif i == 1:
+                    p_slow_k = item[0]
+                else:
+                    break
+
+        self.cursor_stock.execute('select stochastic_slow_k, max(ymd) from stock_analysis_weekly where code=? group by 1 order by ymd desc', (stock_code, ))
+        items = self.cursor_stock.fetchall()
+        if items is not None and len(items) > 1:
+            for i, item in enumerate(items):
+                if i == 0:
+                    slow_k_week = item[0]
+                elif i == 1:
+                    p_slow_k_week = item[0]
+                else:
+                    break
+
+        self.cursor_stock.execute('select stochastic_slow_k, max(ymd) from stock_analysis_monthly where code=? group by 1 order by ymd desc',(stock_code,))
+        items = self.cursor_stock.fetchall()
+        if items is not None and len(items) > 1:
+            for i, item in enumerate(items):
+                if i == 0:
+                    slow_k_month = item[0]
+                elif i == 1:
+                    p_slow_k_month = item[0]
+                else:
+                    break
+
+        if slow_k is None or p_slow_k is None:
+            slow_k , p_slow_k = -1, -1
+        if slow_k_week is None or p_slow_k_week is None:
+            slow_k_week, p_slow_k_week = -1, -1
+        if slow_k_month is None or p_slow_k_month is None:
+            slow_k_month, p_slow_k_month = -1, -1
+
+
+        type_stock = {'day':1, 'week':10, 'month':100}
+        if slow_k > p_slow_k:
+            if slow_k < 10: type_stock['day'] = 10
+            if 10 < slow_k < 20: type_stock['day'] = 7.5
+            if 20 < slow_k < 30: type_stock['day'] = 5
+            if 30 < slow_k < 40: type_stock['day'] = 2.5
+        if slow_k_week > p_slow_k_week:
+            if slow_k_week < 10: type_stock['week'] = 100
+            if 10 < slow_k_week < 20: type_stock['week'] = 75
+            if 20 < slow_k_week < 30: type_stock['week'] = 50
+            if 30 < slow_k_week < 40: type_stock['week'] = 25
+        if slow_k_month > p_slow_k_month:
+            if slow_k_month < 10: type_stock['month'] = 1000
+            if 10 < slow_k_month < 20: type_stock['month'] = 750
+            if 20 < slow_k_month < 30: type_stock['month'] = 500
+            if 30 < slow_k_month < 40: type_stock['month'] = 250
+
+        return type_stock
+
+    def getBuyCount(self, bs_buy_price, kospi_type, stock_type):
+
+        base_price = 10000
+        log_base = 1.2
+        p_k_m, p_k_w, p_k_d, p_s_m, p_s_w, p_s_d = 0.3, 0.2, 0.05, 0.25, 0.18, 0.02
+        weight_1, weight_2, weight_3, weight_4, weight_5 = 0.5, 0.3, 0.14, 0.05, 0.01
+        kospi_weight = weight_5
+        if kospi_type['day'] == 10: kospi_weight = weight_1
+        if kospi_type['day'] == 7.5: kospi_weight = weight_2
+        if kospi_type['day'] == 5: kospi_weight = weight_3
+        if kospi_type['day'] == 2.5: kospi_weight = weight_4
+        stock_weight = weight_5
+        if stock_type['day'] == 10: stock_weight = weight_1
+        if stock_type['day'] == 7.5: stock_weight = weight_2
+        if stock_type['day'] == 5: stock_weight = weight_3
+        if stock_type['day'] == 2.5: stock_weight = weight_4
+
+        max_price =  math.log(
+            kospi_weight * p_k_m * kospi_type['month'] +
+            kospi_weight * p_k_w * kospi_type['week'] +
+            kospi_weight * p_k_d * kospi_type['day'] +
+            stock_weight * p_s_m * stock_type['month'] +
+            stock_weight * p_s_w * stock_type['week'] +
+            stock_weight * p_s_d * stock_type['day'], log_base) * base_price
+
+        buy_count = 0
+        if max_price > 1:
+            buy_count = int(math.floor(max_price / bs_buy_price))
+
+        return buy_count
+
+    def buyRealTime(self, today, stocks, analyzed_day=1000):
+
+        print ("START...")
+        THIS_TIME = datetime.now()
+        kospi_type = self.getStockType("^KS11", short=False)
+
+        LAST_DATA = {}
+        for stock in stocks:
+            LAST_DATA[stock['stock_code']] = self.getLastData(stock['stock_code'], today)
+
+        while datetime.strptime(today + " 070000", '%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 + " 151500", '%Y%m%d %H%M%S'):
+
+                # 매도를 체크한다.
+                # self.sellStocks()
+
+                for idx, stock in enumerate(stocks):
+
+                    time.sleep(0.1)
+
+                    print("%5d: %8s, %-50s"%(idx, stock['stock_code'], stock['stock_name']))
+
+                    try:
+                        # 데이터를 가지고 온다.
+                        result = self.getRealTime(stock['stock_code'], today, LAST_DATA[stock['stock_code']])
+                    except:
+                        print("#ERROR:", stock['stock_code'], stock['stock_name'])
+                        continue
+
+                    result_5 = self.makeTickData(result, mins=5)
+                    result_30 = self.makeTickData(result, mins=30)
+                    if len(result_30['time']) < 100:
+                        continue
+
+                    data = self.buySellChecker.analyze(result)
+                    data.drop(data.index[:len(data) - analyzed_day], inplace=True)
+
+                    # 현재 매수가
+                    bs_buy_price = data["close"][len(data["close"]) - 1]
+
+                    # 미체결 기록을 가져와서 10분 이상 된 매수 주문을 취소 한다.
+                    ORDER_LIST = self.requestOrderList()
+                    orderListToCancel = self.orderChecker.cancel(today, "A" + stock['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" + stock['stock_code'], hours=9):
+                            stock_type = self.getStockType(stock['stock_code'], short=False)
+                            buy_count = self.getBuyCount(bs_buy_price, kospi_type, stock_type)
+
+                            if buy_count > 0:
+
+                                # 매수를 주문한다.
+                                orderNum = self.requestOrder(OrderType.buy, stock['stock_code'], buy_count , bs_buy_price)
+                                self.orderChecker.buy(today, "A" + stock['stock_code'], buy_count, bs_buy_price, orderNum)
+
+                                # slackbot에 메시지를 보냄
+                                self.slackBot.post_to_slack(stock['stock_code'], stock['stock_name'], "BUY", bsLine['buy'][len(bsLine['buy']) - 1], buy_count)
+
+                                # 로그 출력
+                                print("BUY", THIS_TIME.strftime('%Y%m%d %H%M%S'), orderNum, stock['stock_code'], stock['stock_name'], bs_buy_price, buy_count)
+
+                    # 로그 출력
+                    print("TIMECHECK: %s, code: %s, name: %s, buy: %d, sell: %d, avg5: %.2f, avg30: %.2f, open: %d, high: %d, low: %d, slow_k: %.2f, slow_k_5: %.2f, slow_k_30: %.2f" %
+                          (str(THIS_TIME), stock['stock_code'], stock['stock_name'], bs_buy_price, bs_sell_price, data["avg5"][0], data["avg30"][0],
+                           data["open"][0], data["high"][0], data["low"][0], data["slow_k"][0], data_5["slow_k"][0], data_30["slow_k"][0]))
+
+                """
+                elif datetime.strptime(today + " 151530", '%Y%m%d %H%M%S') < THIS_TIME < datetime.strptime(today + " 151600", '%Y%m%d %H%M%S'):
+                    # 3시 15분 30초부터 3시 16분 사이는 잔량을 매도한다.
+    
+                    if not final_sell_check:
+                        ####
+                        # 손해 보지 않는 가격에 매도한다.
+                        ####
+    
+                        for stock in stocks:
+                            # 주문 리스트를 가져온다.
+                            orderList = self.requestOrderList()
+                            # 15:10:00 이후라면 모든 미체결 취소한다.
+                            self.cancelOrderList(orderList)
+    
+                            # 매도 가격을 가져온다.
+                            result = self.getRealTime(stock['stock_code'], today, LAST_DATA[stock['stock_code']])
+                            final_price = result["close"][len(result["close"]) - 1]
+    
+                            orderNum, sell_time, jango, sell_price = self.getSellingPrice(THIS_TIME, stock['stock_code'], final_price, without_loss=True)
+                            # 로그 출력
+                            print("SELL", sell_time, stock['stock_code'], stock['stock_name'], final_price, str(orderNum), jango, sell_price)
+    
+                            final_sell_check = True
+                """
+
+            time.sleep(3600)
+            THIS_TIME = datetime.now()
+
+        return True
+
+    def updteTodayStock(self, stock_code, today_str):
+        bsLine, data = self.labelChecker.makeCandidate(stock_code, today_str)
+        self.labelChecker.updateLabel(stock_code, bsLine, data, today_str)
+        return
+
+
+if __name__ == "__main__":
+
+    today = datetime.today()
+
+    PROJECT_HOME = os.getcwd()
+    RESOURCE_PATH = os.path.join(PROJECT_HOME, "resources")
+
+    # KODEX 인버스 * 2
+    stocks = [
+        {"stock_code": "122630", "stock_name": "KODEX 레버리지"},
+        {"stock_code": "305720", "stock_name": "KODEX 2차전지산업"},
+        {"stock_code": "102780", "stock_name": "KODEX 삼성그룹"},
+        {"stock_code": "139260", "stock_name": "TIGER 200 IT"},
+        {"stock_code": "091180", "stock_name": "KODEX 자동차"},
+        {"stock_code": "401470", "stock_name": "KODEX K-메타버스액티브"},
+        {"stock_code": "329200", "stock_name": "TIGER 리츠부동산인프라"},
+        {"stock_code": "091170", "stock_name": "KODEX 은행"},
+        {"stock_code": "091160", "stock_name": "KODEX 반도체"},
+        {"stock_code": "161510", "stock_name": "ARIRANG 고배당주"},
+        {"stock_code": "228800", "stock_name": "TIGER 여행레저"},
+        {"stock_code": "150460", "stock_name": "TIGER 중국소비테마"},
+        {"stock_code": "143860", "stock_name": "TIGER 헬스케어"},
+        {"stock_code": "228810", "stock_name": "TIGER 미디어컨텐츠"},
+        {"stock_code": "139220", "stock_name": "TIGER 200 건설"},
+        {"stock_code": "139280", "stock_name": "TIGER 경기방어"},
+        {"stock_code": "322400", "stock_name": "HANARO e커머스"},
+        {"stock_code": "157490", "stock_name": "TIGER 소프트웨어"},
+        {"stock_code": "228790", "stock_name": "TIGER 화장품"},
+        {"stock_code": "139230", "stock_name": "TIGER 200 중공업"},
+        {"stock_code": "396500", "stock_name": "TIGER Fn반도체TOP10"},
+        {"stock_code": "365000", "stock_name": "TIGER KRX인터넷K-뉴딜"},
+        {"stock_code": "102970", "stock_name": "KODEX 증권"},
+        {"stock_code": "117680", "stock_name": "KODEX 철강"},
+        {"stock_code": "244580", "stock_name": "KODEX 바이오"},
+        {"stock_code": "266360", "stock_name": "KODEX 미디어&엔터테인먼트"},
+        {"stock_code": "375770", "stock_name": "KODEX 탄소효율그린뉴딜"},
+        {"stock_code": "364990", "stock_name": "TIGER KRX게임K-뉴딜"},
+        {"stock_code": "388420", "stock_name": "KBSTAR 비메모리반도체액티브"},
+        {"stock_code": "117460", "stock_name": "KODEX 에너지화학"},
+        {"stock_code": "300950", "stock_name": "KODEX 게임산업"},
+        {"stock_code": "266410", "stock_name": "KODEX 필수소비재"},
+        {"stock_code": "140700", "stock_name": "KODEX 보험"},
+        {"stock_code": "139270", "stock_name": "TIGER 200 금융"},
+        {"stock_code": "395160", "stock_name": "KODEX Fn시스템반도체"},
+        {"stock_code": "140710", "stock_name": "KODEX 운송"},
+        {"stock_code": "139240", "stock_name": "TIGER 200 철강소재"},
+        {"stock_code": "395150", "stock_name": "KODEX Fn웹툰&드라마"},
+        {"stock_code": "307510", "stock_name": "TIGER 의료기기"},
+        {"stock_code": "315270", "stock_name": "TIGER 200커뮤니케이션서비스"},
+        {"stock_code": "132030", "stock_name": "KODEX 골드선물(H)"},
+        {"stock_code": "144600", "stock_name": "KODEX 은선물(H)"},
+        {"stock_code": "261220", "stock_name": "KODEX WTI원유선물(H)"},
+        {"stock_code": "271050", "stock_name": "KODEX WTI원유선물인버스(H)"},
+        {"stock_code": "138910", "stock_name": "KODEX 구리선물(H)"}
+    ]
+
+    hts = HTS_etf(RESOURCE_PATH)
+    hts.connect2DB("hts.db")
+    hts.connect2StockDB()
+
+    today_str = today.strftime('%Y%m%d')
+    hts.buyRealTime(today_str, stocks, analyzed_day=1000)
+
+    db_filename = os.path.join(RESOURCE_PATH, "hts.db")
+    hts.insertStockData(stocks, today)
+
+    hts.disconnectStockDB()
+    hts.disconnect()
+    print ("done...")

HTS_etf_short.py

@@ -0,0 +1,365 @@
+import time
+import os
+import math
+import sqlite3
+from datetime import datetime, timedelta
+
+from hts.HTS import HTS
+from hts.OrderType import OrderType
+
+from hts.BuySellChecker import BuySellChecker
+from hts.OrderChecker import OrderChecker
+from stock.util.LabelChecker import LabelChecker
+from stock.util.SlackBot import SlackBot
+from stock.analysis.StockStatus import StockStatus
+
+class HTS_etf (HTS):
+
+    RESOURCE_PATH = None
+    stock_code = None
+    buy_count = None
+    orderChecker = None
+    buySellChecker = None
+    labelChecker = None
+    slackBot = None
+    stockStatus = None
+
+    def __init__(self, RESOURCE_PATH):
+        super().__init__(RESOURCE_PATH)
+
+        self.RESOURCE_PATH = RESOURCE_PATH
+
+        self.orderChecker = OrderChecker(self.RESOURCE_PATH, "ETF")
+        self.buySellChecker = BuySellChecker()
+        self.labelChecker = LabelChecker(RESOURCE_PATH)
+        self.slackBot = SlackBot()
+        self.stockStatus = StockStatus(RESOURCE_PATH)
+
+        return
+
+    def connect2StockDB(self):
+
+        self.conn_stock = sqlite3.connect(os.path.join(self.RESOURCE_PATH, "stock.db"))
+        self.cursor_stock = self.conn_stock.cursor()
+
+        return
+
+    def disconnectStockDB(self):
+
+        self.cursor_stock.close()
+        self.conn_stock.close()
+        return
+
+    def sellStocks(self, stock_code=None, bs_sell_price=None):
+        check = False
+        jangoDic = self.requstJango()
+        if jangoDic and len(jangoDic.keys()) > 0:
+            for code in jangoDic:
+                if stock_code is not None:
+                    if code == "A"+stock_code and bs_sell_price is not None:
+                        if jangoDic[code]['매도가능'] > 0:
+                            if 2 < jangoDic[code]['평가손익']:
+                                self.requestOrder(OrderType.sell, code[1:], jangoDic[code]['매도가능'], bs_sell_price)
+                                self.slackBot.post_to_slack(code, jangoDic[code]['종목명'], "SELL", bs_sell_price, jangoDic[code]['매도가능'])
+                                check = True
+                    else:
+                        continue
+                else:
+                    if jangoDic[code]['매도가능'] > 0:
+                        if 3 < jangoDic[code]['평가손익']:
+                            # 3% 이상 시 수익 매도
+                            currentStock = self.currentStock(code[1:])
+                            self.requestOrder(OrderType.sell, code[1:], jangoDic[code]['매도가능'], currentStock['close'])
+                            self.slackBot.post_to_slack(code, jangoDic[code]['종목명'], "SELL", currentStock['close'], jangoDic[code]['매도가능'])
+                            check = True
+        return check
+
+
+    def getSellingPrice(self, log_time, stock_code, final_price, without_loss=False):
+        # final_price와 diff를 받으면, 해당 가격으로 그냥 매도한다는 의미
+        # final_price와 diff가 None이면 장부가와 final 중 max로 팔겠다는 의미
+        # final_price가 0이고 diff가 None이면 장부가로 팔겠다는 의미임
+        orderNum = None
+        jangoDic = self.requstJango()
+        if jangoDic and len(jangoDic.keys()) > 0:
+            for code in jangoDic:
+                if jangoDic[code]['매도가능'] > 0:
+                    if without_loss:
+                        if jangoDic[code]['장부가']*0.07 < jangoDic[code]['장부가'] - final_price:
+                            sell_price = jangoDic[code]['장부가']
+                            if code == "A" + stock_code:
+                                orderNum = self.requestOrder(OrderType.sell, stock_code, jangoDic[code]['매도가능'], sell_price)
+                                return orderNum, log_time.strftime('%Y%m%d %H%M%S'), jangoDic[code]['매도가능'], sell_price
+                    else:
+                        max_price = max(jangoDic[code]['장부가'], final_price)
+                        sell_price = (int(max_price) - int(max_price) % 5) + 5
+                        if code == "A"+stock_code:
+                            orderNum = self.requestOrder(OrderType.sell, stock_code, jangoDic[code]['매도가능'], sell_price)
+                            return orderNum, log_time.strftime('%Y%m%d %H%M%S'), jangoDic[code]['매도가능'], sell_price
+        return orderNum, None, None, None
+
+
+    def makeTickData(self, data, mins=30):
+        result = {"check": set(),
+                  "time": [],
+                  "open": [],
+                  "close": [],
+                  "high": [],
+                  "low": [],
+                  "vol": [],
+                  "label": []}
+
+        for i in range(mins, len(data['time'])+1):
+            result["check"].add(data['time'][i-1])
+            result["time"].append(data['time'][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["vol"].append(sum(data['vol'][i - mins: i]))
+
+        return result
+
+    def getStockType(self, stock_code, short=False):
+        slow_k, p_slow_k, slow_k_week, p_slow_k_week, slow_k_month, p_slow_k_month = -1, -1, -1, -1, -1, -1
+
+        self.cursor_stock.execute('select stochastic_slow_k, max(ymd) from stock_analysis where code=? group by 1 order by ymd desc',(stock_code,))
+        items = self.cursor_stock.fetchall()
+        if items is not None and len(items) > 1:
+            for i, item in enumerate(items):
+                if i == 0:
+                    slow_k = item[0]
+                elif i == 1:
+                    p_slow_k = item[0]
+                else:
+                    break
+
+        self.cursor_stock.execute('select stochastic_slow_k, max(ymd) from stock_analysis_weekly where code=? group by 1 order by ymd desc', (stock_code, ))
+        items = self.cursor_stock.fetchall()
+        if items is not None and len(items) > 1:
+            for i, item in enumerate(items):
+                if i == 0:
+                    slow_k_week = item[0]
+                elif i == 1:
+                    p_slow_k_week = item[0]
+                else:
+                    break
+
+        self.cursor_stock.execute('select stochastic_slow_k, max(ymd) from stock_analysis_monthly where code=? group by 1 order by ymd desc',(stock_code,))
+        items = self.cursor_stock.fetchall()
+        if items is not None and len(items) > 1:
+            for i, item in enumerate(items):
+                if i == 0:
+                    slow_k_month = item[0]
+                elif i == 1:
+                    p_slow_k_month = item[0]
+                else:
+                    break
+
+        if slow_k is None or p_slow_k is None:
+            slow_k , p_slow_k = -1, -1
+        if slow_k_week is None or p_slow_k_week is None:
+            slow_k_week, p_slow_k_week = -1, -1
+        if slow_k_month is None or p_slow_k_month is None:
+            slow_k_month, p_slow_k_month = -1, -1
+
+
+        type_stock = {'day':1, 'week':10, 'month':100}
+        if short:
+            if slow_k > p_slow_k:
+                if slow_k < 10: type_stock['day'] = 10
+                if 10 < slow_k < 20: type_stock['day'] = 7.5
+                if 20 < slow_k < 30: type_stock['day'] = 5
+                if 30 < slow_k < 40: type_stock['day'] = 2.5
+            if slow_k_week > p_slow_k_week:
+                if slow_k_week < 10: type_stock['week'] = 100
+                if 10 < slow_k_week < 20: type_stock['week'] = 75
+                if 20 < slow_k_week < 30: type_stock['week'] = 50
+                if 30 < slow_k_week < 40: type_stock['week'] = 25
+            if slow_k_month > p_slow_k_month:
+                if slow_k_month < 10: type_stock['month'] = 1000
+                if 10 < slow_k_month < 20: type_stock['month'] = 750
+                if 20 < slow_k_month < 30: type_stock['month'] = 500
+                if 30 < slow_k_month < 40: type_stock['month'] = 250
+        else:
+            if slow_k < p_slow_k:
+                if slow_k > 90: type_stock['day'] = 10
+                if 80 < slow_k < 90: type_stock['day'] = 7.5
+                if 70 < slow_k < 80: type_stock['day'] = 5
+                if 60 < slow_k < 70: type_stock['day'] = 2.5
+            if slow_k_week > p_slow_k_week:
+                if slow_k_week > 90: type_stock['week'] = 100
+                if 80 < slow_k_week < 90: type_stock['week'] = 75
+                if 70 < slow_k_week < 80: type_stock['week'] = 50
+                if 60 < slow_k_week < 70: type_stock['week'] = 25
+            if slow_k_month > p_slow_k_month:
+                if slow_k_month > 90: type_stock['month'] = 1000
+                if 80 < slow_k_month < 90: type_stock['month'] = 750
+                if 70 < slow_k_month < 80: type_stock['month'] = 500
+                if 60 < slow_k_month < 70: type_stock['month'] = 250
+        return type_stock
+
+    def getBuyCount(self, bs_buy_price, kospi_type, stock_type):
+
+        base_price = 10000
+        log_base = 1.2
+        p_k_m, p_k_w, p_k_d, p_s_m, p_s_w, p_s_d = 0.3, 0.2, 0.05, 0.25, 0.18, 0.02
+        weight_1, weight_2, weight_3, weight_4, weight_5 = 0.5, 0.3, 0.14, 0.05, 0.01
+        kospi_weight = weight_5
+        if kospi_type['day'] == 10: kospi_weight = weight_1
+        if kospi_type['day'] == 7.5: kospi_weight = weight_2
+        if kospi_type['day'] == 5: kospi_weight = weight_3
+        if kospi_type['day'] == 2.5: kospi_weight = weight_4
+        stock_weight = weight_5
+        if stock_type['day'] == 10: stock_weight = weight_1
+        if stock_type['day'] == 7.5: stock_weight = weight_2
+        if stock_type['day'] == 5: stock_weight = weight_3
+        if stock_type['day'] == 2.5: stock_weight = weight_4
+
+        max_price =  math.log(
+            kospi_weight * p_k_m * kospi_type['month'] +
+            kospi_weight * p_k_w * kospi_type['week'] +
+            kospi_weight * p_k_d * kospi_type['day'] +
+            stock_weight * p_s_m * stock_type['month'] +
+            stock_weight * p_s_w * stock_type['week'] +
+            stock_weight * p_s_d * stock_type['day'], log_base) * base_price
+
+        buy_count = 0
+        if max_price > 1:
+            buy_count = int(math.floor(max_price / bs_buy_price))
+
+        return buy_count
+
+    def buyRealTime(self, today, stocks, analyzed_day=1000):
+
+        print ("START...")
+        THIS_TIME = datetime.now()
+        kospi_type = self.getStockType("^KS11", short=False)
+
+        LAST_DATA = {}
+        for stock in stocks:
+            LAST_DATA[stock['stock_code']] = self.getLastData(stock['stock_code'], today)
+
+        while datetime.strptime(today + " 070000", '%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 + " 151500", '%Y%m%d %H%M%S'):
+
+                # 매도를 체크한다.
+                # self.sellStocks()
+
+                for idx, stock in enumerate(stocks):
+
+                    time.sleep(0.1)
+
+                    print("%5d: %8s, %-50s"%(idx, stock['stock_code'], stock['stock_name']))
+
+                    try:
+                        # 데이터를 가지고 온다.
+                        result = self.getRealTime(stock['stock_code'], today, LAST_DATA[stock['stock_code']])
+                    except:
+                        print("#ERROR:", stock['stock_code'], stock['stock_name'])
+                        continue
+
+                    result_5 = self.makeTickData(result, mins=5)
+                    result_30 = self.makeTickData(result, mins=30)
+                    if len(result_30['time']) < 100:
+                        continue
+
+                    data = self.buySellChecker.analyze(result)
+                    data.drop(data.index[:len(data) - analyzed_day], inplace=True)
+
+                    # 현재 매수가
+                    bs_buy_price = data["close"][len(data["close"]) - 1]
+
+                    # 미체결 기록을 가져와서 10분 이상 된 매수 주문을 취소 한다.
+                    ORDER_LIST = self.requestOrderList()
+                    orderListToCancel = self.orderChecker.cancel(today, "A" + stock['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" + stock['stock_code'], hours=9):
+                            stock_type = self.getStockType(stock['stock_code'], short=True)
+                            buy_count = self.getBuyCount(bs_buy_price, kospi_type, stock_type)
+
+                            if buy_count > 0:
+
+                                # 매수를 주문한다.
+                                orderNum = self.requestOrder(OrderType.buy, stock['stock_code'], buy_count , bs_buy_price)
+                                self.orderChecker.buy(today, "A" + stock['stock_code'], buy_count, bs_buy_price, orderNum)
+
+                                # slackbot에 메시지를 보냄
+                                self.slackBot.post_to_slack(stock['stock_code'], stock['stock_name'], "BUY", bsLine['buy'][len(bsLine['buy']) - 1], buy_count)
+
+                                # 로그 출력
+                                print("BUY", THIS_TIME.strftime('%Y%m%d %H%M%S'), orderNum, stock['stock_code'], stock['stock_name'], bs_buy_price, buy_count)
+
+                    # 로그 출력
+                    print("TIMECHECK: %s, code: %s, name: %s, buy: %d, sell: %d, avg5: %.2f, avg30: %.2f, open: %d, high: %d, low: %d, slow_k: %.2f, slow_k_5: %.2f, slow_k_30: %.2f" %
+                          (str(THIS_TIME), stock['stock_code'], stock['stock_name'], bs_buy_price, bs_sell_price, data["avg5"][0], data["avg30"][0],
+                           data["open"][0], data["high"][0], data["low"][0], data["slow_k"][0], data_5["slow_k"][0], data_30["slow_k"][0]))
+
+                """
+                elif datetime.strptime(today + " 151530", '%Y%m%d %H%M%S') < THIS_TIME < datetime.strptime(today + " 151600", '%Y%m%d %H%M%S'):
+                    # 3시 15분 30초부터 3시 16분 사이는 잔량을 매도한다.
+    
+                    if not final_sell_check:
+                        ####
+                        # 손해 보지 않는 가격에 매도한다.
+                        ####
+    
+                        for stock in stocks:
+                            # 주문 리스트를 가져온다.
+                            orderList = self.requestOrderList()
+                            # 15:10:00 이후라면 모든 미체결 취소한다.
+                            self.cancelOrderList(orderList)
+    
+                            # 매도 가격을 가져온다.
+                            result = self.getRealTime(stock['stock_code'], today, LAST_DATA[stock['stock_code']])
+                            final_price = result["close"][len(result["close"]) - 1]
+    
+                            orderNum, sell_time, jango, sell_price = self.getSellingPrice(THIS_TIME, stock['stock_code'], final_price, without_loss=True)
+                            # 로그 출력
+                            print("SELL", sell_time, stock['stock_code'], stock['stock_name'], final_price, str(orderNum), jango, sell_price)
+    
+                            final_sell_check = True
+                """
+
+            time.sleep(3600)
+            THIS_TIME = datetime.now()
+
+        return True
+
+    def updteTodayStock(self, stock_code, today_str):
+        bsLine, data = self.labelChecker.makeCandidate(stock_code, today_str)
+        self.labelChecker.updateLabel(stock_code, bsLine, data, today_str)
+        return
+
+
+if __name__ == "__main__":
+
+    today = datetime.today()
+
+    PROJECT_HOME = os.getcwd()
+    RESOURCE_PATH = os.path.join(PROJECT_HOME, "resources")
+
+    # KODEX 인버스 * 2
+    stocks = [
+        {"stock_code": "252670", "stock_name": "KODEX 200선물인버스2X"}
+    ]
+
+    hts = HTS_etf(RESOURCE_PATH)
+    hts.connect2DB("hts.db")
+    hts.connect2StockDB()
+
+    today_str = today.strftime('%Y%m%d')
+    hts.buyRealTime(today_str, stocks, analyzed_day=1000)
+
+    db_filename = os.path.join(RESOURCE_PATH, "hts.db")
+    hts.insertStockData(stocks, today)
+
+    hts.disconnectStockDB()
+    hts.disconnect()
+    print ("done...")

resources/preprocess.py

@@ -0,0 +1,39 @@
+log_base = "$E$1"
+
+weight_1="$I$1"
+weight_2="$I$2"
+weight_3="$I$3"
+weight_4="$I$4"
+weight_5="$I$5"
+
+p_k_m = "$A$9"
+p_k_w = "$B$9"
+p_k_d = "$C$9"
+p_s_m = "$D$9"
+p_s_w = "$E$9"
+p_s_d = "$F$9"
+
+base_price_1 = "$B$2"
+base_price_2 = "$B$3"
+base_price_3 = "$B$4"
+base_price_4 = "$B$5"
+base_price_5 = "$B$6"
+
+line_no_a, line_no_b, line_no_c = 11, 11, 11
+for a in range(1, 6):
+    for b in range(1, 6):
+        for c in range(1, 6):
+            weight = weight_1
+            if c == 2: weight = weight_2
+            if c == 3: weight = weight_3
+            if c == 4: weight = weight_4
+            if c == 5: weight = weight_5
+            p1 = "=LOG("+weight+"*"+p_k_m+"*$A$"+str(line_no_a)+"+"+weight+"*"+p_k_w+"*$B$"+str(line_no_b)+"+"+weight+"*"+p_k_d+"*C"+str(line_no_c)+"+"+weight+"*"+p_s_m+"*$D$"+str(line_no_a)+"+"+weight+"*"+p_s_w+"*$E$"+str(line_no_b)+"+"+weight+"*"+p_s_d+"*F"+str(line_no_c)+", "+log_base+") * "+base_price_1
+            p2 = "=LOG("+weight+"*"+p_k_m+"*$A$"+str(line_no_a)+"+"+weight+"*"+p_k_w+"*$B$"+str(line_no_b)+"+"+weight+"*"+p_k_d+"*C"+str(line_no_c)+"+"+weight+"*"+p_s_m+"*$D$"+str(line_no_a)+"+"+weight+"*"+p_s_w+"*$E$"+str(line_no_b)+"+"+weight+"*"+p_s_d+"*F"+str(line_no_c)+", "+log_base+") * "+base_price_2
+            p3 = "=LOG("+weight+"*"+p_k_m+"*$A$"+str(line_no_a)+"+"+weight+"*"+p_k_w+"*$B$"+str(line_no_b)+"+"+weight+"*"+p_k_d+"*C"+str(line_no_c)+"+"+weight+"*"+p_s_m+"*$D$"+str(line_no_a)+"+"+weight+"*"+p_s_w+"*$E$"+str(line_no_b)+"+"+weight+"*"+p_s_d+"*F"+str(line_no_c)+", "+log_base+") * "+base_price_3
+            p4 = "=LOG("+weight+"*"+p_k_m+"*$A$"+str(line_no_a)+"+"+weight+"*"+p_k_w+"*$B$"+str(line_no_b)+"+"+weight+"*"+p_k_d+"*C"+str(line_no_c)+"+"+weight+"*"+p_s_m+"*$D$"+str(line_no_a)+"+"+weight+"*"+p_s_w+"*$E$"+str(line_no_b)+"+"+weight+"*"+p_s_d+"*F"+str(line_no_c)+", "+log_base+") * "+base_price_4
+            p5 = "=LOG("+weight+"*"+p_k_m+"*$A$"+str(line_no_a)+"+"+weight+"*"+p_k_w+"*$B$"+str(line_no_b)+"+"+weight+"*"+p_k_d+"*C"+str(line_no_c)+"+"+weight+"*"+p_s_m+"*$D$"+str(line_no_a)+"+"+weight+"*"+p_s_w+"*$E$"+str(line_no_b)+"+"+weight+"*"+p_s_d+"*F"+str(line_no_c)+", "+log_base+") * "+base_price_5
+            print (p1 + "\t" + p2 + "\t" + p3 + "\t" + p4 + "\t" + p5)
+            line_no_c += 1
+        line_no_b += 5
+    line_no_a += 25