analyser_hj3415 4.1.4__py3-none-any.whl → 4.2.0__py3-none-any.whl

analyser_hj3415/analyser/eval/mil.py

@@ -7,8 +7,6 @@ from utils_hj3415 import tools, setup_logger
 from db_hj3415 import myredis, mymongo
 
 from analyser_hj3415.analyser.eval.common import Tools
-import pickle
-
 
 mylogger = setup_logger(__name__,'INFO')
 expire_time = tools.to_int(os.getenv('DEFAULT_EXPIRE_TIME_H', 48)) * 3600
@@ -377,48 +375,9 @@ class Mil:
         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], refresh: bool) -> Dict[str, MilData]:
-        # --- (1) 파이프라인 GET ---
-        pipe = myredis.Base.redis_client.pipeline()
-        redis_keys = [f"{code}_{cls.REDIS_MIL_DATA_SUFFIX}" 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)._generate_data(refresh=True)
-            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_MIL_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
+    def bulk_get_data(cls, codes: List[str], refresh: bool) -> Dict[str, MilData]:
+        return myredis.Corps.bulk_get_or_compute(
+            [f"{code}_{cls.REDIS_MIL_DATA_SUFFIX}" for code in codes],
+            lambda key: cls(key[:6])._generate_data(refresh=True),
+            refresh=refresh
+        )

analyser_hj3415/analyser/eval/red.py

@@ -3,7 +3,6 @@ from collections import OrderedDict
 from dataclasses import dataclass
 from typing import Tuple, Dict, List
 import math
-import pickle
 
 from utils_hj3415 import tools, setup_logger
 from db_hj3415 import myredis
@@ -162,7 +161,7 @@ class Red:
                 # 날짜 데이터가 없는경우
                 date = ''
             계산된비유동부채value = round(tools.nan_to_zero(v1) + tools.nan_to_zero(v2) + tools.nan_to_zero(v3) + tools.nan_to_zero(v4),1)
-            mylogger.info(f"{self} - 계산된 비유동부채 : {계산된비유동부채value}")
+            mylogger.debug(f"{self} - 계산된 비유동부채 : {계산된비유동부채value}")
             return date, 계산된비유동부채value
         else:
             return d, 비유동부채
@@ -278,57 +277,19 @@ class Red:
         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=True)
-            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
+    def bulk_get_data(cls, codes: List[str], expect_earn: float, refresh: bool) -> Dict[str, RedData]:
+        return myredis.Corps.bulk_get_or_compute(
+            [f"{code}_{cls.REDIS_RED_DATA_SUFFIX}_{expect_earn}" for code in codes],
+            lambda key: cls(key[:6], expect_earn)._generate_data(refresh=True),
+            refresh=refresh
+        )
+
 
     @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)
+        data = Red.bulk_get_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/prophet.py

@@ -2,7 +2,6 @@ from collections import OrderedDict
 from datetime import datetime, timedelta
 from typing import Tuple, List, Dict, Union
 
-import pickle
 import yfinance as yf
 import pandas as pd
 from prophet import Prophet
@@ -137,6 +136,7 @@ class MyProphet:
             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)
             self.initialized = True
@@ -171,15 +171,20 @@ class MyProphet:
             mylogger.debug(forecast)
             return forecast
 
-        mylogger.debug("Initializing data for MyProphet")
+        mylogger.debug(f"{self.ticker} : Initializing data for MyProphet")
 
         self.scaler = StandardScaler()
         self.model = Prophet()
 
         self.raw_data = get_raw_data()
         mylogger.debug(self.raw_data)
-        self.df_real = preprocessing_for_prophet()
-        self.df_forecast = make_forecast()
+        try:
+            self.df_real = preprocessing_for_prophet()
+            self.df_forecast = make_forecast()
+        except ValueError as e:
+            mylogger.error(f"{self.ticker} : 빈 데이터프레임...{e}")
+            self.df_real = pd.DataFrame()
+            self.df_forecast = pd.DataFrame()
 
     def _make_prophet_latest_data(self) -> ProphetLatestData:
         def scoring(price: float, yhat_lower: float, yhat_upper: float, method: str = 'sigmoid') -> Tuple[str, int]:
@@ -226,22 +231,32 @@ class MyProphet:
 
         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[
-                0].to_dict()
-
-        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'],
-        )
+        try:
+            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.trading_action, data.score = scoring(data.price, data.yhat_lower, data.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)
+        except Exception:
+            data = ProphetLatestData(
+                ticker=self.ticker,
+                date=datetime.now().date(),
+                price=float('nan'),
+                yhat=float('nan'),
+                yhat_lower=float('nan'),
+                yhat_upper=float('nan'),
+            )
         return data
 
     def generate_latest_data(self, refresh: bool) -> ProphetLatestData:
@@ -257,7 +272,7 @@ class MyProphet:
         mylogger.debug("**** Start generate_data... ****")
         redis_name = f'{self.ticker}_{self.REDIS_LATEST_DATA_SUFFIX}'
 
-        mylogger.info(
+        mylogger.debug(
             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)
@@ -285,20 +300,31 @@ class MyProphet:
             if not self.initialized:
                 self.initializing()
 
-            # 날짜를 기준으로 합치기 (outer join)
-            merged_df = pd.merge(self.df_real, self.df_forecast, on="ds", how="outer")
-            # 날짜 정렬
-            merged_df = merged_df.sort_values(by="ds").reset_index(drop=True)
-
-            data = ProphetChartData(
-                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
-                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=tsa.common.is_up_by_OLS(self.df_forecast.set_index('ds')['yhat'].to_dict()),
-            )
+            try:
+                # 날짜를 기준으로 합치기 (outer join)
+                merged_df = pd.merge(self.df_real, self.df_forecast, on="ds", how="outer")
+                # 날짜 정렬
+                merged_df = merged_df.sort_values(by="ds").reset_index(drop=True)
+
+                data = ProphetChartData(
+                    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
+                    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=tsa.common.is_up_by_OLS(self.df_forecast.set_index('ds')['yhat'].to_dict()),
+                )
+            except Exception:
+                data = ProphetChartData(
+                    ticker=self.ticker,
+                    labels=[],
+                    prices=[],
+                    yhats=[],
+                    yhat_uppers=[],
+                    yhat_lowers=[],
+                    is_prophet_up=False,
+                )
             return data
 
         prophet_chart_data = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_generate_prophet_chart_data,
@@ -326,49 +352,11 @@ class MyProphet:
 
     @staticmethod
     def bulk_get_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
+        return myredis.Base.bulk_get_or_compute(
+            tickers,
+            lambda ticker: MyProphet(ticker)._make_prophet_latest_data(),
+            refresh=refresh,
+        )
 
 
 class CorpProphet(MyProphet):

{analyser_hj3415-4.1.4.dist-info → analyser_hj3415-4.2.0.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.3
 Name: analyser_hj3415
-Version: 4.1.4
+Version: 4.2.0
 Summary: Stock analyser and database processing programs
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 Requires-Dist: utils-hj3415>=3.0.10
-Requires-Dist: db-hj3415>=4.5.0
+Requires-Dist: db-hj3415>=4.6.0
 Requires-Dist: scikit-learn>=1.5.2
 Requires-Dist: plotly>=5.24.1
 Requires-Dist: yfinance>=0.2.44

{analyser_hj3415-4.1.4.dist-info → analyser_hj3415-4.2.0.dist-info}/RECORD

@@ -5,13 +5,13 @@ analyser_hj3415/analyser/eval/__init__.py,sha256=IP1d0Q3nOCAD3zK1qxrC685MkJQfUh-
 analyser_hj3415/analyser/eval/blue.py,sha256=p5JPwkQYoO0dsOe3VnfMV3pOWLzNsAFvLCUK56f85Xo,10782
 analyser_hj3415/analyser/eval/common.py,sha256=sNXapoofShA43ww_SLjXmIjkrAr1AhAcezdaN_X_3Us,11443
 analyser_hj3415/analyser/eval/growth.py,sha256=tlHxLx4u5h7bNG0T8ViJujX20QllfrSaBl-TBqFNkEs,6362
-analyser_hj3415/analyser/eval/mil.py,sha256=aSEqlpytkI0A5_jZKOFLUbPgXc-WiKJUVDZuyI_L3fI,17147
-analyser_hj3415/analyser/eval/red.py,sha256=1wbZWFBWQjnnE4uQQVE34Wfl2YXePzJ2yqKmfLxicoc,13906
+analyser_hj3415/analyser/eval/mil.py,sha256=m1Ca7U7IR3A3tbRYAw8wG7SQsI-_LzwYdY9xfM9G8II,15426
+analyser_hj3415/analyser/eval/red.py,sha256=iA4wpuayJalnlwn2SypsHuWPcthvxvNx2CleDraucFs,12168
 analyser_hj3415/analyser/tsa/__init__.py,sha256=pg20ZQRABedTdaIoOr5t043RNKtJ7ji_WmnZrD1IhPg,147
 analyser_hj3415/analyser/tsa/common.py,sha256=ZLUkifupOlLKsrPiqR3y6FaEN4M_loZhxCZXYxkX0us,1874
 analyser_hj3415/analyser/tsa/lstm.py,sha256=oENuJyyo6U9MMn4UF4ZauGai51_dJisMSUNBiH8udXo,28998
-analyser_hj3415/analyser/tsa/prophet.py,sha256=a8XPiikRFbqHjbDT7C3hK5RsqOp5JyAbY7lDFNQfBzM,17884
-analyser_hj3415-4.1.4.dist-info/entry_points.txt,sha256=ZfjPnJuH8SzvhE9vftIPMBIofsc65IAWYOhqOC_L5ck,65
-analyser_hj3415-4.1.4.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-analyser_hj3415-4.1.4.dist-info/METADATA,sha256=UqtHmuR79l4cAs6pEa4YD4wiuoMPfgEmpTzsCiamFDs,6777
-analyser_hj3415-4.1.4.dist-info/RECORD,,
+analyser_hj3415/analyser/tsa/prophet.py,sha256=0xcZWk8wf-A7W_27dJErUZ9x3_Fei37KgDRwH0SUT_I,17142
+analyser_hj3415-4.2.0.dist-info/entry_points.txt,sha256=ZfjPnJuH8SzvhE9vftIPMBIofsc65IAWYOhqOC_L5ck,65
+analyser_hj3415-4.2.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+analyser_hj3415-4.2.0.dist-info/METADATA,sha256=LzOMuNTAdFxO0HV_7kI1HrVWqEm-AxQCR3RQky_i6lc,6777
+analyser_hj3415-4.2.0.dist-info/RECORD,,