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

analyser_hj3415/analyser/tsa/prophet.py

@@ -1,14 +1,13 @@
+from collections import OrderedDict
 from datetime import datetime, timedelta
-from typing import Optional, Tuple, List, Dict
+from typing import Tuple, List, Dict, Union
 
 import pandas
+import pickle
 import yfinance as yf
 import pandas as pd
 from prophet import Prophet
 from sklearn.preprocessing import StandardScaler
-import matplotlib.pyplot as plt  # Matplotlib 수동 임포트
-import plotly.graph_objs as go
-from plotly.offline import plot
 from dataclasses import dataclass
 import os
 
@@ -18,12 +17,12 @@ from db_hj3415 import myredis
 from analyser_hj3415.analyser import eval, 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
 
 
 @dataclass
-class ProphetData:
+class ProphetLatestData:
     ticker: str
 
     date: datetime.date
@@ -45,13 +44,19 @@ class ProphetChartData:
     yhat_uppers: List[Dict[pandas.Timestamp, float]]
     yhat_lowers: List[Dict[pandas.Timestamp, float]]
 
+    is_prophet_up: bool
+
 
 class MyProphet:
+
+    REDIS_LATEST_DATA_SUFFIX = "myprophet_data"
+
     def __init__(self, ticker: str):
-        mylogger.info(f'set up ticker : {ticker}')
+        mylogger.debug(f'set up ticker : {ticker}')
         self.scaler = StandardScaler()
         self.model = Prophet()
         self._ticker = ticker
+        self.initialized = False
 
         self.raw_data = pd.DataFrame()
         self.df_real = pd.DataFrame()
@@ -75,10 +80,11 @@ class MyProphet:
         매개변수:
             ticker (str): 새로 설정할 티커 값.
         """
-        mylogger.info(f'change ticker : {self.ticker} -> {ticker}')
+        mylogger.debug(f'change ticker : {self.ticker} -> {ticker}')
         self.scaler = StandardScaler()
         self.model = Prophet()
         self._ticker = ticker
+        self.initialized = False
 
         self.raw_data = pd.DataFrame()
         self.df_real = pd.DataFrame()
@@ -132,6 +138,7 @@ class MyProphet:
             df['volume_scaled'] = self.scaler.fit_transform(df[['volume']])
             mylogger.debug('_preprocessing_for_prophet')
             mylogger.debug(df)
+            self.initialized = True
             return df
 
         def make_forecast() -> pd.DataFrame:
@@ -163,7 +170,7 @@ class MyProphet:
             mylogger.debug(forecast)
             return forecast
 
-        print("Initializing data for MyProphet")
+        mylogger.debug("Initializing data for MyProphet")
 
         self.scaler = StandardScaler()
         self.model = Prophet()
@@ -172,86 +179,86 @@ class MyProphet:
         self.df_real = preprocessing_for_prophet()
         self.df_forecast = make_forecast()
 
-    def generate_data(self, refresh: bool) -> ProphetData:
-        """
-        ProphetData 객체를 생성하거나 캐시된 데이터를 반환합니다.
+    def _make_prophet_latest_data(self) -> ProphetLatestData:
+        def scoring(price: float, yhat_lower: float, yhat_upper: float, method: str = 'sigmoid') -> Tuple[str, int]:
+            """
+            주어진 가격과 임계값을 기준으로 매매 행동('buy', 'sell', 'hold')과 점수를 결정합니다.
 
-        매개변수:
-            refresh (bool): 데이터를 새로 생성할지 여부.
+            매개변수:
+                price (float): 자산의 현재 가격.
+                yhat_lower (float): 가격 예측의 하한 임계값.
+                yhat_upper (float): 가격 예측의 상한 임계값.
+                method (str, optional): 점수를 계산하는 방법 ('sigmoid' 또는 'log'). 기본값은 'sigmoid'.
 
-        반환값:
-            ProphetData: 생성된 ProphetData 객체.
-        """
-        print("**** Start generate_data... ****")
-        redis_name = f'{self.ticker}_myprophet_data'
+            반환값:
+                Tuple[str, int]: 매매 행동('buy', 'sell', 'hold')과 관련 점수로 이루어진 튜플.
 
-        print(
-            f"redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time / 3600}h")
+            예외:
+                ValueError: 지원되지 않는 점수 계산 방법이 제공된 경우 발생.
+            """
 
-        def fetch_generate_prophet_data() -> ProphetData:
-            def scoring(price: float, yhat_lower: float, yhat_upper: float, method: str = 'sigmoid') -> Tuple[str, int]:
-                """
-                주어진 가격과 임계값을 기준으로 매매 행동('buy', 'sell', 'hold')과 점수를 결정합니다.
-
-                매개변수:
-                    price (float): 자산의 현재 가격.
-                    yhat_lower (float): 가격 예측의 하한 임계값.
-                    yhat_upper (float): 가격 예측의 상한 임계값.
-                    method (str, optional): 점수를 계산하는 방법 ('sigmoid' 또는 'log'). 기본값은 'sigmoid'.
-
-                반환값:
-                    Tuple[str, int]: 매매 행동('buy', 'sell', 'hold')과 관련 점수로 이루어진 튜플.
-
-                예외:
-                    ValueError: 지원되지 않는 점수 계산 방법이 제공된 경우 발생.
-                """
-
-                def calculate_score(deviation: float, method_in: str) -> int:
-                    if method_in == 'sigmoid':
-                        return tools.to_int(eval.Tools.sigmoid_score(deviation))
-                    elif method_in == 'log':
-                        return tools.to_int(eval.Tools.log_score(deviation))
-                    else:
-                        raise ValueError(f"Unsupported scoring method: {method}")
-
-                buying_deviation = eval.Tools.cal_deviation(price, yhat_lower)
-                buying_score = calculate_score(buying_deviation, method)
-                if price >= yhat_lower:
-                    buying_score = -buying_score
-
-                selling_deviation = eval.Tools.cal_deviation(price, yhat_upper)
-                selling_score = calculate_score(selling_deviation, method)
-                if price <= yhat_upper:
-                    selling_score = -selling_score
-
-                if buying_score > 0:
-                    return 'buy', buying_score
-                elif selling_score > 0:
-                    return 'sell', selling_score
+            def calculate_score(deviation: float, method_in: str) -> int:
+                if method_in == 'sigmoid':
+                    return tools.to_int(eval.Tools.sigmoid_score(deviation))
+                elif method_in == 'log':
+                    return tools.to_int(eval.Tools.log_score(deviation))
                 else:
-                    return 'hold', 0
-
+                    raise ValueError(f"Unsupported scoring method: {method}")
+
+            buying_deviation = eval.Tools.cal_deviation(price, yhat_lower)
+            buying_score = calculate_score(buying_deviation, method)
+            if price >= yhat_lower:
+                buying_score = -buying_score
+
+            selling_deviation = eval.Tools.cal_deviation(price, yhat_upper)
+            selling_score = calculate_score(selling_deviation, method)
+            if price <= yhat_upper:
+                selling_score = -selling_score
+
+            if buying_score > 0:
+                return 'buy', buying_score
+            elif selling_score > 0:
+                return 'sell', selling_score
+            else:
+                return 'hold', 0
+
+        if not self.initialized:
             self.initializing()
-            latest_row = self.df_real.iloc[-1]
-            latest_yhat = \
-            self.df_forecast.loc[self.df_forecast['ds'] == latest_row['ds'], ['ds', 'yhat_lower', 'yhat_upper', 'yhat']].iloc[
+        latest_row = self.df_real.iloc[-1]
+        latest_yhat = \
+            self.df_forecast.loc[
+                self.df_forecast['ds'] == latest_row['ds'], ['ds', 'yhat_lower', 'yhat_upper', 'yhat']].iloc[
                 0].to_dict()
 
-            data = ProphetData(
-                ticker=self.ticker,
-                date=latest_row['ds'].date(),
-                price=latest_row['y'],
-                yhat=latest_yhat['yhat'],
-                yhat_lower=latest_yhat['yhat_lower'],
-                yhat_upper=latest_yhat['yhat_upper'],
-            )
+        data = ProphetLatestData(
+            ticker=self.ticker,
+            date=latest_row['ds'].date(),
+            price=latest_row['y'],
+            yhat=latest_yhat['yhat'],
+            yhat_lower=latest_yhat['yhat_lower'],
+            yhat_upper=latest_yhat['yhat_upper'],
+        )
 
-            data.trading_action, data.score = scoring(data.price, data.yhat_lower, data.yhat_upper)
-            return data
+        data.trading_action, data.score = scoring(data.price, data.yhat_lower, data.yhat_upper)
+        return data
 
+    def generate_latest_data(self, refresh: bool) -> ProphetLatestData:
+        """
+        ProphetData 객체를 생성하거나 캐시된 데이터를 반환합니다.
 
-        prophet_data = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_generate_prophet_data, timer=expire_time)
+        매개변수:
+            refresh (bool): 데이터를 새로 생성할지 여부.
 
+        반환값:
+            ProphetData: 생성된 ProphetData 객체.
+        """
+        mylogger.debug("**** Start generate_data... ****")
+        redis_name = f'{self.ticker}_{self.REDIS_LATEST_DATA_SUFFIX}'
+
+        mylogger.info(
+            f"redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time / 3600}h")
+
+        prophet_data = myredis.Base.fetch_and_cache_data(redis_name, refresh, self._make_prophet_latest_data, timer=expire_time)
         return prophet_data
 
     def generate_chart_data(self, refresh: bool) -> ProphetChartData:
@@ -265,14 +272,15 @@ class MyProphet:
             •	df_forecast['yhat_lower'] → y축 (최소 예측값)
             •	df_forecast['yhat_upper'] → y축 (최대 예측값)
         """
-        print("**** Start generate_chart_data... ****")
+        mylogger.debug("**** Start generate_prophet_chart_data... ****")
         redis_name = f'{self.ticker}_myprophet_chart_data'
 
-        print(
+        mylogger.info(
             f"redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time / 3600}h")
 
         def fetch_generate_prophet_chart_data() -> ProphetChartData:
-            self.initializing()
+            if self.initialized:
+                self.initializing()
 
             # 날짜를 기준으로 합치기 (outer join)
             merged_df = pd.merge(self.df_real, self.df_forecast, on="ds", how="outer")
@@ -286,6 +294,7 @@ class MyProphet:
                 yhats=[{"x": ds, "y": yhat} for ds, yhat in zip(merged_df["ds"], merged_df["yhat"])], # type: ignore
                 yhat_uppers=[{"x": ds, "y": yhat_upper} for ds, yhat_upper in zip(merged_df["ds"], merged_df["yhat_upper"])], # type: ignore
                 yhat_lowers=[{"x": ds, "y": yhat_lower} for ds, yhat_lower in zip(merged_df["ds"], merged_df["yhat_lower"])], # type: ignore
+                is_prophet_up=self.is_prophet_up(refresh=refresh),
             )
             return data
 
@@ -293,79 +302,6 @@ class MyProphet:
                                                          timer=expire_time)
         return prophet_chart_data
 
-
-    def visualization(self):
-        """
-        Prophet 모델의 예측 결과를 시각화합니다.
-
-        - Matplotlib를 사용하여 예측 결과 및 추세/계절성을 그래프로 출력.
-        """
-        self.initializing()
-        # 예측 결과 출력
-        print(self.df_forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail())
-        # 예측 결과 시각화 (Matplotlib 사용)
-        fig = self.model.plot(self.df_forecast)
-        # 추세 및 계절성 시각화
-        fig2 = self.model.plot_components(self.df_forecast)
-        plt.show()  # 시각화 창 띄우기
-
-    def export(self, to="html") -> Optional[str]:
-        """
-        예측 결과를 시각화하여 다양한 형식으로 내보냅니다.
-
-        매개변수:
-            refresh (bool): 데이터를 새로 생성할지 여부.
-            to (str): 내보낼 형식 ('html', 'png', 'file').
-
-        반환값:
-            Optional[str]: HTML 문자열로 반환하거나 PNG/HTML 파일로 저장합니다.
-
-        예외:
-            Exception: 지원되지 않는 형식의 경우 예외 발생.
-        """
-        self.initializing()
-        # Plotly를 사용한 시각화
-        fig = go.Figure()
-
-        # 실제 데이터
-        fig.add_trace(go.Scatter(x=self.df_real['ds'], y=self.df_real['y'], mode='markers', name='실제주가'))
-        # 예측 데이터
-        fig.add_trace(go.Scatter(x=self.df_forecast['ds'], y=self.df_forecast['yhat'], mode='lines', name='예측치'))
-
-        # 상한/하한 구간
-        fig.add_trace(
-            go.Scatter(x=self.df_forecast['ds'], y=self.df_forecast['yhat_upper'], fill=None, mode='lines', name='상한'))
-        fig.add_trace(
-            go.Scatter(x=self.df_forecast['ds'], y=self.df_forecast['yhat_lower'], fill='tonexty', mode='lines', name='하한'))
-
-        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,
-        )
-
-        if to == 'html':
-            # 그래프 HTML로 변환 (string 형식으로 저장)
-            graph_html = plot(fig, output_type='div')
-            return graph_html
-        elif to == 'png':
-            # 그래프를 PNG 파일로 저장
-            fig.write_image(f"myprophet_{self.ticker}.png")
-            return None
-        elif to == 'file':
-            # 그래프를 HTML 파일로 저장
-            plot(fig, filename=f'myprophet_{self.ticker}.html', auto_open=False)
-            return None
-        else:
-            Exception("to 인자가 맞지 않습니다.")
-
     def is_prophet_up(self, refresh: bool) -> bool:
         """
         Prophet 예측이 상승 추세인지 여부를 확인합니다.
@@ -376,12 +312,13 @@ class MyProphet:
         반환값:
             bool: 상승 추세 여부.
         """
-        print("**** Caching is_prophet_up ... ****")
+        mylogger.debug("**** Caching is_prophet_up ... ****")
         redis_name = f'{self.ticker}_is_prophet_up'
-        print(f"redisname: '{redis_name}' / expire_time : {expire_time / 3600}h")
+        mylogger.info(f"redisname: '{redis_name}' / expire_time : {expire_time / 3600}h")
 
         def fetch_is_prophet_up():
-            self.initializing()
+            if self.initialized:
+                self.initializing()
             yhat_dict = self.df_forecast.set_index('ds')['yhat'].to_dict()
             return tsa.common.is_up_by_OLS(yhat_dict)
 
@@ -406,6 +343,51 @@ class MyProphet:
             # 변환이 실패하면 ValueError가 발생, 형식이 맞지 않음
             return False
 
+    @staticmethod
+    def bulk_generate_latest_data(tickers: List[str], refresh: bool) -> Dict[str, ProphetLatestData]:
+        # --- (1) 파이프라인 GET ---
+        pipe = myredis.Base.redis_client.pipeline()
+        redis_keys = [f"{ticker}_{MyProphet.REDIS_LATEST_DATA_SUFFIX}" for ticker in tickers]
+        for redis_key in redis_keys:
+            pipe.get(redis_key)
+        results_from_redis = pipe.execute()  # [val1, val2, ...]
+
+        final_results = {}
+        missing_tickers = []
+
+        # refresh=True 이면 기존 데이터 무시하고 다시 계산해야 하므로 모두 missing 처리
+        if refresh:
+            missing_tickers = tickers[:]
+        else:
+            # refresh=False 이면, Redis 값이 None인 티커만 다시 계산
+            for ticker, val in zip(tickers, results_from_redis):
+                if val is None:
+                    missing_tickers.append(ticker)
+                else:
+                    # Redis에 pickled 데이터가 있다면 언피클해서 담기
+                    prophet_data = pickle.loads(val)
+                    final_results[ticker] = prophet_data
+
+        # --- (2) 필요한 티커만 직접 연산 ---
+        newly_computed_data = {}
+        for ticker in missing_tickers:
+            data = MyProphet(ticker)._make_prophet_latest_data()
+            newly_computed_data[ticker] = data
+
+        # --- (3) 파이프라인 SET ---
+        if newly_computed_data:
+            pipe = myredis.Base.redis_client.pipeline()
+            for ticker, data in newly_computed_data.items():
+                redis_key = f"{ticker}_{MyProphet.REDIS_LATEST_DATA_SUFFIX}"
+                # 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
 
 
 class CorpProphet(MyProphet):
@@ -433,6 +415,40 @@ class CorpProphet(MyProphet):
         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 ranking(top: Union[int, str] = 'all', refresh=False) -> OrderedDict:
+        mylogger.info("**** Start prophet ranking ... ****")
+
+        data = {}
+        for ticker, latest_data in MyProphet.bulk_generate_latest_data(
+                [CorpProphet.code_to_ticker(code) for code in myredis.Corps.list_all_codes()], refresh=refresh).items():
+            code = CorpProphet.ticker_to_code(ticker)
+            score = latest_data.score
+            mylogger.debug(f'{code} score : {score}')
+            data[code] = score
+
+        ranking = OrderedDict(sorted(data.items(), key=lambda x: x[1], reverse=True))
+
+        if top == 'all':
+            return ranking
+        else:
+            if isinstance(top, int):
+                return OrderedDict(list(ranking.items())[:top])
+            else:
+                raise ValueError("top 인자는 'all' 이나 int형 이어야 합니다.")
+
+    @staticmethod
+    def bulk_generate_latest_data(codes: List[str], refresh: bool) -> Dict[str, ProphetLatestData]:
+        return MyProphet.bulk_generate_latest_data([CorpProphet.code_to_ticker(code) for code in codes], refresh=refresh)
+
 
 class MIProphet(MyProphet):
     """

analyser_hj3415/cli.py

@@ -2,7 +2,7 @@ import argparse
 import pprint
 
 from utils_hj3415 import tools
-from analyser_hj3415.analyser import eval, tsa, compile, MIs
+from analyser_hj3415.analyser import eval, tsa, MIs
 from db_hj3415 import myredis, mymongo
 
 
@@ -10,16 +10,6 @@ def analyser_manager():
     parser = argparse.ArgumentParser(description="Analyser Commands")
     type_subparsers = parser.add_subparsers(dest='type', help='분석 타입')
 
-    # compile 명령어 서브파서
-    compile_parser = type_subparsers.add_parser('compile', help='Compile 타입')
-    compile_subparser = compile_parser.add_subparsers(dest='command', help='Compile 관련된 명령')
-    # compile - caching 파서
-    caching_parser = compile_subparser.add_parser('caching', help='lstm 랭킹 책정 및 레디스 저장')
-    caching_parser.add_argument('-r', '--refresh', action='store_true', help='래디스 캐시를 사용하지 않고 강제로 재계산 할지')
-    caching_parser.add_argument('-mi', '--market_index', action='store_true', help='Market index도 캐싱할지')
-    caching_parser.add_argument('-t', '--top', type=int, help='prophet ranking 몇위까지 작업을 할지')
-
-
     # prophet 명령어 서브파서
     prophet_parser = type_subparsers.add_parser('prophet', help='MyProphet 타입')
     prophet_subparser = prophet_parser.add_subparsers(dest='command', help='prophet 관련된 명령')
@@ -34,11 +24,16 @@ def analyser_manager():
     # lstm 명령어 서브파서
     lstm_parser = type_subparsers.add_parser('lstm', help='MyLSTM 타입')
     lstm_subparser = lstm_parser.add_subparsers(dest='command', help='lstm 관련된 명령')
-    # lstm - predict 파서
-    lstm_get_parser = lstm_subparser.add_parser('predict', help='lstm get final prediction 시행')
-    lstm_get_parser.add_argument('target', type=str, help=f'종목코드 or {list(MIs._fields)}')
-    lstm_get_parser.add_argument('-n', '--num', type=int, default=5, help='ensemble training 횟수 설정')
-    lstm_get_parser.add_argument('-r', '--refresh', action='store_true', help='래디스 캐시를 사용하지 않고 강제로 재계산 할지')
+    # lstm - caching 파서
+    caching_parser = lstm_subparser.add_parser('caching', help='lstm 차트데이터 산출 및 레디스 저장')
+    target_subparser = caching_parser.add_subparsers(dest='target', help='corp or mi')
+    # lstm - caching - corp 파서
+    corp_parser = target_subparser.add_parser('corp', help='corp lstm top n 데이터 산출 및 레디스 저장')
+    corp_parser.add_argument('-n', '--num', type=int, help='앙상블트레이닝을 몇회반복할것인지')
+    corp_parser.add_argument('-t', '--top', type=int, help='prophet ranking 몇위까지 작업을 할지')
+    # lstm - caching - mi 파서
+    mi_parser = target_subparser.add_parser('mi', help='mi lstm 데이터 산출 및 레디스 저장')
+    mi_parser.add_argument('-n', '--num', type=int, help='앙상블트레이닝을 몇회반복할것인지')
 
     # red 명령어 서브파서
     red_parser = type_subparsers.add_parser('red', help='red 타입')
@@ -91,7 +86,7 @@ def analyser_manager():
                 for i, code in enumerate(myredis.Corps.list_all_codes()):
                     red.code = code
                     print(f"*** {i} / {red} ***")
-                    pprint.pprint(red.get(args.refresh, verbose=False))
+                    pprint.pprint(red.get(args.refresh))
             else:
                 assert tools.is_6digit(args.code), "code 인자는 6자리 숫자이어야 합니다."
                 # 저장된 기대수익률을 불러서 임시저장
@@ -104,9 +99,9 @@ def analyser_manager():
             mymongo.Logs.save('cli', 'INFO', 'run >> analyser red ranking')
             try:
                 if args.expect_earn is None:
-                    result = compile.CorpCompile.red_ranking(refresh=args.refresh)
+                    result = eval.Red.ranking(refresh=args.refresh)
                 else:
-                    result = compile.CorpCompile.red_ranking(expect_earn=args.expect_earn, refresh=args.refresh)
+                    result = eval.Red.ranking(expect_earn=args.expect_earn, refresh=args.refresh)
                 print(result)
             except Exception as e:
                 print(e)
@@ -176,7 +171,7 @@ def analyser_manager():
         if args.command == 'ranking':
             mymongo.Logs.save('cli', 'INFO', 'run >> analyser prophet ranking')
             try:
-                result = compile.CorpCompile.prophet_ranking(refresh=args.refresh)
+                result = tsa.CorpProphet.ranking(refresh=args.refresh)
                 print(result)
             except Exception as e:
                 print(e)
@@ -189,35 +184,23 @@ def analyser_manager():
                 myprophet = tsa.CorpProphet(args.target)
             else:
                 raise Exception("Invalid target")
-            print(myprophet.generate_data(refresh=args.refresh).score)
+            print(myprophet.generate_latest_data(refresh=args.refresh).score)
             # mymongo.Logs.save('cli','INFO', f'run >> analyser prophet get {args.target}')
-
-    elif args.type == 'compile':
+    elif args.type == 'lstm':
         if args.command == 'caching':
-            mymongo.Logs.save('cli', 'INFO', f'run >> analyser compile caching')
             try:
-                if args.top:
-                    compile.CorpCompile.caching_corp_compile_topn(refresh=args.refresh, top=args.top)
+                if args.target == 'corp':
+                    tsa.CorpLSTM.caching_chart_data_topn(top=args.top, num=args.num)
+                    mymongo.Logs.save('cli', 'INFO',
+                                      f'run >> analyser lstm caching corp -t {args.top} -n {args.num}')
+                elif args.target == 'mi':
+                    tsa.MILSTM.caching_chart_data_mi_all(num=args.num)
+                    mymongo.Logs.save('cli', 'INFO',
+                                      f'run >> analyser lstm caching mi -n {args.num}')
                 else:
-                    compile.CorpCompile.caching_corp_compile_topn(refresh=args.refresh)
-                if args.market_index:
-                    compile.MICompile.caching_mi_compile_all(refresh=args.refresh)
+                    print("올바른 'type' 값을 입력하세요 (corp / mi)")
             except Exception as e:
                 print(e)
-                mymongo.Logs.save('cli','ERROR', f'analyser lstm caching 실행중 에러 - {e}')
-
-    elif args.type == 'lstm':
-        if args.command == 'predict':
-            mi_type = str(args.target).upper()
-            if mi_type in MIs._fields:
-                mylstm = tsa.MILSTM(mi_type)
-            elif tools.is_6digit(args.target):
-                mylstm = tsa.CorpLSTM(args.target)
-            else:
-                raise Exception("Invalid target")
-            future_data, grade = mylstm.get_final_predictions(refresh=args.refresh, num=args.num)
-            print(future_data)
-            print(grade)
-            # mymongo.Logs.save('cli','INFO', f'run >> analyser lstm get {args.target}')
+                mymongo.Logs.save('cli', 'ERROR', f'analyser lstm caching 실행중 에러 - {e}')
     else:
         parser.print_help()

{analyser_hj3415-3.4.2.dist-info → analyser_hj3415-4.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: analyser_hj3415
-Version: 3.4.2
+Version: 4.0.0
 Summary: Stock analyser and database processing programs
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown

analyser_hj3415-4.0.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+analyser_hj3415/__init__.py,sha256=jqHEUoBeihYOMaS0bPOe3nRVXBufZ0clxc6M6jxPY0o,320
+analyser_hj3415/cli.py,sha256=-6YRrlcPi15McWS7mI8QADnRv3UGRGMMbUPFGyIkolA,11455
+analyser_hj3415/analyser/__init__.py,sha256=N0XyBfWJNpDS_6JYziKETWePO_jtFB1m7E8Qbwt1w0Q,1096
+analyser_hj3415/analyser/eval/__init__.py,sha256=IP1d0Q3nOCAD3zK1qxrC685MkJQfUh-qaXc7xptTxk8,80
+analyser_hj3415/analyser/eval/blue.py,sha256=p9_ddqLMJGq5HSn6NApuLhrX29qD--AASig9F71eb8I,10952
+analyser_hj3415/analyser/eval/common.py,sha256=sNXapoofShA43ww_SLjXmIjkrAr1AhAcezdaN_X_3Us,11443
+analyser_hj3415/analyser/eval/growth.py,sha256=sfJ7h06efrTfL4ylhUCV525IzUzilbun1ya9r5SVCtU,6526
+analyser_hj3415/analyser/eval/mil.py,sha256=mFMiFCuCBvlQrhQcM5hMg8U4zF32TS1GnUmk8fPd950,15178
+analyser_hj3415/analyser/eval/red.py,sha256=b-Odud8pxQIO2NjI7m3HbK4FOND5WhaoYV94mCHqDPo,13907
+analyser_hj3415/analyser/tsa/__init__.py,sha256=pg20ZQRABedTdaIoOr5t043RNKtJ7ji_WmnZrD1IhPg,147
+analyser_hj3415/analyser/tsa/common.py,sha256=OnsZ_cFYmNzmk0tV5qSqVW-5jJyrwMWHguWdS2Z6fvY,979
+analyser_hj3415/analyser/tsa/lstm.py,sha256=SoUx7JlgW4d3CGahtG4dUJoKBe0meqiI6CSTTL7iSL0,27977
+analyser_hj3415/analyser/tsa/prophet.py,sha256=YNSHnNRl41JrcrmOuuuwHyVoZMpeV4IMliLAF9XXxCk,17651
+analyser_hj3415-4.0.0.dist-info/entry_points.txt,sha256=ZfjPnJuH8SzvhE9vftIPMBIofsc65IAWYOhqOC_L5ck,65
+analyser_hj3415-4.0.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+analyser_hj3415-4.0.0.dist-info/METADATA,sha256=HbzCJ7SF7frEi1AkS4zLsNhhez1CVz5_icnpkIPhPm4,6777
+analyser_hj3415-4.0.0.dist-info/RECORD,,