analyser_hj3415 3.4.2__py3-none-any.whl → 4.0.0__py3-none-any.whl

analyser_hj3415/workroom/score.py

@@ -1,342 +0,0 @@
-import math
-import numpy
-import pprint
-import copy
-from typing import Tuple
-
-from db_hj3415 import myredis, mymongo
-from utils_hj3415 import utils
-
-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)
-
-
-
-def mil(code: str, expect_earn: float) -> Tuple[int, int, int, int]:
-    """
-    이익 지표 일반적인 기준 설정
-
-	1.	비율이 10% 이상일 경우 주의:
-	•	이 비율이 10%를 넘을 경우, 이는 기업의 순이익이 현금 흐름과 비교하여 너무 높아졌음을 나타냅니다.
-	•	순이익이 과도하게 부풀려졌을 가능성이 있으며, 회계적인 항목(예: 미수금, 재고자산의 평가차익 등)이나 비현금성 이익이 이익에 크게 기여하고 있을 수 있습니다. 이런 경우, 현금 흐름이 제대로 발생하지 않고 있음에도 순이익만 높게 기록되는 상황이 발생할 수 있어 이익의 질이 낮다고 평가됩니다.
-	•	특히, 비율이 지속적으로 높다면 재무 건전성에 문제가 있을 수 있습니다.
-	2.	비율이 5% 이상 ~ 10% 미만일 때:
-	•	비율이 5% ~ 10% 사이라면, 기업의 이익이 여전히 현금 흐름과 괴리가 있지만, 업종에 따라 일정 부분은 허용될 수 있습니다.
-	•	예를 들어, 기술 기업이나 고성장 산업에서는 초기 투자나 R&D 비용이 많기 때문에 순이익과 현금 흐름의 차이가 다소 발생할 수 있습니다. 이런 경우 비율이 5%를 넘더라도 성장성을 고려한 투자 관점에서 용인될 수 있습니다.
-	•	다만, 일반적인 제조업 등 현금 창출이 중요한 업종에서는 5% 이상의 괴리도 주의 깊게 볼 필요가 있습니다.
-	3.	비율이 5% 미만일 때:
-	•	비율이 5% 미만이라면, 기업의 순이익과 현금 흐름 간의 차이가 크지 않으므로, 이익의 질이 높고 재무 건전성이 양호하다고 평가할 수 있습니다.
-	•	특히 음수일 경우, 영업활동에서 벌어들인 현금이 순이익을 초과한다는 것을 의미하므로, 이는 매우 긍정적인 신호입니다. 기업이 순이익보다도 더 많은 현금을 창출하고 있는 상태로, 이익이 실제 현금 흐름으로 뒷받침되고 있음을 나타냅니다.
-
-	참고할 수 있는 기준
-    1. 경고 신호: 10% 이상
-	•	비율이 10% 이상이라면, 기업의 이익이 실제 현금 흐름과 크게 괴리되어 있음을 의미하며, 이익의 질이 낮고 재무 건전성이 떨어질 가능성이 큽니다. 특히, 이 비율이 지속적으로 높다면, 주의가 필요합니다.
-    2. 주의: 5% ~ 10%
-	•	이 비율은 어느 정도 괴리가 있는 상태이며, 업종 특성에 따라 감안할 수 있지만, 일반적인 기업의 경우 주의를 요합니다.
-    3. 안정적: 5% 미만
-	•	5% 미만은 비교적 안정적인 상태로 평가될 수 있습니다. 이익과 현금 흐름 간의 괴리가 크지 않기 때문에, 기업의 재무 상태와 이익의 질이 건전하다고 볼 수 있습니다.
-    4. 매우 긍정적: 음수
-	•	비율이 음수일 경우, 현금 창출 능력이 매우 우수한 상태입니다. 현금 흐름이 순이익보다 더 크므로, 이는 매우 긍정적인 신호로 평가됩니다.
-
-    사례별 해석
-
-	1.	비율이 15%:
-	•	회사는 순이익이 영업활동현금흐름에 비해 과도하게 높습니다. 이는 비현금성 이익이 많이 포함되어 있거나, 회계적인 처리로 인해 순이익이 부풀려졌을 가능성이 큽니다. 기업의 이익 질에 의문을 가져야 하며, 장기적으로 재무 구조에 문제가 생길 수 있습니다.
-	2.	비율이 7%:
-	•	괴리가 존재하지만, 일부 산업에서는 용인될 수 있는 범위입니다. 다만, 현금 흐름이 안정적인지 추가적인 분석이 필요합니다.
-	3.	비율이 -3%:
-	•	매우 긍정적인 상황입니다. 회사는 순이익보다 더 많은 현금을 벌어들이고 있어, 이익의 질이 매우 높으며, 주주들에게도 더 많은 이익을 돌려줄 가능성이 큽니다.
-
-    기타 고려 사항
-
-	•	업종별 차이: 기술 기업, 스타트업 등은 고정자산 투자나 R&D 비용이 많아 현금 흐름과 이익이 괴리될 수 있습니다. 이 경우 이익의 질이 낮다고 단정할 수는 없으므로 산업 특성을 고려해야 합니다.
-	•	기업의 성장 단계: 빠르게 성장하는 기업일수록 현금 흐름보다 순이익이 클 수 있지만, 시간이 지나면서 현금 창출 능력이 증가할 수 있습니다.
-	•	비현금성 항목 분석: 감가상각, 미수금 등의 비현금성 항목이 이익에 얼마나 영향을 미치는지 분석하여 이익의 질을 파악하는 것이 중요합니다.
-	ROIC 평가 기준
-
-	1.	10% 이상:
-	•	일반적으로 ROIC가 10% 이상이면 매우 우수한 기업으로 평가됩니다.
-	•	이는 기업이 투자된 자본으로 높은 수익을 창출하고 있음을 의미하며, 자본의 사용 효율성이 매우 높다는 것을 나타냅니다.
-	2.	7% ~ 10%:
-	•	ROIC가 7%에서 10% 사이라면, 기업은 자본을 비교적 효율적으로 사용하고 있는 상태입니다.
-	•	자본비용(WACC)이 이보다 낮다면, 투자자는 기업이 가치 창출을 하고 있다고 판단할 수 있습니다.
-	3.	5% ~ 7%:
-	•	이 범위에서는 보통 수준의 효율성을 보여줍니다. ROIC가 자본비용보다 낮지 않다면 투자자에게 긍정적일 수 있지만, 이 수익률이 경쟁사 대비 낮다면 경쟁력이 떨어질 수 있음을 시사할 수 있습니다.
-	4.	5% 미만:
-	•	ROIC가 5% 미만이라면, 기업은 자본을 비효율적으로 사용하고 있음을 의미할 수 있습니다.
-	•	자본을 투입해 수익을 내지 못하거나, 투자된 자본으로부터 적절한 수익을 창출하지 못하고 있는 상태일 수 있습니다.
-    :param code:
-    :param expect_earn:
-    :return:
-    """
-
-    mil_dict = eval.mil(code)
-
-    # print(pprint.pformat(mil_dict, width=200))
-
-    # 주주수익률 평가
-    if math.isnan(mil_dict['주주수익률']):
-        score1 = 0
-    else:
-        주주수익률평가 = math.ceil(mil_dict['주주수익률'] - (expect_earn * 100))
-        score1 = 0 if 0 > 주주수익률평가 else 주주수익률평가
-
-    # 이익지표 평가
-    score2 = 10 if mil_dict['이익지표'] < 0 else 0
-
-    # 투자수익률 평가
-    MAX3 = 20
-    score3 = 0
-    roic = mil_dict['투자수익률']['ROIC']
-    roe = mil_dict['투자수익률']['ROE']
-    if math.isnan(roic) or roic <= 0:
-        # roic 가 비정상이라 평가할 수 없는 경우
-        if 10 < roe <= 20:
-            score3 += round(MAX3 * 0.333)
-        elif 20 < roe:
-            score3 += round(MAX3 * 0.666)
-    elif 0 < roic:
-        # roic 로 평가할 수 있는 경우
-        if 0 < roic <= 15:
-            score3 += round(MAX3 * 0.333)
-        elif 15 < roic <= 30:
-            score3 += round(MAX3 * 0.666)
-        elif 30 < roic:
-            score3 += MAX3
-
-    # PFCF 평가
-    pfcf_dict = mil_dict['가치지표']['PFCF']
-    _, 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
-    score4 = 0 if 0 > p else p
-
-    return score1, score2, score3, score4
-
-
-def blue(code: str) -> Tuple[int, int, int, int, int]:
-    """회사의 안정성을 보는 지표들
-
-    0을 기준으로 상태가 좋치 않을 수록 마이너스 값을 가진다.
-
-    Returns:
-        tuple : 유동비율, 이자보상배율, 순부채비율, 순운전자본회전율, 재고자산회전율 평가 포인트
-
-    Notes:
-    """
-    def _calc_point_with_std(data: dict) -> int:
-        """표준편차를 통해 점수를 계산하는 내부 함수
-
-        Args:
-            data(dict): 재무재표상의 연/분기 딕셔너리 데이터
-        """
-        NEG_MAX = -5
-        d_values = [i for i in data.values() if not math.isnan(i)]
-        logger.debug(f'd_values : {d_values}')
-        if len(d_values) == 0:
-            p = NEG_MAX
-        else:
-            std = numpy.std(d_values)
-            # 표준편차가 작을수록 데이터의 변환가 적다는 의미임.
-            logger.debug(f'표준편차 : {std}')
-            p = NEG_MAX if float(std) > -NEG_MAX else -math.floor(float(std))
-
-        return int(p)
-
-    c104y = myredis.C104(code, 'c104y')
-
-    blue_dict = eval.blue(code)
-
-    # print(pprint.pformat(blue_dict, width=200))
-
-    def 유동비율평가(유동비율: float) -> int:
-        # 채점은 0을 기준으로 마이너스 해간다. 즉 0이 제일 좋은 상태임.
-        # 유동비율 평가 - 100 이하는 문제 있음
-        NEG_MAX = -10
-        if math.isnan(유동비율) or 유동비율 <= 0:
-            p = NEG_MAX
-        elif math.isinf(유동비율):
-            p = 0
-        else:
-            p = 0 if 100 < round(유동비율) else NEG_MAX + round(유동비율/10)
-        logger.debug(f'유동비율평가 point : {p}')
-        return int(p)
-
-    p1 = 유동비율평가(blue_dict['유동비율'])
-
-    def 이자보상배율평가(이자보상배율: tuple) -> int:
-        # 이자보상배율평가 : 1이면 자금사정 빡빡 5이상이면 양호
-        NEG_MAX = -5
-        최근이자보상배율q, dict_y = 이자보상배율
-
-        if math.isnan(최근이자보상배율q) or 최근이자보상배율q <= 1:
-            # 최근 분기의 값이 비정상이면 최근 년도를 한번 더 비교해 보지만 좀더 엄격하게 전년대비도 비교한다.
-
-            _, 최근이자보상배율y = mymongo.C1034.latest_dict_value(dict_y)
-            c104y.page = 'c104y'
-            전년대비 = c104y.find_yoy(title='이자보상배율')
-
-            if math.isnan(최근이자보상배율y) or 최근이자보상배율y <= 1 or math.isnan(전년대비) or 전년대비 < 0:
-                p = NEG_MAX
-            else:
-                p = 0 if 5 < 최근이자보상배율y else NEG_MAX + round(최근이자보상배율y)
-        else:
-            p = 0 if 5 < 최근이자보상배율q else NEG_MAX + round(최근이자보상배율q)
-        logger.debug(f'이자보상배율평가 point : {p}')
-        return int(p)
-
-    p2 = 이자보상배율평가(blue_dict['이자보상배율'])
-
-    def 순부채비율평가(순부채비율: tuple) -> int:
-        # 부채비율은 업종마다 달라 일괄비교 어려우나 순부채 비율이 20%이하인것이 좋고 꾸준히 늘어나지 않는것이 좋다.
-        # 순부채 비율이 30%이상이면 좋치 않다.
-        NEG_MAX = -5
-        최근순부채비율q, dict_y = 순부채비율
-
-        if math.isnan(최근순부채비율q) or 최근순부채비율q >= 80:
-            # 최근 분기의 값이 비정상이면 최근 년도를 한번 더 비교해 보지만 좀더 엄격하게 전년대비도 비교한다.
-            _, 최근순부채비율y = mymongo.C1034.latest_dict_value(dict_y)
-            c104y.page = 'c104y'
-            전년대비 = c104y.find_yoy(title='순부채비율')
-            if math.isnan(최근순부채비율y) or 최근순부채비율y >= 80 or math.isnan(전년대비) or 전년대비 > 0:
-                p = NEG_MAX
-            else:
-                p = 0 if 최근순부채비율y < 30 else round((30 - 최근순부채비율y) / 10)
-        else:
-            p = 0 if 최근순부채비율q < 30 else round((30 - 최근순부채비율q) / 10)
-        logger.debug(f'순부채비율평가 point : {p}')
-        return int(p)
-
-    p3 = 순부채비율평가(blue_dict['순부채비율'])
-
-    def 순운전자본회전율평가(순운전자본회전율: tuple) -> int:
-        # 순운전자본회전율은 매출액/순운전자본으로 일정비율이 유지되는것이 좋으며 너무 작아지면 순운전자본이 많아졌다는 의미로 재고나 외상이 쌓인다는 뜻
-        _, dict_y = 순운전자본회전율
-        p = _calc_point_with_std(data=dict_y)
-        logger.debug(f'순운전자본회전율평가 point : {p}')
-        return p
-
-    p4 = 순운전자본회전율평가(blue_dict['순운전자본회전율'])
-
-    def 재고자산회전율평가(재고자산회전율: tuple) -> int:
-        # 재고자산회전율은 매출액/재고자산으로 회전율이 낮을수록 재고가 많다는 이야기이므로 불리 전년도등과 비교해서 큰차이 발생하면 알람.
-        # 재고자산회전율이 작아지면 재고가 쌓인다는뜻
-        _, dict_y = 재고자산회전율
-        p = _calc_point_with_std(data=dict_y)
-        # 라이벌기업과 비교점수 추가
-        logger.debug(f'재고자산회전율평가 point : {p}')
-        return p
-
-    p5 = 재고자산회전율평가(blue_dict['재고자산회전율'])
-
-    return p1, p2, p3, p4, p5
-
-
-def growth(code: str) -> Tuple[int, int]:
-    """회사의 성장성을 보는 지표들
-
-    <매출액>
-    매출액은 어떤경우에도 성장하는 기업이 좋다.매출이 20%씩 늘어나는 종목은 유망한 종목
-    <영업이익률>
-    영업이익률은 기업의 경쟁력척도로 경쟁사에 비해 높으면 경제적해자를 갖춘셈
-
-    Returns:
-        tuple : 매출액증가율, 영업이익률 평가 포인트
-    """
-    growth_dict = eval.growth(code)
-
-    logger.debug(pprint.pformat(growth_dict, width=200))
-
-    def 매출액증가율평가(매출액증가율: tuple) -> int:
-        # 매출액은 어떤경우에도 성장하는 기업이 좋다.매출이 20%씩 늘어나는 종목은 유망한 종목
-        MAX = 20
-        최근매출액증가율q, dict_y = 매출액증가율
-        _, 최근매출액증가율y = mymongo.C1034.latest_dict_value(dict_y)
-
-        # 최근 자료가 성장하는 중인지 판단
-        if math.isnan(최근매출액증가율q):
-            최근매출액증가율q = 최근매출액증가율y
-
-        sp1 = 0
-        if math.isnan(최근매출액증가율y):
-            pass
-        elif 0 < 최근매출액증가율y and 0 < 최근매출액증가율q:
-            # 최근에 마이너스 성장이 아닌경우 MAX/10점 보너스
-            sp1 += MAX / 10
-            if 최근매출액증가율y < 최근매출액증가율q:
-                # 최근에 이전보다 더 성장중이면 MAX/10점 보너스
-                sp1 += MAX / 10
-            # 나머지는 성장률 기반 점수 배정
-            sp1 += MAX / 2 if 최근매출액증가율q > MAX else 최근매출액증가율q / 2
-        elif 최근매출액증가율y <= 0 < 최근매출액증가율q:
-            # 직전에 마이너스였다가 최근에 회복된 경우 MAX/10점 보너스
-            sp1 += MAX / 10
-            # 나머지는 성장률 기반 점수 배정
-            sp1 += MAX / 2 if 최근매출액증가율q > MAX else 최근매출액증가율q / 2
-        else:
-            # 최근 자료가 마이너스인 경우 마이너스만큼 점수를 차감한다.
-            sp1 += -(MAX / 2) if 최근매출액증가율q < -MAX else 최근매출액증가율q / 2
-
-        # 평균매출액증가율 구하기
-        d_values = [i for i in dict_y.values() if not math.isnan(i)]
-        logger.debug(f'평균매출액증가율 d_values : {d_values}')
-
-        if len(d_values) == 0:
-            평균매출액증가율 = float('nan')
-        else:
-            평균매출액증가율 = float(numpy.mean(d_values))
-        logger.debug(f'평균 : {평균매출액증가율}')
-
-        sp2 = 0
-        if math.isnan(평균매출액증가율):
-            sp2 += -(MAX/2)
-        elif 평균매출액증가율 <= 0:
-            # 평균매출액증가율이 마이너스인 경우 마이너스만큼 점수를 차감한다.
-            sp2 += -(MAX / 2) if 평균매출액증가율 < -MAX else 평균매출액증가율 / 2
-        else:
-            sp2 = MAX / 2 if 평균매출액증가율 > MAX else 평균매출액증가율 / 2
-
-        logger.debug(f'매출액증가율평가 point : {sp1 + sp2}')
-
-        return int(sp1 + sp2)
-
-    p1 = 매출액증가율평가(growth_dict['매출액증가율'])
-
-    def 영업이익률평가(영업이익률: dict) -> int:
-        # 영업이익률은 기업의 경쟁력척도로 경쟁사에 비해 높으면 경제적해자를 갖춘셈
-        영업이익률 = copy.deepcopy(영업이익률)
-        name = myredis.Corps.get_name(code)
-
-        p = 0
-        try:
-            myprofit = utils.to_float(영업이익률.pop(name))
-        except KeyError:
-            logger.warning(f'{name} 영업이익률 does not exist.')
-            return 0
-        logger.debug(f'종목영업이익률 : {myprofit}')
-
-        for profit in 영업이익률.values():
-            profit = utils.to_float(profit)
-            if math.isnan(profit):
-                continue
-            elif myprofit > profit:
-                p += 1
-            else:
-                continue
-
-        logger.debug(f'영업이익률평가 point : {p}')
-        return p
-
-    p2 = 영업이익률평가(growth_dict['영업이익률'])
-
-    return p1, p2

analyser_hj3415/workroom/trash.py

@@ -1,289 +0,0 @@
-
-
-def _make_df_part(db_addr, codes: list, q):
-    def make_record(my_client, my_code: str) -> dict:
-        # 장고에서 사용할 eval 테이블을 만들기 위해 각각의 레코드를 구성하는 함수
-        c101 = mongo.C101(my_client, my_code).get_recent()
-
-        red_dict = red(my_client, my_code)
-        mil_dict = mil(my_client, my_code)
-        growth_dict = growth(my_client, my_code)
-
-        mil_date = mil_dict['date']
-        red_date = red_dict['date']
-        growth_date = growth_dict['date']
-
-        return {
-            'code': c101['코드'],
-            '종목명': c101['종목명'],
-            '주가': utils.to_int(c101['주가']),
-            'PER': utils.to_float(c101['PER']),
-            'PBR': utils.to_float(c101['PBR']),
-            '시가총액': utils.to_float(c101['시가총액']),
-            'RED': utils.to_int(red_dict['red_price']),
-            '주주수익률': utils.to_float(mil_dict['주주수익률']),
-            '이익지표': utils.to_float(mil_dict['이익지표']),
-            'ROIC': utils.to_float(mil_dict['투자수익률']['ROIC']),
-            'ROE': utils.to_float(mil_dict['투자수익률']['ROE']),
-            'PFCF': utils.to_float(mongo.Corps.latest_value(mil_dict['가치지표']['PFCF'])[1]),
-            'PCR': utils.to_float(mongo.Corps.latest_value(mil_dict['가치지표']['PCR'])[1]),
-            '매출액증가율': utils.to_float(growth_dict['매출액증가율'][0]),
-            'date': list(set(mil_date + red_date + growth_date))
-        }
-    # 각 코어별로 디비 클라이언트를 만들어야만 한다. 안그러면 에러발생
-    client = mongo.connect_mongo(db_addr)
-    t = len(codes)
-    d = []
-    for i, code in enumerate(codes):
-        print(f'{i+1}/{t} {code}')
-        try:
-            d.append(make_record(client, code))
-        except:
-            logger.error(f'error on {code}')
-            continue
-    df = pd.DataFrame(d)
-    logger.info(df)
-    q.put(df)
-
-
-def make_today_eval_df(client, refresh: bool = False) -> pd.DataFrame:
-    """ 멀티프로세싱을 사용하여 전체 종목의 eval 을 데이터프레임으로 만들어 반환
-
-    기본값으로 refresh 는 False 로 설정되어 당일자의 저장된 데이터프레임이 있으면 새로 생성하지 않고 mongo DB를 이용한다.
-    """
-    today_str = datetime.datetime.today().strftime('%Y%m%d')
-    df = mongo.EvalByDate(client, today_str).load_df()
-    if refresh or len(df) == 0:
-        codes_in_db = mongo.Corps.get_all_codes(client)
-
-        print('*' * 25, f"Eval all using multiprocess(refresh={refresh})", '*' * 25)
-        print(f'Total {len(codes_in_db)} items..')
-        logger.debug(codes_in_db)
-        n, divided_list = utils.code_divider_by_cpu_core(codes_in_db)
-
-        addr = mongo.extract_addr_from_client(client)
-
-        start_time = time.time()
-        q = Queue()
-        ths = []
-        for i in range(n):
-            ths.append(Process(target=_make_df_part, args=(addr, divided_list[i], q)))
-        for i in range(n):
-            ths[i].start()
-
-        df_list = []
-        for i in range(n):
-            df_list.append(q.get())
-        # 부분데이터프레임들을 하나로 합침
-        final_df = pd.concat(df_list, ignore_index=True)
-
-        for i in range(n):
-            ths[i].join()
-
-        print(f'Total spent time : {round(time.time() - start_time, 2)} sec.')
-        logger.debug(final_df)
-        print(f"Save to mongo db(db: eval col: {today_str})")
-        mongo.EvalByDate(client, today_str).save_df(final_df)
-    else:
-        print(f"Use saved dataframe from mongo db..")
-        final_df = df
-    return final_df
-
-
-def yield_valid_spac(client) -> tuple:
-    """
-    전체 스팩주의 현재가를 평가하여 2000원 이하인 경우 yield한다.
-
-    Returns:
-        tuple: (code, name, price)
-    """
-    codes = mongo.Corps.get_all_codes(client)
-    logger.debug(f'len(codes) : {len(codes)}')
-    print('<<< Finding valuable SPAC >>>')
-    for i, code in enumerate(codes):
-        name = mongo.Corps.get_name(client, code)
-        logger.debug(f'code : {code} name : {name}')
-        if '스팩' in str(name):
-            logger.debug(f'>>> spac - code : {code} name : {name}')
-            price, _, _ = utils.get_price_now(code=code)
-            if price <= 2000:
-                logger.warning(f'현재가:{price}')
-                print(f"code: {code} name: {name}, price: {price}")
-                yield code, name, price
-
-
-
-class GetDFTest(unittest.TestCase):
-    def test_make_df_part(self):
-        codes = ['025320', '000040', '060280', '003240']
-        from multiprocessing import Queue
-        q = Queue()
-        eval._make_df_part(addr, codes, q)
-
-    def test_get_df(self):
-        print(eval.make_today_eval_df(client, refresh=True))
-        print(eval.make_today_eval_df(client, refresh=False))
-
-
-class SpacTest(unittest.TestCase):
-    def test_valid_spac(self):
-        for code, name, price in eval.yield_valid_spac(client):
-            print(code, name, price)
-
-
-
-
-def mil(code: str) -> Tuple[int, int, int, int]:
-    """
-    - 재무활동현금흐름이 마이너스라는 것은 배당급 지급했거나, 자사주 매입했거나, 부채를 상환한 상태임.
-    - 반대는 채권자로 자금을 조달했거나 신주를 발행했다는 의미
-    <주주수익률> - 재무활동현금흐름/시가총액 => 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배이하 추천
-
-    Returns:
-        tuple: 주주수익률, 이익지표, 투자수익률, PFCF포인트
-    """
-    mil_dict = eval.mil(code)
-
-    print(pprint.pformat(mil_dict, width=200))
-
-    # 주주수익률 평가
-    if math.isnan(mil_dict['주주수익률']):
-        score1 = 0
-    else:
-        주주수익률평가 = math.ceil(mil_dict['주주수익률'] - (eval.EXPECT_EARN * 100))
-        score1 = 0 if 0 > 주주수익률평가 else 주주수익률평가
-
-    # 이익지표 평가
-    score2 = 10 if mil_dict['이익지표'] < 0 else 0
-
-    # 투자수익률 평가
-    MAX3 = 20
-    score3 = 0
-    roic = mil_dict['투자수익률']['ROIC']
-    roe = mil_dict['투자수익률']['ROE']
-    if math.isnan(roic) or roic <= 0:
-        # roic 가 비정상이라 평가할 수 없는 경우
-        if 10 < roe <= 20:
-            score3 += round(MAX3 * 0.333)
-        elif 20 < roe:
-            score3 += round(MAX3 * 0.666)
-    elif 0 < roic:
-        # roic 로 평가할 수 있는 경우
-        if 0 < roic <= 15:
-            score3 += round(MAX3 * 0.333)
-        elif 15 < roic <= 30:
-            score3 += round(MAX3 * 0.666)
-        elif 30 < roic:
-            score3 += MAX3
-
-    # PFCF 평가
-    pfcf_dict = mil_dict['가치지표']['PFCF']
-    _, pfcf = mongo.Corps.latest_value(pfcf_dict)
-
-    logger.debug(f'recent pfcf {_}, {pfcf}')
-    try:
-        p = round(-40 * math.log10(pfcf) + 40)
-    except ValueError:
-        p = 0
-    score4 = 0 if 0 > p else p
-
-    return score1, score2, score3, score4
-
-
-
-
-def dbmanager():
-    cmd = ['repair', 'sync', 'eval', 'update']
-    parser = argparse.ArgumentParser()
-    parser.add_argument('cmd', help=f"Command - {cmd}")
-    parser.add_argument('target', help="Target for scraping (type 6digit code or 'all' or 'parts')")
-    parser.add_argument('-d', '--db_path', help="Set mongo database path")
-
-    args = parser.parse_args()
-
-    db_path = args.db_path if args.db_path else "mongodb://192.168.0.173:27017"
-    client = mongo.connect_mongo(db_path)
-
-    if args.cmd in cmd:
-        if args.cmd == 'repair':
-            if args.target == 'all' or utils.is_6digit(args.target):
-                need_for_repair_codes = chk_db.chk_integrity_corps(client, args.target)
-                # repair dict 예시 - {'343510': ['c106', 'c104', 'c103'], '298000': ['c104'], '091810': ['c104']}
-                print(f"Need for repairing codes :{need_for_repair_codes}")
-                if need_for_repair_codes:
-                    # x = input("Do you want to try to repair db by scraping? (y/N)")
-                    # if x == 'y' or x == 'Y':
-                        for code, failed_page_list in need_for_repair_codes.items():
-                            for page in failed_page_list:
-                                if page == 'c101':
-                                    nfsrun.c101([code, ], db_path)
-                                elif page == 'c103':
-                                    nfsrun.c103([code, ], db_path)
-                                elif page == 'c104':
-                                    nfsrun.c104([code, ], db_path)
-                                elif page == 'c106':
-                                    nfsrun.c106([code, ], db_path)
-                            recheck_result = chk_db.chk_integrity_corps(client, code)
-                            if recheck_result:
-                                # 다시 스크랩해도 오류가 지속되는 경우
-                                print(f"The db integrity failure persists..{recheck_result}")
-                                # x = input(f"Do you want to delete {code} on DB? (y/N)")
-                                # if x == 'y' or x == 'Y':
-                                #    mongo.Corps.del_db(client, code)
-                                # else:
-                                #    print("Canceled.")
-                                mongo.Corps.del_db(client, code)
-                    # else:
-                    #     print("Done.")
-                else:
-                    print("Done.")
-            else:
-                print(f"Invalid target option : {args.target}")
-        elif args.cmd == 'update':
-            if args.target == 'all' or utils.is_6digit(args.target):
-                need_for_update_codes = list(chk_db.chk_modifying_corps(client, args.target).keys())
-                # need_for_update_codes 예시 - [codes....]
-                print(f"Need for updating codes :{need_for_update_codes}")
-                if need_for_update_codes:
-                    nfsrun.c103(need_for_update_codes, db_path)
-                    nfsrun.c104(need_for_update_codes, db_path)
-                    nfsrun.c106(need_for_update_codes, db_path)
-            elif args.target == 'parts':
-                pass
-            else:
-                print(f"Invalid target option : {args.target}")
-        elif args.cmd == 'sync':
-            if args.target == 'all':
-                chk_db.sync_mongo_with_krx(client)
-            else:
-                print(f"The target should be 'all' in sync command.")
-        elif args.cmd == 'eval':
-            if args.target == 'all':
-                # eval을 평가해서 데이터베이스에 저장한다.
-                eval.make_today_eval_df(client, refresh=True)
-            else:
-                print(f"The target should be 'all' in sync command.")
-    else:
-        print(f"The command should be in {cmd}")
-
-    client.close()

analyser_hj3415-3.4.2.dist-info/RECORD

@@ -1,23 +0,0 @@
-analyser_hj3415/__init__.py,sha256=jqHEUoBeihYOMaS0bPOe3nRVXBufZ0clxc6M6jxPY0o,320
-analyser_hj3415/cli.py,sha256=dnmhYBucWWNYsnyf0xVHcx87j7rciG7T2omD3_oGiYk,12300
-analyser_hj3415/analyser/__init__.py,sha256=N0XyBfWJNpDS_6JYziKETWePO_jtFB1m7E8Qbwt1w0Q,1096
-analyser_hj3415/analyser/compile.py,sha256=wMTuVadcSODHjjTP5ma_GuygujqCeYDQkad2rAsCprw,12535
-analyser_hj3415/analyser/eval/__init__.py,sha256=IP1d0Q3nOCAD3zK1qxrC685MkJQfUh-qaXc7xptTxk8,80
-analyser_hj3415/analyser/eval/blue.py,sha256=p9_ddqLMJGq5HSn6NApuLhrX29qD--AASig9F71eb8I,10952
-analyser_hj3415/analyser/eval/common.py,sha256=sNXapoofShA43ww_SLjXmIjkrAr1AhAcezdaN_X_3Us,11443
-analyser_hj3415/analyser/eval/growth.py,sha256=sfJ7h06efrTfL4ylhUCV525IzUzilbun1ya9r5SVCtU,6526
-analyser_hj3415/analyser/eval/mil.py,sha256=mFMiFCuCBvlQrhQcM5hMg8U4zF32TS1GnUmk8fPd950,15178
-analyser_hj3415/analyser/eval/red.py,sha256=8aJPpiVzLOZtt6kILCzqcfL8BrEVgIld1iI3StGvg8A,12193
-analyser_hj3415/analyser/tsa/__init__.py,sha256=pg20ZQRABedTdaIoOr5t043RNKtJ7ji_WmnZrD1IhPg,147
-analyser_hj3415/analyser/tsa/common.py,sha256=OnsZ_cFYmNzmk0tV5qSqVW-5jJyrwMWHguWdS2Z6fvY,979
-analyser_hj3415/analyser/tsa/lstm.py,sha256=P8peqg6ZUpCSNKupjFlyba3xbPZoYtpd2UihXib_4Do,28548
-analyser_hj3415/analyser/tsa/prophet.py,sha256=AlDU6YmjSf094diTVpMe0w06Z-FZ_2KAsDm2rshzxpA,16957
-analyser_hj3415/workroom/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-analyser_hj3415/workroom/mysklearn.py,sha256=wJXKz5MqqTzADdG2mqRMMzc_G9RzwYjj5_j4gyOopxQ,2030
-analyser_hj3415/workroom/mysklearn2.py,sha256=1lIy6EWEQHkOzDS-av8U0zQH6DuCLKWMI73dnJx5KRs,1495
-analyser_hj3415/workroom/score.py,sha256=P6nHBJYmyhigGtT4qna4BmNtvt4B93b7SKyzdstJK24,17376
-analyser_hj3415/workroom/trash.py,sha256=zF-W0piqkGr66UP6-iybo9EXh2gO0RP6R1FnIpsGkl8,12262
-analyser_hj3415-3.4.2.dist-info/entry_points.txt,sha256=ZfjPnJuH8SzvhE9vftIPMBIofsc65IAWYOhqOC_L5ck,65
-analyser_hj3415-3.4.2.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-analyser_hj3415-3.4.2.dist-info/METADATA,sha256=F3_EIBCZD-sDpwathQJp9cCa_yF46fgHDegSF_FPeB8,6777
-analyser_hj3415-3.4.2.dist-info/RECORD,,