init

Simulation.py

@@ -36,6 +36,7 @@ class Simulation (HTS):
         if bsLine is None:
             return
 
+        bsLine = bsLine[stock_code]
         # 어제 데이터는 지운다.
         data = data.loc[pd.DatetimeIndex(data.index).day == int(given_day[6:])]
         buy_line = bsLine['buy'][len(bsLine['buy'])-len(data):]
@@ -73,7 +74,7 @@ class Simulation (HTS):
                 buy_line[i] = nan
                 buy_size.append(0)
             else:
-                buy_colors.append("#B2028C")
+                buy_colors.append("#0C752E")
                 buy_size.append(10 + (5 * buy_weight_line[i]))
 
         sell_colors = []
@@ -91,6 +92,7 @@ class Simulation (HTS):
         lower = go.Scatter(x=data['date'], y=data["lower"], name="lower", line_color='#000000')
         avg5 = go.Scatter(x=data['date'], y=data["avg5"], name="avg5", line_color='#F81191')
         avg20 = go.Scatter(x=data['date'], y=data["avg20"], name="avg20", line_color='#097F19')
+        avg30 = go.Scatter(x=data['date'], y=data["avg30"], name="avg30", line_color='#097F19')
         avg60 = go.Scatter(x=data['date'], y=data["avg60"], name="avg60", line_color='#671BEA')
         avg120 = go.Scatter(x=data['date'], y=data["avg120"], name="avg120", line_color='#DFB809')
         avg200 = go.Scatter(x=data['date'], y=data["avg200"], name="avg200", line_color='#000000')
@@ -104,6 +106,7 @@ class Simulation (HTS):
 
         disparity_avg5 = go.Scatter(x=data['date'], y=data["disparity_avg5"], name="disparity_avg5", line_color='#F81191')
         disparity_avg20 = go.Scatter(x=data['date'], y=data["disparity_avg20"], name="disparity_avg20", line_color='#097F19')
+        disparity_avg30 = go.Scatter(x=data['date'], y=data["disparity_avg30"], name="disparity_avg30", line_color='#097F19')
         disparity_avg60 = go.Scatter(x=data['date'], y=data["disparity_avg60"], name="disparity_avg60", line_color='#671BEA')
         disparity_avg120 = go.Scatter(x=data['date'], y=data["disparity_avg120"], name="disparity_avg120", line_color='#DFB809')
         disparity_avg200 = go.Scatter(x=data['date'], y=data["disparity_avg200"], name="disparity_avg200", line_color='#000000')
@@ -119,9 +122,11 @@ class Simulation (HTS):
         rsi_line = go.Scatter(x=data['date'], y=data["rsi"], line=dict(color='red', width=2), name='rsi')
         rsis_line = go.Scatter(x=data['date'], y=data["rsis"], line=dict(dash='dashdot', color='black', width=2), name='rsis')
 
-        candle_data = [candle_stick, upper, lower, avg5, avg20, avg60, avg120, avg200, buy_check, sell_check, laggingSpan, changeLine, baseLine]
+        #candle_data = [candle_stick, upper, lower, avg5, avg20, avg30, avg60, avg120, avg200, buy_check, sell_check, laggingSpan, changeLine, baseLine]
+        candle_data = [candle_stick, avg5, avg20, avg30, avg60, avg200, buy_check, sell_check]
+        #candle_data = [candle_stick, buy_check, sell_check]
         volume_data = [volume_line]
-        disparity_data = [disparity_avg5, disparity_avg20, disparity_avg60, disparity_avg120, disparity_avg200]
+        disparity_data = [disparity_avg5, disparity_avg20, disparity_avg30, disparity_avg60, disparity_avg120, disparity_avg200]
         macd_data = [macd_line, macd_s_line, macd_o_line]
         stochastic_data = [slow_k_line, slow_d_line]
         rsi_data = [rsi_line, rsis_line]
@@ -213,6 +218,9 @@ class Simulation (HTS):
 
                     # 사야 할 시점과 팔아야 할 시점을 체크한다.
                     #bsLine = self.buySellChecker.checkTransaction(stock_code, data, data_5, data_30, isRealTime=False)
+
+                    # 어제 데이터는 지운다.
+                    #data = data.loc[pd.DatetimeIndex(data.index).day == int(given_day[6:])]
                     bsLine = self.buySellChecker.checkTransaction(stock_code, data, None, None, isRealTime=False)
 
                     # 그래프를 그린다.
@@ -232,12 +240,8 @@ if __name__ == "__main__":
 
     # to check bying
     stock_codes = {
-        "252670": [
+        "252670": ['20220906'],
-            '20220901', '20220902', '20220905', '20220906'
+        #"122630": ['20220901', '20220902', '20220905', '20220906']
-        ],
-        "122630": [
-            '20220901', '20220902', '20220905', '20220906'
-        ]
     }
     #simulation.simulate(stock_codes)
     simulation.simulate(stock_codes)

hts/BuySellChecker.py

@@ -1,5 +1,6 @@
 import pandas as pd
 
+from datetime import datetime
 from stock.analysis.Common import Common
 from stock.analysis.Stochastic import Stochastic
 from stock.analysis.RSI import RSI
@@ -109,7 +110,7 @@ class BuySellChecker:
             return -1
         return 0
 
-    def getBuyPriceAndWeight(self, i, data, data_5=None, data_30=None):
+    def getBuyPriceAndWeight(self, stock_code, i, data, data_5=None, data_30=None):
         buy, weight = -1, -1
 
         if data_5 is not None and data_30 is not None:
@@ -136,14 +137,30 @@ class BuySellChecker:
                     buy = data['close'][i]
                     weight = 0.3
         else:
-            if data['avg5'][i-1] < data['avg200'][i-1] and data['avg200'][i] < data['avg5'][i]:
+            if data['close'][i-1] < data['avg200'][i-1] and data['avg200'][i] < data['close'][i]:
-                if data['avg60'][i]<data['avg20'][i]<data['avg5'][i]:
+                if not self.common.checkUpward(data['avg200'], i):
+                    if data['avg60'][i]<data['avg20'][i]<data['avg5'][i]:
+                        buy = data['close'][i]
+                        weight = 0.3
+
+            if (0 < max(data['avg5'][i], data['avg20'][i], data['avg60'][i], data['avg200'][i]) - min(data['avg5'][i], data['avg20'][i], data['avg60'][i], data['avg200'][i]) < 2):
+                if data['avg200'][i-10] < data['avg200'][i]:
+                    buy = data['close'][i]
+                    weight = 0.3
+
+            valid = True
+            for idx in range(1, 31):
+                if data['avg30'][i-idx] < data['avg20'][i-idx]:
+                    valid = False
+                    break
+            if valid:
+                if data['avg5'][i-1] < data['avg30'][i-1] and data['avg30'][i] < data['avg5'][i]:
                     buy = data['close'][i]
                     weight = 0.3
 
         return buy, weight
 
-    def getSellPriceAndWeight(self, i, data, data_5=None, data_30=None):
+    def getSellPriceAndWeight(self, stock_code, i, data, data_5=None, data_30=None):
         sell, weight = -1, -1
 
         if data_5 is not None and data_30 is not None:
@@ -163,81 +180,26 @@ class BuySellChecker:
                 sell = data['close'][i]
                 weight = 100
         else:
-            if data['avg200'][i-1] < data['avg5'][i-1] and data['avg5'][i] < data['avg200'][i]:
+            if (5 < max(data['avg5'][i], data['avg20'][i], data['avg60'][i], data['avg200'][i]) - min(data['avg5'][i], data['avg20'][i], data['avg60'][i], data['avg200'][i])):
-                sell = data['close'][i]
+                if data['avg200'][i-1] < data['avg200'][i]  and (data['avg30'][i-1] > data['avg30'][i] or data['close'][i] < data['avg30'][i]):
-                weight = 100
+                    sell = data['close'][i]
+                    weight = 100
+
+                if data['avg30'][i-1] < data['close'][i-1] and data['close'][i] < data['avg30'][i]:
+                    sell = data['close'][i]
+                    weight = 100
+
+                if stock_code == '252670':
+                    diff = 15
+                else:
+                    diff = 50
+                if diff < max(data['high'][i-5],data['high'][i-4],data['high'][i-3],data['high'][i-2],data['high'][i-1]) - data['low'][i]:
+                    sell = data['close'][i]
+                    weight = 100
 
         return sell, weight
 
 
-    def getBuyPriceAndWeight_122630(self, data, i):
-        buy, weight, type = -1, -1, -1
-
-        START_TIME_INDEX = 0
-        for c in range(370, len(data.index)):
-            if data.index[c].strftime("%H:%M:%S") == "09:01:00":
-                START_TIME_INDEX = c
-                break
-
-        if START_TIME_INDEX + 10 < i < START_TIME_INDEX + 350:
-            # 매수 분석
-
-            if data['macd'][i] < -50:
-                buy = max(data["open"][i], data["close"][i])
-                weight = 1
-                type = 1
-                return buy, weight, type
-
-            """
-            if data['changeLine'][i - 1] <= data['baseLine'][i - 1] and data['baseLine'][i] < data['changeLine'][i]:
-                changeLine_count = sum([1 if data['changeLine'][c] <= data['baseLine'][c] else 0 for c in range(i-30, i-10)])
-                if changeLine_count >= 15:
-                    changeLine_count = sum([1 if data['changeLine'][c] <= data['baseLine'][c] else 0 for c in range(i-10, i)])
-                    if changeLine_count >= 7:
-                        buy = min(data["open"][i], data["close"][i])
-                        weight = 5
-                        type = 1
-                        return buy, weight, type
-            """
-
-            """
-            if i > 381 + 26:
-                if data['laggingSpan'][i-1] < data['avg3'][i-1] and data['avg3'][i] < data['laggingSpan'][i]:
-                    if self.checkUpDirection(data, i) == 1:
-                        avg20_line = sum([1 if data['avg20'][c] < data['avg20'][c-1] else 0 for c in range(i - 10, i)])
-                        if avg20_line < 10:
-                            if data["macd"][i] < 0:
-                                buy = min(data["open"][i], data["close"][i])
-                                weight = 1
-                                type = 1
-                                return buy, weight, type
-            """
-        return buy, weight, type
-
-    def getSellPriceAndWeight_122630(self, data, i):
-        sell, weight, type = -1, -1, -1
-
-        START_TIME_INDEX = 0
-        for c in range(370, len(data.index)):
-            if data.index[c].strftime("%H:%M:%S") == "09:01:00":
-                START_TIME_INDEX = c
-                break
-
-        if i > START_TIME_INDEX:
-            # 매도 분석
-
-            if data['changeLine'][i - 1] >= data['laggingSpan'][i - 1] and data['laggingSpan'][i] < data['changeLine'][
-                i]:
-                changeLine_count = sum(
-                    [1 if data['changeLine'][c] <= data['laggingSpan'][c] else 0 for c in range(i - 20, i)])
-                if changeLine_count >= 17:
-                    sell = min(data["open"][i], data["close"][i])
-                    weight = 1
-                    type = 1
-                    return sell, weight, type
-
-        return sell, weight, type
-
     def analyze(self, result):
         # 기본 캔들 정보
         open = result["open"]
@@ -259,13 +221,15 @@ class BuySellChecker:
         avg120_list = close_df.rolling(window=120).mean().fillna(close[0]).values.tolist()
         avg120 = [item[0] for item in avg120_list]
         avg200_list = close_df.rolling(window=200).mean().fillna(close[0]).values.tolist()
-        avg200 = [item[0] for item in avg120_list]
+        avg200 = [item[0] for item in avg200_list]
 
         open_df = pd.DataFrame(close)
         disparity_avg5_list = (open_df / close_df.rolling(window=5).mean()).values.tolist()
         disparity_avg5 = [item[0] for item in disparity_avg5_list]
         disparity_avg20_list = (open_df / close_df.rolling(window=20).mean()).values.tolist()
         disparity_avg20 = [item[0] for item in disparity_avg20_list]
+        disparity_avg30_list = (open_df / close_df.rolling(window=30).mean()).values.tolist()
+        disparity_avg30 = [item[0] for item in disparity_avg30_list]
         disparity_avg60_list = (open_df / close_df.rolling(window=60).mean()).values.tolist()
         disparity_avg60 = [item[0] for item in disparity_avg60_list]
         disparity_avg120_list = (open_df / close_df.rolling(window=120).mean()).values.tolist()
@@ -293,7 +257,7 @@ class BuySellChecker:
         STOCK = []
         for i in range(len(open)):
             STOCK.append({'volume': vol[i], 'close': close[i], 'open': open[i], 'high': high[i], 'low': low[i],
-                          'avg5': avg5[i], 'avg20': avg20[i], 'avg60': avg60[i], 'avg120': avg120[i], 'avg200': avg200[i]})
+                          'avg5': avg5[i], 'avg20': avg20[i], 'avg30': avg30[i], 'avg60': avg60[i], 'avg120': avg120[i], 'avg200': avg200[i]})
 
         # stochastic
         stochastic_df = self.stochastic.apply(STOCK, n=30, m=5, t=5)
@@ -325,8 +289,8 @@ class BuySellChecker:
         temp = {
             "date": point_temp,
             "open": open, "high": high, "low": low, "close": close, "volume": vol,
-            "avg5": avg5, "avg20": avg20, "avg60": avg60, "avg120": avg120, "avg200": avg200,
+            "avg5": avg5, "avg20": avg20, "avg30": avg30, "avg60": avg60, "avg120": avg120, "avg200": avg200,
-            "disparity_avg5": disparity_avg5, "disparity_avg20": disparity_avg20,
+            "disparity_avg5": disparity_avg5, "disparity_avg20": disparity_avg20, "disparity_avg30": disparity_avg30,
             "disparity_avg60": disparity_avg60, "disparity_avg120": disparity_avg120, "disparity_avg200": disparity_avg200,
             "upper": upper, "lower": lower,
             "macd": macd, "macds": macds, "macdo": macdo,
@@ -343,434 +307,71 @@ class BuySellChecker:
         data = data.fillna(-1)
         return data
 
-    def analyze1(self, result):
-        # 기본 캔들 정보
-        open = result["open"]
-        close = result["close"]
-        high = result["high"]
-        low = result["low"]
-        vol = result["vol"]
-        label = result["label"]
-
-        # 캔들 정보 연산
-        height = [close[i] - open[i] for i in range(0, len(close))]
-        top_tail_height = [high[i] - max(open[i], close[i]) for i in range(0, len(close))]
-        bottom_tail_height = [min(open[i], close[i]) - low[i] for i in range(0, len(close))]
-
-        # 이동 평균
-        close_df = pd.DataFrame(close)
-        avg3_list = close_df.rolling(window=3).mean().fillna(close[0]).values.tolist()
-        avg3 = [item[0] for item in avg3_list]
-        avg6_list = close_df.rolling(window=6).mean().fillna(close[0]).values.tolist()
-        avg6 = [item[0] for item in avg6_list]
-        avg9_list = close_df.rolling(window=9).mean().fillna(close[0]).values.tolist()
-        avg9 = [item[0] for item in avg9_list]
-        avg12_list = close_df.rolling(window=12).mean().fillna(close[0]).values.tolist()
-        avg12 = [item[0] for item in avg12_list]
-        avg27_list = close_df.rolling(window=27).mean().fillna(close[0]).values.tolist()
-        avg27 = [item[0] for item in avg27_list]
-        avg54_list = close_df.rolling(window=54).mean().fillna(close[0]).values.tolist()
-        avg54 = [item[0] for item in avg54_list]
-
-        abs_avg_1 = [
-            max(avg3[i], avg6[i], avg9[i], avg12[i], avg27[i], avg54[i]) - min(avg3[i], avg6[i], avg9[i], avg12[i],
-                                                                               avg27[i], avg54[i]) for i in
-            range(0, len(close))]
-        abs_avg_2 = [
-            max(avg3[i], avg6[i], avg9[i], avg12[i], avg27[i]) - min(avg3[i], avg6[i], avg9[i], avg12[i], avg27[i]) for
-            i in range(0, len(close))]
-        abs_avg_3 = [max(avg3[i], avg6[i], avg9[i], avg12[i]) - min(avg3[i], avg6[i], avg9[i], avg12[i]) for i in
-                     range(0, len(close))]
-        abs_avg_4 = [max(avg3[i], avg6[i], avg9[i]) - min(avg3[i], avg6[i], avg9[i]) for i in range(0, len(close))]
-        abs_avg_5 = [max(avg3[i], avg6[i]) - min(avg3[i], avg6[i]) for i in range(0, len(close))]
-
-        diff_open, diff_close, diff_low, diff_high = [], [], [], []
-        diff_open.append(0)
-        for i in range(1, len(open)):
-            diff_open.append(open[i] - open[i - 1])
-        diff_close.append(0)
-        for i in range(1, len(close)):
-            diff_close.append(close[i] - close[i - 1])
-        diff_low.append(0)
-        for i in range(1, len(low)):
-            diff_low.append(low[i] - low[i - 1])
-        diff_high.append(0)
-        for i in range(1, len(high)):
-            diff_high.append(high[i] - high[i - 1])
-
-        diff_avg3, diff_avg6, diff_avg9, diff_avg12, diff_avg27, diff_avg54 = [], [], [], [], [], []
-        diff_avg3.append(0)
-        for i in range(1, len(avg3)):
-            diff_avg3.append(avg3[i] - avg3[i - 1])
-        diff_avg6.append(0)
-        for i in range(1, len(avg6)):
-            diff_avg6.append(avg6[i] - avg6[i - 1])
-        diff_avg9.append(0)
-        for i in range(1, len(avg9)):
-            diff_avg9.append(avg9[i] - avg9[i - 1])
-        diff_avg12.append(0)
-        for i in range(1, len(avg12)):
-            diff_avg12.append(avg12[i] - avg12[i - 1])
-        diff_avg27.append(0)
-        for i in range(1, len(avg27)):
-            diff_avg27.append(avg27[i] - avg27[i - 1])
-        diff_avg54.append(0)
-        for i in range(1, len(avg54)):
-            diff_avg54.append(avg54[i] - avg54[i - 1])
-
-        diff_avg3_avg6 = [avg3[i] - avg6[i] for i in range(0, len(close))]
-        diff_avg3_avg9 = [avg3[i] - avg9[i] for i in range(0, len(close))]
-        diff_avg3_avg12 = [avg3[i] - avg12[i] for i in range(0, len(close))]
-        diff_avg3_avg27 = [avg3[i] - avg27[i] for i in range(0, len(close))]
-        diff_avg3_avg54 = [avg3[i] - avg54[i] for i in range(0, len(close))]
-        diff_avg6_avg9 = [avg6[i] - avg9[i] for i in range(0, len(close))]
-        diff_avg6_avg12 = [avg6[i] - avg12[i] for i in range(0, len(close))]
-        diff_avg6_avg27 = [avg6[i] - avg27[i] for i in range(0, len(close))]
-        diff_avg6_avg54 = [avg6[i] - avg54[i] for i in range(0, len(close))]
-        diff_avg9_avg12 = [avg9[i] - avg12[i] for i in range(0, len(close))]
-        diff_avg9_avg27 = [avg9[i] - avg27[i] for i in range(0, len(close))]
-        diff_avg9_avg54 = [avg9[i] - avg54[i] for i in range(0, len(close))]
-        diff_avg12_avg27 = [avg12[i] - avg27[i] for i in range(0, len(close))]
-        diff_avg12_avg54 = [avg12[i] - avg54[i] for i in range(0, len(close))]
-        diff_avg27_avg54 = [avg27[i] - avg54[i] for i in range(0, len(close))]
-
-        # 볼린져 밴드
-        df = pd.DataFrame(close)
-        max20 = df.rolling(window=20).mean()
-        stddev20 = df.rolling(window=20).std()
-        upper_df = max20 + (stddev20 * 2)  # 상단 볼린저 밴드
-        lower_df = max20 - (stddev20 * 2)  # 하단 볼린저 밴드
-
-        upper, lower = [], []
-        for i in range(len(upper_df)):
-            if i < 10:
-                upper.append(upper_df.values[0][0])
-                lower.append(lower_df.values[0][0])
-            else:
-                upper.append(upper_df.values[i][0])
-                lower.append(lower_df.values[i][0])
-
-        point_temp = result["time"]
-        STOCK = []
-        for i in range(len(open)):
-            STOCK.append({'volume': vol[i], 'close': close[i], 'open': open[i], 'high': high[i], 'low': low[i],
-                          'avg3': avg3[i], 'avg6': avg6[i], 'avg9': avg9[i], 'avg12': avg12[i], 'avg27': avg27[i],
-                          'avg54': avg54[i]})
-
-        # stochastic
-        stochastic_df = self.stochastic.apply(STOCK, n=30, m=5, t=5)
-        fast_k = stochastic_df['fast_k'].values.tolist()
-        slow_k = stochastic_df['slow_k'].values.tolist()
-        slow_d = stochastic_df['slow_d'].values.tolist()
-
-        # macd
-        macd_df = self.macd.apply(STOCK, short=12, long=26, t=9)
-        macd = macd_df['macd'].values.tolist()
-        macds = macd_df['macds'].values.tolist()
-        macdo = macd_df['macdo'].values.tolist()
-
-        # rsi
-        rsi_df = self.rsi.apply(STOCK, period=30, window=5)
-        rsi = rsi_df['rsi'].values.tolist()
-        rsis = rsi_df['rsis'].values.tolist()
-
-        # ichimokuCloud
-        ichimokuCloud_df = self.ichimokuCloud.apply(STOCK, c=9, b=26, l=52)
-        ichimokuCloud_df = ichimokuCloud_df[:len(ichimokuCloud_df) - 51]
-        changeLine = ichimokuCloud_df['changeLine'].values.tolist()
-        baseLine = ichimokuCloud_df['baseLine'].values.tolist()
-        leadingSpan1 = ichimokuCloud_df['leadingSpan1'].values.tolist()
-        leadingSpan2 = ichimokuCloud_df['leadingSpan2'].values.tolist()
-
-        # 간격
-        ##### 볼린져 밴드
-        diff_upper_lower = [upper[i] - lower[i] for i in range(0, len(upper))]
-        diff_open_lower = [open[i] - lower[i] for i in range(0, len(open))]
-        diff_open_upper = [open[i] - upper[i] for i in range(0, len(open))]
-        diff_close_lower = [close[i] - lower[i] for i in range(0, len(close))]
-        diff_close_upper = [close[i] - upper[i] for i in range(0, len(close))]
-        diff_high_lower = [high[i] - lower[i] for i in range(0, len(high))]
-        diff_high_upper = [high[i] - upper[i] for i in range(0, len(high))]
-        diff_low_lower = [low[i] - lower[i] for i in range(0, len(low))]
-        diff_low_upper = [low[i] - upper[i] for i in range(0, len(low))]
-
-        ##### 일목균형표
-        diff_lead1_lead2 = [leadingSpan1[i] - leadingSpan2[i] for i in range(0, len(leadingSpan1))]
-        diff_change_base = [changeLine[i] - baseLine[i] for i in range(0, len(baseLine))]
-        diff_base_lead1 = [baseLine[i] - leadingSpan1[i] for i in range(0, len(baseLine))]
-        diff_base_lead2 = [baseLine[i] - leadingSpan2[i] for i in range(0, len(baseLine))]
-        diff_change_lead1 = [changeLine[i] - leadingSpan1[i] for i in range(0, len(changeLine))]
-        diff_change_lead2 = [changeLine[i] - leadingSpan2[i] for i in range(0, len(changeLine))]
-        diff_open_lead2 = [open[i] - leadingSpan2[i] for i in range(0, len(open))]
-        diff_open_lead1 = [open[i] - leadingSpan1[i] for i in range(0, len(open))]
-        diff_open_change = [open[i] - changeLine[i] for i in range(0, len(open))]
-        diff_open_base = [open[i] - baseLine[i] for i in range(0, len(open))]
-        diff_close_lead2 = [close[i] - leadingSpan2[i] for i in range(0, len(close))]
-        diff_close_lead1 = [close[i] - leadingSpan1[i] for i in range(0, len(close))]
-        diff_close_change = [close[i] - changeLine[i] for i in range(0, len(close))]
-        diff_close_base = [close[i] - baseLine[i] for i in range(0, len(close))]
-        diff_high_lead2 = [high[i] - leadingSpan2[i] for i in range(0, len(high))]
-        diff_high_lead1 = [high[i] - leadingSpan1[i] for i in range(0, len(high))]
-        diff_high_change = [high[i] - changeLine[i] for i in range(0, len(high))]
-        diff_high_base = [high[i] - baseLine[i] for i in range(0, len(high))]
-        diff_low_lead2 = [low[i] - leadingSpan2[i] for i in range(0, len(low))]
-        diff_low_lead1 = [low[i] - leadingSpan1[i] for i in range(0, len(low))]
-        diff_low_change = [low[i] - changeLine[i] for i in range(0, len(low))]
-        diff_low_base = [low[i] - baseLine[i] for i in range(0, len(low))]
-        diff_macd_macds = [macd[i] - macds[i] for i in range(0, len(macd))]
-        diff_slowk_slowd = [slow_k[i] - slow_d[i] for i in range(0, len(slow_k))]
-        diff_rsi_rsis = [rsi[i] - rsis[i] for i in range(0, len(rsi))]
-
-        diff_macd, diff_macdo, diff_macds = [], [], []
-        diff_macd.append(0)
-        for i in range(1, len(macd)):
-            diff_macd.append(macd[i] - macd[i - 1])
-        diff_macdo.append(0)
-        for i in range(1, len(macdo)):
-            diff_macdo.append(macdo[i] - macdo[i - 1])
-        diff_macds.append(0)
-        for i in range(1, len(macds)):
-            diff_macds.append(macds[i] - macds[i - 1])
-
-        diff_fast_k, diff_slow_k, diff_slow_d = [], [], []
-        diff_fast_k.append(0)
-        for i in range(1, len(fast_k)):
-            diff_fast_k.append(fast_k[i] - fast_k[i - 1])
-        diff_slow_k.append(0)
-        for i in range(1, len(slow_k)):
-            diff_slow_k.append(slow_k[i] - slow_k[i - 1])
-        diff_slow_d.append(0)
-        for i in range(1, len(slow_d)):
-            diff_slow_d.append(slow_d[i] - slow_d[i - 1])
-
-        diff_rsi, diff_rsis = [], []
-        diff_rsi.append(0)
-        for i in range(1, len(rsi)):
-            diff_rsi.append(rsi[i] - rsi[i - 1])
-        diff_rsis.append(0)
-        for i in range(1, len(rsis)):
-            diff_rsis.append(rsis[i] - rsis[i - 1])
-
-        diff_changeLine, diff_baseLine = [], []
-        diff_changeLine.append(0)
-        for i in range(1, len(changeLine)):
-            diff_changeLine.append(changeLine[i] - changeLine[i - 1])
-        diff_baseLine.append(0)
-        for i in range(1, len(baseLine)):
-            diff_baseLine.append(baseLine[i] - baseLine[i - 1])
-
-        diff_upper, diff_lower = [], []
-        diff_upper.append(0)
-        for i in range(1, len(upper)):
-            diff_upper.append(upper[i] - upper[i - 1])
-        diff_lower.append(0)
-        for i in range(1, len(lower)):
-            diff_lower.append(lower[i] - lower[i - 1])
-
-        # 결과
-        temp = {
-            "date": point_temp,
-            "open": open, "high": high, "low": low, "close": close, "volume": vol,
-            "avg3": avg3, "avg6": avg6, "avg9": avg9, "avg12": avg12, "avg27": avg27, "avg54": avg54,
-            "upper": upper, "lower": lower,
-            "macd": macd, "macds": macds, "macdo": macdo,
-            "fast_k": fast_k, "slow_k": slow_k, "slow_d": slow_d,
-            "rsi": rsi, "rsis": rsis,
-            "changeLine": changeLine, "baseLine": baseLine, "leadingSpan1": leadingSpan1, "leadingSpan2": leadingSpan2,
-            "height": height, "top_tail_height": top_tail_height, "bottom_tail_height": bottom_tail_height,
-            "abs_avg_1": abs_avg_1, "abs_avg_2": abs_avg_2, "abs_avg_3": abs_avg_3, "abs_avg_4": abs_avg_4,
-            "abs_avg_5": abs_avg_5,
-            "diff_open": diff_open, "diff_close": diff_close, "diff_low": diff_low, "diff_high": diff_high,
-            "diff_avg3": diff_avg3, "diff_avg6": diff_avg6, "diff_avg9": diff_avg9, "diff_avg12": diff_avg12,
-            "diff_avg27": diff_avg27, "diff_avg54": diff_avg54,
-            "diff_macd": diff_macd, "diff_macdo": diff_macdo, "diff_macds": diff_macds,
-            "diff_fast_k": diff_fast_k, "diff_slow_k": diff_slow_k, "diff_slow_d": diff_slow_d,
-            "diff_rsi": diff_rsi, "diff_rsis": diff_rsis,
-            "diff_changeLine": diff_changeLine, "diff_baseLine": diff_baseLine,
-            "diff_upper": diff_upper, "diff_lower": diff_lower,
-            "diff_avg3_avg6": diff_avg3_avg6,
-            "diff_avg3_avg9": diff_avg3_avg9,
-            "diff_avg3_avg12": diff_avg3_avg12,
-            "diff_avg3_avg27": diff_avg3_avg27,
-            "diff_avg3_avg54": diff_avg3_avg54,
-            "diff_avg6_avg9": diff_avg6_avg9,
-            "diff_avg6_avg12": diff_avg6_avg12,
-            "diff_avg6_avg27": diff_avg6_avg27,
-            "diff_avg6_avg54": diff_avg6_avg54,
-            "diff_avg9_avg12": diff_avg9_avg12,
-            "diff_avg9_avg27": diff_avg9_avg27,
-            "diff_avg9_avg54": diff_avg9_avg54,
-            "diff_avg12_avg27": diff_avg12_avg27,
-            "diff_avg12_avg54": diff_avg12_avg54,
-            "diff_avg27_avg54": diff_avg27_avg54,
-            "diff_upper_lower": diff_upper_lower,
-            "diff_open_lower": diff_open_lower,
-            "diff_open_upper": diff_open_upper,
-            "diff_close_lower": diff_close_lower,
-            "diff_close_upper": diff_close_upper,
-            "diff_high_lower": diff_high_lower,
-            "diff_high_upper": diff_high_upper,
-            "diff_low_lower": diff_low_lower,
-            "diff_low_upper": diff_low_upper,
-            "diff_lead1_lead2": diff_lead1_lead2,
-            "diff_change_base": diff_change_base,
-            "diff_base_lead1": diff_base_lead1,
-            "diff_base_lead2": diff_base_lead2,
-            "diff_change_lead1": diff_change_lead1,
-            "diff_change_lead2": diff_change_lead2,
-            "diff_open_lead2": diff_open_lead2,
-            "diff_open_lead1": diff_open_lead1,
-            "diff_open_change": diff_open_change,
-            "diff_open_base": diff_open_base,
-            "diff_close_lead2": diff_close_lead2,
-            "diff_close_lead1": diff_close_lead1,
-            "diff_close_change": diff_close_change,
-            "diff_close_base": diff_close_base,
-            "diff_high_lead2": diff_high_lead2,
-            "diff_high_lead1": diff_high_lead1,
-            "diff_high_change": diff_high_change,
-            "diff_high_base": diff_high_base,
-            "diff_low_lead2": diff_low_lead2,
-            "diff_low_lead1": diff_low_lead1,
-            "diff_low_change": diff_low_change,
-            "diff_low_base": diff_low_base,
-            "diff_macd_macds": diff_macd_macds,
-            "diff_slowk_slowd": diff_slowk_slowd,
-            "diff_rsi_rsis": diff_rsi_rsis,
-
-            "label": label
-        }
-
-        data = pd.DataFrame(temp)
-        df_final_time = pd.DatetimeIndex(point_temp)
-        data.index = df_final_time
-
-        data = data.fillna(close[0])
-        return data
-
-    def write(self, outFp, df, i):
-        outFp.write(str(df["macd"][i]) + "\t")
-        outFp.write(str(df["macds"][i]) + "\t")
-        outFp.write(str(df["macdo"][i]) + "\t")
-        outFp.write(str(df["fast_k"][i]) + "\t")
-        outFp.write(str(df["slow_k"][i]) + "\t")
-        outFp.write(str(df["slow_d"][i]) + "\t")
-        outFp.write(str(df["rsi"][i]) + "\t")
-        outFp.write(str(df["rsis"][i]) + "\t")
-        outFp.write(str(df["height"][i]) + "\t")
-        outFp.write(str(df["top_tail_height"][i]) + "\t")
-        outFp.write(str(df["bottom_tail_height"][i]) + "\t")
-        outFp.write(str(df["abs_avg_1"][i]) + "\t")
-        outFp.write(str(df["abs_avg_2"][i]) + "\t")
-        outFp.write(str(df["abs_avg_3"][i]) + "\t")
-        outFp.write(str(df["abs_avg_4"][i]) + "\t")
-        outFp.write(str(df["abs_avg_5"][i]) + "\t")
-        outFp.write(str(df["diff_open"][i]) + "\t")
-        outFp.write(str(df["diff_close"][i]) + "\t")
-        outFp.write(str(df["diff_low"][i]) + "\t")
-        outFp.write(str(df["diff_high"][i]) + "\t")
-        outFp.write(str(df["diff_avg3"][i]) + "\t")
-        outFp.write(str(df["diff_avg6"][i]) + "\t")
-        outFp.write(str(df["diff_avg9"][i]) + "\t")
-        outFp.write(str(df["diff_avg12"][i]) + "\t")
-        outFp.write(str(df["diff_avg27"][i]) + "\t")
-        outFp.write(str(df["diff_avg54"][i]) + "\t")
-        outFp.write(str(df["diff_macd"][i]) + "\t")
-        outFp.write(str(df["diff_macdo"][i]) + "\t")
-        outFp.write(str(df["diff_macds"][i]) + "\t")
-        outFp.write(str(df["diff_fast_k"][i]) + "\t")
-        outFp.write(str(df["diff_slow_k"][i]) + "\t")
-        outFp.write(str(df["diff_slow_d"][i]) + "\t")
-        outFp.write(str(df["diff_rsi"][i]) + "\t")
-        outFp.write(str(df["diff_rsis"][i]) + "\t")
-        outFp.write(str(df["diff_changeLine"][i]) + "\t")
-        outFp.write(str(df["diff_baseLine"][i]) + "\t")
-        outFp.write(str(df["diff_upper"][i]) + "\t")
-        outFp.write(str(df["diff_lower"][i]) + "\t")
-        outFp.write(str(df["diff_avg3_avg6"][i]) + "\t")
-        outFp.write(str(df["diff_avg3_avg9"][i]) + "\t")
-        outFp.write(str(df["diff_avg3_avg12"][i]) + "\t")
-        outFp.write(str(df["diff_avg3_avg27"][i]) + "\t")
-        outFp.write(str(df["diff_avg3_avg54"][i]) + "\t")
-        outFp.write(str(df["diff_avg6_avg9"][i]) + "\t")
-        outFp.write(str(df["diff_avg6_avg12"][i]) + "\t")
-        outFp.write(str(df["diff_avg6_avg27"][i]) + "\t")
-        outFp.write(str(df["diff_avg6_avg54"][i]) + "\t")
-        outFp.write(str(df["diff_avg9_avg12"][i]) + "\t")
-        outFp.write(str(df["diff_avg9_avg27"][i]) + "\t")
-        outFp.write(str(df["diff_avg9_avg54"][i]) + "\t")
-        outFp.write(str(df["diff_avg12_avg27"][i]) + "\t")
-        outFp.write(str(df["diff_avg12_avg54"][i]) + "\t")
-        outFp.write(str(df["diff_avg27_avg54"][i]) + "\t")
-        outFp.write(str(df["diff_upper_lower"][i]) + "\t")
-        outFp.write(str(df["diff_open_lower"][i]) + "\t")
-        outFp.write(str(df["diff_open_upper"][i]) + "\t")
-        outFp.write(str(df["diff_close_lower"][i]) + "\t")
-        outFp.write(str(df["diff_close_upper"][i]) + "\t")
-        outFp.write(str(df["diff_high_lower"][i]) + "\t")
-        outFp.write(str(df["diff_high_upper"][i]) + "\t")
-        outFp.write(str(df["diff_low_lower"][i]) + "\t")
-        outFp.write(str(df["diff_low_upper"][i]) + "\t")
-        outFp.write(str(df["diff_lead1_lead2"][i]) + "\t")
-        outFp.write(str(df["diff_change_base"][i]) + "\t")
-        outFp.write(str(df["diff_base_lead1"][i]) + "\t")
-        outFp.write(str(df["diff_base_lead2"][i]) + "\t")
-        outFp.write(str(df["diff_change_lead1"][i]) + "\t")
-        outFp.write(str(df["diff_change_lead2"][i]) + "\t")
-        outFp.write(str(df["diff_open_lead2"][i]) + "\t")
-        outFp.write(str(df["diff_open_lead1"][i]) + "\t")
-        outFp.write(str(df["diff_open_change"][i]) + "\t")
-        outFp.write(str(df["diff_open_base"][i]) + "\t")
-        outFp.write(str(df["diff_close_lead2"][i]) + "\t")
-        outFp.write(str(df["diff_close_lead1"][i]) + "\t")
-        outFp.write(str(df["diff_close_change"][i]) + "\t")
-        outFp.write(str(df["diff_close_base"][i]) + "\t")
-        outFp.write(str(df["diff_high_lead2"][i]) + "\t")
-        outFp.write(str(df["diff_high_lead1"][i]) + "\t")
-        outFp.write(str(df["diff_high_change"][i]) + "\t")
-        outFp.write(str(df["diff_high_base"][i]) + "\t")
-        outFp.write(str(df["diff_low_lead2"][i]) + "\t")
-        outFp.write(str(df["diff_low_lead1"][i]) + "\t")
-        outFp.write(str(df["diff_low_change"][i]) + "\t")
-        outFp.write(str(df["diff_low_base"][i]) + "\t")
-        outFp.write(str(df["diff_macd_macds"][i]) + "\t")
-        outFp.write(str(df["diff_slowk_slowd"][i]) + "\t")
-        outFp.write(str(df["diff_rsi_rsis"][i]) + "\t")
-        outFp.write(str(df["label"][i]) + "\n")
-        return
-
     def checkTransaction(self, stock_code, data, data_5=None, data_30=None, isRealTime=True):
         # 어제 오늘 데이터로 분석
-        bsLine = {}
+        bsLine = {stock_code: {}}
         size = len(data["close"])
 
         if isRealTime:
             # isRealTime=True, 실시간 적용
             last_index = size - 1
 
-            buy, buy_weight = self.getBuyPriceAndWeight(last_index, data, data_5, data_30)
+            buy, buy_weight = self.getBuyPriceAndWeight(stock_code, last_index, data, data_5, data_30)
-            sell, sell_weight = self.getSellPriceAndWeight(last_index, data, data_5, data_30)
+            sell, sell_weight = self.getSellPriceAndWeight(stock_code, last_index, data, data_5, data_30)
+            if sell > 0 and 'last_buy' in bsLine[stock_code]:
+                if bsLine[stock_code]['last'] == 'buy':
+                    if sell - bsLine[stock_code]['last_buy'] < 0.007:
+                        sell, weight = -1, -1
+            if 'last' in bsLine[stock_code] and bsLine[stock_code]['last'] != 'buy':
+                sell, weight = -1, -1
 
-            bsLine['buy'] = [buy]
+            bsLine[stock_code]['buy'] = [buy]
-            bsLine['buy_weight'] = [buy_weight]
+            bsLine[stock_code]['buy_weight'] = [buy_weight]
-            bsLine['sell'] = [sell]
+            bsLine[stock_code]['sell'] = [sell]
-            bsLine['sell_weight'] = [sell_weight]
+            bsLine[stock_code]['sell_weight'] = [sell_weight]
+            if buy > 0:
+                bsLine[stock_code]['last'] = 'buy'
+                bsLine[stock_code]['last_buy'] = buy
+            if sell > 0:
+                bsLine[stock_code]['last'] = 'sell'
 
         else:
             # Type=False, 시뮬레이션 적용
-            bsLine['buy'] = [-1 for i in range(size)]
+            bsLine[stock_code]['buy'] = [-1 for i in range(size)]
-            bsLine['buy_weight'] = [-1 for i in range(size)]
+            bsLine[stock_code]['buy_weight'] = [-1 for i in range(size)]
-            bsLine['sell'] = [-1 for i in range(size)]
+            bsLine[stock_code]['sell'] = [-1 for i in range(size)]
-            bsLine['sell_weight'] = [-1 for i in range(size)]
+            bsLine[stock_code]['sell_weight'] = [-1 for i in range(size)]
 
-            for i in range(size):
+            for last_index in range(size):
-                buy, buy_weight = self.getBuyPriceAndWeight(i, data, data_5, data_30)
+                buy, buy_weight = self.getBuyPriceAndWeight(stock_code, last_index, data, data_5, data_30)
-                sell, sell_weight = self.getSellPriceAndWeight(i, data, data_5, data_30)
+                sell, sell_weight = self.getSellPriceAndWeight(stock_code, last_index, data, data_5, data_30)
+                if data.index[last_index].strftime('%H:%M:%S') > datetime.strptime(datetime.today().strftime("%Y-%m-%d 15:00:00"), "%Y-%m-%d %H:%M:%S").strftime('%H:%M:%S'):
+                    buy, buy_weight = -1, -1
 
-                bsLine['buy'][i] = buy
+                if sell > 0:
-                bsLine['buy_weight'][i] = buy_weight
+                    if 'last_buy' in bsLine[stock_code]:
-                bsLine['sell'][i] = sell
+                        if bsLine[stock_code]['last'] == 'buy':
-                bsLine['sell_weight'][i] = sell_weight
+                            if sell - bsLine[stock_code]['last_buy'] < 0.007:
+                                sell, weight = -1, -1
+                    else:
+                        sell, weight = -1, -1
+                if 'last' in bsLine[stock_code] and bsLine[stock_code]['last'] != 'buy':
+                    sell, weight = -1, -1
+                if data.index[last_index].strftime('%H:%M:%S') > datetime.strptime(datetime.today().strftime("%Y-%m-%d 15:10:00"), "%Y-%m-%d %H:%M:%S").strftime('%H:%M:%S'):
+                    if 'last' in bsLine[stock_code] and bsLine[stock_code]['last'] == 'buy':
+                        sell, weight = data['close'][last_index], -1
+                        bsLine[stock_code]['last'] = ''
+                        bsLine[stock_code]['last_buy'] = -1
+
+                bsLine[stock_code]['buy'][last_index] = buy
+                bsLine[stock_code]['buy_weight'][last_index] = buy_weight
+                bsLine[stock_code]['sell'][last_index] = sell
+                bsLine[stock_code]['sell_weight'][last_index] = sell_weight
+                if buy > 0:
+                    bsLine[stock_code]['last'] = 'buy'
+                    bsLine[stock_code]['last_buy'] = buy
+                if sell > 0:
+                    bsLine[stock_code]['last'] = 'sell'
 
         return bsLine
 

stock/analysis/Common.py

@@ -4,21 +4,16 @@ from stock.analysis.MovingAverage import MovingAverage
 class Common:
 
     # 상향
-    def checkUpward(self, type, data):
+    def checkUpward(self, data, idx):
-        check = True
+        up, down = 0, 0
-        if type is not None:
+        for i in range(idx, idx-11, -1):
-            for i in range(len(data)-1):
+            if data[i-1] < data[i]:
-                # 만약 이전이 이후보다 크다면, 상승이 아님
+                up += 1
-                if data[i][type] > data[i+1][type]:
+            else:
-                    check = False
+                down += 1
-                    break
+        if up > down:
-        else:
+            return True
-            for i in range(len(data)-1):
+        return False
-                # 만약 이전이 이후보다 크다면, 상승이 아님
-                if data[i] > data[i+1]:
-                    check = False
-                    break
-        return check
 
     # 하향
     def checkDownward(self, type, data):