analyser_hj3415 3.2.2__tar.gz → 3.3.1__tar.gz

{analyser_hj3415-3.2.2 → analyser_hj3415-3.3.1}/PKG-INFO

@@ -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/analyser_hj3415/analyser/__init__.py

@@ -0,0 +1,30 @@
+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-3.3.1/analyser_hj3415/analyser/compile.py

@@ -0,0 +1,353 @@
+import os
+from collections import OrderedDict
+from typing import Union
+from dataclasses import dataclass
+
+from db_hj3415 import myredis
+from utils_hj3415 import tools, setup_logger
+
+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(Market Index) 데이터를 컴파일하여 저장하는 데이터 클래스.
+
+    속성:
+        mi_type (str): 시장 지수 유형.
+        prophet_data (tsa.ProphetData): Prophet 예측 데이터.
+        lstm_grade (tsa.LSTMGrade): LSTM 등급 데이터.
+        is_lstm_up (bool): LSTM 상승 여부.
+        is_prophet_up (bool): Prophet 상승 여부.
+        lstm_html (str): LSTM 시각화 HTML.
+        prophet_html (str): Prophet 시각화 HTML.
+    """
+    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:
+    """
+    MI(Market Index) 데이터를 컴파일하는 클래스.
+
+    메서드:
+        get(refresh=False) -> MICompileData:
+            MI 데이터를 컴파일하거나 캐시에서 가져옵니다.
+
+        analyser_lstm_all_mi(refresh: bool):
+            모든 MI에 대해 LSTM 예측 및 초기화 수행.
+    """
+    def __init__(self, mi_type: str):
+        """
+        MICompile 객체를 초기화합니다.
+
+        매개변수:
+            mi_type (str): 시장 지수 유형.
+        """
+        assert mi_type in MIs._fields, f"Invalid MI type ({MIs._fields})"
+        self._mi_type = mi_type
+
+    @property
+    def mi_type(self) -> str:
+        """
+        MI 유형을 반환합니다.
+
+        반환값:
+            str: MI 유형.
+        """
+        return self._mi_type
+
+    @mi_type.setter
+    def mi_type(self, mi_type: str):
+        """
+        MI 유형을 변경합니다.
+
+        매개변수:
+            mi_type (str): 새로 설정할 MI 유형.
+        """
+        assert mi_type in MIs._fields, f"Invalid MI type ({MIs._fields})"
+        self._mi_type = mi_type
+
+    def get(self, refresh=False) -> MICompileData:
+        """
+        MI 데이터를 컴파일하거나 캐시에서 가져옵니다.
+
+        매개변수:
+            refresh (bool): 데이터를 새로 가져올지 여부.
+
+        반환값:
+            MICompileData: 컴파일된 MI 데이터.
+        """
+        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_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(Market Index)에 대해 LSTM 예측과 초기화를 수행합니다.
+
+        매개변수:
+            refresh (bool): 데이터를 새로 가져올지 여부.
+        """
+        mi_lstm = tsa.MILSTM('WTI')
+        print(f"*** LSTM prediction redis cashing Market Index items ***")
+        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): RED 분석 데이터.
+        mil_data (eval.MilData): MIL 분석 데이터.
+        prophet_data (tsa.ProphetData): Prophet 예측 데이터.
+        lstm_grade (tsa.LSTMGrade): LSTM 등급 데이터.
+        is_lstm_up (bool): LSTM 상승 여부.
+        is_prophet_up (bool): Prophet 상승 여부.
+        lstm_html (str): LSTM 시각화 HTML.
+        prophet_html (str): Prophet 시각화 HTML.
+    """
+    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:
+    """
+    기업 데이터를 컴파일하는 클래스.
+
+    메서드:
+        get(refresh=False) -> CorpCompileData:
+            기업 데이터를 컴파일하거나 캐시에서 가져옵니다.
+
+        red_ranking(expect_earn: float = 0.06, refresh=False) -> OrderedDict:
+            RED 데이터를 기반으로 기업 순위를 계산합니다.
+
+        prophet_ranking(refresh=False, top: Union[int, str]='all') -> OrderedDict:
+            Prophet 데이터를 기반으로 기업 순위를 계산합니다.
+
+        analyse_lstm_topn(refresh: bool, top=40):
+            상위 N개의 기업에 대해 LSTM 예측 수행.
+    """
+    def __init__(self, code: str, expect_earn=0.06):
+        """
+        CorpCompile 객체를 초기화합니다.
+
+        매개변수:
+            code (str): 기업 코드.
+            expect_earn (float, optional): 예상 수익률. 기본값은 0.06.
+        """
+        assert tools.is_6digit(code), f'Invalid value : {code}'
+        self._code = code
+        self.expect_earn = expect_earn
+
+    @property
+    def code(self) -> str:
+        """
+        기업 코드를 반환합니다.
+
+        반환값:
+            str: 기업 코드.
+        """
+        return self._code
+
+    @code.setter
+    def code(self, code: str):
+        """
+        기업 코드를 변경합니다.
+
+        매개변수:
+            code (str): 새로 설정할 기업 코드.
+        """
+        assert tools.is_6digit(code), f'Invalid value : {code}'
+        mylogger.info(f'change code : {self.code} -> {code}')
+        self._code = code
+
+    def get(self, refresh=False) -> CorpCompileData:
+        """
+        기업 데이터를 컴파일하거나 캐시에서 가져옵니다.
+
+        매개변수:
+            refresh (bool): 데이터를 새로 가져올지 여부.
+
+        반환값:
+            CorpCompileData: 컴파일된 기업 데이터.
+        """
+        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_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:
+        """
+        RED 데이터를 기반으로 기업 순위를 계산합니다.
+
+        매개변수:
+            expect_earn (float, optional): 예상 수익률. 기본값은 0.06.
+            refresh (bool): 데이터를 새로 가져올지 여부.
+
+        반환값:
+            OrderedDict: RED 점수를 기준으로 정렬된 기업 순위.
+        """
+        redis_name = 'red_ranking_prev_expect_earn'
+        pee = tools.to_float(myredis.Base.get_value(redis_name))
+        if pee != 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))
+
+    @staticmethod
+    def prophet_ranking(refresh=False, top: Union[int, str]='all') -> OrderedDict:
+        """
+        Prophet 데이터를 기반으로 기업 순위를 계산합니다.
+
+        매개변수:
+            refresh (bool): 데이터를 새로 가져올지 여부.
+            top (Union[int, str], optional): 상위 기업 개수. 'all'이면 전체 반환. 기본값은 'all'.
+
+        반환값:
+            OrderedDict: Prophet 점수를 기준으로 정렬된 기업 순위.
+        """
+        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_prophet_ranking() -> dict:
+            data = {}
+            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
+                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_prophet_ranking, timer=expire_time)
+
+        ranking = OrderedDict(sorted(data_dict.items(), key=lambda x: x[1], reverse=True))
+
+        if top == 'all':
+            return ranking
+        else:
+            if isinstance(top, int):
+                return OrderedDict(list(ranking.items())[:top])
+            else:
+                raise ValueError("top 인자는 'all' 이나 int형 이어야 합니다.")
+
+    @staticmethod
+    def analyse_lstm_topn(refresh: bool, top=40):
+        """
+        상위 N개의 기업에 대해 LSTM 예측을 수행합니다.
+
+        매개변수:
+            refresh (bool): 데이터를 새로 가져올지 여부.
+            top (int, optional): 상위 기업 개수. 기본값은 40.
+        """
+        ranking_topn = CorpCompile.prophet_ranking(refresh=False, top=top)
+        mylogger.info(ranking_topn)
+        corp_lstm = tsa.CorpLSTM('005930')
+        print(f"*** LSTM prediction redis cashing top{top} items ***")
+        for i, (code, _) in enumerate(ranking_topn.items()):
+            corp_lstm.code = code
+            print(f"{i + 1}. {corp_lstm.code}/{corp_lstm.name}")
+            corp_lstm.get_final_predictions(refresh=refresh, num=5)

{analyser_hj3415-3.2.2 → analyser_hj3415-3.3.1}/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)