analyser_hj3415 3.4.2__py3-none-any.whl → 4.0.0__py3-none-any.whl

analyser_hj3415/analyser/eval/red.py

@@ -1,7 +1,9 @@
 import os
+from collections import OrderedDict
 from dataclasses import dataclass
-from typing import Tuple
+from typing import Tuple, Dict, List
 import math
+import pickle
 
 from utils_hj3415 import tools, setup_logger
 from db_hj3415 import myredis
@@ -9,7 +11,7 @@ from db_hj3415 import myredis
 from analyser_hj3415.analyser.eval.common import Tools
 
 
-mylogger = setup_logger(__name__,'WARNING')
+mylogger = setup_logger(__name__,'INFO')
 expire_time = tools.to_int(os.getenv('DEFAULT_EXPIRE_TIME_H', 48)) * 3600
 
 
@@ -87,6 +89,7 @@ class Red:
         recent_price (float): 최근 주가.
         expect_earn (float): 기대수익률. 기본값은 0.06 (6%).
     """
+    REDIS_RED_DATA_SUFFIX = "red_data"
 
     def __init__(self, code: str, expect_earn: float = 0.06):
         assert tools.is_6digit(code), f'Invalid value : {code}'
@@ -137,7 +140,7 @@ class Red:
         로그:
             - 비유동부채 데이터가 없을 경우 경고 메시지를 출력합니다.
         """
-        mylogger.info(f'In the calc비유동부채... refresh : {refresh}')
+        mylogger.debug(f'In the calc비유동부채... refresh : {refresh}')
         self.c103.page = 'c103재무상태표q'
 
         d, 비유동부채 = self.c103.sum_recent_4q('비유동부채', refresh)
@@ -264,30 +267,69 @@ class Red:
             score = score,
         )
 
-    def get(self, refresh = False, verbose = True) -> RedData:
-        """
-        RedData 객체를 Redis 캐시에서 가져오거나, 새로 계산하여 반환합니다.
-
-        캐시에서 데이터를 검색하고, 없을 경우 `_generate_data`를 호출하여 새로운 데이터를 생성한 후,
-        캐시에 저장합니다.
-
-        매개변수:
-            refresh (bool, optional): 캐시 데이터를 무시하고 새로 계산 여부. 기본값은 False.
-            verbose (bool, optional): 실행 중 상세 정보를 출력 여부. 기본값은 True.
-
-        반환값:
-            RedData: Redis 캐시에서 가져오거나 새로 생성된 RedData 객체.
-
-        로그:
-            - 캐시 검색 상태와 새로 계산된 데이터를 출력합니다.
-        """
-        redis_name = f"{self.code}_red_data"
-        mylogger.info(f"{self} RedData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
-        if verbose:
-            print(f"{self} redisname: '{redis_name}' / expect_earn: {self.expect_earn} / refresh : {refresh} / expire_time : {expire_time/3600}h")
+    def get(self, refresh = False) -> RedData:
+        mylogger.info(f"*** Get red data ***")
+        redis_name = f"{self.code}_{self.REDIS_RED_DATA_SUFFIX}_{self.expect_earn}"
+        mylogger.info(f"{self} redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time/3600}h")
 
         def fetch_generate_data(refresh_in: bool) -> RedData:
             return self._generate_data(refresh_in) # type: ignore
 
         return myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_generate_data, refresh, timer=expire_time)
 
+    @classmethod
+    def bulk_generate_data(cls, codes: List[str], expect_earn: float, refresh: bool) -> Dict[str, RedData]:
+        # --- (1) 파이프라인 GET ---
+        pipe = myredis.Base.redis_client.pipeline()
+        redis_keys = [f"{code}_{cls.REDIS_RED_DATA_SUFFIX}_{expect_earn}" for code in codes]
+        for redis_key in redis_keys:
+            pipe.get(redis_key)
+        results_from_redis = pipe.execute()  # [val1, val2, ...]
+
+        final_results = {}
+        missing_codes = []
+
+        # refresh=True 이면 기존 데이터 무시하고 다시 계산해야 하므로 모두 missing 처리
+        if refresh:
+            missing_codes = codes[:]
+        else:
+            # refresh=False 이면, Redis 값이 None인 티커만 다시 계산
+            for code, val in zip(codes, results_from_redis):
+                if val is None:
+                    missing_codes.append(code)
+                else:
+                    # Redis에 pickled 데이터가 있다면 언피클해서 담기
+                    red_data = pickle.loads(val)
+                    final_results[code] = red_data
+
+        # --- (2) 필요한 티커만 직접 연산 ---
+        newly_computed_data = {}
+        for code in missing_codes:
+            mylogger.debug(f"*** bulk_generate_data : {code}")
+            data = cls(code, expect_earn)._generate_data(refresh=refresh)
+            newly_computed_data[code] = data
+
+        # --- (3) 파이프라인 SET ---
+        if newly_computed_data:
+            pipe = myredis.Base.redis_client.pipeline()
+            for code, data in newly_computed_data.items():
+                redis_key = f"{code}_{cls.REDIS_RED_DATA_SUFFIX}_{expect_earn}"
+                # ProphetLatestData 객체를 pickle로 직렬화
+                pickled_data = pickle.dumps(data)
+                # SET + expire_time
+                pipe.setex(redis_key, expire_time, pickled_data)
+            pipe.execute()
+
+        # 최종 결과 딕셔너리 (캐시에 있었던 것 + 새로 만든 것)
+        final_results.update(newly_computed_data)
+        return final_results
+
+    @staticmethod
+    def ranking(expect_earn: float = 0.06, refresh=False) -> OrderedDict:
+        mylogger.info("**** Start red ranking ... ****")
+
+        data = Red.bulk_generate_data(myredis.Corps.list_all_codes(), expect_earn, refresh)
+        mylogger.debug(data)
+        return  OrderedDict(sorted(data.items(), key=lambda x: x[1].score, reverse=True))
+
+

analyser_hj3415/analyser/tsa/lstm.py

@@ -1,12 +1,10 @@
 import os
 import numpy as np
+import pandas
 import yfinance as yf
 from datetime import datetime, timedelta
 import pandas as pd
-from typing import Optional, Tuple
-import plotly.graph_objs as go
-from plotly.offline import plot
-import matplotlib.pyplot as plt  # Matplotlib 수동 임포트
+from typing import Tuple, Dict, List
 from sklearn.preprocessing import MinMaxScaler
 from tensorflow.keras.models import Sequential # type: ignore
 from tensorflow.keras.layers import LSTM, Dense, Dropout # type: ignore
@@ -19,7 +17,7 @@ from utils_hj3415 import tools, setup_logger
 from db_hj3415 import myredis
 from analyser_hj3415.analyser import MIs, tsa
 
-mylogger = setup_logger(__name__,'WARNING')
+mylogger = setup_logger(__name__,'INFO')
 expire_time = tools.to_int(os.getenv('DEFAULT_EXPIRE_TIME_H', 48)) * 3600
 
 
@@ -75,6 +73,17 @@ class LSTMGrade:
     test_r2: float
 
 
+@dataclass
+class LSTMChartData:
+    ticker: str
+    labels: List[pandas.Timestamp]
+    prices: List[Dict[pandas.Timestamp, float]]
+    future_prices: List[Dict[pandas.Timestamp, float]]
+    grade: LSTMGrade
+    num: int
+    is_lstm_up: bool
+
+
 class MyLSTM:
     """
     주가 데이터를 기반으로 LSTM 모델을 생성, 학습 및 예측하는 클래스.
@@ -90,9 +99,10 @@ class MyLSTM:
     future_days = 30
 
     def __init__(self, ticker: str):
-        mylogger.info(f'set up ticker : {ticker}')
+        mylogger.info(f'MyLSTM set up ticker : {ticker}')
         self.scaler = MinMaxScaler(feature_range=(0, 1))
         self._ticker = ticker
+        self.initialized = False
 
         self.raw_data = pd.DataFrame()
         self.lstm_data = LSTMData(
@@ -113,9 +123,10 @@ class MyLSTM:
 
     @ticker.setter
     def ticker(self, ticker: str):
-        mylogger.info(f'change ticker : {self.ticker} -> {ticker}')
+        mylogger.info(f'MyLstm change ticker : {self.ticker} -> {ticker}')
         self.scaler = MinMaxScaler(feature_range=(0, 1))
         self._ticker = ticker
+        self.initialized = False
 
         self.raw_data = pd.DataFrame()
         self.lstm_data = LSTMData(
@@ -148,7 +159,7 @@ class MyLSTM:
 
             # 4년 전 날짜 계산 (4년 = 365일 * 4)
             four_years_ago = today - timedelta(days=365 * 4)
-            mylogger.info(
+            mylogger.debug(
                 f"Get raw data from yfinance - start: {four_years_ago.strftime('%Y-%m-%d')}, end: {today.strftime('%Y-%m-%d')}")
 
             df = yf.download(
@@ -165,7 +176,7 @@ class MyLSTM:
             lstm이 사용할 수 있도록 데이터 준비(정규화 및 8:2 훈련데이터 검증데이터 분리 및 차원변환)
             :return:
             """
-            mylogger.info("lstm이 사용할 수 있도록 데이터 준비(정규화 및 8:2 훈련데이터 검증데이터 분리 및 차원변환)")
+            mylogger.debug("lstm이 사용할 수 있도록 데이터 준비(정규화 및 8:2 훈련데이터 검증데이터 분리 및 차원변환)")
             # 필요한 열만 선택 (종가만 사용) - 2차웜 배열로 변환
             data_2d = self.raw_data['Close'].values.reshape(-1, 1)
             mylogger.debug(f"종가데이터 2차원베열값[:5] : {data_2d[:5]}")
@@ -178,7 +189,7 @@ class MyLSTM:
             train_size = int(len(scaled_data_2d) * 0.8)
             train_data_2d = scaled_data_2d[:train_size]
             test_data_2d = scaled_data_2d[train_size:]
-            mylogger.info(f'총 {len(data_2d)}개 데이터, train size : {train_size}')
+            mylogger.debug(f'총 {len(data_2d)}개 데이터, train size : {train_size}')
 
             # 학습 데이터에 대한 입력(X)과 정답(y)를 생성
             def create_dataset(data, time_step=60):
@@ -228,10 +239,13 @@ class MyLSTM:
                 y_test_1d=y_test_1d,
             )
 
+        mylogger.info("*** Initializing ***")
+
         self.scaler = MinMaxScaler(feature_range=(0, 1))
 
         self.raw_data = get_raw_data()
         self.lstm_data = preprocessing_for_lstm()
+        self.initialized = True
 
     def ensemble_training(self, num) -> Tuple[list, LSTMGrade]:
         """
@@ -289,7 +303,7 @@ class MyLSTM:
             """
             predictions_2d = model_in.predict(data)
             predictions_scaled_2d = self.scaler.inverse_transform(predictions_2d)  # 스케일링 복원
-            mylogger.info(
+            mylogger.debug(
                 f'predictions_scaled_2d : ndim - {predictions_scaled_2d.ndim} len - {len(predictions_scaled_2d)}')  # numpy.ndarray 타입
             mylogger.debug(f'predictions_scaled_2d[:5] :{predictions_scaled_2d[:5]}')
             return predictions_scaled_2d
@@ -331,10 +345,10 @@ class MyLSTM:
             test_r2 = r2_score(y_test_scaled_2d, mean_test_predictions_2d)
 
             # 평가 결과 출력
-            print("Training Data:")
-            print(f"Train MSE: {train_mse}, Train MAE: {train_mae}, Train R²: {train_r2}")
-            print("\nTesting Data:")
-            print(f"Test MSE: {test_mse}, Test MAE: {test_mae}, Test R²: {test_r2}")
+            mylogger.debug("Training Data:")
+            mylogger.debug(f"Train MSE: {train_mse}, Train MAE: {train_mae}, Train R²: {train_r2}")
+            mylogger.debug("\nTesting Data:")
+            mylogger.debug(f"Test MSE: {test_mse}, Test MAE: {test_mae}, Test R²: {test_r2}")
             # mse, mae는 작을수록 좋으며 R^2은 0-1 사이값 1에 가까울수록 정확함
             # 과적합에 대한 평가는 train 과 test를 비교하여 test가 너무 않좋으면 과적합 의심.
 
@@ -348,19 +362,21 @@ class MyLSTM:
                 test_r2=test_r2,
             )
 
+        mylogger.info(f"*** ensemble training / num : {num} ***")
+
         ensemble_train_predictions_2d = []
         ensemble_test_predictions_2d = []
         ensemble_future_predictions_2d = []
 
         for i in range(num):
-            print(f"Training model {i + 1}/{num}...")
+            mylogger.info(f"Training model {i + 1}/{num}...")
             model = model_training()
 
             if len(model.layers) == 0:
                 mylogger.warning("이 모델은 빈 Sequential() 입니다.")
                 return [], grading([],[])
             else:
-                mylogger.info("레이어가 있는 모델입니다.")
+                mylogger.debug("레이어가 있는 모델입니다.")
 
                 # 훈련 데이터 예측
                 train_predictions_scaled_2d = prediction(model, self.lstm_data.X_train_3d)
@@ -390,11 +406,12 @@ class MyLSTM:
                 future_predictions_scaled_2d = self.scaler.inverse_transform(future_predictions_2d)
                 ensemble_future_predictions_2d.append(future_predictions_scaled_2d)
 
+
         lstm_grade = grading(ensemble_train_predictions_2d, ensemble_test_predictions_2d)
 
         return ensemble_future_predictions_2d, lstm_grade
 
-    def get_final_predictions(self, refresh: bool, num=5) -> Tuple[dict, LSTMGrade]:
+    def get_final_predictions(self, refresh: bool, num=5) -> Tuple[Dict[str, float], LSTMGrade]:
         """
         LSTM 모델을 사용하여 미래 주가를 예측하고 평가 데이터를 반환합니다.
 
@@ -409,10 +426,10 @@ class MyLSTM:
             - 캐시 데이터 검색 및 새 데이터 생성 과정 출력.
             - 예측 값의 증가 추세를 분석하여 캐시에 저장.
         """
-        print("**** Start get_final_predictions... ****")
+        mylogger.info("**** Start get_final_predictions... ****")
         redis_name = f'{self.ticker}_mylstm_predictions'
 
-        print(
+        mylogger.info(
             f"redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time/3600}h")
 
         def caching_is_lstm_up(future_data_in: dict):
@@ -424,9 +441,9 @@ class MyLSTM:
                 bool: 기울기가 양수이면 True, 아니면 False
             """
 
-            print("**** Caching is_lstm_up ... ****")
+            mylogger.debug("**** Caching is_lstm_up ... ****")
             redis_name = f'{self.ticker}_is_lstm_up'
-            print(f"redisname: '{redis_name}' / expire_time : {expire_time / 3600}h")
+            mylogger.debug(f"redisname: '{redis_name}' / expire_time : {expire_time / 3600}h")
 
             is_up = tsa.common.is_up_by_OLS(future_data_in)
             mylogger.debug(f"is_up: {is_up}")
@@ -456,7 +473,8 @@ class MyLSTM:
                     data[future_dates[i].strftime("%Y-%m-%d")] = final_future_predictions[i][0]
                 return data
 
-            self.initializing()
+            if not self.initialized:
+                self.initializing()
             # 앙상블 트레이닝 시행
             future_predictions_2d, lstm_grade = self.ensemble_training(num=num_in)
             mylogger.debug(f'future_predictions_2d[:5] : {future_predictions_2d[:5]}')
@@ -477,159 +495,72 @@ class MyLSTM:
 
         return future_data, lstm_grade
 
-    def export(self, refresh=False, to="html", num=5) -> Optional[str]:
-        """
-        과거 및 예측된 주가 데이터를 기반으로 시각화를 생성하고 저장합니다.
+    def generate_chart_data(self, refresh:bool, num=5) -> LSTMChartData:
+        mylogger.info("**** Start generate_lstm_chart_data... ****")
+        redis_name = f'{self.ticker}_lstm_chart_data'
 
-        매개변수:
-            refresh (bool): 데이터 새로고침 여부. 기본값은 False.
-            to (str): 그래프 출력 형식 ('hrml', 'png', 'file'). 기본값은 'html'.
-            num (int): 예측 모델 수. 기본값은 5.
+        mylogger.info(
+            f"redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time / 3600}h")
 
-        반환값:
-            Optional[str]: HTML 형식의 그래프 문자열(`to='html'`인 경우).
-            None: PNG 또는 HTML 파일로 저장된 경우.
+        def fetch_generate_lstm_chart_data(num_in) -> LSTMChartData:
+            def prepare_past_data(past_days) -> tuple:
+                mylogger.info("*** prepare past data ... ****")
+                # 데이터 준비
+                raw_data_copied = self.raw_data.reset_index()
+                data = raw_data_copied[['Date', 'Close']][-past_days:].reset_index(drop=True)
 
-        예외:
-            Exception: 잘못된 `to` 값이 주어졌을 때 발생.
-        """
-        def prepare_past_data(past_days) -> tuple:
-            # 데이터 준비
-            raw_data_copied = self.raw_data.reset_index()
-            data = raw_data_copied[['Date', 'Close']][-past_days:].reset_index(drop=True)
-
-            # 'Date'와 'Close' 열 추출
-            past_dates = pd.to_datetime(data['Date'])
-            past_prices = data['Close']
-
-            # 'past_prices'가 Series인지 확인
-            if isinstance(past_prices, pd.DataFrame):
-                past_prices = past_prices.squeeze()
-
-            # 'Close' 열의 데이터 타입 변경
-            past_prices = past_prices.astype(float)
-            return past_dates, past_prices
-
-        def prepare_future_data(refresh_in, num_in) -> tuple:
-            future_data, lstm_grade = self.get_final_predictions(refresh=refresh_in, num=num_in)
-
-            # 예측 데이터 준비
-            future_dates = pd.to_datetime(list(future_data.keys()))
-
-            future_prices = pd.Series(future_data.values(), index=range(len(future_data.values()))).astype(float)
-            return future_dates, future_prices
-
-        self.initializing()
-        past_dates, past_prices = prepare_past_data(past_days=120)
-        future_dates, future_prices = prepare_future_data(refresh_in=refresh, num_in=num)
-
-        # 그래프 생성
-        fig = go.Figure()
-
-        # 실제 데이터 추가
-        fig.add_trace(go.Scatter(
-            x=past_dates,
-            y=past_prices,
-            mode='markers',
-            name='실제주가'
-        ))
-
-        # 예측 데이터 추가
-        fig.add_trace(go.Scatter(
-            x=future_dates,
-            y=future_prices,
-            mode='lines+markers',
-            name='예측치(30일)'
-        ))
-
-        # 레이아웃 업데이트
-        fig.update_layout(
-            xaxis_title='일자',
-            yaxis_title='주가(원)',
-            xaxis=dict(
-                tickformat='%Y/%m',
-            ),
-            yaxis=dict(
-                tickformat=".0f",
-            ),
-            showlegend=True,
-        )
+                # 'Date'와 'Close' 열 추출
+                past_dates = pd.to_datetime(data['Date'])
+                past_prices = data['Close']
 
-        mylogger.debug(f"past_dates({len(past_dates)}) - {past_dates}")
-        mylogger.debug(f"past_prices({len(past_prices)} - {past_prices}")
-        mylogger.debug(f"future_dates({len(future_dates)}) - {future_dates}")
-        mylogger.debug(f"future_prices({len(future_prices)}) - {future_prices}")
-
-        fig.update_layout(
-            # title=f'{self.code} {self.name} 주가 예측 그래프(prophet)',
-            xaxis_title='일자',
-            yaxis_title='주가(원)',
-            xaxis=dict(
-                tickformat='%Y/%m',  # X축을 '연/월' 형식으로 표시
-            ),
-            yaxis=dict(
-                tickformat=".0f",  # 소수점 없이 원래 숫자 표시
-            ),
-            showlegend=False,
-        )
+                # 'past_prices'가 Series인지 확인
+                if isinstance(past_prices, pd.DataFrame):
+                    past_prices = past_prices.squeeze()
 
-        if to == 'html':
-            # 그래프 HTML로 변환 (string 형식으로 저장)
-            graph_html = plot(fig, output_type='div')
-            return graph_html
-        elif to == 'png':
-            # 그래프를 PNG 파일로 저장
-            fig.write_image(f"myLSTM_{self.ticker}.png")
-            return None
-        elif to == 'file':
-            # 그래프를 HTML로 저장
-            plot(fig, filename=f'myLSTM_{self.ticker}.html', auto_open=False)
-            return None
-        else:
-            Exception("to 인자가 맞지 않습니다.")
-
-    def visualization(self, refresh=True):
-        """
-        실제 주가와 예측 주가를 시각화합니다.
+                # 'Close' 열의 데이터 타입 변경
+                past_prices = past_prices.astype(float)
+                return past_dates, past_prices
 
-        매개변수:
-            refresh (bool): 예측 데이터를 새로고침할지 여부. 기본값은 True.
+            def prepare_future_data(refresh_in, num_in) -> tuple:
+                mylogger.info("*** prepare future data ... ****")
+                future_data, lstm_grade = self.get_final_predictions(refresh=refresh_in, num=num_in)
 
-        반환값:
-            None: 시각화를 출력합니다.
-        """
-        self.initializing()
-        future_data, _ = self.get_final_predictions(refresh=refresh)
-        mylogger.debug(f'future_data : {future_data}')
-        future_dates = pd.to_datetime(list(future_data.keys()))
-        mylogger.debug(f'future_dates : {future_dates}')
-        future_prices = pd.Series(future_data.values(), index=range(len(future_data.values()))).astype(float)
-        mylogger.debug(f'future_prices : {future_prices}')
-
-        # 시각화1
-        plt.figure(figsize=(10, 6))
-
-        # 실제 주가
-        plt.plot(self.raw_data.index, self.raw_data['Close'], label='Actual Price')
-
-        # 미래 주가 예측
-        plt.plot(future_dates, future_prices, label='Future Predicted Price', linestyle='--')
-
-        plt.xlabel('Date')
-        plt.ylabel('Stock Price')
-        plt.legend()
-        plt.title(f'{self.ticker} Stock Price Prediction with LSTM')
-        plt.show()
-
-        """# 시각화2
-        plt.figure(figsize=(10, 6))
-        plt.plot(self.raw_data.index[self.lstm_data.train_size + 60:], self.lstm_data.data_2d[self.lstm_data.train_size + 60:], label='Actual Price')
-        plt.plot(self.raw_data.index[self.lstm_data.train_size + 60:], lstm_grade.mean_test_predictions_2d, label='Predicted Price')
-        plt.xlabel('Date')
-        plt.ylabel('Price')
-        plt.legend()
-        plt.title('Stock Price Prediction with LSTM Ensemble')
-        plt.show()"""
+                # 예측 데이터 준비
+                future_dates = pd.to_datetime(list(future_data.keys()))
+
+                future_prices = pd.Series(future_data.values(), index=range(len(future_data.values()))).astype(float)
+                return future_dates, future_prices, lstm_grade
+
+            if not self.initialized:
+                self.initializing()
+            past_dates, past_prices = prepare_past_data(past_days=120)
+            future_dates, future_prices, lstm_grade = prepare_future_data(refresh_in=refresh, num_in=num)
+            past_df = pd.DataFrame({"ds": past_dates, "y": past_prices})
+            future_df = pd.DataFrame({"ds": future_dates, "future_price": future_prices})
+
+            # 날짜(ds)를 기준으로 outer join
+            merged_df = pd.merge(past_df, future_df, on="ds", how="outer")
+            mylogger.debug(f"df_merged head: {merged_df.head()}")
+            mylogger.debug(f"df_merged tail: {merged_df.tail()}")
+
+            data = LSTMChartData(
+                ticker=self.ticker,
+                labels=merged_df["ds"].tolist(),
+                prices=[{"x": ds, "y": y} for ds, y in zip(merged_df["ds"], merged_df["y"]) if pd.notna(y)], # type: ignore
+                future_prices=[{"x": ds, "y": future_price} for ds, future_price in zip(merged_df["ds"], merged_df["future_price"])], # type: ignore
+                grade=lstm_grade,
+                num=num_in,
+                is_lstm_up=self.is_lstm_up(),
+            )
+            #import pprint
+            #pprint.pprint(data.prices[-10:], compact=True)
+            #pprint.pprint(data.future_prices[:10], compact=True)
+            #print(data.grade)
+            return data
+
+        lstm_chart_data = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_generate_lstm_chart_data,
+                                                            num, timer=expire_time)
+        return lstm_chart_data
 
     def is_lstm_up(self) -> bool:
         """
@@ -640,6 +571,16 @@ class MyLSTM:
         """
         return myredis.Base.get_value(f'{self.ticker}_is_lstm_up')
 
+    @staticmethod
+    def caching_chart_data(tickers:list, num:int):
+        mylogger.info(f"*** caching_chart_data ***")
+        mylstm = MyLSTM('005930.KS')
+        for i, ticker in enumerate(tickers):
+            mylstm.ticker = ticker
+            mylogger.info(f"{i + 1}. {ticker}")
+            chart_data = mylstm.generate_chart_data(refresh=True, num=num)
+            mylogger.debug(chart_data)
+
 
 class CorpLSTM(MyLSTM):
     """
@@ -666,6 +607,26 @@ class CorpLSTM(MyLSTM):
         self.name = myredis.Corps(code, 'c101').get_name()
         self.ticker = self.code + '.KS'
 
+    @staticmethod
+    def ticker_to_code(ticker: str):
+        return ticker[:-3]
+
+    @staticmethod
+    def code_to_ticker(code: str):
+        return code + '.KS'
+
+    @staticmethod
+    def caching_chart_data_topn(top=40, num=5):
+        mylogger.info(f"*** caching_chart_data_topn : {top}  ***")
+        ranking_topn = tsa.CorpProphet.ranking(refresh=False, top=top)
+        mylogger.debug(ranking_topn)
+        MyLSTM.caching_chart_data([CorpLSTM.code_to_ticker(code) for code in ranking_topn.keys() ], num=num)
+
+    @staticmethod
+    def caching_chart_data_bulk(codes: list, num=5):
+        mylogger.info(f"*** caching_chart_data_bulk : {len(codes)} items  ***")
+        MyLSTM.caching_chart_data([CorpLSTM.code_to_ticker(code) for code in codes], num=num)
+
 
 class MILSTM(MyLSTM):
     """
@@ -689,3 +650,11 @@ class MILSTM(MyLSTM):
         self._mi_type = mi_type
         self.ticker = getattr(MIs, mi_type)
 
+    @staticmethod
+    def caching_chart_data_mi_all(num=5):
+        mylogger.info(f"*** caching_chart_data_mi_all ***")
+        mylogger.debug(f"mi_type : {MIs._fields}")
+        MyLSTM.caching_chart_data([getattr(MIs, mi_type) for mi_type in MIs._fields], num=num)
+
+
+