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

analyser_hj3415/analyser/__init__.py

@@ -1,12 +1,30 @@
-MIs = {
-    "wti": "CL=F",
-    "gold": "GC=F",
-    "silver": "SI=F",
-    "usdidx": "DX-Y.NYB",
-    "usdkrw": "KRW=X",
-    "sp500": "^GSPC",
-    "kospi": "^KS11",
-    "nikkei": "^N225",
-    "china": "^HSI",
-    "irx": "^IRX",
-}
+from typing import NamedTuple
+
+class MarketIndices(NamedTuple):
+    """
+    주요 시장 지수를 나타내는 NamedTuple입니다.
+
+    속성:
+        WTI (str): 서부 텍사스 중질유(WTI) 선물 지수 (심볼: "CL=F").
+        GOLD (str): 금 선물 지수 (심볼: "GC=F").
+        SILVER (str): 은 선물 지수 (심볼: "SI=F").
+        USD_IDX (str): 미국 달러 인덱스 (심볼: "DX-Y.NYB").
+        USD_KRW (str): 달러-원 환율 (심볼: "KRW=X").
+        SP500 (str): S&P 500 주가지수 (심볼: "^GSPC").
+        KOSPI (str): 코스피 지수 (심볼: "^KS11").
+        NIKKEI (str): 닛케이 225 지수 (일본) (심볼: "^N225").
+        CHINA (str): 항셍 지수 (홍콩) (심볼: "^HSI").
+        IRX (str): 미국 단기 국채 금리 지수 (13주 T-빌 금리) (심볼: "^IRX").
+    """
+    WTI: str = "CL=F"
+    GOLD: str = "GC=F"
+    SILVER: str = "SI=F"
+    USD_IDX: str = "DX-Y.NYB"
+    USD_KRW: str = "KRW=X"
+    SP500: str = "^GSPC"
+    KOSPI: str = "^KS11"
+    NIKKEI: str = "^N225"
+    CHINA: str = "^HSI"
+    IRX: str = "^IRX"
+
+MIs = MarketIndices()

analyser_hj3415/analyser/compile.py

@@ -1,8 +1,9 @@
 import os
 from collections import OrderedDict
 from typing import Union
+from dataclasses import dataclass
 
-from db_hj3415 import myredis,mymongo
+from db_hj3415 import myredis
 from utils_hj3415 import tools, setup_logger
 
 from analyser_hj3415.analyser import tsa, eval, MIs
@@ -10,12 +11,25 @@ from analyser_hj3415.analyser import tsa, eval, MIs
 mylogger = setup_logger(__name__,'WARNING')
 expire_time = tools.to_int(os.getenv('DEFAULT_EXPIRE_TIME_H', 48)) * 3600
 
+
+@dataclass
+class MICompileData:
+    mi_type: str
+
+    prophet_data: tsa.ProphetData
+    lstm_grade: tsa.LSTMGrade
+
+    is_lstm_up: bool = False
+    is_prophet_up: bool = False
+
+    lstm_html: str = ''
+    prophet_html: str = ''
+
+
 class MICompile:
     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
-        self.prophet = tsa.MIProphet(mi_type)
-        self.lstm = tsa.MILSTM(mi_type)
 
     @property
     def mi_type(self) -> str:
@@ -23,88 +37,67 @@ class MICompile:
 
     @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.prophet.mi_type = mi_type
-        self.lstm.mi_type = mi_type
 
-    def get(self, refresh=False) -> dict:
-        """
-        특정 MI(Market Index) 타입 데이터를 컴파일하고 반환합니다.
-        데이터를 Redis 캐시에서 가져오거나, 새로 생성하여 캐시에 저장합니다.
-
-        Args:
-            refresh (bool, optional):
-                - True: 캐시를 무시하고 데이터를 새로 생성하여 저장.
-                - False: 캐시된 데이터를 가져오며, 없을 경우 새로 생성.
-                Defaults to False.
-
-        Returns:
-            dict: MI 데이터를 포함하는 딕셔너리로 반환하며, 다음의 키를 포함합니다:
-                - 'name' (str): MI 타입 이름.
-                - 'trading_action' (str): 예측된 매매 신호 ('buy', 'sell', 'hold').
-                - 'prophet_score' (float): Prophet 모델의 예측 점수.
-                - 'lstm_grade' (float): LSTM 모델의 최종 예측 점수.
-                - 'is_lstm_up' (bool): LSTM 모델이 상승 신호를 나타내는지 여부.
-                - 'prophet_html' (str): prophet_html,
-                - 'lstm_html' (str): lstm_html ,
-        Example:
-            {
-                'name': 'example_mi',
-                'trading_action': 'buy',
-                'prophet_score': 0.88,
-                'lstm_grade': 0.92,
-                'is_lstm_up': True,
-                'prophet_html': prophet_html...,
-                'lstm_html': lstm_html...,
-            }
-        """
+    def get(self, refresh=False) -> MICompileData:
         print(f"{self.mi_type}의 compiling을 시작합니다.")
         redis_name = self.mi_type + '_mi_compile'
         print(
             f"redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time / 3600}h")
 
-        def fetch_mi_compile() -> dict:
-            print(f"{self.mi_type}")
-            trading_action, prophet_score = self.prophet.scoring()
-            prophet_html = self.prophet.export()
-            self.lstm.initializing()
-            _, lstm_grade = self.lstm.get_final_predictions(refresh=refresh, num=5)
-            is_lstm_up = self.lstm.is_lstm_up()
-            lstm_html= self.lstm.export()
-
-            return {
-                'name': self.mi_type,
-                'trading_action': trading_action,
-                'prophet_score': prophet_score,
-                'lstm_grade': lstm_grade,
-                'is_lstm_up': is_lstm_up,
-                'prophet_html': prophet_html,
-                'lstm_html': lstm_html,
-            }
-
-        data_dict = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_mi_compile, timer=expire_time)
-        return data_dict
+        def fetch_mi_compile_data() -> MICompileData:
+            prophet = tsa.MIProphet(self.mi_type)
+            lstm = tsa.MILSTM(self.mi_type)
+
+            data = MICompileData(
+                mi_type=self.mi_type,
+                prophet_data=prophet.generate_data(refresh=refresh),
+                lstm_grade=lstm.get_final_predictions(refresh=refresh)[1],
+            )
+            data.is_lstm_up = lstm.is_lstm_up()
+            data.is_prophet_up = prophet.is_prophet_up(refresh=False)
+            data.lstm_html = lstm.export(refresh=False)
+            data.prophet_html = prophet.export()
+            return data
+
+        mi_compile_data = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_mi_compile_data, timer=expire_time)
+        return mi_compile_data
 
     @staticmethod
     def analyser_lstm_all_mi(refresh: bool):
-        mi_lstm = tsa.MILSTM('wti')
+        mi_lstm = tsa.MILSTM('WTI')
         print(f"*** LSTM prediction redis cashing Market Index items ***")
-        for mi_type in MIs.keys():
+        for mi_type in MIs._fields:
             mi_lstm.mi_type = mi_type
             print(f"{mi_lstm.mi_type}")
             mi_lstm.initializing()
             mi_lstm.get_final_predictions(refresh=refresh, num=5)
 
 
+@dataclass
+class CorpCompileData:
+    code: str
+    name: str
+
+    red_data: eval.RedData
+    mil_data: eval.MilData
+
+    prophet_data: tsa.ProphetData
+    lstm_grade: tsa.LSTMGrade
+
+    is_lstm_up: bool = False
+    is_prophet_up: bool = False
+
+    lstm_html: str = ''
+    prophet_html: str = ''
+
+
 class CorpCompile:
     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.CorpProphet(code)
+        self.expect_earn = expect_earn
 
     @property
     def code(self) -> str:
@@ -115,70 +108,34 @@ class CorpCompile:
         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:
-        """
-        특정 기업 데이터를 컴파일하여 반환합니다.
-        데이터를 Redis 캐시에서 가져오거나, 새로 생성하여 캐시에 저장합니다.
-
-        Args:
-            refresh (bool, optional):
-                - True: 캐시를 무시하고 데이터를 새로 생성하여 저장.
-                - False: 캐시된 데이터를 가져오며, 없을 경우 새로 생성.
-                Defaults to False.
-
-        Returns:
-            dict: 기업 데이터를 포함하는 딕셔너리로 반환되며, 다음의 키를 포함합니다:
-                - 'name' (str): 기업 이름.
-                - 'red_score' (float): 기업의 Red Score (위험 점수).
-                - '이익지표' (float): 기업의 이익 지표.
-                - '주주수익률' (float): 주주 수익률.
-                - 'trading_action' (str): 예측된 매매 신호 ('buy', 'sell', 'hold').
-                - 'prophet_score' (float): Prophet 모델의 예측 점수.
-                - 'prophet_html' (str): prophet_html,
-
-        Example:
-            {
-                'name': 'Samsung Electronics',
-                'red_score': 0.85,
-                '이익지표': 0.75,
-                '주주수익률': 0.10,
-                'trading_action': 'buy',
-                'prophet_score': 0.92,
-                'prophet_html': prophet_html...,
-            }
-        """
-        print(f"{self.code}/{self.name}의 compiling을 시작합니다.")
+        print(f"{self.code}의 compiling을 시작합니다.")
         redis_name = self.code + '_corp_compile'
         print(
             f"redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time/3600}h")
 
-        def fetch_corp_compile() -> 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()
-            prophet_html = self.prophet.export()
-
-            return {
-                'name': self.name,
-                'red_score': red_score,
-                '이익지표': mil_data.이익지표,
-                '주주수익률': mil_data.주주수익률,
-                'trading_action': trading_action,
-                'prophet_score': prophet_score,
-                'prophet_html': prophet_html,
-            }
-        data_dict = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_corp_compile, timer=expire_time)
-        return data_dict
+        def fetch_corp_compile_data() -> CorpCompileData:
+            prophet = tsa.CorpProphet(self.code)
+            lstm = tsa.CorpLSTM(self.code)
+
+            data = CorpCompileData(
+                code=self.code,
+                name=myredis.Corps(self.code,'c101').get_name(data_from='mongo'),
+                red_data=eval.Red(self.code, self.expect_earn).get(refresh=refresh, verbose=False),
+                mil_data=eval.Mil(self.code).get(refresh=refresh, verbose=False),
+                prophet_data=prophet.generate_data(refresh=refresh),
+                lstm_grade=lstm.get_final_predictions(refresh=refresh)[1],
+            )
+
+            data.is_lstm_up = lstm.is_lstm_up()
+            data.is_prophet_up = prophet.is_prophet_up(refresh=False)
+            data.lstm_html = lstm.export(refresh=False)
+            data.prophet_html = prophet.export()
+            return data
+
+        corp_compile_data = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_corp_compile_data, timer=expire_time)
+        return corp_compile_data
 
     @staticmethod
     def red_ranking(expect_earn: float = 0.06, refresh=False) -> OrderedDict:
@@ -222,24 +179,24 @@ class CorpCompile:
         print(
             f"redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time/3600}h")
 
-        def fetch_ranking() -> dict:
+        def fetch_prophet_ranking() -> dict:
             data = {}
-            c = CorpCompile('005930')
+            c = tsa.CorpProphet('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
+                score= c.generate_data(refresh=refresh).score
+                print(f'{code} compiled : {score}')
+                data[code] = score
             return data
 
-        data_dict = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_ranking, timer=expire_time)
+        data_dict = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_prophet_ranking, timer=expire_time)
 
         # prophet_score를 기준으로 정렬
-        ranking = OrderedDict(sorted(data_dict.items(), key=lambda x: x[1]['prophet_score'], reverse=True))
+        ranking = OrderedDict(sorted(data_dict.items(), key=lambda x: x[1], reverse=True))
 
         if top == 'all':
             return ranking
@@ -258,7 +215,4 @@ class CorpCompile:
         for i, (code, _) in enumerate(ranking_topn.items()):
             corp_lstm.code = code
             print(f"{i + 1}. {corp_lstm.code}/{corp_lstm.name}")
-            corp_lstm.initializing()
             corp_lstm.get_final_predictions(refresh=refresh, num=5)
-
-

analyser_hj3415/analyser/eval/blue.py

@@ -15,6 +15,28 @@ expire_time = tools.to_int(os.getenv('DEFAULT_EXPIRE_TIME_H', 48)) * 3600
 
 @dataclass()
 class BlueData:
+    """
+    기업의 주요 안정성 지표와 관련된 데이터를 저장하는 데이터 클래스.
+
+    이 클래스는 기업의 유동성, 부채 비율, 자산 회전율 등을 포함하며,
+    이를 활용하여 기업의 안정성을 평가할 수 있습니다.
+
+    속성:
+        code (str): 기업의 종목 코드 (6자리 숫자 문자열).
+        name (str): 기업명.
+        유동비율 (float): 유동 자산 대비 유동 부채 비율.
+        이자보상배율_r (float): 최근 이자보상배율 값.
+        이자보상배율_dict (dict): 이자보상배율 데이터.
+        순운전자본회전율_r (float): 최근 순운전자본회전율 값.
+        순운전자본회전율_dict (dict): 순운전자본회전율 데이터.
+        재고자산회전율_r (float): 최근 재고자산회전율 값.
+        재고자산회전율_dict (dict): 재고자산회전율 데이터.
+        재고자산회전율_c106 (dict): C106 기준 재고자산회전율 데이터.
+        순부채비율_r (float): 최근 순부채비율 값.
+        순부채비율_dict (dict): 순부채비율 데이터.
+        score (list): 평가 점수.
+        date (list): 데이터와 관련된 날짜 목록.
+    """
     code: str
     name: str
 
@@ -38,6 +60,20 @@ class BlueData:
 
 
 class Blue:
+    """
+    기업의 안정성 지표를 분석하고 계산하는 클래스.
+
+    이 클래스는 주어진 기업 코드에 대해 주요 안정성 지표(예: 유동비율, 이자보상배율 등)를 수집하고,
+    이를 기반으로 기업의 안정성을 평가합니다. Redis 캐시를 활용하여 계산된 데이터를 저장하고
+    재사용할 수 있습니다.
+
+    속성:
+        c101 (myredis.C101): 기업 정보 및 최근 데이터 접근 객체.
+        c103 (myredis.C103): 재무 상태표 데이터 접근 객체.
+        c104 (myredis.C104): 투자 지표 데이터 접근 객체.
+        name (str): 기업명.
+        _code (str): 기업 종목 코드.
+    """
     def __init__(self, code: str):
         assert tools.is_6digit(code), f'Invalid value : {code}'
         mylogger.debug(f"Blue : 종목코드 ({code})")
@@ -69,10 +105,22 @@ class Blue:
         self._code = code
 
     def _calc유동비율(self, pop_count: int, refresh: bool) -> Tuple[str, float]:
-        """유동비율계산 - Blue에서 사용
+        """
+        기업의 유동비율을 계산합니다.
+
+        유동비율 데이터가 유효하지 않거나 100 이하일 경우,
+        유동자산과 유동부채를 기반으로 계산을 수행합니다.
+
+        매개변수:
+            pop_count (int): 데이터 검색 시 사용할 값의 개수.
+            refresh (bool): 데이터를 새로고침할지 여부.
+
+        반환값:
+            Tuple[str, float]: 날짜와 계산된 유동비율.
 
-        c104q에서 최근유동비율 찾아보고 유효하지 않거나 \n
-        100이하인 경우에는수동으로 계산해서 다시 한번 평가해 본다.\n
+        로그:
+            - 유동비율 계산 과정과 결과를 출력합니다.
+            - 계산 중 유효하지 않은 데이터가 있으면 경고를 출력합니다.
         """
         mylogger.info(f'In the calc유동비율... refresh : {refresh}')
         self.c104.page = 'c104q'
@@ -111,6 +159,17 @@ class Blue:
         return [0 ,]
 
     def _generate_data(self, refresh: bool) -> BlueData:
+        """
+        BlueData 형식의 데이터를 생성합니다.
+
+        각종 안정성 지표를 계산하고 데이터를 정리하여 BlueData 객체로 반환합니다.
+
+        매개변수:
+            refresh (bool): 데이터를 새로고침할지 여부.
+
+        반환값:
+            BlueData: 계산된 안정성 지표 데이터.
+        """
         d1, 유동비율 = self._calc유동비율(pop_count=3, refresh=refresh)
         mylogger.info(f'유동비율 {유동비율} / [{d1}]')
 
@@ -171,9 +230,20 @@ class Blue:
 
     def get(self, refresh = False, verbose = True) -> BlueData:
         """
-        BlueData 형식의 데이터를 계산하여 리턴하고 레디스 캐시에 저장한다.
-        :param refresh:
-        :return:
+        BlueData 객체를 Redis 캐시에서 가져오거나 새로 생성하여 반환합니다.
+
+        캐시에서 데이터를 검색하고, 없을 경우 `_generate_data`를 호출하여 데이터를 생성합니다.
+        생성된 데이터는 Redis 캐시에 저장되어 재사용됩니다.
+
+        매개변수:
+            refresh (bool): 캐시를 무시하고 새로 데이터를 계산할지 여부. 기본값은 False.
+            verbose (bool): 실행 중 상세 정보를 출력할지 여부. 기본값은 True.
+
+        반환값:
+            BlueData: Redis 캐시에서 가져오거나 새로 생성된 BlueData 객체.
+
+        로그:
+            - 캐시 검색 상태와 새로 생성된 데이터를 출력합니다.
         """
         redis_name = f"{self.code}_blue"
         mylogger.info(f"{self} BlueData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
@@ -181,7 +251,6 @@ class Blue:
             print(f"{self} redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time /3600}h")
 
         def fetch_generate_data(refresh_in: bool) -> dict:
-            return asdict(self._generate_data(refresh_in))
+            return self._generate_data(refresh_in) # type: ignore
 
-        return BlueData \
-            (**myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_generate_data, refresh, timer=expire_time))
+        return myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_generate_data, refresh, timer=expire_time)