analyser_hj3415 3.2.2__py3-none-any.whl → 3.3.1__py3-none-any.whl

analyser_hj3415/analyser/tsa/prophet.py

@@ -7,14 +7,31 @@ 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
 
 from utils_hj3415 import tools, setup_logger
 from db_hj3415 import myredis
 
-from analyser_hj3415.analyser import eval, MIs
+from analyser_hj3415.analyser import eval, MIs, tsa
 
 
 mylogger = setup_logger(__name__,'WARNING')
+expire_time = tools.to_int(os.getenv('DEFAULT_EXPIRE_TIME_H', 48)) * 3600
+
+
+@dataclass
+class ProphetData:
+    ticker: str
+
+    date: datetime.date
+    price: float
+    yhat: float
+    yhat_upper: float
+    yhat_lower: float
+
+    trading_action: str = ''
+    score: int = None
 
 
 class MyProphet:
@@ -24,103 +41,214 @@ class MyProphet:
         self.model = Prophet()
         self._ticker = ticker
 
-        self.raw_data = self._get_raw_data()
-        self.df_real = self._preprocessing_for_prophet()
-        self.df_forecast = self._make_forecast()
+        self.raw_data = pd.DataFrame()
+        self.df_real = pd.DataFrame()
+        self.df_forecast = pd.DataFrame()
 
     @property
     def ticker(self) -> str:
+        """
+        현재 설정된 티커를 반환합니다.
+
+        반환값:
+            str: 현재 티커 값.
+        """
         return self._ticker
 
     @ticker.setter
     def ticker(self, ticker: str):
+        """
+        티커 값을 변경하고 관련 데이터를 초기화합니다.
+
+        매개변수:
+            ticker (str): 새로 설정할 티커 값.
+        """
         mylogger.info(f'change ticker : {self.ticker} -> {ticker}')
         self.scaler = StandardScaler()
         self.model = Prophet()
         self._ticker = ticker
 
-        self.raw_data = self._get_raw_data()
-        self.df_real = self._preprocessing_for_prophet()
-        self.df_forecast = self._make_forecast()
-
-    @staticmethod
-    def is_valid_date(date_string):
-        try:
-            # %Y-%m-%d 형식으로 문자열을 datetime 객체로 변환 시도
-            datetime.strptime(date_string, '%Y-%m-%d')
-            return True
-        except ValueError:
-            # 변환이 실패하면 ValueError가 발생, 형식이 맞지 않음
-            return False
+        self.raw_data = pd.DataFrame()
+        self.df_real = pd.DataFrame()
+        self.df_forecast = pd.DataFrame()
 
-    def _get_raw_data(self) -> pd.DataFrame:
-        """
-        야후에서 해당 종목의 4년간 주가 raw data를 받아온다.
-        :return:
+    def initializing(self):
         """
-        # 오늘 날짜 가져오기
-        today = datetime.today()
+        Prophet 모델 사용을 위한 데이터를 초기화합니다.
 
-        # 4년 전 날짜 계산 (4년 = 365일 * 4)
-        four_years_ago = today - timedelta(days=365 * 4)
-
-        return yf.download(
-            tickers=self.ticker,
-            start=four_years_ago.strftime('%Y-%m-%d'),
-            end=today.strftime('%Y-%m-%d')
-        )
-
-    def _preprocessing_for_prophet(self) -> pd.DataFrame:
-        """
-        Prophet이 사용할 수 있도록 데이터 준비
-        ds는 날짜, y는 주가
-        :return:
+        - Yahoo Finance에서 데이터를 가져옵니다.
+        - 데이터를 Prophet 형식에 맞게 전처리합니다.
+        - Prophet 모델을 사용하여 예측 데이터를 생성합니다.
         """
-        df = self.raw_data[['Close', 'Volume']].reset_index()
-        df.columns = ['ds', 'y', 'volume']  # Prophet의 형식에 맞게 열 이름 변경
-
-        # ds 열에서 타임존 제거
-        df['ds'] = df['ds'].dt.tz_localize(None)
-
-        # 추가 변수를 정규화
-        df['volume_scaled'] = self.scaler.fit_transform(df[['volume']])
-        mylogger.debug('_preprocessing_for_prophet')
-        mylogger.debug(df)
-        return df
-
-    def _make_forecast(self) -> pd.DataFrame:
-        # 정규화된 'volume_scaled' 변수를 외부 변수로 추가
-        self.model.add_regressor('volume_scaled')
+        def get_raw_data() -> pd.DataFrame:
+            """
+            Yahoo Finance에서 4년간의 주가 데이터를 가져옵니다.
+
+            반환값:
+                pd.DataFrame: 가져온 주가 데이터프레임.
+            """
+            # 오늘 날짜 가져오기
+            today = datetime.today()
+
+            # 4년 전 날짜 계산 (4년 = 365일 * 4)
+            four_years_ago = today - timedelta(days=365 * 4)
+
+            return yf.download(
+                tickers=self.ticker,
+                start=four_years_ago.strftime('%Y-%m-%d'),
+                end=today.strftime('%Y-%m-%d')
+            )
+
+        def preprocessing_for_prophet() -> pd.DataFrame:
+            """
+            Prophet 모델에서 사용할 수 있도록 데이터를 준비합니다.
+
+            - 'Close'와 'Volume' 열을 사용.
+            - 날짜를 'ds', 종가를 'y', 거래량을 'volume'으로 변경.
+            - 거래량 데이터를 정규화하여 'volume_scaled' 열 추가.
+
+            반환값:
+                pd.DataFrame: Prophet 모델 입력 형식에 맞게 처리된 데이터프레임.
+            """
+            df = self.raw_data[['Close', 'Volume']].reset_index()
+            df.columns = ['ds', 'y', 'volume']  # Prophet의 형식에 맞게 열 이름 변경
+
+            # ds 열에서 타임존 제거
+            df['ds'] = df['ds'].dt.tz_localize(None)
+
+            # 추가 변수를 정규화
+            df['volume_scaled'] = self.scaler.fit_transform(df[['volume']])
+            mylogger.debug('_preprocessing_for_prophet')
+            mylogger.debug(df)
+            return df
+
+        def make_forecast() -> pd.DataFrame:
+            """
+            Prophet 모델을 사용하여 향후 180일간 주가를 예측합니다.
+
+            - 거래량 데이터('volume_scaled')를 추가 변수로 사용.
+            - 예측 결과를 데이터프레임으로 반환.
+
+            반환값:
+                pd.DataFrame: 예측 결과를 포함한 데이터프레임.
+            """
+            # 정규화된 'volume_scaled' 변수를 외부 변수로 추가
+            self.model.add_regressor('volume_scaled')
+
+            self.model.fit(self.df_real)
+
+            # 향후 180일 동안의 주가 예측
+            future = self.model.make_future_dataframe(periods=180)
+            mylogger.debug('_make_forecast_future')
+            mylogger.debug(future)
+
+            # 미래 데이터에 거래량 추가 (평균 거래량을 사용해 정규화)
+            future_volume = pd.DataFrame({'volume': [self.raw_data['Volume'].mean()] * len(future)})
+            future['volume_scaled'] = self.scaler.transform(future_volume[['volume']])
+
+            forecast = self.model.predict(future)
+            mylogger.debug('_make_forecast')
+            mylogger.debug(forecast)
+            return forecast
+
+        print("Initializing data for MyProphet")
 
-        self.model.fit(self.df_real)
+        self.scaler = StandardScaler()
+        self.model = Prophet()
 
-        # 향후 180일 동안의 주가 예측
-        future = self.model.make_future_dataframe(periods=180)
-        mylogger.debug('_make_forecast_future')
-        mylogger.debug(future)
+        self.raw_data = get_raw_data()
+        self.df_real = preprocessing_for_prophet()
+        self.df_forecast = make_forecast()
 
-        # 미래 데이터에 거래량 추가 (평균 거래량을 사용해 정규화)
-        future_volume = pd.DataFrame({'volume': [self.raw_data['Volume'].mean()] * len(future)})
-        future['volume_scaled'] = self.scaler.transform(future_volume[['volume']])
+    def generate_data(self, refresh: bool) -> ProphetData:
+        """
+        ProphetData 객체를 생성하거나 캐시된 데이터를 반환합니다.
 
-        forecast = self.model.predict(future)
-        mylogger.debug('_make_forecast')
-        mylogger.debug(forecast)
-        return forecast
+        매개변수:
+            refresh (bool): 데이터를 새로 생성할지 여부.
 
-    def get_yhat(self) -> dict:
-        """
-        최근 날짜의 예측데이터를 반환한다.
-        :return: {'ds':..., 'yhat':.., 'yhat_lower':.., 'yhat_upper':..,}
+        반환값:
+            ProphetData: 생성된 ProphetData 객체.
         """
-        df = self.df_forecast
-        last_real_date = self.df_real.iloc[-1]['ds']
-        mylogger.info(last_real_date)
-        yhat_dict = df[df['ds']==last_real_date].iloc[0][['ds', 'yhat_lower', 'yhat_upper', 'yhat']].to_dict()
-        mylogger.info(yhat_dict)
-        return yhat_dict
+        print("**** Start generate_data... ****")
+        redis_name = f'{self.ticker}_myprophet_data'
+
+        print(
+            f"redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time / 3600}h")
+
+        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
+                else:
+                    return 'hold', 0
+
+            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[
+                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.trading_action, data.score = scoring(data.price, data.yhat_lower, data.yhat_upper)
+            return data
+
+
+        prophet_data = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_generate_prophet_data, timer=expire_time)
+
+        return prophet_data
 
     def visualization(self):
+        """
+        Prophet 모델의 예측 결과를 시각화합니다.
+
+        - Matplotlib를 사용하여 예측 결과 및 추세/계절성을 그래프로 출력.
+        """
+        self.initializing()
         # 예측 결과 출력
         print(self.df_forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail())
         # 예측 결과 시각화 (Matplotlib 사용)
@@ -131,10 +259,19 @@ class MyProphet:
 
     def export(self, to="html") -> Optional[str]:
         """
-        prophet과 plotly로 그래프를 그려서 html을 문자열로 반환
-        :param to: html, png, file
-        :return:
+        예측 결과를 시각화하여 다양한 형식으로 내보냅니다.
+
+        매개변수:
+            refresh (bool): 데이터를 새로 생성할지 여부.
+            to (str): 내보낼 형식 ('html', 'png', 'file').
+
+        반환값:
+            Optional[str]: HTML 문자열로 반환하거나 PNG/HTML 파일로 저장합니다.
+
+        예외:
+            Exception: 지원되지 않는 형식의 경우 예외 발생.
         """
+        self.initializing()
         # Plotly를 사용한 시각화
         fig = go.Figure()
 
@@ -177,62 +314,56 @@ class MyProphet:
         else:
             Exception("to 인자가 맞지 않습니다.")
 
-    def scoring(self) -> Tuple[str, int]:
+    def is_prophet_up(self, refresh: bool) -> bool:
         """
-        Calculate and return a trading action and associated score based on recent market data and forecasted values.
-
-        The method computes deviations between the recent price and predefined forecasted bounds (`yhat_lower` and `yhat_upper`)
-        to determine whether to buy, sell, or hold a financial instrument. The calculation involves generating a deviation score
-        that is transformed using a sigmoid function. The scores are then adjusted based on the position of the recent price relative
-        to the forecasted bounds. Logging is used extensively throughout the method to record the values and decisions for debugging
-        and traceability purposes.
+        Prophet 예측이 상승 추세인지 여부를 확인합니다.
 
-        Returns:
-            A tuple containing a string indicating the recommended trading action ('buy', 'sell', 'hold')
-            and an integer score associated with that action.
+        매개변수:
+            refresh (bool): 데이터를 새로 생성할지 여부.
 
-        Raises:
-            KeyError: If required keys are missing in the `yhat_dict` or `last_real_data` dictionary-like structures.
+        반환값:
+            bool: 상승 추세 여부.
         """
-        last_real_data = self.df_real.iloc[-1]
-        recent_price = last_real_data['y']
-        recent_date = datetime.strftime(last_real_data['ds'], '%Y-%m-%d')
-        yhat_dict = self.get_yhat()
-        mylogger.info(f'recent_price: {recent_price}, yhat_dict: {yhat_dict}')
-
-        yhat_lower = tools.to_int(yhat_dict['yhat_lower'])
-        yhat_upper = tools.to_int(yhat_dict['yhat_upper'])
-        #yhat = tools.to_int(yhat_dict['yhat'])
-
-        buying_deviation = eval.Tools.cal_deviation(recent_price, yhat_lower)
-
-        buying_score = tools.to_int(eval.Tools.sigmoid_score(buying_deviation))
-        # score = tools.to_int(Tools.log_score(deviation))
+        print("**** Caching is_prophet_up ... ****")
+        redis_name = f'{self.ticker}_is_prophet_up'
+        print(f"redisname: '{redis_name}' / expire_time : {expire_time / 3600}h")
 
-        if recent_price >= yhat_lower:
-            buying_score = -buying_score
+        def fetch_is_prophet_up():
+            self.initializing()
+            yhat_dict = self.df_forecast.set_index('ds')['yhat'].to_dict()
+            return tsa.common.is_up_by_OLS(yhat_dict)
 
-        selling_deviation = eval.Tools.cal_deviation(recent_price, yhat_upper)
+        return myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_is_prophet_up, timer=expire_time)
 
-        selling_score = tools.to_int(eval.Tools.sigmoid_score(selling_deviation))
-        # score = tools.to_int(Tools.log_score(deviation))
+    @staticmethod
+    def is_valid_date(date_string):
+        """
+        주어진 문자열이 'YYYY-MM-DD' 형식의 유효한 날짜인지 확인합니다.
 
-        if recent_price <= yhat_upper:
-            selling_score = -selling_score
+        매개변수:
+            date_string (str): 확인할 날짜 문자열.
 
-        mylogger.info(f"{self.ticker} date: {recent_date} 가격: {recent_price}"
-                      f" yhat_lower:{yhat_lower} yhat_upper:{yhat_upper}"
-                      f" buying_score:{buying_score} selling_score:{selling_score}")
+        반환값:
+            bool: 유효한 날짜 형식이면 True, 그렇지 않으면 False.
+        """
+        try:
+            # %Y-%m-%d 형식으로 문자열을 datetime 객체로 변환 시도
+            datetime.strptime(date_string, '%Y-%m-%d')
+            return True
+        except ValueError:
+            # 변환이 실패하면 ValueError가 발생, 형식이 맞지 않음
+            return False
 
-        if buying_score > 0:
-            return 'buy', buying_score
-        elif selling_score > 0:
-            return 'sell', selling_score
-        else:
-            return 'hold', 0
 
 
 class CorpProphet(MyProphet):
+    """
+    기업 코드를 기반으로 주가를 예측하는 Prophet 모델 클래스.
+
+    속성:
+        code (str): 기업 코드.
+        name (str): 기업명.
+    """
     def __init__(self, code: str):
         assert tools.is_6digit(code), f'Invalid value : {code}'
         self._code = code
@@ -252,10 +383,16 @@ class CorpProphet(MyProphet):
 
 
 class MIProphet(MyProphet):
+    """
+    특정 MI(Market Indicator) 타입에 따라 주가를 예측하는 Prophet 모델 클래스.
+
+    속성:
+        mi_type (str): MI 타입.
+    """
     def __init__(self, mi_type: str):
-        assert mi_type in MIs.keys(), f"Invalid MI type ({MIs.keys()})"
+        assert mi_type in MIs._fields, f"Invalid MI type ({MIs._fields})"
         self._mi_type = mi_type
-        super().__init__(ticker=MIs[mi_type])
+        super().__init__(ticker=getattr(MIs, mi_type))
 
     @property
     def mi_type(self) -> str:
@@ -263,6 +400,6 @@ class MIProphet(MyProphet):
 
     @mi_type.setter
     def mi_type(self, mi_type: str):
-        assert mi_type in MIs.keys(), f"Invalid MI type ({MIs.keys()})"
+        assert mi_type in MIs._fields, f"Invalid MI type ({MIs._fields})"
         self._mi_type = mi_type
-        self.ticker = MIs[mi_type]
+        self.ticker = getattr(MIs, mi_type)

analyser_hj3415/cli.py

@@ -18,7 +18,7 @@ def analyser_manager():
     ranking_parser.add_argument('-r', '--refresh', action='store_true', help='래디스 캐시를 사용하지 않고 강제로 재계산 할지')
     # prophet - score 파서
     prophet_get_parser = prophet_subparser.add_parser('score', help='prophet score 계산')
-    prophet_get_parser.add_argument('target', type=str, help=f'종목코드 or {list(MIs.keys())}')
+    prophet_get_parser.add_argument('target', type=str, help=f'종목코드 or {list(MIs._fields)}')
     prophet_get_parser.add_argument('-r', '--refresh', action='store_true', help='래디스 캐시를 사용하지 않고 강제로 재계산 할지')
 
     # lstm 명령어 서브파서
@@ -27,10 +27,11 @@ def analyser_manager():
     # lstm - caching 파서
     caching_parser = lstm_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 몇위까지 작업을 할지')
     # 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.keys())}')
+    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='래디스 캐시를 사용하지 않고 강제로 재계산 할지')
 
@@ -176,13 +177,14 @@ def analyser_manager():
                 print(e)
                 mymongo.Logs.save('cli', 'ERROR', f'analyser prophet ranking 실행중 에러 - {e}')
         elif args.command == 'score':
-            if args.target in MIs.keys():
-                myprophet = tsa.MIProphet(args.target)
+            mi_type = str(args.target).upper()
+            if mi_type in MIs._fields:
+                myprophet = tsa.MIProphet(mi_type)
             elif tools.is_6digit(args.target):
                 myprophet = tsa.CorpProphet(args.target)
             else:
                 raise Exception("Invalid target")
-            print(myprophet.scoring())
+            print(myprophet.generate_data(refresh=args.refresh).score)
             # mymongo.Logs.save('cli','INFO', f'run >> analyser prophet get {args.target}')
 
     elif args.type == 'lstm':
@@ -193,18 +195,19 @@ def analyser_manager():
                     compile.CorpCompile.analyse_lstm_topn(refresh=args.refresh, top=args.top)
                 else:
                     compile.CorpCompile.analyse_lstm_topn(refresh=args.refresh)
-                compile.MICompile.analyser_lstm_all_mi(refresh=args.refresh)
+                if args.market_index:
+                    compile.MICompile.analyser_lstm_all_mi(refresh=args.refresh)
             except Exception as e:
                 print(e)
                 mymongo.Logs.save('cli','ERROR', f'analyser lstm caching 실행중 에러 - {e}')
         elif args.command == 'predict':
-            if args.target in MIs.keys():
-                mylstm = tsa.MILSTM(args.target)
+            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")
-            mylstm.initializing()
             future_data, grade = mylstm.get_final_predictions(refresh=args.refresh, num=args.num)
             print(future_data)
             print(grade)

{analyser_hj3415-3.2.2.dist-info → analyser_hj3415-3.3.1.dist-info}/METADATA

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

analyser_hj3415-3.3.1.dist-info/RECORD

@@ -0,0 +1,23 @@
+analyser_hj3415/__init__.py,sha256=jqHEUoBeihYOMaS0bPOe3nRVXBufZ0clxc6M6jxPY0o,320
+analyser_hj3415/cli.py,sha256=rn9feZcUpgIXM8JX0OsNCKy9oZauMnEcNKR38sSQfds,12017
+analyser_hj3415/analyser/__init__.py,sha256=N0XyBfWJNpDS_6JYziKETWePO_jtFB1m7E8Qbwt1w0Q,1096
+analyser_hj3415/analyser/compile.py,sha256=xumUdFxcBWPqiT0fLzl7ZP6Sx0Vj3uThPTMOJcjfeUE,12513
+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=CXAMxGUcjC75RRS6sDhC_Ol5p-y2L7Wl4LR3a04ouxM,6525
+analyser_hj3415/analyser/eval/mil.py,sha256=mFMiFCuCBvlQrhQcM5hMg8U4zF32TS1GnUmk8fPd950,15178
+analyser_hj3415/analyser/eval/red.py,sha256=8aJPpiVzLOZtt6kILCzqcfL8BrEVgIld1iI3StGvg8A,12193
+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=P8peqg6ZUpCSNKupjFlyba3xbPZoYtpd2UihXib_4Do,28548
+analyser_hj3415/analyser/tsa/prophet.py,sha256=50tyvTZSfo3UcLuXMsgzr3ibsh5QHCv5SiQqKjM9igg,14658
+analyser_hj3415/workroom/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+analyser_hj3415/workroom/mysklearn.py,sha256=wJXKz5MqqTzADdG2mqRMMzc_G9RzwYjj5_j4gyOopxQ,2030
+analyser_hj3415/workroom/mysklearn2.py,sha256=1lIy6EWEQHkOzDS-av8U0zQH6DuCLKWMI73dnJx5KRs,1495
+analyser_hj3415/workroom/score.py,sha256=P6nHBJYmyhigGtT4qna4BmNtvt4B93b7SKyzdstJK24,17376
+analyser_hj3415/workroom/trash.py,sha256=zF-W0piqkGr66UP6-iybo9EXh2gO0RP6R1FnIpsGkl8,12262
+analyser_hj3415-3.3.1.dist-info/entry_points.txt,sha256=ZfjPnJuH8SzvhE9vftIPMBIofsc65IAWYOhqOC_L5ck,65
+analyser_hj3415-3.3.1.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+analyser_hj3415-3.3.1.dist-info/METADATA,sha256=fkHlNPU6RQq-I-oxqzDi1vb7C0nFH6UNg0AbQ6SyWfw,6777
+analyser_hj3415-3.3.1.dist-info/RECORD,,

analyser_hj3415-3.2.2.dist-info/RECORD

@@ -1,22 +0,0 @@
-analyser_hj3415/__init__.py,sha256=jqHEUoBeihYOMaS0bPOe3nRVXBufZ0clxc6M6jxPY0o,320
-analyser_hj3415/cli.py,sha256=E4ElTT5QRuxlbBecayzjFgL32JKHRacBoy3OCyes_n8,11780
-analyser_hj3415/analyser/__init__.py,sha256=rAY-FS6d1MtK3ShIYtuBAV5fk-GFlzxGF8c7JaGwD5Y,227
-analyser_hj3415/analyser/compile.py,sha256=KmU4CD5xrjwcNbkZomju3eOWqElKSJdU5sO1TTAcEiE,10775
-analyser_hj3415/analyser/eval/__init__.py,sha256=IP1d0Q3nOCAD3zK1qxrC685MkJQfUh-qaXc7xptTxk8,80
-analyser_hj3415/analyser/eval/blue.py,sha256=fq_eln7-EdwICNQ2sMXAfZKXGhQ29EaJwsGvn7xA29U,7632
-analyser_hj3415/analyser/eval/common.py,sha256=wcWJg_jNgr02i1U62oZGgLt2iscdle9X-u4aMnZl89Q,14127
-analyser_hj3415/analyser/eval/growth.py,sha256=OXuBuPzVw3q6kpelNigiX7xvJNUP1gv26DNetc4aews,3315
-analyser_hj3415/analyser/eval/mil.py,sha256=wN1jPu5zLJjoDk3kL7piL-4jWhpsAMeQpsTZll0a2dw,10568
-analyser_hj3415/analyser/eval/red.py,sha256=rJbidKlo2s2EJHBGn4HDbfCDcEGP5Rst8iQeJ6jlzNA,10988
-analyser_hj3415/analyser/tsa/__init__.py,sha256=OSl4eQUw0dN0del3-KF746jj-ouhNFtSaLUA5iC1JXs,100
-analyser_hj3415/analyser/tsa/lstm.py,sha256=LuxpW9cQoQeSfYkqEtIelVb8QBNhujXOphu5VB2Ag3E,29881
-analyser_hj3415/analyser/tsa/prophet.py,sha256=1qOyXHlupzto1wurOt80k_I6_-J7qWcEkWGhopgnAYI,10056
-analyser_hj3415/workroom/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-analyser_hj3415/workroom/mysklearn.py,sha256=wJXKz5MqqTzADdG2mqRMMzc_G9RzwYjj5_j4gyOopxQ,2030
-analyser_hj3415/workroom/mysklearn2.py,sha256=1lIy6EWEQHkOzDS-av8U0zQH6DuCLKWMI73dnJx5KRs,1495
-analyser_hj3415/workroom/score.py,sha256=P6nHBJYmyhigGtT4qna4BmNtvt4B93b7SKyzdstJK24,17376
-analyser_hj3415/workroom/trash.py,sha256=zF-W0piqkGr66UP6-iybo9EXh2gO0RP6R1FnIpsGkl8,12262
-analyser_hj3415-3.2.2.dist-info/entry_points.txt,sha256=ZfjPnJuH8SzvhE9vftIPMBIofsc65IAWYOhqOC_L5ck,65
-analyser_hj3415-3.2.2.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-analyser_hj3415-3.2.2.dist-info/METADATA,sha256=Dtq5P_Uy1wwtvdg8oh7AcIbjF1p2XakhGO38ByLDII4,6777
-analyser_hj3415-3.2.2.dist-info/RECORD,,