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

analyser_hj3415/__init__.py

@@ -6,8 +6,3 @@ env_path = get_env_path()
 if env_path is None:
     mylogger.warning(f"환경변수 파일(.env)를 찾을수 없습니다. 기본 설정값으로 프로그램을 실행합니다.")
 load_dotenv(env_path)
-
-from analyser_hj3415.analyser import eval
-from analyser_hj3415.analyser import compile
-from analyser_hj3415.analyser import tsa
-

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/analyser/compile.py

@@ -1,22 +1,35 @@
 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
-from analyser_hj3415.analyser import eval
+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 tsa.MIs.keys(), f"Invalid MI type ({tsa.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:
@@ -24,54 +37,67 @@ class MICompile:
 
     @mi_type.setter
     def mi_type(self, mi_type: str):
-        assert mi_type in tsa.MIs.keys(), f"Invalid MI type ({tsa.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:
+    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:
-            trading_action, prophet_score = self.prophet.scoring()
-            print(f"{self.mi_type}")
-            self.lstm.initializing()
-            _, lstm_grade = self.lstm.get_final_predictions(refresh=refresh, num=5)
-            is_lstm_up = self.lstm.is_lstm_up()
+        def fetch_mi_compile_data() -> MICompileData:
+            prophet = tsa.MIProphet(self.mi_type)
+            lstm = tsa.MILSTM(self.mi_type)
 
-            return {
-                'name': self.mi_type,
-                'trading_action': trading_action,
-                'prophet_score': prophet_score,
-                'lstm_grade': lstm_grade,
-                'is_lstm_up': is_lstm_up
-            }
+            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
 
-        data_dict = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_mi_compile, timer=expire_time)
-        return data_dict
+        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 tsa.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:
@@ -82,38 +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:
-
-        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)
+        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],
+            )
 
-            mylogger.info("\tProphet 최근 데이터 조회중..")
-            trading_action, prophet_score = self.prophet.scoring()
+            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
 
-            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_corp_compile, timer=expire_time)
-        return data_dict
+        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:
@@ -157,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
@@ -193,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)

analyser_hj3415/analyser/eval/common.py

@@ -9,22 +9,34 @@ mylogger = setup_logger(__name__,'WARNING')
 
 
 class Tools:
+    """
+    재무 데이터 분석 및 계산에 필요한 유틸리티 메서드를 제공하는 클래스.
+
+    이 클래스는 주어진 재무 데이터를 기반으로 다양한 계산을 수행하며,
+    로그를 통해 계산 과정 및 결과를 디버깅할 수 있도록 지원합니다.
+
+    주요 기능:
+        - Sigmoid 및 로그 점수 계산.
+        - 두 값 간의 괴리율(Deviation) 계산.
+        - 유효하지 않은 값(NaN, None 등) 필터링.
+        - 당기순이익, 유동자산, 유동부채 계산 등.
+    """
     @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.
+        """"
+        주어진 괴리율(Deviation)에 대해 Sigmoid 함수를 적용하여 점수를 계산합니다.
 
-        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`.
+        이 함수는 Sigmoid 함수에 로그 변환된 괴리율을 입력으로 사용하며,
+        결과를 0에서 100 사이의 점수로 변환합니다. `a`와 `b` 매개변수를 사용하여
+        Sigmoid 곡선의 기울기와 x-축 오프셋을 조정할 수 있습니다.
 
-        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.
+        매개변수:
+            deviation (float): 계산할 괴리율 값 (0 이상의 값이어야 함).
+            a (float): Sigmoid 곡선의 기울기 조정값. 기본값은 1.0.
+            b (float): Sigmoid 곡선의 x-축 오프셋. 기본값은 2.0.
 
-        Returns:
-            float: A score between 0 and 100 derived from the provided deviation value.
+        반환값:
+            float: Sigmoid 함수로 변환된 0~100 사이의 점수.
         """
         # 예: x = log10(deviation + 1)
         x = math.log10(deviation + 1)
@@ -34,40 +46,33 @@ class Tools:
     @staticmethod
     def log_score(deviation):
         """
-            Compute and return the logarithmic score scaled by a constant factor.
+        주어진 괴리율(Deviation)에 대해 로그 점수를 계산합니다.
 
-            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.
+        괴리율 값에 1을 더한 뒤, 로그 변환(Base-10)을 수행하고
+        결과를 상수(33)로 곱하여 점수를 계산합니다.
 
-            Parameters:
-                deviation (float): The numerical deviation value to calculate the
-                logarithmic score for. Should be a non-negative number.
+        매개변수:
+            deviation (float): 계산할 괴리율 값.
 
-            Returns:
-                float: The scaled logarithmic score computed based on the input deviation.
+        반환값:
+            float: 계산된 로그 점수.
         """
         return math.log10(deviation + 1) * 33
 
     @staticmethod
     def cal_deviation(v1: float, v2: float) -> float:
         """
-            Calculates the percentage deviation between two values.
-
-            This method computes the percentage deviation of the second value
-            from the first value based on the formula:
-            deviation = abs((v1 - v2) / v1) * 100. In the event the first value is
-            zero (division by zero), the function will return NaN to signify
-            an invalid computation.
-
-            Parameters:
-            v1 (float): The reference value. It represents the base for the relative
-                        deviation calculation.
-            v2 (float): The value to compare against the reference.
-
-            Returns:
-            float: The computed percentage deviation. Returns NaN if the reference
-                   value (v1) is zero.
+        두 값 간의 퍼센트 괴리율(Deviation)을 계산합니다.
+
+        주어진 두 값 간의 상대적 차이를 백분율로 반환합니다.
+        기준값(v1)이 0인 경우, 계산은 NaN을 반환합니다.
+
+        매개변수:
+            v1 (float): 기준값.
+            v2 (float): 비교할 값.
+
+        반환값:
+            float: 두 값 간의 퍼센트 괴리율. 기준값이 0인 경우 NaN.
         """
         try:
             deviation = abs((v1 - v2) / v1) * 100
@@ -78,50 +83,33 @@ class Tools:
     @staticmethod
     def date_set(*args) -> list:
         """
-            인자로 받은 값의 비유효한 내용 제거(None,nan)하고 중복된 항목 제거하고 리스트로 반환한다.
+        주어진 값들에서 유효하지 않은 값을 제거하고 중복 없이 리스트로 반환합니다.
 
-            여기서 set의 의미는 집합을 뜻함
+        NaN, None, 빈 문자열 등 유효하지 않은 값을 필터링한 뒤,
+        고유한 값만 포함하는 리스트를 생성합니다.
 
-            Filters and returns a list of unique non-null, non-empty values from
-            the provided arguments.
+        매개변수:
+            *args: 필터링할 값들.
 
-            This static method processes the input arguments to retain only unique
-            values that are not empty strings, NaN values, or None. The result is
-            returned as a list.
-
-            Args:
-                *args: Arbitrary positional arguments to be filtered.
-
-            Returns:
-                list: A list of unique values after filtering out invalid entries.
+        반환값:
+            list: 유효한 값만 포함하는 고유 리스트.
         """
         return [i for i in {*args} if i != "" and i is not math.nan and i is not None]
 
     @staticmethod
     def calc당기순이익(c103: myredis.C103, refresh: bool) -> Tuple[str, float]:
         """
-            지배지분 당기순이익 계산
-
-            일반적인 경우로는 직전 지배주주지분 당기순이익을 찾아서 반환한다.
-
-            금융기관의 경우는 지배당기순이익이 없기 때문에 계산을 통해서 간접적으로 구한다.
+        지배주주지분 당기순이익을 계산하여 반환합니다.
 
-            Calculates "지배당기순이익" (Controlling Comprehensive Income) based on the given
-            financial data. The method retrieves or computes the value utilizing methods from
-            the `myredis.C103` class. It handles missing or 'Not-a-Number' conditions by
-            manually calculating from quarterly and annual financial figures. Logs the process
-            at various stages for debugging and auditing.
+        기본적으로 재무 데이터에서 지배주주지분 당기순이익을 검색하며,
+        데이터가 없거나 유효하지 않은 경우 간접적으로 계산합니다.
 
-            Args:
-                c103 (myredis.C103): An instance containing financial data and utilities to
-                    access specific data points for the targeted calculation.
-                refresh (bool): A flag to determine whether or not to refresh the data
-                    while accessing or computing financial values.
+        매개변수:
+            c103 (myredis.C103): 재무 데이터에 접근하기 위한 객체.
+            refresh (bool): 데이터를 새로고침할지 여부.
 
-            Returns:
-                Tuple[str, float]: A tuple where the first item is the most relevant date for
-                    the calculated or retrieved value, and the second item is the calculated
-                    or retrieved "지배당기순이익" (Controlling Comprehensive Income).
+        반환값:
+            Tuple[str, float]: 날짜와 계산된 지배주주지분 당기순이익.
         """
         name = myredis.Corps(c103.code, 'c101').get_name(refresh=refresh)
 
@@ -156,35 +144,17 @@ class Tools:
     @staticmethod
     def calc유동자산(c103: myredis.C103, refresh: bool) -> Tuple[str, float]:
         """
-            유효한 유동자산 계산
+        기업의 유동자산을 계산하여 반환합니다.
 
-            일반적인 경우로 유동자산을 찾아서 반환한다.
+        최근 4분기의 데이터를 기반으로 유동자산을 계산하며,
+        데이터가 없거나 유효하지 않을 경우 간접적으로 계산합니다.
 
-            금융기관의 경우는 간접적으로 계산한다.
+        매개변수:
+            c103 (myredis.C103): 재무 데이터에 접근하기 위한 객체.
+            refresh (bool): 데이터를 새로고침할지 여부.
 
-            Calculates the current assets for a given company code.
-
-            For a specified company, the function calculates the recent 4-quarter
-            sum of current assets if available. If the data is not available or
-            contains invalid values, it attempts to calculate the current assets
-            manually using financial asset data such as cash equivalents, trading
-            securities, available-for-sale securities, and held-to-maturity securities.
-
-            Logs relevant information and warnings during the calculation process,
-            including any cases where data is unavailable or a manual calculation
-            is required.
-
-            Parameters:
-                c103 (myredis.C103): The instance representing financial data of a
-                    specific company. This includes methods to extract and calculate
-                    various data points.
-                refresh (bool): Indicator flag to determine whether to refresh the
-                    underlying data before performing calculations.
-
-            Returns:
-                Tuple[str, float]: A tuple containing the date associated with the
-                    financial data and the calculated or retrieved value of current
-                    assets. If dates are not available, the date field may be empty.
+        반환값:
+            Tuple[str, float]: 날짜와 계산된 유동자산.
         """
 
         name = myredis.Corps(c103.code, 'c101').get_name(refresh=refresh)
@@ -220,25 +190,17 @@ class Tools:
     @staticmethod
     def calc유동부채(c103: myredis.C103, refresh: bool) -> Tuple[str, float]:
         """
-            유효한 유동부채 계산
-
-            일반적인 경우로 유동부채를 찾아서 반환한다.
-
-            금융기관의 경우는 간접적으로 계산한다.
-
-            Calculate '유동부채' (Current Liabilities) based on financial data of a specific entity.
+        기업의 유동부채를 계산하여 반환합니다.
 
-            This static method computes the recent '유동부채' value either from the sum of recent four
-            quarters using predefined keys or calculates manually if no valid data is available.
-            It includes logging for intermediate steps and supports handling missing values by logging
-            warnings and attempting a composed manual computation using alternative financial terms.
+        최근 4분기의 데이터를 기반으로 유동부채를 계산하며,
+        데이터가 없거나 유효하지 않을 경우 간접적으로 계산합니다.
 
-            Args:
-                c103 (myredis.C103): The object containing financial data and operations for obtaining the required data.
-                refresh (bool): A flag to indicate whether to fetch the latest data forcibly.
+        매개변수:
+            c103 (myredis.C103): 재무 데이터에 접근하기 위한 객체.
+            refresh (bool): 데이터를 새로고침할지 여부.
 
-            Returns:
-                Tuple[str, float]: A tuple containing the `date` of financial data and the computed '유동부채' value.
+        반환값:
+            Tuple[str, float]: 날짜와 계산된 유동부채.
         """
 
         name = myredis.Corps(c103.code, 'c101').get_name(refresh=refresh)