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":
+    def getLIMITInfo(self, stock_code, ymd, dbfile_name="stock.db"):
-            # "KODEX 200선물인버스2X"
+        conn = sqlite3.connect(os.path.join(self.RESOURCE_PATH, dbfile_name))
-            if stochastic_slow_k < 20:
+        cursor = conn.cursor()
-                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
 
-        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):
+        match = False
-        stochastic_slow_k = self.getTodayStateValue(self.stock_code)
+        LIMIT_PRICE = []
-        MAX_PRICE = self.get_MAX_PRICE(self.stock_code, stochastic_slow_k)
+        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]

HTS_etf_122630.py

@@ -20,7 +20,9 @@ if __name__ == "__main__":
     if not os.path.exists(os.path.join(RESOURCE_PATH, "log")):
         os.mkdir(os.path.join(RESOURCE_PATH, "log"))
     logFp = open(os.path.join(RESOURCE_PATH, "log", today_str + "_" + stock_code + ".log"), "w", encoding='utf-8')
-    hts.buyRealTime(today_str, analyzed_day=1000, logFp=logFp)
+
+    MAX_PRICE = 30000
+    hts.buyRealTime(today_str, analyzed_day=1000, logFp=logFp, MAX_PRICE=MAX_PRICE)
     logFp.close()
 
     db_filename = os.path.join(RESOURCE_PATH, "hts.db")

HTS_etf_233740.py

@@ -20,7 +20,9 @@ if __name__ == "__main__":
     if not os.path.exists(os.path.join(RESOURCE_PATH, "log")):
         os.mkdir(os.path.join(RESOURCE_PATH, "log"))
     logFp = open(os.path.join(RESOURCE_PATH, "log", today_str + "_" + stock_code + ".log"), "w", encoding='utf-8')
-    hts.buyRealTime(today_str, analyzed_day=1000, logFp=logFp)
+
+    MAX_PRICE = 30000
+    hts.buyRealTime(today_str, analyzed_day=1000, logFp=logFp, MAX_PRICE=MAX_PRICE)
     logFp.close()
 
     db_filename = os.path.join(RESOURCE_PATH, "hts.db")

HTS_etf_251340.py

@@ -20,7 +20,9 @@ if __name__ == "__main__":
     if not os.path.exists(os.path.join(RESOURCE_PATH, "log")):
         os.mkdir(os.path.join(RESOURCE_PATH, "log"))
     logFp = open(os.path.join(RESOURCE_PATH, "log", today_str + "_" + stock_code + ".log"), "w", encoding='utf-8')
-    hts.buyRealTime(today_str, analyzed_day=1000, logFp=logFp)
+
+    MAX_PRICE = 30000
+    hts.buyRealTime(today_str, analyzed_day=1000, logFp=logFp, MAX_PRICE=MAX_PRICE)
     logFp.close()
 
     db_filename = os.path.join(RESOURCE_PATH, "hts.db")

HTS_etf_252670.py

@@ -20,7 +20,9 @@ if __name__ == "__main__":
     if not os.path.exists(os.path.join(RESOURCE_PATH, "log")):
         os.mkdir(os.path.join(RESOURCE_PATH, "log"))
     logFp = open(os.path.join(RESOURCE_PATH, "log", today_str + "_" + stock_code + ".log"), "w", encoding='utf-8')
-    hts.buyRealTime(today_str, analyzed_day=1000, logFp=logFp)
+
+    MAX_PRICE = 30000
+    hts.buyRealTime(today_str, analyzed_day=1000, logFp=logFp, MAX_PRICE=MAX_PRICE)
     logFp.close()
 
     db_filename = os.path.join(RESOURCE_PATH, "hts.db")

Simulation.py

@@ -3,23 +3,35 @@ import pandas as pd
 import plotly.graph_objects as go
 from plotly import subplots
 import os
+import sqlite3
 
 from hts.HTS import HTS
 from stock.util.Stock2Vector import Stock2Vector
 from stock.util.LabelChecker import LabelChecker
-from hts.BuySellChecker import BuySellChecker
+
-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 Simulation (HTS):
     stock2Vector = None
     buySellChecker = None
 
-    def __init__(self, RESOURCE_PATH):
+    def __init__(self, RESOURCE_PATH, stock_code):
         super().__init__(RESOURCE_PATH)
 
         self.RESOURCE_PATH = RESOURCE_PATH
 
-        self.buySellChecker = BuySellChecker()
+        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()
 
         try:
             self.stock2Vector = Stock2Vector(RESOURCE_PATH)
@@ -230,38 +242,59 @@ class Simulation (HTS):
 
         return result
 
-    def simulate(self, stock_codes:dict=None, analyzed_day=1000):
+    def getLIMITInfo(self, stock_code, ymd, dbfile_name="stock.db"):
-        for stock_code in stock_codes:
+        conn = sqlite3.connect(os.path.join(self.RESOURCE_PATH, dbfile_name))
-            for given_day in stock_codes[stock_code]:
+        cursor = conn.cursor()
-                LAST_DATA = self.stock2Vector.getLastData(stock_code, given_day)
-                # 1분봉
-                result = self.stock2Vector.getRealTime(stock_code, given_day, LAST_DATA)
-                # 5분봉
-                #result = self.makeTickData(result, mins=5)
-                # 30분봉
-                #result = self.makeTickData(result, mins=30)
 
-                data = self.buySellChecker.analyze(result)
+        cursor.execute('select ymd, open, close, high, low, volume from stock where code=? order by ymd desc limit ?', (stock_code, 100, ))
-                data.drop(data.index[:len(data) - analyzed_day], inplace=True)
+        db_result = cursor.fetchall()
+        cursor.close()
+        conn.close()
 
-                # 이동평균, RSI, MACD, 일목균형, 볼린저밴드 상/하단을 계산한다.
+        match = False
-                #data_5 = self.buySellChecker.analyze(result_5)
+        LIMIT_PRICE = []
-                # 분석일 데이터만 활용한다 (이전 데이터는 제거)
+        for i, rows in enumerate(db_result):
-                #data_5.drop(data_5.index[:len(data_5) - analyzed_day], inplace=True)
+            if rows[0].replace('.', '') == ymd:
+                match = True
+            if match:
+                LIMIT_PRICE.append(rows[2])
 
-                #data_30 = self.buySellChecker.analyze(result_30)
+        return {'LIMIT_PRICE': sum(LIMIT_PRICE[:20])/len(LIMIT_PRICE[:20])}
-                # 분석일 데이터만 활용한다 (이전 데이터는 제거)
-                #data_30.drop(data_30.index[:len(data_30) - analyzed_day], inplace=True)
 
-                # 사야 할 시점과 팔아야 할 시점을 체크한다.
+    def simulate(self, stock, analyzed_day=1000):
-                #bsLine = self.buySellChecker.checkTransaction(stock_code, data, data_5, data_30, isRealTime=False)
+        stock_code = stock['code']
+        for ymd in stock['ymd']:
+            LAST_DATA = self.stock2Vector.getLastData(stock_code, ymd)
+            # 1분봉
+            result = self.stock2Vector.getRealTime(stock_code, ymd, LAST_DATA)
+            # 5분봉
+            #result = self.makeTickData(result, mins=5)
+            # 30분봉
+            #result = self.makeTickData(result, mins=30)
 
-                # 어제 데이터는 지운다.
+            data = self.buySellChecker.analyze(result)
-                #data = data.loc[pd.DatetimeIndex(data.index).day == int(given_day[6:])]
+            data.drop(data.index[:len(data) - analyzed_day], inplace=True)
-                bsLine = self.buySellChecker.checkTransaction(stock_code, data, None, None, isRealTime=False)
 
-                # 그래프를 그린다.
+            # 이동평균, RSI, MACD, 일목균형, 볼린저밴드 상/하단을 계산한다.
-                self.draw(stock_code, given_day, data, bsLine)
+            #data_5 = self.buySellChecker.analyze(result_5)
+            # 분석일 데이터만 활용한다 (이전 데이터는 제거)
+            #data_5.drop(data_5.index[:len(data_5) - analyzed_day], inplace=True)
+
+            #data_30 = self.buySellChecker.analyze(result_30)
+            # 분석일 데이터만 활용한다 (이전 데이터는 제거)
+            #data_30.drop(data_30.index[:len(data_30) - analyzed_day], inplace=True)
+
+            # 사야 할 시점과 팔아야 할 시점을 체크한다.
+            #bsLine = self.buySellChecker.checkTransaction(stock_code, data, data_5, data_30, isRealTime=False)
+
+            INFO = self.getLIMITInfo(stock_code, ymd)
+
+            # 어제 데이터는 지운다.
+            #data = data.loc[pd.DatetimeIndex(data.index).day == int(given_day[6:])]
+            bsLine = self.buySellChecker.checkTransaction(stock_code, data, INFO, isRealTime=False)
+
+            # 그래프를 그린다.
+            self.draw(stock_code, ymd, data, bsLine)
         return
 
 if __name__ == "__main__":
@@ -269,17 +302,23 @@ if __name__ == "__main__":
     PROJECT_HOME = os.getcwd()
     RESOURCE_PATH = os.path.join(PROJECT_HOME, "resources")
 
-    simulation = Simulation(RESOURCE_PATH)
+    day_list = ['20231101']
 
-    day_list = ['20231025']
     # to check bying
-    stock_codes = {
+    stock = {'code': '233740', 'name': 'KODEX 200선물인버스2X', 'ymd': day_list}
-        "233740": day_list,
+    simulation = Simulation(RESOURCE_PATH, stock['code'])
-        "252670": day_list,
+    simulation.simulate(stock)
-        "251340": day_list,
+
-        "122630": day_list
+    #stock = {'code': '233740', 'name': 'KODEX 200선물인버스2X', 'ymd': day_list}
-    }
+    #simulation = Simulation(RESOURCE_PATH, stock['code'])
-    #simulation.simulate(stock_codes)
+    #simulation.simulate(stock)
-    simulation.simulate(stock_codes)
+
+    #stock = {'code': '233740', 'name': 'KODEX 200선물인버스2X', 'ymd': day_list}
+    #simulation = Simulation(RESOURCE_PATH, stock['code'])
+    #simulation.simulate(stock)
+
+    #stock = {'code': '233740', 'name': 'KODEX 200선물인버스2X', 'ymd': day_list}
+    #simulation = Simulation(RESOURCE_PATH, stock['code'])
+    #simulation.simulate(stock)
 
     print ("done...")

StockCrawler.py

@@ -171,7 +171,7 @@ if __name__ == "__main__":
     stockCrawlerDaily = StockCrawlerDaily(PROJECT_HOME)
 
     week = datetime.today().weekday()
-    if week in (0, 1, 2, 3, 4, 5):  # 0:월, 1:화, 2:수, 3:목, 4:금, 5:토, 6:일
+    if week in (0, 1, 2, 3, 4):  # 0:월, 1:화, 2:수, 3:목, 4:금, 5:토, 6:일
         start = time.time()
         stockCrawlerDaily.crawl()
         today = datetime.now().strftime("%Y-%m-%d")

hts/BuySellChecker.py

@@ -124,6 +124,7 @@ class BuySellChecker:
         return False
 
 
+    """
     def getBuyPriceAndWeight_122630(self, i, data):
         buy, weight = -1, -1
 
@@ -277,7 +278,7 @@ class BuySellChecker:
                 sell, weight = data['close'][i], 1
 
         return sell, weight
-
+    """
 
 
     def analyze(self, result):
@@ -388,6 +389,7 @@ class BuySellChecker:
         data = data.fillna(-1)
         return data
 
+    """
     def checkTransaction(self, stock_code, data, data_5=None, data_30=None, isRealTime=True):
         # 어제 오늘 데이터로 분석
         bsLine = {}
@@ -429,53 +431,8 @@ class BuySellChecker:
 
         return bsLine
 
-    def checkTransactionML(self, data, stock_code, predY, isRealTime=True):
+    """
-        # 4일치 중에서 앞에 2일은 제거한다.
-        date = data['date'].dt.date.unique().tolist()
-        data = data[data['date'].dt.date != date[0]]
-        data = data[data['date'].dt.date != date[1]]
 
-        # 어제 오늘 데이터로 분석
-        bsLine = {}
-        size = len(data["close"])
-        if isRealTime:
-            # isRealTime=True, 실시간 적용
-            last_index = size - 1
-
-            # Type=False, 시뮬레이션 적용
-            bsLine['buy'] = [-1 for i in range(size)]
-            bsLine['buy_weight'] = [-1 for i in range(size)]
-            bsLine['sell'] = [-1 for i in range(size)]
-            bsLine['sell_weight'] = [-1 for i in range(size)]
-
-            sell, sell_weight, buy, buy_weight = -1, -1, -1, -1
-            if predY[last_index] == 1:
-                sell = int((data["open"][last_index] + data["close"][last_index]) / 2)
-                sell_weight = 1
-            elif predY[last_index] == 2:
-                buy = int((data["open"][last_index] + data["close"][last_index]) / 2)
-                buy_weight = 1
-
-            bsLine['buy'] = [buy]
-            bsLine['buy_weight'] = [buy_weight]
-            bsLine['sell'] = [sell]
-            bsLine['sell_weight'] = [sell_weight]
-        else:
-            # Type=False, 시뮬레이션 적용
-            bsLine['buy'] = [-1 for i in range(size)]
-            bsLine['buy_weight'] = [-1 for i in range(size)]
-            bsLine['sell'] = [-1 for i in range(size)]
-            bsLine['sell_weight'] = [-1 for i in range(size)]
-
-            for i in range(size):
-                if predY[i] == 1:
-                    bsLine['sell'][i] = int((data["open"][i] + data["close"][i]) / 2)
-                    bsLine['sell_weight'][i] = 1
-                elif predY[i] == 2:
-                    bsLine['buy'][i] = int((data["open"][i] + data["close"][i]) / 2)
-                    bsLine['buy_weight'][i] = 1
-
-        return bsLine, data
 
     # middle line에 맞다은 적 없이, low line에 붙었거나 아래에 있었던 캔들의 높은 가격을 얻어옴
     def getPrice_UnderLowWithoutMiddle(self, last_index, data):

hts/BuySellChecker_122630.py

@@ -0,0 +1,103 @@
+from hts.BuySellChecker import BuySellChecker
+
+class BuySellChecker_122630 (BuySellChecker):
+
+    def __init__(self):
+        super().__init__()
+        return
+
+    def getBuyPriceAndWeight(self, stock_code, i, data, INFO):
+        buy, weight = -1, -1
+
+        C_MIN_AVG_5_200 = max(data['disparity_avg5'][i], data['disparity_avg20'][i], data['disparity_avg60'][i], data['disparity_avg200'][i]) - min(data['disparity_avg5'][i], data['disparity_avg20'][i], data['disparity_avg60'][i], data['disparity_avg200'][i])
+        C_MIN_AVG_5_60 = max(data['disparity_avg5'][i], data['disparity_avg20'][i], data['disparity_avg60'][i]) - min(data['disparity_avg5'][i], data['disparity_avg20'][i], data['disparity_avg60'][i])
+
+        MIN_AVG_5_200 = 0.002
+        MIN_AVG_5_60 = 0.002
+        DIFF_200_5 = 0.001
+
+        if (abs(data['disparity_avg200'][i] - data['disparity_avg5'][i]) < DIFF_200_5 and C_MIN_AVG_5_200 < MIN_AVG_5_200 and C_MIN_AVG_5_60 < MIN_AVG_5_60):
+            if data['avg200'][i] < data['avg5'][i]:
+                if 180 < i:
+                    valid = True
+                    for c in range(5, 181):
+                        if data['avg200'][-c] < data['avg200'][-c]:
+                            valid = False
+                            break
+                    if valid:
+                        if max(data['volume'].tolist()[i-10:i]) < data['volume'][i]:
+                            buy = data['close'][i]
+                            weight = 1
+                        if data['open'][i-2] < data['close'][i-2] and data['open'][i-1] < data['close'][i-1] and data['open'][i] < data['close'][i]:
+                            buy = data['close'][i]
+                            weight = 1
+
+            if data['macd'][i-1] < -1000:
+                if -1000 < data['macd'][i]:
+                    buy = data['close'][i]
+                    weight = 1
+
+        return buy, weight
+
+    def checkTransaction(self, stock_code, data, INFO, isRealTime=True):
+        sell, weight = -1, -1
+
+        if data['close'][i] < INFO['LOW_PRICE'] < data['close'][i-1]:
+            sell = data['close'][i]
+            weight = 1
+
+        if (650 < data['macd'][i]) and (0 < data['macdo'][i-1] and data['macdo'][i] <= 0):
+            #if data['macds'][i-1] < data['macd'][i-1] and data['macd'][i] < data['macds'][i]:
+            weight = 1
+            sell = data['close'][i]
+
+        if data['close'][i] < INFO['LIMIT_PRICE']:
+            weight = 1
+            sell = data['close'][i]
+
+        return sell, weight
+
+
+    def checkTransaction(self, stock_code, data, INFO, isRealTime=True):
+        # 어제 오늘 데이터로 분석
+        bsLine = {}
+
+        if data is not None and 'close' in data.columns:
+            size = len(data["close"])
+            if isRealTime:
+
+                # isRealTime=True, 실시간 적용
+                last_index = size - 1
+
+                buy, buy_weight = self.getBuyPriceAndWeight(stock_code, last_index, data, INFO)
+                sell, sell_weight = self.getSellPriceAndWeight(stock_code, last_index, data, INFO)
+
+                bsLine['buy'] = [buy]
+                bsLine['buy_weight'] = [buy_weight]
+                bsLine['sell'] = [sell]
+                bsLine['sell_weight'] = [sell_weight]
+
+            else:
+                # Type=False, 시뮬레이션 적용
+                bsLine['buy'] = [-1 for i in range(size)]
+                bsLine['buy_weight'] = [-1 for i in range(size)]
+                bsLine['sell'] = [-1 for i in range(size)]
+                bsLine['sell_weight'] = [-1 for i in range(size)]
+
+                for last_index in range(size):
+
+                    buy, buy_weight = self.getBuyPriceAndWeight(stock_code, last_index, data, INFO)
+                    sell, sell_weight = self.getSellPriceAndWeight(stock_code, last_index, data, INFO)
+                    # sell, sell_weight = -1, -1
+
+                    bsLine['buy'][last_index] = buy
+                    bsLine['buy_weight'][last_index] = buy_weight
+                    bsLine['sell'][last_index] = sell
+                    bsLine['sell_weight'][last_index] = sell_weight
+        else:
+            bsLine['buy'] = [-1]
+            bsLine['buy_weight'] = [-1]
+            bsLine['sell'] = [-1]
+            bsLine['sell_weight'] = [-1]
+
+        return bsLine

hts/BuySellChecker_233740.py

@@ -0,0 +1,103 @@
+from hts.BuySellChecker import BuySellChecker
+
+class BuySellChecker_233740 (BuySellChecker):
+
+    def __init__(self):
+        super().__init__()
+        return
+
+    def getBuyPriceAndWeight(self, stock_code, i, data, INFO):
+        buy, weight = -1, -1
+
+        C_MIN_AVG_5_200 = max(data['disparity_avg5'][i], data['disparity_avg20'][i], data['disparity_avg60'][i], data['disparity_avg200'][i]) - min(data['disparity_avg5'][i], data['disparity_avg20'][i], data['disparity_avg60'][i], data['disparity_avg200'][i])
+        C_MIN_AVG_5_60 = max(data['disparity_avg5'][i], data['disparity_avg20'][i], data['disparity_avg60'][i]) - min(data['disparity_avg5'][i], data['disparity_avg20'][i], data['disparity_avg60'][i])
+
+        MIN_AVG_5_200 = 0.002
+        MIN_AVG_5_60 = 0.002
+        DIFF_200_5 = 0.001
+
+        if (abs(data['disparity_avg200'][i] - data['disparity_avg5'][i]) < DIFF_200_5 and C_MIN_AVG_5_200 < MIN_AVG_5_200 and C_MIN_AVG_5_60 < MIN_AVG_5_60):
+            if data['avg200'][i] < data['avg5'][i]:
+                if 180 < i:
+                    valid = True
+                    for c in range(5, 181):
+                        if data['avg200'][-c] < data['avg200'][-c]:
+                            valid = False
+                            break
+                    if valid:
+                        if max(data['volume'].tolist()[i-10:i]) < data['volume'][i]:
+                            buy = data['close'][i]
+                            weight = 1
+                        if data['open'][i-2] < data['close'][i-2] and data['open'][i-1] < data['close'][i-1] and data['open'][i] < data['close'][i]:
+                            buy = data['close'][i]
+                            weight = 1
+
+            if data['macd'][i-1] < -1000:
+                if -1000 < data['macd'][i]:
+                    buy = data['close'][i]
+                    weight = 1
+
+        return buy, weight
+
+    def getSellPriceAndWeight(self, stock_code, i, data, INFO):
+        sell, weight = -1, -1
+
+        if data['close'][i] < INFO['LIMIT_PRICE'] < data['close'][i-1]:
+            sell = data['close'][i]
+            weight = 1
+
+        if (650 < data['macd'][i]) and (0 < data['macdo'][i-1] and data['macdo'][i] <= 0):
+            #if data['macds'][i-1] < data['macd'][i-1] and data['macd'][i] < data['macds'][i]:
+            weight = 1
+            sell = data['close'][i]
+
+        if data['close'][i] < INFO['LIMIT_PRICE']:
+            weight = 1
+            sell = data['close'][i]
+
+        return sell, weight
+
+
+    def checkTransaction(self, stock_code, data, INFO, isRealTime=True):
+        # 어제 오늘 데이터로 분석
+        bsLine = {}
+
+        if data is not None and 'close' in data.columns:
+            size = len(data["close"])
+            if isRealTime:
+
+                # isRealTime=True, 실시간 적용
+                last_index = size - 1
+
+                buy, buy_weight = self.getBuyPriceAndWeight(stock_code, last_index, data, INFO)
+                sell, sell_weight = self.getSellPriceAndWeight(stock_code, last_index, data, INFO)
+
+                bsLine['buy'] = [buy]
+                bsLine['buy_weight'] = [buy_weight]
+                bsLine['sell'] = [sell]
+                bsLine['sell_weight'] = [sell_weight]
+
+            else:
+                # Type=False, 시뮬레이션 적용
+                bsLine['buy'] = [-1 for i in range(size)]
+                bsLine['buy_weight'] = [-1 for i in range(size)]
+                bsLine['sell'] = [-1 for i in range(size)]
+                bsLine['sell_weight'] = [-1 for i in range(size)]
+
+                for last_index in range(size):
+
+                    buy, buy_weight = self.getBuyPriceAndWeight(stock_code, last_index, data, INFO)
+                    sell, sell_weight = self.getSellPriceAndWeight(stock_code, last_index, data, INFO)
+                    # sell, sell_weight = -1, -1
+
+                    bsLine['buy'][last_index] = buy
+                    bsLine['buy_weight'][last_index] = buy_weight
+                    bsLine['sell'][last_index] = sell
+                    bsLine['sell_weight'][last_index] = sell_weight
+        else:
+            bsLine['buy'] = [-1]
+            bsLine['buy_weight'] = [-1]
+            bsLine['sell'] = [-1]
+            bsLine['sell_weight'] = [-1]
+
+        return bsLine

hts/BuySellChecker_251340.py

@@ -0,0 +1,103 @@
+from hts.BuySellChecker import BuySellChecker
+
+class BuySellChecker_251340 (BuySellChecker):
+
+    def __init__(self):
+        super().__init__()
+        return
+
+    def getBuyPriceAndWeight(self, stock_code, i, data, INFO):
+        buy, weight = -1, -1
+
+        C_MIN_AVG_5_200 = max(data['disparity_avg5'][i], data['disparity_avg20'][i], data['disparity_avg60'][i], data['disparity_avg200'][i]) - min(data['disparity_avg5'][i], data['disparity_avg20'][i], data['disparity_avg60'][i], data['disparity_avg200'][i])
+        C_MIN_AVG_5_60 = max(data['disparity_avg5'][i], data['disparity_avg20'][i], data['disparity_avg60'][i]) - min(data['disparity_avg5'][i], data['disparity_avg20'][i], data['disparity_avg60'][i])
+
+        MIN_AVG_5_200 = 0.002
+        MIN_AVG_5_60 = 0.002
+        DIFF_200_5 = 0.001
+
+        if (abs(data['disparity_avg200'][i] - data['disparity_avg5'][i]) < DIFF_200_5 and C_MIN_AVG_5_200 < MIN_AVG_5_200 and C_MIN_AVG_5_60 < MIN_AVG_5_60):
+            if data['avg200'][i] < data['avg5'][i]:
+                if 180 < i:
+                    valid = True
+                    for c in range(5, 181):
+                        if data['avg200'][-c] < data['avg200'][-c]:
+                            valid = False
+                            break
+                    if valid:
+                        if max(data['volume'].tolist()[i-10:i]) < data['volume'][i]:
+                            buy = data['close'][i]
+                            weight = 1
+                        if data['open'][i-2] < data['close'][i-2] and data['open'][i-1] < data['close'][i-1] and data['open'][i] < data['close'][i]:
+                            buy = data['close'][i]
+                            weight = 1
+
+            if data['macd'][i-1] < -1000:
+                if -1000 < data['macd'][i]:
+                    buy = data['close'][i]
+                    weight = 1
+
+        return buy, weight
+
+    def getSellPriceAndWeight(self, stock_code, i, data, INFO):
+        sell, weight = -1, -1
+
+        if data['close'][i] < INFO['LOW_PRICE'] < data['close'][i-1]:
+            sell = data['close'][i]
+            weight = 1
+
+        if (650 < data['macd'][i]) and (0 < data['macdo'][i-1] and data['macdo'][i] <= 0):
+            #if data['macds'][i-1] < data['macd'][i-1] and data['macd'][i] < data['macds'][i]:
+            weight = 1
+            sell = data['close'][i]
+
+        if data['close'][i] < INFO['LIMIT_PRICE']:
+            weight = 1
+            sell = data['close'][i]
+
+        return sell, weight
+
+
+    def checkTransaction(self, stock_code, data, INFO, isRealTime=True):
+        # 어제 오늘 데이터로 분석
+        bsLine = {}
+
+        if data is not None and 'close' in data.columns:
+            size = len(data["close"])
+            if isRealTime:
+
+                # isRealTime=True, 실시간 적용
+                last_index = size - 1
+
+                buy, buy_weight = self.getBuyPriceAndWeight(stock_code, last_index, data, INFO)
+                sell, sell_weight = self.getSellPriceAndWeight(stock_code, last_index, data, INFO)
+
+                bsLine['buy'] = [buy]
+                bsLine['buy_weight'] = [buy_weight]
+                bsLine['sell'] = [sell]
+                bsLine['sell_weight'] = [sell_weight]
+
+            else:
+                # Type=False, 시뮬레이션 적용
+                bsLine['buy'] = [-1 for i in range(size)]
+                bsLine['buy_weight'] = [-1 for i in range(size)]
+                bsLine['sell'] = [-1 for i in range(size)]
+                bsLine['sell_weight'] = [-1 for i in range(size)]
+
+                for last_index in range(size):
+
+                    buy, buy_weight = self.getBuyPriceAndWeight(stock_code, last_index, data, INFO)
+                    sell, sell_weight = self.getSellPriceAndWeight(stock_code, last_index, data, INFO)
+                    # sell, sell_weight = -1, -1
+
+                    bsLine['buy'][last_index] = buy
+                    bsLine['buy_weight'][last_index] = buy_weight
+                    bsLine['sell'][last_index] = sell
+                    bsLine['sell_weight'][last_index] = sell_weight
+        else:
+            bsLine['buy'] = [-1]
+            bsLine['buy_weight'] = [-1]
+            bsLine['sell'] = [-1]
+            bsLine['sell_weight'] = [-1]
+
+        return bsLine

hts/BuySellChecker_252670.py

@@ -0,0 +1,103 @@
+from hts.BuySellChecker import BuySellChecker
+
+class BuySellChecker_252670 (BuySellChecker):
+
+    def __init__(self):
+        super().__init__()
+        return
+
+    def getBuyPriceAndWeight(self, stock_code, i, data, INFO):
+        buy, weight = -1, -1
+
+        C_MIN_AVG_5_200 = max(data['disparity_avg5'][i], data['disparity_avg20'][i], data['disparity_avg60'][i], data['disparity_avg200'][i]) - min(data['disparity_avg5'][i], data['disparity_avg20'][i], data['disparity_avg60'][i], data['disparity_avg200'][i])
+        C_MIN_AVG_5_60 = max(data['disparity_avg5'][i], data['disparity_avg20'][i], data['disparity_avg60'][i]) - min(data['disparity_avg5'][i], data['disparity_avg20'][i], data['disparity_avg60'][i])
+
+        MIN_AVG_5_200 = 0.002
+        MIN_AVG_5_60 = 0.002
+        DIFF_200_5 = 0.001
+
+        if (abs(data['disparity_avg200'][i] - data['disparity_avg5'][i]) < DIFF_200_5 and C_MIN_AVG_5_200 < MIN_AVG_5_200 and C_MIN_AVG_5_60 < MIN_AVG_5_60):
+            if data['avg200'][i] < data['avg5'][i]:
+                if 180 < i:
+                    valid = True
+                    for c in range(5, 181):
+                        if data['avg200'][-c] < data['avg200'][-c]:
+                            valid = False
+                            break
+                    if valid:
+                        if max(data['volume'].tolist()[i-10:i]) < data['volume'][i]:
+                            buy = data['close'][i]
+                            weight = 1
+                        if data['open'][i-2] < data['close'][i-2] and data['open'][i-1] < data['close'][i-1] and data['open'][i] < data['close'][i]:
+                            buy = data['close'][i]
+                            weight = 1
+
+            if data['macd'][i-1] < -1000:
+                if -1000 < data['macd'][i]:
+                    buy = data['close'][i]
+                    weight = 1
+
+        return buy, weight
+
+    def getSellPriceAndWeight(self, stock_code, i, data, INFO):
+        sell, weight = -1, -1
+
+        if data['close'][i] < INFO['LOW_PRICE'] < data['close'][i-1]:
+            sell = data['close'][i]
+            weight = 1
+
+        if (650 < data['macd'][i]) and (0 < data['macdo'][i-1] and data['macdo'][i] <= 0):
+            #if data['macds'][i-1] < data['macd'][i-1] and data['macd'][i] < data['macds'][i]:
+            weight = 1
+            sell = data['close'][i]
+
+        if data['close'][i] < INFO['LIMIT_PRICE']:
+            weight = 1
+            sell = data['close'][i]
+
+        return sell, weight
+
+
+    def checkTransaction(self, stock_code, data, INFO, isRealTime=True):
+        # 어제 오늘 데이터로 분석
+        bsLine = {}
+
+        if data is not None and 'close' in data.columns:
+            size = len(data["close"])
+            if isRealTime:
+
+                # isRealTime=True, 실시간 적용
+                last_index = size - 1
+
+                buy, buy_weight = self.getBuyPriceAndWeight(stock_code, last_index, data, INFO)
+                sell, sell_weight = self.getSellPriceAndWeight(stock_code, last_index, data, INFO)
+
+                bsLine['buy'] = [buy]
+                bsLine['buy_weight'] = [buy_weight]
+                bsLine['sell'] = [sell]
+                bsLine['sell_weight'] = [sell_weight]
+
+            else:
+                # Type=False, 시뮬레이션 적용
+                bsLine['buy'] = [-1 for i in range(size)]
+                bsLine['buy_weight'] = [-1 for i in range(size)]
+                bsLine['sell'] = [-1 for i in range(size)]
+                bsLine['sell_weight'] = [-1 for i in range(size)]
+
+                for last_index in range(size):
+
+                    buy, buy_weight = self.getBuyPriceAndWeight(stock_code, last_index, data, INFO)
+                    sell, sell_weight = self.getSellPriceAndWeight(stock_code, last_index, data, INFO)
+                    # sell, sell_weight = -1, -1
+
+                    bsLine['buy'][last_index] = buy
+                    bsLine['buy_weight'][last_index] = buy_weight
+                    bsLine['sell'][last_index] = sell
+                    bsLine['sell_weight'][last_index] = sell_weight
+        else:
+            bsLine['buy'] = [-1]
+            bsLine['buy_weight'] = [-1]
+            bsLine['sell'] = [-1]
+            bsLine['sell_weight'] = [-1]
+
+        return bsLine