init

HTS_etf.py

@@ -6,12 +6,16 @@ from datetime import datetime
 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.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
+
 
 class HTS_etf(HTS):
     RESOURCE_PATH = None
@@ -34,29 +38,23 @@ class HTS_etf(HTS):
         self.stock_code = stock_code
         self.stock_name = stock_name
         self.orderChecker = OrderChecker(self.RESOURCE_PATH, self.stock_code)
-        self.buySellChecker = BuySellChecker()
         self.labelChecker = LabelChecker(RESOURCE_PATH)
         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()
+
+
         return
 
-    def getTodayStateValue(self, stock_code, dbfile_name="stock.db"):
-        try:
-            conn = sqlite3.connect(os.path.join(self.RESOURCE_PATH, dbfile_name))
-            cursor = conn.cursor()
-
-            cursor.execute('SELECT stochastic_slow_k FROM stock_analysis WHERE CODE=? order by ymd desc limit 1', (stock_code,))
-            db_result = cursor.fetchone()
-            cursor.close()
-            conn.close()
-
-            if db_result is not None:
-                return db_result[0]
-        except:
-            return 100
-        return 100
-
     def sellStocks(self, stock_code=None, bs_sell_price=None):
         check = False
         jangoDic = self.requstJango()
@@ -129,55 +127,30 @@ class HTS_etf(HTS):
 
         return result
 
-    def get_MAX_PRICE(self, stock_code, stochastic_slow_k):
-        MAX_PRICE = 30000
 
-        if stock_code == "252670":
-            # "KODEX 200선물인버스2X"
-            if stochastic_slow_k < 20:
-                MAX_PRICE = 400000
-            elif 20 <= stochastic_slow_k < 40:
-                MAX_PRICE = 300000
-            elif 40 <= stochastic_slow_k < 60:
-                MAX_PRICE = 200000
-            else:
-                MAX_PRICE = 100000
-        elif stock_code == "122630":
-            # "KODEX 레버리지"
-            if stochastic_slow_k < 20:
-                MAX_PRICE = 100000
-            elif 20 <= stochastic_slow_k < 40:
-                MAX_PRICE = 70000
-            elif 40 <= stochastic_slow_k < 60:
-                MAX_PRICE = 50000
-            else:
-                MAX_PRICE = 30000
-        elif stock_code == "251340":
-            # "KODEX 코스닥150선물인버스"
-            if stochastic_slow_k < 20:
-                MAX_PRICE = 150000
-            elif 20 <= stochastic_slow_k < 40:
-                MAX_PRICE = 100000
-            elif 40 <= stochastic_slow_k < 60:
-                MAX_PRICE = 70000
-            else:
-                MAX_PRICE = 50000
-        elif stock_code == "233740":
-            # "KODEX 코스닥150레버리지"
-            if stochastic_slow_k < 20:
-                MAX_PRICE = 70000
-            elif 20 <= stochastic_slow_k < 40:
-                MAX_PRICE = 50000
-            elif 40 <= stochastic_slow_k < 60:
-                MAX_PRICE = 30000
-            else:
-                MAX_PRICE = 10000
+    def getLIMITInfo(self, stock_code, ymd, dbfile_name="stock.db"):
+        conn = sqlite3.connect(os.path.join(self.RESOURCE_PATH, dbfile_name))
+        cursor = conn.cursor()
 
-        return MAX_PRICE
+        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()
 
-    def buyRealTime(self, today, analyzed_day=1000, logFp=None):
-        stochastic_slow_k = self.getTodayStateValue(self.stock_code)
-        MAX_PRICE = self.get_MAX_PRICE(self.stock_code, stochastic_slow_k)
+        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])
+
+        return {'LOW_PRICE': sum(LIMIT_PRICE[:20]) / len(LIMIT_PRICE[:20])}
+
+
+    def buyRealTime(self, today, analyzed_day=1000, logFp=None, MAX_PRICE=30000):
+        INFO = self.getLIMITInfo(self.stock_code, today)
 
         print("START...")
         THIS_TIME = datetime.now()
@@ -207,7 +180,7 @@ class HTS_etf(HTS):
                 data.drop(data.index[:len(data) - analyzed_day], inplace=True)
 
                 # 사야 할 시점과 팔아야 할 시점을 체크한다.
-                bsLine = self.buySellChecker.checkTransaction(self.stock_code, data, None, None, isRealTime=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]