analyser_hj3415 3.0.3__tar.gz → 3.0.5__tar.gz

{analyser_hj3415-3.0.3 → analyser_hj3415-3.0.5}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.3
 Name: analyser_hj3415
-Version: 3.0.3
+Version: 3.0.5
 Summary: Stock analyser and database processing programs
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
-Requires-Dist: utils-hj3415>=3.0.8
+Requires-Dist: utils-hj3415>=3.0.10
 Requires-Dist: db-hj3415>=4.3.0
 Requires-Dist: scikit-learn>=1.5.2
 Requires-Dist: plotly>=5.24.1

{analyser_hj3415-3.0.3 → analyser_hj3415-3.0.5}/analyser_hj3415/__init__.py

@@ -8,6 +8,6 @@ if env_path is None:
 load_dotenv(env_path)
 
 from analyser_hj3415.analyser import eval
-from analyser_hj3415.analyser import score
+from analyser_hj3415.analyser import compile
 from analyser_hj3415.analyser import tsa
 

analyser_hj3415-3.0.5/analyser_hj3415/analyser/compile.py

@@ -0,0 +1,145 @@
+import os
+from collections import OrderedDict
+from typing import Union
+
+from db_hj3415 import myredis,mymongo
+from utils_hj3415 import tools, setup_logger
+
+from analyser_hj3415.analyser import tsa
+from analyser_hj3415.analyser import eval
+
+mylogger = setup_logger(__name__,'WARNING')
+expire_time = tools.to_int(os.getenv('DEFAULT_EXPIRE_TIME_H', 48)) * 3600
+
+
+class Compile:
+    def __init__(self, code: str, expect_earn=0.06):
+        assert tools.is_6digit(code), f'Invalid value : {code}'
+        self._code = code
+        self.name = mymongo.Corps.get_name(code)
+        self.red = eval.Red(code, expect_earn)
+        self.mil = eval.Mil(code)
+        self.prophet = tsa.MyProphet(code)
+
+    @property
+    def code(self) -> str:
+        return self._code
+
+    @code.setter
+    def code(self, code: str):
+        assert tools.is_6digit(code), f'Invalid value : {code}'
+        mylogger.info(f'change code : {self.code} -> {code}')
+        self._code = code
+        self.name = mymongo.Corps.get_name(code)
+        self.red.code = code
+        self.mil.code = code
+        self.prophet.code = code
+
+    def get(self, refresh=False) -> dict:
+        print(f"{self.code}/{self.name}의 compiling을 시작합니다.")
+        redis_name = self.code + '_compile_scores'
+        print(
+            f"redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time/3600}h")
+
+        def fetch_compile_scores() -> dict:
+            mylogger.info("Red score 계산중..")
+            red_score = self.red.get(verbose=False).score
+
+            mylogger.info("Mil data 계산중..")
+            mil_data = self.mil.get(verbose=False)
+
+            mylogger.info("\tProphet 최근 데이터 조회중..")
+            trading_action, prophet_score = self.prophet.scoring()
+
+            return {
+                'name': self.name,
+                'red_score': red_score,
+                '이익지표': mil_data.이익지표,
+                '주주수익률': mil_data.주주수익률,
+                'trading_action': trading_action,
+                'prophet_score': prophet_score,
+            }
+        data_dict = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_compile_scores, timer=expire_time)
+        return data_dict
+
+    @staticmethod
+    def prophet_ranking(refresh=False, top: Union[int, str]='all') -> OrderedDict:
+
+        print("**** Start Compiling scores and sorting... ****")
+        redis_name = 'prophet_ranking'
+
+        print(
+            f"redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time/3600}h")
+
+        def fetch_ranking() -> dict:
+            data = {}
+            c = Compile('005930')
+            for code in myredis.Corps.list_all_codes():
+                try:
+                    c.code = code
+                except ValueError:
+                    mylogger.error(f'prophet ranking error : {code}')
+                    continue
+                scores= c.get(refresh=refresh)
+                print(f'{code} compiled : {scores}')
+                data[code] = scores
+            return data
+
+        data_dict = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_ranking, timer=expire_time)
+
+        # prophet_score를 기준으로 정렬
+        ranking = OrderedDict(sorted(data_dict.items(), key=lambda x: x[1]['prophet_score'], 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 analyse_lstm_topn(refresh: bool, top=40):
+        ranking_topn = Compile.prophet_ranking(refresh=False, top=top)
+        mylogger.info(ranking_topn)
+        mylstm = tsa.MyLSTM('005930')
+        print(f"*** LSTM prediction redis cashing top{top} items ***")
+        for i, (code, _) in enumerate(ranking_topn.items()):
+            mylstm.code = code
+            print(f"{i + 1}. {mylstm.code}/{mylstm.name}")
+            mylstm.initializing()
+            mylstm.get_final_predictions(refresh=refresh, num=5)
+
+    @staticmethod
+    def red_ranking(expect_earn: float = 0.06, refresh=False) -> OrderedDict:
+        # 이전 expect earn 과 비교하여 다르거나 없으면 강제 refresh 설정
+        redis_name = 'red_ranking_prev_expect_earn'
+        pee = tools.to_float(myredis.Base.get_value(redis_name))
+        if pee != expect_earn:
+            # expect earn의 이전 계산값이 없거나 이전 값과 다르면 새로 계산
+            mylogger.warning(
+                f"expect earn : {expect_earn} / prev expect earn : {pee} 두 값이 달라 refresh = True"
+            )
+            myredis.Base.set_value(redis_name, str(expect_earn))
+            refresh = True
+
+        print("**** Start red_ranking... ****")
+        redis_name = 'red_ranking'
+        print(
+            f"redisname: '{redis_name}' / expect_earn: {expect_earn} / refresh : {refresh} / expire_time : {expire_time / 3600}h")
+
+        def fetch_ranking(refresh_in: bool) -> dict:
+            data = {}
+            red = eval.Red(code='005930', expect_earn=expect_earn)
+            for i, code in enumerate(myredis.Corps.list_all_codes()):
+                red.code = code
+                red_score = red.get(refresh=refresh_in, verbose=False).score
+                if red_score > 0:
+                    data[code] = red_score
+                    print(f"{i}: {red} - {red_score}")
+            return data
+
+        data_dict = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_ranking, refresh, timer=expire_time)
+
+        return OrderedDict(sorted(data_dict.items(), key=lambda item: item[1], reverse=True))
+

{analyser_hj3415-3.0.3 → analyser_hj3415-3.0.5}/analyser_hj3415/analyser/eval/common.py

@@ -9,6 +9,46 @@ mylogger = setup_logger(__name__,'WARNING')
 
 
 class Tools:
+    @staticmethod
+    def sigmoid_score(deviation, a=1.0, b=2.0):
+        """
+        Calculates a normalized score using a sigmoid function based on the provided deviation value.
+
+        This method applies the sigmoid function to a logarithmically transformed deviation value
+        to map it to a range between 0 and 100. The shape of the sigmoid curve can be adjusted
+        with parameters `a` and `b`.
+
+        Parameters:
+            deviation (float): The deviation value to be transformed. Must be a non-negative value.
+            a (float): The steepness of the sigmoid curve. Default is 1.0.
+            b (float): The x-offset for the sigmoid curve. Default is 2.0.
+
+        Returns:
+            float: A score between 0 and 100 derived from the provided deviation value.
+        """
+        # 예: x = log10(deviation + 1)
+        x = math.log10(deviation + 1)
+        s = 1 / (1 + math.exp(-a * (x - b)))  # 0~1 범위
+        return s * 100  # 0~100 범위
+
+    @staticmethod
+    def log_score(deviation):
+        """
+            Compute and return the logarithmic score scaled by a constant factor.
+
+            This method takes a numerical deviation value, adds one to it, computes its
+            base-10 logarithm, and then multiplies the result by a constant factor of 33
+            to scale the resulting logarithmic score.
+
+            Parameters:
+                deviation (float): The numerical deviation value to calculate the
+                logarithmic score for. Should be a non-negative number.
+
+            Returns:
+                float: The scaled logarithmic score computed based on the input deviation.
+        """
+        return math.log10(deviation + 1) * 33
+
     @staticmethod
     def cal_deviation(v1: float, v2: float) -> float:
         """

{analyser_hj3415-3.0.3 → analyser_hj3415-3.0.5}/analyser_hj3415/analyser/eval/red.py

@@ -1,6 +1,5 @@
 import os
 from dataclasses import dataclass, asdict
-from collections import OrderedDict
 from typing import Tuple
 import math
 
@@ -68,7 +67,7 @@ class RedData:
     발행주식수: int
 
     date: list
-
+    주가: float
     red_price: float
     score: int
 
@@ -98,6 +97,7 @@ class Red:
         self.c103 = myredis.C103(code, 'c103재무상태표q')
 
         self.name = self.c101.get_name()
+        self.recent_price = tools.to_float(self.c101.get_recent()['주가'])
         self._code = code
 
         self.expect_earn = expect_earn
@@ -117,6 +117,7 @@ class Red:
         self.c103.code = code
 
         self.name = self.c101.get_name()
+        self.recent_price = tools.to_float(self.c101.get_recent()['주가'])
         self._code = code
 
     def _calc비유동부채(self, refresh: bool) -> Tuple[str, float]:
@@ -152,24 +153,23 @@ class Red:
         else:
             return d, 비유동부채
 
-    def _score(self, red_price: int, refresh: bool) -> int:
+    def _score(self, red_price: int) -> int:
         """red price와 최근 주가의 괴리율 파악
 
             Returns:
                 int : 주가와 red price 비교한 괴리율
             """
-        try:
-            recent_price = tools.to_float(self.c101.get_recent(refresh)['주가'])
-        except KeyError:
+        if math.isnan(self.recent_price):
             return 0
 
-        deviation = Tools.cal_deviation(recent_price, red_price)
-        if red_price < 0 or (recent_price >= red_price):
-            score = 0
-        else:
-            score = tools.to_int(math.log10(deviation + 1) * 33)  # desmos그래프상 33이 제일 적당한듯(최대100점에 가깝게)
+        deviation = Tools.cal_deviation(self.recent_price, red_price)
 
-        mylogger.debug(f"최근주가 : {recent_price} red가격 : {red_price} 괴리율 : {tools.to_int(deviation)} score : {score}")
+        score = tools.to_int(Tools.sigmoid_score(deviation))
+        #score = tools.to_int(Tools.log_score(deviation))
+        if self.recent_price >= red_price:
+            score = -score
+
+        mylogger.debug(f"최근주가 : {self.recent_price} red가격 : {red_price} 괴리율 : {tools.to_int(deviation)} score : {score}")
 
         return score
 
@@ -201,7 +201,7 @@ class Red:
         except (ZeroDivisionError, ValueError):
             red_price = math.nan
 
-        score = self._score(red_price, refresh)
+        score = self._score(red_price)
 
         try:
             date_list = Tools.date_set(d1, d2, d3, d4)
@@ -224,6 +224,7 @@ class Red:
             발행주식수 = 발행주식수,
             date = date_list,
             red_price = red_price,
+            주가 = self.recent_price,
             score = score,
         )
 
@@ -261,35 +262,3 @@ class Red:
 
         return RedData(**myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_generate_data, refresh, timer=expire_time))
 
-    @classmethod
-    def ranking(cls, expect_earn: float = 0.06, refresh = False) -> OrderedDict:
-        # 이전 expect earn 과 비교하여 다르거나 없으면 강제 refresh 설정
-        redis_name = 'red_ranking_prev_expect_earn'
-        pee = tools.to_float(myredis.Base.get_value(redis_name))
-        if pee != expect_earn:
-            # expect earn의 이전 계산값이 없거나 이전 값과 다르면 새로 계산
-            mylogger.warning(
-                f"expect earn : {expect_earn} / prev expect earn : {pee} 두 값이 달라 refresh = True"
-            )
-            myredis.Base.set_value(redis_name, str(expect_earn))
-            refresh = True
-
-        print("**** Start red_ranking... ****")
-        redis_name = 'red_ranking'
-        print(f"redisname: '{redis_name}' / expect_earn: {expect_earn} / refresh : {refresh} / expire_time : {expire_time/3600}h")
-
-        def fetch_ranking(refresh_in: bool) -> dict:
-            data = {}
-            red = Red(code='005930', expect_earn=expect_earn)
-            for i, code in enumerate(myredis.Corps.list_all_codes()):
-                red.code = code
-                red_score = red.get(refresh=refresh_in, verbose=False).score
-                if red_score > 0:
-                    data[code] = red_score
-                    print(f"{i}: {red} - {red_score}")
-            return data
-
-        data_dict = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_ranking, refresh, timer=expire_time)
-
-        return OrderedDict(sorted(data_dict.items(), key=lambda item: item[1], reverse=True))
-

{analyser_hj3415-3.0.3 → analyser_hj3415-3.0.5}/analyser_hj3415/analyser/tsa/lstm.py

@@ -20,8 +20,6 @@ from dataclasses import dataclass
 
 from utils_hj3415 import tools, setup_logger
 from db_hj3415 import myredis
-from analyser_hj3415.analyser import score
-
 
 mylogger = setup_logger(__name__,'WARNING')
 expire_time = tools.to_int(os.getenv('DEFAULT_EXPIRE_TIME_H', 48)) * 3600
@@ -108,6 +106,9 @@ class MyLSTM:
 
     def initializing(self):
         """
+        LSTM 분석을 위해 데이터를 준비하는 과정
+        get_final_predictions(refresh=True)를 시행하기전에 반드시 먼저 실행해줘아 한다.
+
         Fetches stock price data for the last four years from Yahoo Finance and prepares
         it for use in an LSTM model by normalizing, splitting into training and testing datasets,
         and reshaping the data.
@@ -380,25 +381,30 @@ class MyLSTM:
 
     def get_final_predictions(self, refresh: bool, num=5) -> Tuple[dict, LSTMGrade]:
         """
-        Fetches final predictions based on an ensemble method using deep learning models. This process averages the
-        predictions to forecast future data, primarily for debugging purposes as it is challenging to utilize
-        Redis cache for evaluation.
+        Fetch and process predictions for future data.
+
+        This function fetches predictions from a Redis cache or calculates predictions if the data is
+        not found or if a refresh is requested. Predictions are determined using an ensemble training
+        method which averages predictions to forecast future trends. Additionally, the function checks
+        and caches whether the predicted data demonstrates an increasing trend over time.
+
+        Attributes:
+            redis_name (str): f'{self.code}_mylstm_predictions'
+            future_data (dict): Dictionary containing dates (as keys) and predicted prices (as values).
+            lstm_grade (LSTMGrade): Performance evaluation grade for the LSTM prediction model.
 
-        Parameters:
-            refresh (bool): Flag to indicate whether to refresh cached data.
-            num (int, optional): Number of iterations for predictions. Defaults to 5.
+        Args:
+            refresh (bool): If True, forces recalculation and cache refresh of predictions.
+            num (int): Number of times to repeat ensemble training for more consistent predictions.
+                       Defaults to 5.
 
         Returns:
-            Tuple[dict, LSTMGrade]: A tuple containing a dictionary of future predictions and their corresponding
-            evaluation grade.
+            Tuple[dict, LSTMGrade]: A tuple containing a dictionary of future date-price pairs and the
+            evaluation grade of the LSTM prediction model.
 
         Raises:
-            AssertionError: If the lengths of future dates and predicted values do not match.
-
-        Notes:
-            - This function integrates ensemble training and caching of predictive data.
-            - The future prediction keys correspond to the dates in "YYYY-MM-DD" format.
-            - Makes use of Redis for data retrieval and caching mechanisms.
+            AssertionError: Raised if the lengths of 'future_dates' and 'final_future_predictions' do
+                            not match during the data preparation.
         """
         print("**** Start get_final_predictions... ****")
         redis_name = f'{self.code}_mylstm_predictions'
@@ -406,6 +412,51 @@ class MyLSTM:
         print(
             f"redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time/3600}h")
 
+        def caching_is_lstm_up(future_data_in: dict):
+            """
+            날짜(str)를 키, 수치(float)를 값으로 갖는 딕셔너리를
+            선형회귀분석(최소제곱법)을 통해 추세가 우상향인지 판별.
+
+            Returns:
+                bool: 기울기가 양수이면 True, 아니면 False
+            """
+
+            print("**** Caching is_lstm_up ... ****")
+            redis_name = f'{self.code}_is_lstm_up'
+            print(f"redisname: '{redis_name}' / expire_time : {expire_time / 3600}h")
+
+
+            if not future_data_in:
+                # 데이터가 비어있으면 추세를 판단할 수 없음
+                return False
+
+            # 1) 날짜(키) 기준 오름차순 정렬
+            sorted_dates = sorted(future_data_in.keys())
+            values = [future_data_in[d] for d in sorted_dates]
+
+            # 2) x 축을 0,1,2... 형태로 부여 (날짜 간격을 동일하게 가정)
+            x = np.arange(len(values), dtype=float)
+            y = np.array(values, dtype=float)
+
+            # 3) 선형 회귀(최소제곱법)로 기울기(slope) 계산
+            x_mean = np.mean(x)
+            y_mean = np.mean(y)
+
+            # 분자: sum((xi - x_mean) * (yi - y_mean))
+            numerator = np.sum((x - x_mean) * (y - y_mean))
+            # 분모: sum((xi - x_mean)^2)
+            denominator = np.sum((x - x_mean) ** 2)
+
+            if denominator == 0:
+                # 데이터가 1개 이하인 경우 등
+                return False
+
+            slope = numerator / denominator
+
+            # 4) 기울기가 양수면 "우상향 추세"로 판별
+            is_up = slope > 0
+            myredis.Base.set_value(redis_name, is_up, expire_time)
+
         def fetch_final_predictions(num_in) -> tuple:
             """
             앙상블법으로 딥러닝을 모델을 반복해서 평균을 내서 미래를 예측한다. 평가는 래시스 캐시로 반환하기 어려워 일단 디버그 용도로만 사용하기로
@@ -443,7 +494,12 @@ class MyLSTM:
 
             return future_data, lstm_grade
 
-        return myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_final_predictions, num, timer=expire_time)
+        future_data, lstm_grade = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_final_predictions, num, timer=expire_time)
+
+        # 증가 추세인지 아닌지 레디스 캐시에 저장
+        caching_is_lstm_up(future_data)
+
+        return future_data, lstm_grade
 
     def export(self, refresh=False, to="str", num=5) -> Optional[str]:
         """
@@ -621,49 +677,17 @@ class MyLSTM:
         plt.title('Stock Price Prediction with LSTM Ensemble')
         plt.show()"""
 
-    def is_up(self) -> bool:
+    def is_lstm_up(self) -> bool:
         """
-        Determines if the predicted data indicates an increasing trend.
+        Determines whether the LSTM model is active or not.
 
-        This method evaluates the results of future predictions and checks if all the
-        subsequent values in the prediction data increase compared to their predecessors.
+        This method checks the status of an LSTM model by querying a Redis
+        value identified by a specific code indicating LSTM activity.
 
         Returns:
-            bool: True if all future predicted values increase in sequence, False otherwise.
-
-        Raises:
-            None: This method does not raise any exceptions.
-        """
-        # 튜플의 [0]은 날짜 [1]은 값 배열
-        future_data, _ = self.get_final_predictions(refresh=False)
-        # 데이터를 1D 배열로 변환
-        flattened_data = list(future_data.values())
-        mylogger.debug(f"flattened_data : {flattened_data}")
-        # 증가 여부 확인
-        return all(flattened_data[i] < flattened_data[i + 1] for i in range(len(flattened_data) - 1))
-
-    @staticmethod
-    def caching_based_on_prophet_ranking(refresh: bool, top=20):
-        """
-            This method utilizes a ranking system generated by the Score class for
-            predictive caching.
-
-            Parameters
-            ----------
-            refresh : bool
-                Whether to refresh the predictions for the selected items.
-            top : int, optional
-                The number of top-ranked items to process, by default 20.
+            bool: True if the LSTM model is active (up), False otherwise.
         """
-        ranking_topn = score.Score.ranking(refresh=False, top=top)
-        mylogger.info(ranking_topn)
-        mylstm = MyLSTM('005930')
-        print(f"*** LSTM prediction redis cashing top{top} items ***")
-        for i, (code, _) in enumerate(ranking_topn.items()):
-            mylstm.code = code
-            print(f"{i + 1}. {mylstm.code}/{mylstm.name}")
-            mylstm.initializing()
-            mylstm.get_final_predictions(refresh=refresh, num=5)
+        return myredis.Base.get_value(f'{self.code}_is_lstm_up')
 
 
 

{analyser_hj3415-3.0.3 → analyser_hj3415-3.0.5}/analyser_hj3415/analyser/tsa/prophet.py

@@ -1,5 +1,5 @@
 from datetime import datetime, timedelta
-from typing import Optional
+from typing import Optional, Tuple
 import yfinance as yf
 import pandas as pd
 from prophet import Prophet
@@ -177,31 +177,58 @@ class MyProphet:
         else:
             Exception("to 인자가 맞지 않습니다.")
 
-    def scoring(self) -> int:
+    def scoring(self) -> Tuple[str, int]:
         """
-        prophet의 yhat_lower 예측치와 주가를 비교하여 주가가 낮으면 양의 점수를 높으면 음의 점수를 준다.
+        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.
 
         Returns:
-            int: The calculated score based on the deviation between the recent price
-            and the expected lower limit.
+            A tuple containing a string indicating the recommended trading action ('buy', 'sell', 'hold')
+            and an integer score associated with that action.
 
         Raises:
-            AttributeError: Raised if the necessary attributes like `df_real` or methods like `get_yhat`
-            are not correctly set or implemented.
-            KeyError: Raised if the expected keys (`'yhat_lower'` or `'y'`) are not found in the data involved.
-            ValueError: Raised if the format of data does not conform to expected structure for calculations.
+            KeyError: If required keys are missing in the `yhat_dict` or `last_real_data` dictionary-like structures.
         """
         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 = int(yhat_dict['yhat_lower'])
-        deviation = int(eval.Tools.cal_deviation(recent_price, yhat_lower))
-        if recent_price > yhat_lower:
-            score = -deviation
+
+        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))
+
+        if recent_price >= yhat_lower:
+            buying_score = -buying_score
+
+        selling_deviation = eval.Tools.cal_deviation(recent_price, yhat_upper)
+
+        selling_score = tools.to_int(eval.Tools.sigmoid_score(selling_deviation))
+        # score = tools.to_int(Tools.log_score(deviation))
+
+        if recent_price <= yhat_upper:
+            selling_score = -selling_score
+
+        mylogger.info(f"{self.code}/{self.name} date: {recent_date} 가격: {recent_price}"
+                      f" yhat_lower:{yhat_lower} yhat_upper:{yhat_upper}"
+                      f" buying_score:{buying_score} selling_score:{selling_score}")
+
+        if buying_score > 0:
+            return 'buy', buying_score
+        elif selling_score > 0:
+            return 'sell', selling_score
         else:
-            score = deviation
-        mylogger.info(f"{self.code}/{self.name} date: {recent_date} 가격:{recent_price} 기대하한값:{yhat_lower} 편차:{deviation} score:{score}")
-        return score
+            return 'hold', 0
+
 

{analyser_hj3415-3.0.3 → analyser_hj3415-3.0.5}/analyser_hj3415/cli.py

@@ -2,7 +2,7 @@ import argparse
 import pprint
 
 from utils_hj3415 import tools
-from analyser_hj3415.analyser import eval, tsa, score
+from analyser_hj3415.analyser import eval, tsa, compile
 from db_hj3415 import myredis, mymongo
 
 
@@ -92,9 +92,9 @@ def analyser_manager():
         elif args.command == 'ranking':
             mymongo.Logs.save('cli','INFO', 'run >> analyser red ranking')
             if args.expect_earn is None:
-                result = eval.Red.ranking(refresh=args.refresh)
+                result = compile.Compile.red_ranking(refresh=args.refresh)
             else:
-                result = eval.Red.ranking(expect_earn=args.expect_earn, refresh=args.refresh)
+                result = compile.Compile.red_ranking(expect_earn=args.expect_earn, refresh=args.refresh)
             print(result)
 
     elif args.type == 'mil':
@@ -147,16 +147,16 @@ def analyser_manager():
 
     elif args.type == 'prophet':
         if args.command == 'ranking':
-            result = score.Score.ranking(refresh=args.refresh)
+            result = compile.Compile.prophet_ranking(refresh=args.refresh)
             print(result)
             mymongo.Logs.save('cli','INFO', 'run >> analyser prophet ranking')
 
     elif args.type == 'lstm':
         if args.command == 'caching':
             if args.top:
-                tsa.MyLSTM.caching_based_on_prophet_ranking(refresh=args.refresh, top=args.top)
+                compile.Compile.analyse_lstm_topn(refresh=args.refresh, top=args.top)
             else:
-                tsa.MyLSTM.caching_based_on_prophet_ranking(refresh=args.refresh)
+                compile.Compile.analyse_lstm_topn(refresh=args.refresh)
             mymongo.Logs.save('cli','INFO', f'run >> analyser lstm caching / top={args.top if args.top else 20}')
         elif args.command == 'get':
             assert tools.is_6digit(args.code), "code 인자는 6자리 숫자이어야 합니다."

{analyser_hj3415-3.0.3 → analyser_hj3415-3.0.5}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "analyser_hj3415"
-version = "3.0.3"
+version = "3.0.5"
 description = "Stock analyser and database processing programs"
 readme = "README.md"
 requires-python = ">=3.6"
@@ -20,7 +20,7 @@ requires-python = ">=3.6"
 #    "Operating System :: OS Independent"
 #]
 dependencies = [
-    "utils-hj3415>=3.0.8",
+    "utils-hj3415>=3.0.10",
     "db-hj3415>=4.3.0",
     "scikit-learn>=1.5.2",
     "plotly>=5.24.1",

analyser_hj3415-3.0.3/analyser_hj3415/analyser/score.py

@@ -1,164 +0,0 @@
-import os
-import datetime
-from collections import OrderedDict
-
-from db_hj3415 import myredis
-from utils_hj3415 import tools, setup_logger
-
-from analyser_hj3415.analyser import tsa
-from analyser_hj3415.analyser import eval
-
-mylogger = setup_logger(__name__,'WARNING')
-expire_time = tools.to_int(os.getenv('DEFAULT_EXPIRE_TIME_H', 48)) * 3600
-
-
-def is_within_last_three_days(date_to_check: datetime.datetime.date) -> bool:
-    today = datetime.datetime.now().date()  # 현재 날짜 (시간은 무시)
-    # print('today - ', today)
-    three_days_ago = today - datetime.timedelta(days=3)  # 3일 전 날짜
-    return three_days_ago <= date_to_check <= today
-
-
-class Score:
-    def __init__(self, code):
-        self._code = code
-        self.c101 = myredis.C101(code)
-        self.name = self.c101.get_name()
-        self.c108 = myredis.C108(code)
-        self.dart = myredis.Dart(code)
-        self.red = eval.Red(code)
-        self.mil = eval.Mil(code)
-        self.lstm = tsa.MyLSTM(code)
-        self.prophet = tsa.MyProphet(code)
-
-    @property
-    def code(self) -> str:
-        return self._code
-
-    @code.setter
-    def code(self, code: str):
-        assert tools.is_6digit(code), f'Invalid value : {code}'
-        mylogger.info(f'change code : {self.code} -> {code}')
-        self._code = code
-        self.c101.code = code
-        self.name = self.c101.get_name()
-        self.c108.code = code
-        self.dart.code = code
-        self.red.code = code
-        self.mil.code = code
-        self.lstm.code = code
-        self.prophet.code = code
-
-    def get(self, refresh=False) -> dict:
-        """
-        한 종목의 각분야 평가를 모아서 딕셔너리 형태로 반환함.
-        redis_name = self.code + '_score'
-
-        Returns:
-            dict: A dictionary containing the following key-value pairs:
-                - 'name': str - 종목명
-                - '시가총액': str - 시가총액
-                - 'is_update_c108': bool - 최근 3일 이내에 c108이 없데이트 되었는가
-                - 'red_score': float - Red score
-                - '이익지표': float - Mil의 이익지표
-                - '주주수익률': float - Mil의 주주수익률
-                - 'is_lstm_up': Union[bool, None] - lstm 예측치가 상승인지 아닌지, returns None - 데이터가 없으면..
-                - 'prophet_score': int - prophet score
-        """
-        print(f"{self.code}/{self.name}의 scoring을 시작합니다.")
-        redis_name = self.code + '_score'
-        print(
-            f"redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time/3600}h")
-
-        def fetch_score() -> dict:
-            mylogger.info("시가총액 데이터 추출중..")
-            시가총액 = tools.format_large_number(int(self.c101.get_recent()['시가총액']))
-
-            mylogger.info("C108 최근 데이터 추출중..")
-            # c108이 최근에 업데이트 되었는지...
-            c108_recent_date = self.c108.get_recent_date()
-            # print('code - ', code, ' | c108 recent date - ', c108_recent_date.date())
-            if c108_recent_date is None:
-                is_update_c108 = False
-            else:
-                is_update_c108 = is_within_last_three_days(c108_recent_date.date())
-
-            mylogger.info("Red score 계산중..")
-            red_score = self.red.get(verbose=False).score
-
-            mylogger.info("Mil data 계산중..")
-            mil_data = self.mil.get(verbose=False)
-
-            mylogger.info("Lstm 최근 데이터 조회중..")
-            if myredis.Base.exists(f'{self.code}_mylstm_predictions'):
-                is_lstm_up = self.lstm.is_up()
-            else:
-                is_lstm_up = None
-
-            mylogger.info("\tProphet 최근 데이터 조회중..")
-            prophet_score = self.prophet.scoring()
-
-            return {
-                'name': self.name,
-                '시가총액': 시가총액,
-                'is_update_c108': is_update_c108,
-                'red_score': red_score,
-                '이익지표': mil_data.이익지표,
-                '주주수익률': mil_data.주주수익률,
-                'is_lstm_up': is_lstm_up,
-                'prophet_score': prophet_score,
-            }
-        data_dict = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_score, timer=expire_time)
-        return data_dict
-
-    @classmethod
-    def ranking(self, refresh=False, top='all') -> OrderedDict:
-        """
-            prophet score 기준으로 정렬하여 ordered dict로 반환함
-
-            Parameters:
-                refresh (bool): Specifies whether to refresh the ranking data. Defaults
-                    to `False`.
-                top (Union[str, int]): Determines how many top rankings to return.
-                    Defaults to `'all'`. If an integer is provided, it limits the
-                    ranking to the specified count.
-
-            Returns:
-                OrderedDict: A dictionary containing the rankings, sorted in
-                    descending order by `prophet_score`.
-
-            Raises:
-                ValueError: Raised if the parameter `top` is neither `'all'` nor an
-                    integer.
-        """
-        print("**** Start score_ranking... ****")
-        redis_name = 'score_ranking'
-
-        print(
-            f"redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time/3600}h")
-
-        def fetch_ranking() -> dict:
-            data = {}
-            s = Score('005930')
-            for code in myredis.Corps.list_all_codes():
-                try:
-                    s.code = code
-                except ValueError:
-                    mylogger.error(f'score ranking error : {code}')
-                    continue
-                score = s.get(refresh=refresh)
-                data[code] = score
-            return data
-
-        data_dict = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_ranking, timer=expire_time)
-
-        # prophet_score를 기준으로 정렬
-        ranking = OrderedDict(sorted(data_dict.items(), key=lambda x: x[1]['prophet_score'], reverse=True))
-
-        if top == 'all':
-            return ranking
-        else:
-            if isinstance(top, int):
-                return OrderedDict(list(ranking.items())[:top])
-            else:
-                raise ValueError("top 인자는 'all' 이나 int형 이어야 합니다.")