analyser_hj3415 2.8.3__tar.gz → 2.9.0__tar.gz

{analyser_hj3415-2.8.3 → analyser_hj3415-2.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: analyser_hj3415
-Version: 2.8.3
+Version: 2.9.0
 Summary: Stock analyser and database processing programs
 Author-email: Hyungjin Kim <hj3415@gmail.com>
 Description-Content-Type: text/markdown

{analyser_hj3415-2.8.3 → analyser_hj3415-2.9.0}/analyser_hj3415/cli.py

@@ -41,14 +41,22 @@ def analyser_manager():
     parser = argparse.ArgumentParser(description="Analyser Commands")
     type_subparsers = parser.add_subparsers(dest='type', help='분석 타입')
 
-    # tsa 명령어 서브파서
-    tsa_parser = type_subparsers.add_parser('tsa', help='Time serial analysis 타입')
-    tsa_subparser = tsa_parser.add_subparsers(dest='command', help='tsa 관련된 명령')
+    # prophet 명령어 서브파서
+    prophet_parser = type_subparsers.add_parser('prophet', help='MyProphet 타입')
+    prophet_subparser = prophet_parser.add_subparsers(dest='command', help='prophet 관련된 명령')
     # ranking 파서
-    ranking_parser = tsa_subparser.add_parser('ranking', help='tsa 랭킹 책정 및 레디스 저장')
+    ranking_parser = prophet_subparser.add_parser('ranking', help='prophet 랭킹 책정 및 레디스 저장')
     ranking_parser.add_argument('-r', '--refresh', action='store_true', help='래디스 캐시를 사용하지 않고 강제로 재계산 할지')
     ranking_parser.add_argument('-n', '--noti', action='store_true', help='작업 완료 후 메시지 전송 여부')
 
+    # lstm 명령어 서브파서
+    lstm_parser = type_subparsers.add_parser('lstm', help='MyLSTM 타입')
+    lstm_subparser = lstm_parser.add_subparsers(dest='command', help='lstm 관련된 명령')
+    # caching 파서
+    caching_parser = lstm_subparser.add_parser('caching', help='lstm 랭킹 책정 및 레디스 저장')
+    caching_parser.add_argument('-r', '--refresh', action='store_true', help='래디스 캐시를 사용하지 않고 강제로 재계산 할지')
+    caching_parser.add_argument('-n', '--noti', action='store_true', help='작업 완료 후 메시지 전송 여부')
+
     # red 명령어 서브파서
     red_parser = type_subparsers.add_parser('red', help='red 타입')
     red_subparser = red_parser.add_subparsers(dest='command', help='red 관련된 명령')
@@ -203,12 +211,17 @@ def analyser_manager():
                 pprint.pprint(growth.get(args.refresh))
             if args.noti:
                 noti.telegram_to('manager', f"오늘의 Growth({args.code})를 레디스 캐시에 저장했습니다.(유효 12시간)")
-    elif args.type == 'tsa':
+    elif args.type == 'prophet':
         if args.command == 'ranking':
             result = tsa.MyProphet.ranking(refresh=args.refresh)
             print(result)
             if args.noti:
-                noti.telegram_to('manager', "오늘의 tsa ranking을 레디스캐시에 저장했습니다.(유효 12시간)")
+                noti.telegram_to('manager', "오늘의 prophet ranking을 레디스캐시에 저장했습니다.(유효 24시간)")
+    elif args.type == 'lstm':
+        if args.command == 'caching':
+            result = tsa.MyLSTM('005930').caching_based_on_prophet_ranking(refresh=args.refresh)
+            if args.noti:
+                noti.telegram_to('manager', "오늘의 lstm caching을 레디스캐시에 저장했습니다.(유효 24시간)")
     elif args.type == 'setting':
         if args.command == 'set':
             settings_manager.set_value(args.title, args.value)

{analyser_hj3415-2.8.3 → analyser_hj3415-2.9.0}/analyser_hj3415/eval.py

@@ -8,7 +8,7 @@ from analyser_hj3415.cli import AnalyserSettingsManager
 from collections import OrderedDict
 import logging
 
-analyser_logger = helpers.setup_logger('analyser_logger', logging.WARNING)
+eval_logger = helpers.setup_logger('eval_logger', logging.WARNING)
 
 expire_time = 3600 * 12
 
@@ -48,30 +48,30 @@ class Tools:
         """
         name = myredis.Corps(c103.code, 'c101').get_name(refresh=refresh)
 
-        analyser_logger.info(f'{c103.code} / {name} Tools : 당기순이익 계산.. refresh : {refresh}')
+        eval_logger.info(f'{c103.code} / {name} Tools : 당기순이익 계산.. refresh : {refresh}')
         c103.page = 'c103재무상태표q'
 
         d1, 지배당기순이익 = c103.latest_value_pop2('*(지배)당기순이익', refresh)
-        analyser_logger.debug(f"*(지배)당기순이익: {지배당기순이익}")
+        eval_logger.debug(f"*(지배)당기순이익: {지배당기순이익}")
 
         if math.isnan(지배당기순이익):
-            analyser_logger.warning(f"{c103.code} / {name} - (지배)당기순이익이 없는 종목. 수동으로 계산합니다.")
+            eval_logger.warning(f"{c103.code} / {name} - (지배)당기순이익이 없는 종목. 수동으로 계산합니다.")
             c103.page = 'c103손익계산서q'
             d2, 최근4분기당기순이익 = c103.sum_recent_4q('당기순이익', refresh)
-            analyser_logger.debug(f"{c103.code} / {name} - 최근4분기당기순이익 : {최근4분기당기순이익}")
+            eval_logger.debug(f"{c103.code} / {name} - 최근4분기당기순이익 : {최근4분기당기순이익}")
             c103.page = 'c103재무상태표y'
             d3, 비지배당기순이익 = c103.latest_value_pop2('*(비지배)당기순이익', refresh)
-            analyser_logger.debug(f"{c103.code} / {name} - 비지배당기순이익y : {비지배당기순이익}")
+            eval_logger.debug(f"{c103.code} / {name} - 비지배당기순이익y : {비지배당기순이익}")
             # 가변리스트 언패킹으로 하나의 날짜만 사용하고 나머지는 버린다.
             # 여기서 *_는 “나머지 값을 다 무시하겠다”는 의미
-            analyser_logger.debug(f"d2:{d2}, d3: {d3}")
+            eval_logger.debug(f"d2:{d2}, d3: {d3}")
             try:
                 date, *_ = Tools.date_set(d2, d3)
             except ValueError:
                 # 날짜 데이터가 없는경우
                 date = ''
             계산된지배당기순이익= round(최근4분기당기순이익 - utils.nan_to_zero(비지배당기순이익), 1)
-            analyser_logger.debug(f"{c103.code} / {name} - 계산된 지배당기순이익 : {계산된지배당기순이익}")
+            eval_logger.debug(f"{c103.code} / {name} - 계산된 지배당기순이익 : {계산된지배당기순이익}")
             return date, 계산된지배당기순이익
         else:
             return d1, 지배당기순이익
@@ -85,20 +85,20 @@ class Tools:
         """
         name = myredis.Corps(c103.code, 'c101').get_name(refresh=refresh)
 
-        analyser_logger.info(f'{c103.code} / {name} Tools : 유동자산계산... refresh : {refresh}')
+        eval_logger.info(f'{c103.code} / {name} Tools : 유동자산계산... refresh : {refresh}')
         c103.page = 'c103재무상태표q'
 
         d, 유동자산 = c103.sum_recent_4q('유동자산', refresh)
         if math.isnan(유동자산):
-            analyser_logger.warning(f"{c103.code} / {name} - 유동자산이 없는 종목. 수동으로 계산합니다(금융관련업종일 가능성있음).")
+            eval_logger.warning(f"{c103.code} / {name} - 유동자산이 없는 종목. 수동으로 계산합니다(금융관련업종일 가능성있음).")
             d1, v1 = c103.latest_value_pop2('현금및예치금', refresh)
             d2, v2 = c103.latest_value_pop2('단기매매금융자산', refresh)
             d3, v3 = c103.latest_value_pop2('매도가능금융자산', refresh)
             d4, v4 = c103.latest_value_pop2('만기보유금융자산', refresh)
-            analyser_logger.debug(f'{c103.code} / {name} 현금및예치금 : {d1}, {v1}')
-            analyser_logger.debug(f'{c103.code} / {name} 단기매매금융자산 : {d2}, {v2}')
-            analyser_logger.debug(f'{c103.code} / {name} 매도가능금융자산 : {d3}, {v3}')
-            analyser_logger.debug(f'{c103.code} / {name} 만기보유금융자산 : {d4}, {v4}')
+            eval_logger.debug(f'{c103.code} / {name} 현금및예치금 : {d1}, {v1}')
+            eval_logger.debug(f'{c103.code} / {name} 단기매매금융자산 : {d2}, {v2}')
+            eval_logger.debug(f'{c103.code} / {name} 매도가능금융자산 : {d3}, {v3}')
+            eval_logger.debug(f'{c103.code} / {name} 만기보유금융자산 : {d4}, {v4}')
 
             try:
                 date, *_ = Tools.date_set(d1, d2, d3, d4)
@@ -107,7 +107,7 @@ class Tools:
                 date = ''
             계산된유동자산value = round(utils.nan_to_zero(v1) + utils.nan_to_zero(v2) + utils.nan_to_zero(v3) + utils.nan_to_zero(v4),1)
 
-            analyser_logger.info(f"{c103.code} / {name} - 계산된 유동자산 : {계산된유동자산value}")
+            eval_logger.info(f"{c103.code} / {name} - 계산된 유동자산 : {계산된유동자산value}")
             return date, 계산된유동자산value
         else:
             return d, 유동자산
@@ -121,20 +121,20 @@ class Tools:
         """
         name = myredis.Corps(c103.code, 'c101').get_name(refresh=refresh)
 
-        analyser_logger.info(f'{c103.code} / {name} Tools : 유동부채계산... refresh : {refresh}')
+        eval_logger.info(f'{c103.code} / {name} Tools : 유동부채계산... refresh : {refresh}')
         c103.page = 'c103재무상태표q'
 
         d, 유동부채 = c103.sum_recent_4q('유동부채', refresh)
         if math.isnan(유동부채):
-            analyser_logger.warning(f"{c103.code} / {name} - 유동부채가 없는 종목. 수동으로 계산합니다.")
+            eval_logger.warning(f"{c103.code} / {name} - 유동부채가 없는 종목. 수동으로 계산합니다.")
             d1, v1 = c103.latest_value_pop2('당기손익인식(지정)금융부채', refresh)
             d2, v2 = c103.latest_value_pop2('당기손익-공정가치측정금융부채', refresh)
             d3, v3 = c103.latest_value_pop2('매도파생결합증권', refresh)
             d4, v4 = c103.latest_value_pop2('단기매매금융부채', refresh)
-            analyser_logger.debug(f'{c103.code} / {name} 당기손익인식(지정)금융부채 : {d1}, {v1}')
-            analyser_logger.debug(f'{c103.code} / {name} 당기손익-공정가치측정금융부채 : {d2}, {v2}')
-            analyser_logger.debug(f'{c103.code} / {name} 매도파생결합증권 : {d3}, {v3}')
-            analyser_logger.debug(f'{c103.code} / {name} 단기매매금융부채 : {d4}, {v4}')
+            eval_logger.debug(f'{c103.code} / {name} 당기손익인식(지정)금융부채 : {d1}, {v1}')
+            eval_logger.debug(f'{c103.code} / {name} 당기손익-공정가치측정금융부채 : {d2}, {v2}')
+            eval_logger.debug(f'{c103.code} / {name} 매도파생결합증권 : {d3}, {v3}')
+            eval_logger.debug(f'{c103.code} / {name} 단기매매금융부채 : {d4}, {v4}')
 
             try:
                 date, *_ = Tools.date_set(d1, d2, d3, d4)
@@ -143,7 +143,7 @@ class Tools:
                 date = ''
             계산된유동부채value = round(utils.nan_to_zero(v1) + utils.nan_to_zero(v2) + utils.nan_to_zero(v3) + utils.nan_to_zero(v4), 1)
 
-            analyser_logger.info(f"{c103.code} / {name} - 계산된 유동부채 : {계산된유동부채value}")
+            eval_logger.info(f"{c103.code} / {name} - 계산된 유동부채 : {계산된유동부채value}")
             return date, 계산된유동부채value
         else:
             return d, 유동부채
@@ -192,7 +192,7 @@ class Red:
 
     def __init__(self, code: str):
         assert utils.is_6digit(code), f'Invalid value : {code}'
-        analyser_logger.debug(f"Red : 초기화 ({code})")
+        eval_logger.debug(f"Red : 초기화 ({code})")
         self.c101 = myredis.C101(code)
         self.c103 = myredis.C103(code, 'c103재무상태표q')
 
@@ -209,7 +209,7 @@ class Red:
     @code.setter
     def code(self, code: str):
         assert utils.is_6digit(code), f'Invalid value : {code}'
-        analyser_logger.debug(f"Red : 종목코드 변경({self.code} -> {code})")
+        eval_logger.debug(f"Red : 종목코드 변경({self.code} -> {code})")
         self.c101.code = code
         self.c103.code = code
 
@@ -222,21 +222,21 @@ class Red:
         일반적인 경우로 비유동부채를 찾아서 반환한다.\n
         금융기관의 경우는 간접적으로 계산한다.\n
         """
-        analyser_logger.info(f'In the calc비유동부채... refresh : {refresh}')
+        eval_logger.info(f'In the calc비유동부채... refresh : {refresh}')
         self.c103.page = 'c103재무상태표q'
 
         d, 비유동부채 = self.c103.sum_recent_4q('비유동부채', refresh)
         if math.isnan(비유동부채):
-            analyser_logger.warning(f"{self} - 비유동부채가 없는 종목. 수동으로 계산합니다.")
+            eval_logger.warning(f"{self} - 비유동부채가 없는 종목. 수동으로 계산합니다.")
             # 보험관련업종은 예수부채가 없는대신 보험계약부채가 있다...
             d1, v1 = self.c103.latest_value_pop2('예수부채', refresh)
             d2, v2 = self.c103.latest_value_pop2('보험계약부채(책임준비금)', refresh)
             d3, v3 = self.c103.latest_value_pop2('차입부채', refresh)
             d4, v4 = self.c103.latest_value_pop2('기타부채', refresh)
-            analyser_logger.debug(f'예수부채 : {d1}, {v1}')
-            analyser_logger.debug(f'보험계약부채(책임준비금) : {d2}, {v2}')
-            analyser_logger.debug(f'차입부채 : {d3}, {v3}')
-            analyser_logger.debug(f'기타부채 : {d4}, {v4}')
+            eval_logger.debug(f'예수부채 : {d1}, {v1}')
+            eval_logger.debug(f'보험계약부채(책임준비금) : {d2}, {v2}')
+            eval_logger.debug(f'차입부채 : {d3}, {v3}')
+            eval_logger.debug(f'기타부채 : {d4}, {v4}')
 
             try:
                 date, *_ = Tools.date_set(d1, d2, d3, d4)
@@ -244,7 +244,7 @@ class Red:
                 # 날짜 데이터가 없는경우
                 date = ''
             계산된비유동부채value = round(utils.nan_to_zero(v1) + utils.nan_to_zero(v2) + utils.nan_to_zero(v3) + utils.nan_to_zero(v4),1)
-            analyser_logger.info(f"{self} - 계산된 비유동부채 : {계산된비유동부채value}")
+            eval_logger.info(f"{self} - 계산된 비유동부채 : {계산된비유동부채value}")
             return date, 계산된비유동부채value
         else:
             return d, 비유동부채
@@ -266,13 +266,13 @@ class Red:
         else:
             score = utils.to_int(math.log10(deviation + 1) * 33)  # desmos그래프상 33이 제일 적당한듯(최대100점에 가깝게)
 
-        analyser_logger.debug(f"최근주가 : {recent_price} red가격 : {red_price} 괴리율 : {utils.to_int(deviation)} score : {score}")
+        eval_logger.debug(f"최근주가 : {recent_price} red가격 : {red_price} 괴리율 : {utils.to_int(deviation)} score : {score}")
 
         return score
 
     def _generate_data(self, refresh: bool) -> RedData:
         d1, 지배주주당기순이익 = Tools.calc당기순이익(self.c103, refresh)
-        analyser_logger.debug(f"{self} 지배주주당기순이익: {지배주주당기순이익}")
+        eval_logger.debug(f"{self} 지배주주당기순이익: {지배주주당기순이익}")
         d2, 유동자산 = Tools.calc유동자산(self.c103, refresh)
         d3, 유동부채 = Tools.calc유동부채(self.c103, refresh)
         d4, 부채평가 = self._calc비유동부채(refresh)
@@ -331,7 +331,7 @@ class Red:
         :return:
         """
         redis_name = f"{self.code}_red"
-        analyser_logger.info(f"{self} RedData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
+        eval_logger.info(f"{self} RedData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
         expire_time = 3600 * 12
         if verbose:
             print(f"{self} redisname: '{redis_name}' / expect_earn: {Red.expect_earn} / refresh : {refresh} / expire_time : {expire_time/3600}h")
@@ -355,11 +355,11 @@ class Red:
         # expect_earn 및 refresh 설정
         if expect_earn is None:
             expect_earn = cls.expect_earn
-        analyser_logger.info(f"기대수익률을 {expect_earn}으로 설정합니다.")
+        eval_logger.info(f"기대수익률을 {expect_earn}으로 설정합니다.")
         previous_expect_earn = float(AnalyserSettingsManager().get_value('RED_RANKING_EXPECT_EARN'))
-        analyser_logger.debug(f"previous red ranking expect earn : {previous_expect_earn}")
+        eval_logger.debug(f"previous red ranking expect earn : {previous_expect_earn}")
         if previous_expect_earn != expect_earn:
-            analyser_logger.warning(f"expect earn : {expect_earn} / RED_RANKING_EXPECT_EARN : {previous_expect_earn} 두 값이 달라 refresh = True")
+            eval_logger.warning(f"expect earn : {expect_earn} / RED_RANKING_EXPECT_EARN : {previous_expect_earn} 두 값이 달라 refresh = True")
             refresh = True
 
         redis_name = 'red_ranking'
@@ -422,7 +422,7 @@ class MilData:
 class Mil:
     def __init__(self, code: str):
         assert utils.is_6digit(code), f'Invalid value : {code}'
-        analyser_logger.debug(f"Mil : 종목코드 ({code})")
+        eval_logger.debug(f"Mil : 종목코드 ({code})")
 
         self.c101 = myredis.C101(code)
         self.c103 = myredis.C103(code, 'c103현금흐름표q')
@@ -442,7 +442,7 @@ class Mil:
     @code.setter
     def code(self, code: str):
         assert utils.is_6digit(code), f'Invalid value : {code}'
-        analyser_logger.debug(f"Mil : 종목코드 변경({self.code} -> {code})")
+        eval_logger.debug(f"Mil : 종목코드 변경({self.code} -> {code})")
 
         self.c101.code = code
         self.c103.code = code
@@ -459,7 +459,7 @@ class Mil:
         """
         c101r = self.c101.get_recent(refresh)
         시가총액 = int(utils.to_int(c101r.get('시가총액', math.nan)) / 100000000)
-        analyser_logger.debug(f"시가총액: {시가총액}억원")
+        eval_logger.debug(f"시가총액: {시가총액}억원")
         return 시가총액
 
     def _calc주주수익률(self, 시가총액_억: float, refresh: bool) -> Tuple[str, float, float]:
@@ -469,7 +469,7 @@ class Mil:
             주주수익률 = round((재무활동현금흐름 / 시가총액_억 * -100), 2)
         except ZeroDivisionError:
             주주수익률 = math.nan
-            analyser_logger.warning(f'{self} 주주수익률: {주주수익률} 재무활동현금흐름: {재무활동현금흐름}')
+            eval_logger.warning(f'{self} 주주수익률: {주주수익률} 재무활동현금흐름: {재무활동현금흐름}')
         return d, 주주수익률, 재무활동현금흐름
 
     def _calc이익지표(self, 시가총액_억: float, refresh: bool) -> Tuple[str, float, float, float]:
@@ -480,7 +480,7 @@ class Mil:
             이익지표 = round(((지배주주당기순이익 - 영업활동현금흐름) / 시가총액_억) * 100, 2)
         except ZeroDivisionError:
             이익지표 = math.nan
-            analyser_logger.warning(f'{self} 이익지표: {이익지표} 영업활동현금흐름: {영업활동현금흐름} 지배주주당기순이익: {지배주주당기순이익}')
+            eval_logger.warning(f'{self} 이익지표: {이익지표} 영업활동현금흐름: {영업활동현금흐름} 지배주주당기순이익: {지배주주당기순이익}')
         try:
             date, *_ = Tools.date_set(d1, d2)
         except ValueError:
@@ -521,15 +521,15 @@ class Mil:
         self.c103.page = 'c103재무상태표y'
         _, capex = self.c103.find('*CAPEX', remove_yoy=True, del_unnamed_key=True, refresh=refresh)
 
-        analyser_logger.debug(f'영업활동현금흐름 {영업활동현금흐름_dict}')
-        analyser_logger.debug(f'CAPEX {capex}')
+        eval_logger.debug(f'영업활동현금흐름 {영업활동현금흐름_dict}')
+        eval_logger.debug(f'CAPEX {capex}')
 
         if len(영업활동현금흐름_dict) == 0:
             return {}
 
         if len(capex) == 0:
             # CAPEX 가 없는 업종은 영업활동현금흐름을 그대로 사용한다.
-            analyser_logger.warning(f"{self} - CAPEX가 없는 업종으로 영업현금흐름을 그대로 사용합니다..")
+            eval_logger.warning(f"{self} - CAPEX가 없는 업종으로 영업현금흐름을 그대로 사용합니다..")
             return 영업활동현금흐름_dict
 
         # 영업 활동으로 인한 현금 흐름에서 CAPEX 를 각 연도별로 빼주어 fcf 를 구하고 리턴값으로 fcf 딕셔너리를 반환한다.
@@ -543,7 +543,7 @@ class Mil:
                 if 영업활동현금흐름date == CAPEXdate:
                     fcf_dict[영업활동현금흐름date] = round(영업활동현금흐름value - CAPEXvalue, 2)
 
-        analyser_logger.debug(f'fcf_dict {fcf_dict}')
+        eval_logger.debug(f'fcf_dict {fcf_dict}')
         # 연도순으로 정렬해서 딕셔너리로 반환한다.
         return dict(sorted(fcf_dict.items(), reverse=False))
 
@@ -556,7 +556,7 @@ class Mil:
                 https://www.investopedia.com/terms/p/pricetofreecashflow.asp
             """
         if math.isnan(시가총액_억):
-            analyser_logger.warning(f"{self} - 시가총액이 nan으로 pFCF를 계산할수 없습니다.")
+            eval_logger.warning(f"{self} - 시가총액이 nan으로 pFCF를 계산할수 없습니다.")
             return {}
 
         # pfcf 계산
@@ -569,7 +569,7 @@ class Mil:
 
         pfcf_dict = mymongo.C1034.del_unnamed_key(pfcf_dict)
 
-        analyser_logger.debug(f'pfcf_dict : {pfcf_dict}')
+        eval_logger.debug(f'pfcf_dict : {pfcf_dict}')
         return pfcf_dict
 
     def _calc가치지표(self, 시가총액_억: float, refresh: bool) -> tuple:
@@ -585,15 +585,15 @@ class Mil:
         return [0,]
 
     def _generate_data(self, refresh: bool) -> MilData:
-        analyser_logger.info(f"In generate_data..refresh : {refresh}")
+        eval_logger.info(f"In generate_data..refresh : {refresh}")
         시가총액_억 = self.get_marketcap억(refresh)
-        analyser_logger.info(f"{self} 시가총액(억) : {시가총액_억}")
+        eval_logger.info(f"{self} 시가총액(억) : {시가총액_억}")
 
         d1, 주주수익률, 재무활동현금흐름 = self._calc주주수익률(시가총액_억, refresh)
-        analyser_logger.info(f"{self} 주주수익률 : {주주수익률}, {d1}")
+        eval_logger.info(f"{self} 주주수익률 : {주주수익률}, {d1}")
 
         d2, 이익지표, 영업활동현금흐름, 지배주주당기순이익 = self._calc이익지표(시가총액_억, refresh)
-        analyser_logger.info(f"{self} 이익지표 : {이익지표}, {d2}")
+        eval_logger.info(f"{self} 이익지표 : {이익지표}, {d2}")
 
         d3, roic_r, roic_dict, roe_r, roe106, roa_r = self._calc투자수익률(refresh)
         d4, fcf_dict, pfcf_dict, pcr_dict = self._calc가치지표(시가총액_억, refresh)
@@ -640,7 +640,7 @@ class Mil:
         :return:
         """
         redis_name = f"{self.code}_mil"
-        analyser_logger.info(f"{self} MilData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
+        eval_logger.info(f"{self} MilData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
         if verbose:
             print(f"{self} redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time/3600}h")
 
@@ -677,7 +677,7 @@ class BlueData:
 class Blue:
     def __init__(self, code: str):
         assert utils.is_6digit(code), f'Invalid value : {code}'
-        analyser_logger.debug(f"Blue : 종목코드 ({code})")
+        eval_logger.debug(f"Blue : 종목코드 ({code})")
 
         self.c101 = myredis.C101(code)
         self.c103 = myredis.C103(code, 'c103재무상태표q')
@@ -696,7 +696,7 @@ class Blue:
     @code.setter
     def code(self, code: str):
         assert utils.is_6digit(code), f'Invalid value : {code}'
-        analyser_logger.debug(f"Blue : 종목코드 변경({self.code} -> {code})")
+        eval_logger.debug(f"Blue : 종목코드 변경({self.code} -> {code})")
 
         self.c101.code = code
         self.c103.code = code
@@ -711,11 +711,11 @@ class Blue:
         c104q에서 최근유동비율 찾아보고 유효하지 않거나 \n
         100이하인 경우에는수동으로 계산해서 다시 한번 평가해 본다.\n
         """
-        analyser_logger.info(f'In the calc유동비율... refresh : {refresh}')
+        eval_logger.info(f'In the calc유동비율... refresh : {refresh}')
         self.c104.page = 'c104q'
 
         유동비율date, 유동비율value = self.c104.latest_value('유동비율', pop_count=pop_count)
-        analyser_logger.info(f'{self} 유동비율 : {유동비율value}/({유동비율date})')
+        eval_logger.info(f'{self} 유동비율 : {유동비율value}/({유동비율date})')
 
         if math.isnan(유동비율value) or 유동비율value < 100:
             유동자산date, 유동자산value = Tools.calc유동자산(self.c103, refresh)
@@ -723,23 +723,23 @@ class Blue:
 
             self.c103.page = 'c103현금흐름표q'
             추정영업현금흐름date, 추정영업현금흐름value = self.c103.sum_recent_4q('영업활동으로인한현금흐름', refresh)
-            analyser_logger.debug(f'{self} 계산전 유동비율 : {유동비율value} / ({유동비율date})')
+            eval_logger.debug(f'{self} 계산전 유동비율 : {유동비율value} / ({유동비율date})')
 
             계산된유동비율 = 0
             try:
                 계산된유동비율 = round(((유동자산value + 추정영업현금흐름value) / 유동부채value) * 100, 2)
             except ZeroDivisionError:
-                analyser_logger.info(f'유동자산: {유동자산value} + 추정영업현금흐름: {추정영업현금흐름value} / 유동부채: {유동부채value}')
+                eval_logger.info(f'유동자산: {유동자산value} + 추정영업현금흐름: {추정영업현금흐름value} / 유동부채: {유동부채value}')
                 계산된유동비율 = float('inf')
             finally:
-                analyser_logger.debug(f'{self} 계산된 유동비율 : {계산된유동비율}')
+                eval_logger.debug(f'{self} 계산된 유동비율 : {계산된유동비율}')
 
                 try:
                     date, *_ = Tools.date_set(유동자산date, 유동부채date, 추정영업현금흐름date)
                 except ValueError:
                     # 날짜 데이터가 없는경우
                     date = ''
-                analyser_logger.warning(f'{self} 유동비율 이상(100 이하 또는 nan) : {유동비율value} -> 재계산 : {계산된유동비율}')
+                eval_logger.warning(f'{self} 유동비율 이상(100 이하 또는 nan) : {유동비율value} -> 재계산 : {계산된유동비율}')
                 return date, 계산된유동비율
         else:
             return 유동비율date, 유동비율value
@@ -749,7 +749,7 @@ class Blue:
 
     def _generate_data(self, refresh: bool) -> BlueData:
         d1, 유동비율 = self._calc유동비율(pop_count=3, refresh=refresh)
-        analyser_logger.info(f'유동비율 {유동비율} / [{d1}]')
+        eval_logger.info(f'유동비율 {유동비율} / [{d1}]')
 
         재고자산회전율_c106 = myredis.C106.make_like_c106(self.code, 'c104q', '재고자산회전율', refresh)
 
@@ -766,16 +766,16 @@ class Blue:
         d9, 순부채비율_r = self.c104.latest_value_pop2('순부채비율', refresh)
 
         if len(이자보상배율_dict) == 0:
-            analyser_logger.warning(f'empty dict - 이자보상배율 : {이자보상배율_r} / {이자보상배율_dict}')
+            eval_logger.warning(f'empty dict - 이자보상배율 : {이자보상배율_r} / {이자보상배율_dict}')
 
         if len(순운전자본회전율_dict) == 0:
-            analyser_logger.warning(f'empty dict - 순운전자본회전율 : {순운전자본회전율_r} / {순운전자본회전율_dict}')
+            eval_logger.warning(f'empty dict - 순운전자본회전율 : {순운전자본회전율_r} / {순운전자본회전율_dict}')
 
         if len(재고자산회전율_dict) == 0:
-            analyser_logger.warning(f'empty dict - 재고자산회전율 : {재고자산회전율_r} / {재고자산회전율_dict}')
+            eval_logger.warning(f'empty dict - 재고자산회전율 : {재고자산회전율_r} / {재고자산회전율_dict}')
 
         if len(순부채비율_dict) == 0:
-            analyser_logger.warning(f'empty dict - 순부채비율 : {순부채비율_r} / {순부채비율_dict}')
+            eval_logger.warning(f'empty dict - 순부채비율 : {순부채비율_r} / {순부채비율_dict}')
 
         score = self._score()
 
@@ -813,7 +813,7 @@ class Blue:
         :return:
         """
         redis_name = f"{self.code}_blue"
-        analyser_logger.info(f"{self} BlueData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
+        eval_logger.info(f"{self} BlueData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
         if verbose:
             print(f"{self} redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time/3600}h")
 
@@ -841,7 +841,7 @@ class GrowthData:
 class Growth:
     def __init__(self, code: str):
         assert utils.is_6digit(code), f'Invalid value : {code}'
-        analyser_logger.debug(f"Growth : 종목코드 ({code})")
+        eval_logger.debug(f"Growth : 종목코드 ({code})")
 
         self.c101 = myredis.C101(code)
         self.c104 = myredis.C104(code, 'c104q')
@@ -860,7 +860,7 @@ class Growth:
     @code.setter
     def code(self, code: str):
         assert utils.is_6digit(code), f'Invalid value : {code}'
-        analyser_logger.debug(f"Growth : 종목코드 변경({self.code} -> {code})")
+        eval_logger.debug(f"Growth : 종목코드 변경({self.code} -> {code})")
 
         self.c101.code = code
         self.c104.code = code
@@ -879,7 +879,7 @@ class Growth:
         self.c104.page = 'c104q'
         d2, 매출액증가율_r = self.c104.latest_value_pop2('매출액증가율')
 
-        analyser_logger.info(f'매출액증가율 : {매출액증가율_r} {매출액증가율_dict}')
+        eval_logger.info(f'매출액증가율 : {매출액증가율_r} {매출액증가율_dict}')
 
         # c106 에서 타 기업과 영업이익률 비교
         self.c106.page = 'c106y'
@@ -913,7 +913,7 @@ class Growth:
         :return:
         """
         redis_name = f"{self.code}_growth"
-        analyser_logger.info(f"{self} GrowthData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
+        eval_logger.info(f"{self} GrowthData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
         if verbose:
             print(f"{self} redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time/3600}h")