analyser_hj3415 2.0.1__py2.py3-none-any.whl → 2.1.0__py2.py3-none-any.whl

analyser_hj3415/analysers/eval.py

@@ -0,0 +1,289 @@
+"""red, mil, blue 3가지 분야에서 자료를 계산하여 리턴하는 함수 모음
+"""
+import math
+
+from analyser_hj3415 import tools
+from utils_hj3415 import utils
+from db_hj3415 import myredis
+
+import logging
+
+logger = logging.getLogger(__name__)
+formatter = logging.Formatter('%(levelname)s: [%(name)s] %(message)s')
+ch = logging.StreamHandler()
+ch.setFormatter(formatter)
+logger.addHandler(ch)
+logger.setLevel(logging.WARNING)
+
+
+# 주식을 통한 기대수익률 - 금리가 3%일 경우 두배인 6% 정도로 잡는다.
+EXPECT_EARN = 0.06
+
+
+def red(code: str) -> dict:
+    """
+    리턴값
+    {
+        'red_price': red_price,
+        '사업가치': 사업가치,
+        '재산가치': 재산가치,
+        '부채평가': 부채평가,
+        '발행주식수': 발행주식수,
+        'date': [각 유효한 값의 년월값 리스트(ex- 2020/09)],
+    }
+    """
+    c103q = myredis.C103(code, 'c103재무상태표q')
+
+    d1, 지배주주당기순이익 = tools.calc당기순이익(code)
+    d2, 유동자산 = tools.calc유동자산(code)
+    d3, 유동부채 = tools.calc유동부채(code)
+    d4, 부채평가 = tools.calc비유동부채(code)
+
+    c103q.page = 'c103재무상태표q'
+    d5, 투자자산 = c103q.latest_value_pop2('투자자산')
+    d6, 투자부동산 = c103q.latest_value_pop2('투자부동산')
+
+    # 사업가치 계산 - 지배주주지분 당기순이익 / 기대수익률
+    사업가치 = round(utils.nan_to_zero(지배주주당기순이익) / EXPECT_EARN, 2)
+
+    # 재산가치 계산 - 유동자산 - (유동부채*1.2) + 고정자산중 투자자산
+    재산가치 = round(유동자산 - (유동부채 * 1.2) + utils.nan_to_zero(투자자산) + utils.nan_to_zero(투자부동산), 2)
+
+    _, 발행주식수 = c103q.latest_value_pop2('발행주식수')
+    if math.isnan(발행주식수):
+        발행주식수 = utils.to_int(myredis.C101(code).get_recent().get('발행주식'))
+    else:
+        발행주식수 = 발행주식수 * 1000
+
+    try:
+        red_price = round(((사업가치 + 재산가치 - 부채평가) * 100000000) / 발행주식수)
+    except (ZeroDivisionError, ValueError) as e:
+        red_price = math.nan
+
+    logger.debug(f'Red Price : {red_price}원')
+    return {
+        'red_price': red_price,
+        '사업가치': 사업가치,
+        '재산가치': 재산가치,
+        '부채평가': 부채평가,
+        '발행주식수': 발행주식수,
+        'date': tools.set_data(d1, d2, d3, d4, d5, d6),  # ''값을 제거하고 리스트로 바꾼다.
+    }
+
+
+def mil(code: str) -> dict:
+    """
+    리턴값
+    {
+        '주주수익률': 주주수익률,
+        '이익지표': 이익지표,
+        '투자수익률': {'ROIC': roic, 'ROE': roe , 'ROE106': {}},
+        '가치지표': {'FCF': fcf_dict, 'PFCF': pfcf_dict, 'PCR': pcr_dict},
+        'date': [각 유효한 값의 년월값 리스트(ex- 2020/09)],
+    }
+
+    - 재무활동현금흐름이 마이너스라는 것은 배당급 지급했거나, 자사주 매입했거나, 부채를 상환한 상태임.
+    - 반대는 채권자로 자금을 조달했거나 신주를 발행했다는 의미
+    <주주수익률> - 재무활동현금흐름/시가총액 => 5%이상인가?
+
+    투하자본수익률(ROIC)가 30%이상인가
+    ROE(자기자본이익률) 20%이상이면 아주 우수 다른 투자이익률과 비교해볼것 10%미만이면 별로...단, 부채비율을 확인해야함.
+
+    이익지표 ...영업현금흐름이 순이익보다 많은가 - 결과값이 음수인가..
+
+    FCF는 영업현금흐름에서 자본적 지출(유·무형투자 비용)을 차감한 순수한 현금력이라 할 수 있다.
+    말 그대로 자유롭게(Free) 사용할 수 있는 여윳돈을 뜻한다.
+    잉여현금흐름이 플러스라면 미래의 투자나 채무상환에 쓸 재원이 늘어난 것이다.
+    CAPEX(Capital expenditures)는 미래의 이윤을 창출하기 위해 지출된 비용을 말한다.
+    이는 기업이 고정자산을 구매하거나, 유효수명이 당회계년도를 초과하는 기존의 고정자산에 대한 투자에 돈이 사용될 때 발생한다.
+
+    잉여현금흐름이 마이너스일때는 설비투자가 많은 시기라 주가가 약세이며 이후 설비투자 마무리되면서 주가가 상승할수 있다.
+    주가는 잉여현금흐름이 증가할때 상승하는 경향이 있다.
+    fcf = 영업현금흐름 - capex
+
+    가치지표평가
+    price to fcf 계산
+    https://www.investopedia.com/terms/p/pricetofreecashflow.asp
+    pcr보다 정확하게 주식의 가치를 평가할수 있음. 10배이하 추천
+    """
+    c103q = myredis.C103(code, 'c103현금흐름표q')
+    c104q = myredis.C104(code, 'c104q')
+    c106q = myredis.C106(code, 'c106q')
+
+    marketcap억 = tools.get_marketcap(code) / 100000000
+    logger.debug(f'{code} market cap: {marketcap억}')
+    fcf_dict = tools.findFCF(code)
+    pfcf_dict = tools.findPFCF(code)
+    d1, 지배주주당기순이익 = tools.calc당기순이익(code)
+
+    d2, 재무활동현금흐름 = c103q.sum_recent_4q('재무활동으로인한현금흐름')
+    d3, 영업활동현금흐름 = c103q.sum_recent_4q('영업활동으로인한현금흐름')
+
+    d4, roic = c104q.sum_recent_4q('ROIC')
+    d5, roe = c104q.latest_value_pop2('ROE')
+    roe106 = c106q.find('ROE')
+
+    _, pcr_dict = c104q.find_without_yoy('PCR')
+
+    try:
+        주주수익률 = round((재무활동현금흐름 / marketcap억 * -100), 2)
+        이익지표 = round((지배주주당기순이익 - 영업활동현금흐름) / marketcap억, 5)
+    except ZeroDivisionError:
+        주주수익률 = math.nan
+        이익지표 = math.nan
+
+    if math.isnan(주주수익률) or math.isnan(이익지표):
+        logger.warning(f'주주수익률: {주주수익률} 이익지표: {이익지표}')
+        logger.warning(f'재무활동현금흐름: {재무활동현금흐름} / 지배주주당기순이익: {지배주주당기순이익} / 영업활동현금흐름: {영업활동현금흐름}')
+
+    logger.debug(f'{code} fcf_dict : {fcf_dict}')
+    logger.debug(f"{code} market_cap : {marketcap억}")
+    logger.debug(f'{code} pfcf_dict : {pfcf_dict}')
+    logger.debug(f'{code} pcr_dict : {pcr_dict}')
+
+    return {
+        '주주수익률': 주주수익률,
+        '이익지표': 이익지표,
+        '투자수익률': {'ROIC': roic, 'ROE': roe, 'ROE106': roe106},
+        '가치지표': {'FCF': fcf_dict, 'PFCF': pfcf_dict, 'PCR': pcr_dict},
+        'date': tools.set_data(d1, d2, d3, d4, d5),
+    }
+
+
+def blue(code: str) -> dict:
+    """
+    리턴값
+    {
+    'date': [각 유효한 값의 최근분기 값 리스트(ex- 2020/09)],
+    '순부채비율': (29.99, {'2018/12': 19.45, '2019/12': 19.52, '2020/12': 12.07, '2021/12': 82.2, '2022/12': 29.99, '2023/12': nan}),
+    '순운전자본회전율': (1.04, {'2018/12': 21.91, '2019/12': 23.12, '2020/12': 5.88, '2021/12': 5.6, '2022/12': 6.04, '2023/12': nan}),
+    '유동비율': 64.29,
+    '이자보상배율': (-3.64, {'2018/12': 4.01, '2019/12': 1.3, '2020/12': -5.05, '2021/12': 0.56, '2022/12': -1.28, '2023/12': nan}),
+    '재고자산회전율': (1.66, {'2018/12': 12.41, '2019/12': 12.44, '2020/12': 9.18, '2021/12': 9.76, '2022/12': 8.79, '2023/12': nan})
+    }
+
+    <유동비율>
+    100미만이면 주의하나 현금흐름창출력이 좋으면 괜찮을수 있다.
+    만약 100%이하면 유동자산에 추정영업현금흐름을 더해서 다시계산해보아 기회를 준다.
+    <이자보상배율>
+    이자보상배율 영업이익/이자비용으로 1이면 자금사정빡빡 5이상이면 양호
+    <순운전자금회전율>
+    순운전자금 => 기업활동을 하기 위해 필요한 자금 (매출채권 + 재고자산 - 매입채무)
+    순운전자본회전율은 매출액/순운전자본으로 일정비율이 유지되는것이 좋으며 너무 작아지면 순운전자본이 많아졌다는 의미로 재고나 외상이 쌓인다는 뜻
+    <재고자산회전율>
+    재고자산회전율은 매출액/재고자산으로 회전율이 낮을수록 재고가 많다는 이야기이므로 불리 전년도등과 비교해서 큰차이 발생하면 알람.
+    재고자산회전율이 작아지면 재고가 쌓인다는뜻
+    <순부채비율>
+    부채비율은 업종마다 달라 일괄비교 어려우나 순부채 비율이 20%이하인것이 좋고 꾸준히 늘어나지 않는것이 좋다.
+    순부채 비율이 30%이상이면 좋치 않다.
+    <매출액>
+    매출액은 어떤경우에도 성장하는 기업이 좋다.매출이 20%씩 늘어나는 종목은 유망한 종목
+    <영업이익률>
+    영업이익률은 기업의 경쟁력척도로 경쟁사에 비해 높으면 경제적해자를 갖춘셈
+    """
+
+    d1, 유동비율 = tools.calc유동비율(code, pop_count=3)
+    logger.debug(f'유동비율 {유동비율} / [{d1}]')
+
+    c104y = myredis.C104(code, 'c104y')
+    _, dict이자보상배율y = c104y.find_with_yoy('이자보상배율')
+    _, dict순운전자본회전율y = c104y.find_with_yoy('순운전자본회전율')
+    _, dict재고자산회전율y = c104y.find_with_yoy('재고자산회전율')
+    _, dict순부채비율y = c104y.find_with_yoy('순부채비율')
+
+    c104q = myredis.C104(code, 'c104q')
+    d6, 이자보상배율q = c104q.latest_value_pop2('이자보상배율')
+    d7, 순운전자본회전율q = c104q.latest_value_pop2('순운전자본회전율')
+    d8, 재고자산회전율q = c104q.latest_value_pop2('재고자산회전율')
+    d9, 순부채비율q = c104q.latest_value_pop2('순부채비율')
+
+    if len(dict이자보상배율y) == 0:
+        logger.warning(f'empty dict - 이자보상배율 : {이자보상배율q} {dict이자보상배율y}')
+
+    if len(dict순운전자본회전율y) == 0:
+        logger.warning(f'empty dict - 순운전자본회전율 : {순운전자본회전율q} {dict순운전자본회전율y}')
+
+    if len(dict재고자산회전율y) == 0:
+        logger.warning(f'empty dict - 재고자산회전율 : {재고자산회전율q} {dict재고자산회전율y}')
+
+    if len(dict순부채비율y) == 0:
+        logger.warning(f'empty dict - 순부채비율 : {순부채비율q} {dict순부채비율y}')
+
+    ################################################################
+
+    return {
+        '유동비율': 유동비율,
+        '이자보상배율': (이자보상배율q, dict이자보상배율y),
+        '순운전자본회전율': (순운전자본회전율q, dict순운전자본회전율y),
+        '재고자산회전율': (재고자산회전율q, dict재고자산회전율y),
+        '순부채비율': (순부채비율q, dict순부채비율y),
+        'date': tools.set_data(d1, d6, d7, d8, d9),  # ''값을 제거하고 리스트로 바꾼다.
+    }
+
+
+def growth(code: str) -> dict:
+    """
+    리턴값
+    {'date': [각 유효한 값의 최근분기 값 리스트(ex- 2020/09)],
+    '매출액증가율': (-14.37, {'2018/12': -24.56, '2019/12': -20.19, '2020/12': -12.64, '2021/12': 38.65, '2022/12': -8.56, '2023/12': nan}),
+    '영업이익률': {'뉴프렉스': '17.36', '동일기연': '13.58', '비에이치': '16.23', '에이엔피': '-9.30', '이브이첨단소재': '-4.93'}}
+
+    <매출액>
+    매출액은 어떤경우에도 성장하는 기업이 좋다.매출이 20%씩 늘어나는 종목은 유망한 종목
+    <영업이익률>
+    영업이익률은 기업의 경쟁력척도로 경쟁사에 비해 높으면 경제적해자를 갖춘셈
+    """
+    c104y = myredis.C104(code, 'c104y')
+    c106y = myredis.C106(code, 'c106y')
+
+    _, dict매출액증가율y = c104y.find_with_yoy('매출액증가율')
+
+    c104q = myredis.C104(code, 'c104q')
+    d2, 매출액증가율q = c104q.latest_value_pop2('매출액증가율')
+
+    logger.debug(f'매출액증가율 : {매출액증가율q} {dict매출액증가율y}')
+
+    ################################################################
+
+    # c106 에서 타 기업과 영업이익률 비교
+    dict영업이익률 = c106y.find('영업이익률')
+
+    return {
+        '매출액증가율': (매출액증가율q, dict매출액증가율y),
+        '영업이익률': dict영업이익률,
+        'date': [d2, ]}
+
+
+"""
+- 각분기의 합이 연이 아닌 타이틀(즉 sum_4q를 사용하면 안됨)
+'*(지배)당기순이익'
+'*(비지배)당기순이익'
+'장기차입금'
+'현금및예치금'
+'매도가능금융자산'
+'매도파생결합증권'
+'만기보유금융자산'
+'당기손익-공정가치측정금융부채'
+'당기손익인식(지정)금융부채'
+'단기매매금융자산'
+'단기매매금융부채'
+'예수부채'
+'차입부채'
+'기타부채'
+'보험계약부채(책임준비금)'
+'*CAPEX'
+'ROE'
+"""
+
+"""
+- sum_4q를 사용해도 되는 타이틀
+'자산총계'
+'당기순이익'
+'유동자산'
+'유동부채'
+'비유동부채'
+
+'영업활동으로인한현금흐름'
+'재무활동으로인한현금흐름'
+'ROIC'
+"""

analyser_hj3415/{report.py → analysers/report.py}

@@ -1,8 +1,8 @@
 """다양한 문자열 출력 형식에 맞춘 함수들
 """
-from .db import mongo
-from .eval import red as eval_red, mil as eval_mil, blue as eval_blue, growth as eval_growth
-from .score import red as score_red, mil as score_mil, blue as score_blue, growth as score_growth
+from db_hj3415 import myredis
+from analyser_hj3415.analysers import eval
+from analyser_hj3415.analysers import score
 from utils_hj3415 import utils
 import textwrap
 
@@ -21,7 +21,7 @@ class Report:
     def __init__(self, client, code: str):
         self.client = client
         self.code = code
-        self.name = mongo.Corps.get_name(client, code)
+        self.name = myredis.Corps.get_name(code)
 
     def __str__(self):
         return (self.c101() + self.separate_line
@@ -32,7 +32,7 @@ class Report:
         # + make_str.c108())
 
     def c101(self, full=True):
-        c101 = mongo.C101(self.client, self.code).get_recent(merge_intro=True)
+        c101 = myredis.C101(self.code).get_recent()
         logger.info(c101)
 
         title = '=' * 35 + f"\t{c101['코드']}\t\t{c101['종목명']}\t\t{c101['업종']}\t" + '=' * 35
@@ -65,11 +65,11 @@ class Report:
         return title + '\n' + intro + self.separate_line + price + '\n' + info
 
     def red(self, full=True) -> str:
-        red_dict = eval_red(self.client, self.code)
-        p, 괴리율 = score_red(self.client, self.code)
+        red_dict = eval.red(self.code)
+        괴리율 = score.red(self.code)
         logger.info(red_dict)
 
-        title = f"Red\tPoint({p})\t괴리율({괴리율}%)\t{red_dict['date']}\n"
+        title = f"Red\t괴리율({괴리율}%)\t{red_dict['date']}\n"
         if full:
             contents = (f"사업가치({utils.deco_num(red_dict['사업가치'])}억) "
                         f"+ 재산가치({utils.deco_num(red_dict['재산가치'])}억) "
@@ -81,8 +81,8 @@ class Report:
         return title + contents
 
     def mil(self, full=True) -> str:
-        mil_dict = eval_mil(self.client, self.code)
-        p1, p2, p3, p4 = score_mil(self.client, self.code)
+        mil_dict = eval.mil(self.code)
+        p1, p2, p3, p4 = score.mil(self.code)
         logger.info(mil_dict)
 
         title = f"Millenial\tPoint({p1+p2+p3+p4})\t{mil_dict['date']}\n"
@@ -104,8 +104,8 @@ class Report:
         return title + contents
 
     def blue(self, full=True) -> str:
-        blue_dict = eval_blue(self.client, self.code)
-        p1, p2, p3, p4, p5 = score_blue(self.client, self.code)
+        blue_dict = eval.blue(self.code)
+        p1, p2, p3, p4, p5 = score.blue(self.code)
         logger.info(blue_dict)
 
         title = f"Blue\tPoint({p1+p2+p3+p4+p5})\t{blue_dict['date']}\n"
@@ -121,8 +121,8 @@ class Report:
         return title + contents
 
     def growth(self, full=True) -> str:
-        growth_dict = eval_growth(self.client, self.code)
-        p1, p2 = score_growth(self.client, self.code)
+        growth_dict = eval.growth(self.code)
+        p1, p2 = score.growth(self.code)
         logger.info(growth_dict)
 
         title = f"Growth\tPoint({p1 + p2})\t{growth_dict['date']}\n"
@@ -169,50 +169,14 @@ class Report:
         'red_s': (53, -75.42)}
         """
         return {
-            'c101': mongo.C101(self.client, self.code).get_recent(merge_intro=True),
-            'red': eval_red(self.client, self.code),
-            'mil': eval_mil(self.client, self.code),
-            'blue': eval_blue(self.client, self.code),
-            'growth': eval_growth(self.client, self.code),
-            # 'c108': mongo.C108(self.client, self.code).get_recent(),
-            'red_s': score_red(self.client, self.code),
-            'mil_s': score_mil(self.client, self.code),
-            'blue_s': score_blue(self.client, self.code),
-            'growth_s': score_growth(self.client, self.code),
+            'c101': myredis.C101(self.code).get_recent(),
+            'red': eval.red(self.code),
+            'mil': eval.mil(self.code),
+            'blue': eval.blue(self.code),
+            'growth': eval.growth(self.code),
+            'red_s': score.red(self.code),
+            'mil_s': score.mil(self.code),
+            'blue_s': score.blue(self.code),
+            'growth_s': score.growth(self.code),
         }
 
-
-    """
-    def c108(self, full=True) -> str:
-        if full:
-            c108_list = mongo.C108(self.client, self.code).get_all()
-        else:
-            c108_list = mongo.C108(self.client, self.code).get_recent()
-        s = ''
-        logger.info(c108_list)
-        for i, c108_dict in enumerate(c108_list):
-            logger.info(c108_dict)
-            if i == 0:
-                pass
-            else:
-                s += '\n'
-            header = f"{c108_dict['날짜']}\thprice : {c108_dict['목표가']} 원\n"
-            title = f"<<{c108_dict['제목']}>>\n"
-            contents = ''
-            for line in c108_dict['내용'].split('▶'):
-                contents += line.strip()
-            s += header + title + textwrap.fill(contents, width=70) + self.separate_line
-        return s
-    """
-
-
-
-def for_telegram(client, code: str) -> str:
-    make_str = MakeStr(client, code)
-
-    return (make_str.c101(full=False) + make_str.separate_line
-            + make_str.red(full=False) + make_str.separate_line
-            + make_str.mil(full=False) + make_str.separate_line
-            + make_str.blue(full=False) + make_str.separate_line
-            + make_str.growth(full=False))
-            # + make_str.c108(full=False))

analyser_hj3415/{score.py → analysers/score.py}

@@ -4,8 +4,8 @@ import pprint
 import copy
 from typing import Tuple
 
-from .db import mongo
-from .eval import EXPECT_EARN, red as eval_red, mil as eval_mil, blue as eval_blue, growth as eval_growth
+from db_hj3415 import myredis, mymongo
+from analyser_hj3415.analysers import eval
 from utils_hj3415 import utils
 
 import logging
@@ -18,50 +18,45 @@ logger.addHandler(ch)
 logger.setLevel(logging.WARNING)
 
 
-def red(client, code: str) -> Tuple[int, float]:
-    """red price와 최근 주가의 괴리율 파악
+def cal_deviation(v1: float, v2: float) -> float:
+    """
+    괴리율 구하는 공식
+    :param v1:
+    :param v2:
+    :return:
+    """
+    try:
+        deviation = abs((v1 - v2) / v1) * 100
+    except ZeroDivisionError:
+        deviation = math.nan
+    return deviation
+
 
-    양수면 주가가 고평가되어 있는 상태, 음수면 저평가
-    음수가 현재 주가가 싸다는 의미
+def red(code: str) -> int:
+    """red price와 최근 주가의 괴리율 파악
 
     Returns:
-        tuple : 괴리율을 기반으로한 포인트, 주가와 red price 비교한 괴리율
+        int : 주가와 red price 비교한 괴리율
     """
-    c101 = mongo.C101(client, code)
-
-    logger.debug(f'c101 {c101.get_recent()}')
-
     try:
-        recent_price = utils.to_int(c101.get_recent()['주가'])
+        recent_price = utils.to_int(myredis.C101(code).get_recent()['주가'])
     except KeyError:
         recent_price = float('nan')
-    red_price = eval_red(client, code)['red_price']
-
-    logger.debug(f"recent_price : {recent_price}\tred_price : {red_price}")
+        return 0
 
-    try:
-        # 괴리율 구하는 공식이 두가지임. 어떤걸 사용해도 동일함
-        f1 = round((recent_price / red_price - 1) * 100, 2)
-        f2 = round((recent_price - red_price) / red_price * 100, 2)
-        logger.debug(f'f1 : {f1}, f2 : {f2}')
-        괴리율 = round((recent_price / red_price - 1) * 100, 2)
-    except ZeroDivisionError:
-        괴리율 = float('nan')
+    red_price = eval.red(code)['red_price']
+    deviation = cal_deviation(recent_price, red_price)
+    if red_price < 0 or (recent_price >= red_price):
+        score = 0
+    else:
+        score = math.log10(deviation + 1) * 33  # desmos그래프상 33이 제일 적당한듯(최대100점에 가깝게)
 
-    logger.debug(f'괴리율 : {괴리율}')
+    #print(f"최근주가 : {recent_price}", f"red가격 : {red_price}", f"괴리율 : {utils.to_int(deviation)}", f"score : {utils.to_int(score)}")
 
-    if math.isnan(괴리율) or red_price <= 0:
-        return 0, float('nan')
-    else:
-        try:
-            p = round(100*math.log10(-괴리율+31.622777)-150)
-            return p if p > 0 else 0, 괴리율
-        except ValueError:
-            # 괴리율+31.622777이 0이하인 경우 ValueError 발생함.
-            return 0, 괴리율
+    return utils.to_int(score)
 
 
-def mil(client, code: str) -> Tuple[int, int, int, int]:
+def mil(code: str) -> Tuple[int, int, int, int]:
     """
     - 재무활동현금흐름이 마이너스라는 것은 배당급 지급했거나, 자사주 매입했거나, 부채를 상환한 상태임.
     - 반대는 채권자로 자금을 조달했거나 신주를 발행했다는 의미
@@ -90,55 +85,55 @@ def mil(client, code: str) -> Tuple[int, int, int, int]:
     Returns:
         tuple: 주주수익률, 이익지표, 투자수익률, PFCF포인트
     """
-    mil_dict = eval_mil(client, code)
+    mil_dict = eval.mil(code)
 
-    logger.debug(pprint.pformat(mil_dict, width=200))
+    print(pprint.pformat(mil_dict, width=200))
 
     # 주주수익률 평가
     if math.isnan(mil_dict['주주수익률']):
-        p1 = 0
+        score1 = 0
     else:
-        주주수익률평가 = math.ceil(mil_dict['주주수익률'] - (EXPECT_EARN * 100))
-        p1 = 0 if 0 > 주주수익률평가 else 주주수익률평가
+        주주수익률평가 = math.ceil(mil_dict['주주수익률'] - (eval.EXPECT_EARN * 100))
+        score1 = 0 if 0 > 주주수익률평가 else 주주수익률평가
 
     # 이익지표 평가
-    p2 = 10 if mil_dict['이익지표'] < 0 else 0
+    score2 = 10 if mil_dict['이익지표'] < 0 else 0
 
     # 투자수익률 평가
     MAX3 = 20
-    p3 = 0
+    score3 = 0
     roic = mil_dict['투자수익률']['ROIC']
     roe = mil_dict['투자수익률']['ROE']
     if math.isnan(roic) or roic <= 0:
         # roic 가 비정상이라 평가할 수 없는 경우
         if 10 < roe <= 20:
-            p3 += round(MAX3 * 0.333)
+            score3 += round(MAX3 * 0.333)
         elif 20 < roe:
-            p3 += round(MAX3 * 0.666)
+            score3 += round(MAX3 * 0.666)
     elif 0 < roic:
         # roic 로 평가할 수 있는 경우
         if 0 < roic <= 15:
-            p3 += round(MAX3 * 0.333)
+            score3 += round(MAX3 * 0.333)
         elif 15 < roic <= 30:
-            p3 += round(MAX3 * 0.666)
+            score3 += round(MAX3 * 0.666)
         elif 30 < roic:
-            p3 += MAX3
+            score3 += MAX3
 
     # PFCF 평가
     pfcf_dict = mil_dict['가치지표']['PFCF']
-    _, pfcf = mongo.Corps.latest_value(pfcf_dict)
+    _, pfcf = mymongo.C1034.latest_dict_value(pfcf_dict)
 
     logger.debug(f'recent pfcf {_}, {pfcf}')
     try:
         p = round(-40 * math.log10(pfcf) + 40)
     except ValueError:
         p = 0
-    p4 = 0 if 0 > p else p
+    score4 = 0 if 0 > p else p
 
-    return p1, p2, p3, p4
+    return score1, score2, score3, score4
 
 
-def blue(client, code: str) -> Tuple[int, int, int, int, int]:
+def blue(code: str) -> Tuple[int, int, int, int, int]:
     """회사의 안정성을 보는 지표들
 
     0을 기준으로 상태가 좋치 않을 수록 마이너스 값을 가진다.
@@ -181,11 +176,11 @@ def blue(client, code: str) -> Tuple[int, int, int, int, int]:
 
         return int(p)
 
-    c104y = mongo.C104(client, code, 'c104y')
+    c104y = myredis.C104(code, 'c104y')
 
-    blue_dict = eval_blue(client, code)
+    blue_dict = eval.blue(code)
 
-    logger.debug(pprint.pformat(blue_dict, width=200))
+    print(pprint.pformat(blue_dict, width=200))
 
     def 유동비율평가(유동비율: float) -> int:
         # 채점은 0을 기준으로 마이너스 해간다. 즉 0이 제일 좋은 상태임.
@@ -210,9 +205,9 @@ def blue(client, code: str) -> Tuple[int, int, int, int, int]:
         if math.isnan(최근이자보상배율q) or 최근이자보상배율q <= 1:
             # 최근 분기의 값이 비정상이면 최근 년도를 한번 더 비교해 보지만 좀더 엄격하게 전년대비도 비교한다.
 
-            _, 최근이자보상배율y = mongo.Corps.latest_value(dict_y)
+            _, 최근이자보상배율y = mymongo.C1034.latest_dict_value(dict_y)
             c104y.page = 'c104y'
-            _, 전년대비 = c104y.find_증감율(title='이자보상배율').popitem()
+            전년대비 = c104y.find_yoy(title='이자보상배율')
 
             if math.isnan(최근이자보상배율y) or 최근이자보상배율y <= 1 or math.isnan(전년대비) or 전년대비 < 0:
                 p = NEG_MAX
@@ -233,9 +228,9 @@ def blue(client, code: str) -> Tuple[int, int, int, int, int]:
 
         if math.isnan(최근순부채비율q) or 최근순부채비율q >= 80:
             # 최근 분기의 값이 비정상이면 최근 년도를 한번 더 비교해 보지만 좀더 엄격하게 전년대비도 비교한다.
-            _, 최근순부채비율y = mongo.Corps.latest_value(dict_y)
+            _, 최근순부채비율y = mymongo.C1034.latest_dict_value(dict_y)
             c104y.page = 'c104y'
-            _, 전년대비 = c104y.find_증감율(title='순부채비율').popitem()
+            전년대비 = c104y.find_yoy(title='순부채비율')
             if math.isnan(최근순부채비율y) or 최근순부채비율y >= 80 or math.isnan(전년대비) or 전년대비 > 0:
                 p = NEG_MAX
             else:
@@ -269,7 +264,7 @@ def blue(client, code: str) -> Tuple[int, int, int, int, int]:
     return p1, p2, p3, p4, p5
 
 
-def growth(client, code: str) -> Tuple[int, int]:
+def growth(code: str) -> Tuple[int, int]:
     """회사의 성장성을 보는 지표들
 
     <매출액>
@@ -280,7 +275,7 @@ def growth(client, code: str) -> Tuple[int, int]:
     Returns:
         tuple : 매출액증가율, 영업이익률 평가 포인트
     """
-    growth_dict = eval_growth(client, code)
+    growth_dict = eval.growth(code)
 
     logger.debug(pprint.pformat(growth_dict, width=200))
 
@@ -288,7 +283,7 @@ def growth(client, code: str) -> Tuple[int, int]:
         # 매출액은 어떤경우에도 성장하는 기업이 좋다.매출이 20%씩 늘어나는 종목은 유망한 종목
         MAX = 20
         최근매출액증가율q, dict_y = 매출액증가율
-        _, 최근매출액증가율y = mongo.Corps.latest_value(dict_y)
+        _, 최근매출액증가율y = mymongo.C1034.latest_dict_value(dict_y)
 
         # 최근 자료가 성장하는 중인지 판단
         if math.isnan(최근매출액증가율q):
@@ -342,7 +337,7 @@ def growth(client, code: str) -> Tuple[int, int]:
     def 영업이익률평가(영업이익률: dict) -> int:
         # 영업이익률은 기업의 경쟁력척도로 경쟁사에 비해 높으면 경제적해자를 갖춘셈
         영업이익률 = copy.deepcopy(영업이익률)
-        name = mongo.Corps.get_name(client, code)
+        name = myredis.Corps.get_name(code)
 
         p = 0
         try: