analyser_hj3415 2.0.0__py2.py3-none-any.whl

analyser_hj3415/analyser/cli.py

@@ -0,0 +1,109 @@
+import argparse
+from utils_hj3415 import utils
+from .db import chk_db, mongo
+from . import eval, report
+from scraper2_hj3415.nfscrapy import run as nfsrun
+
+
+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()
+
+
+def evalmanager():
+    cmd = ['report', ]
+    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 == 'report':
+            if utils.is_6digit(args.target):
+                print(report.Report(client, args.target))
+            else:
+                print(f"Invalid target option : {args.target}")
+    else:
+        print(f"The command should be in {cmd}")
+
+
+if __name__ == "__main__":
+    # dbmanager()
+    evalmanager()

analyser_hj3415/analyser/db/chk_db.py

@@ -0,0 +1,240 @@
+import time
+import sys
+from _datetime import datetime
+from typing import Dict, List, Tuple, Callable
+from multiprocessing import Process, Queue
+from . import mongo
+from utils_hj3415 import utils, noti
+from scraper2_hj3415.krx import krx
+from scraper2_hj3415.nfscrapy import run as nfsrun
+from pymongo import MongoClient
+from selenium.webdriver.chrome.webdriver import WebDriver
+
+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.INFO)
+
+
+"""
+chk_integrity_corps 함수로 종목코드를 데이터베이스명으로 가지는 DB의 유효성을 검사한다. 
+"""
+
+
+def test_corp_one(client1: MongoClient, code: str, driver: WebDriver = None, waiting_time: int = 10) -> Dict[str, list]:
+    """
+    종목 하나의 컬렉션의 유효성을 검사하여 부족한 컬렉션을 딕셔너리로 만들어서 반환한다.
+    driver와 waiting_time은 본 함수에서 사용하지는 않으나 다른 함수와 인자를 맞추기위해 인자로 받아준다.
+    리턴값 - {'005930': ['c104','c103'...]}
+    """
+
+    def is_same_count_of_docs(col_name1: str, col_name2: str) -> bool:
+        logger.debug(f"In is_same_count_of_docs {code}/ {col_name1}, {col_name2}")
+        corp_one.page = col_name1
+        count_doc1 = corp_one.count_docs_in_col()
+        corp_one.page = col_name2
+        count_doc2 = corp_one.count_docs_in_col()
+        if count_doc1 == count_doc2:
+            return True
+        else:
+            return False
+
+    proper_collections = {'c101', 'c104y', 'c104q', 'c106y', 'c106q', 'c103손익계산서q', 'c103재무상태표q',
+                          'c103현금흐름표q', 'c103손익계산서y', 'c103재무상태표y', 'c103현금흐름표y'}
+
+    logger.debug('In test_corp_one function...')
+    return_dict = {}
+
+    logger.debug(f'return_dict is ... {return_dict}')
+    # 한 종목의 유효성 검사코드
+    corp_one = mongo.Corps(client1, code, 'c101')
+
+    # 차집합을 사용해서 db내에 없는 컬렉션이 있는지 확인한다.
+    set_deficient_collentions = set.difference(proper_collections, set(corp_one.list_collection_names()))
+
+    logger.debug(f'After take a set of difference : {set_deficient_collentions}')
+
+    return_dict[code] = set()
+    # 컬렉션이 아예 없는 것이 있다면 falied_codes에 추가한다.
+    if set_deficient_collentions != set():
+        for item in set_deficient_collentions:
+            # 컬렉션 이름 중 앞의 네글자만 추려서 추가해준다.(ex - c103손익계산서q -> c103)
+            return_dict[code].add(item[:4])
+
+    # 각 컬렉션의 q와 y의 도큐먼트 갯수를 비교하여 차이가 있는지 확인한다.
+    if not is_same_count_of_docs('c104y', 'c104q'):
+        return_dict[code].add('c104')
+    if not is_same_count_of_docs('c106y', 'c106q'):
+        return_dict[code].add('c106')
+    if not is_same_count_of_docs('c103손익계산서q', 'c103손익계산서y') \
+            or not is_same_count_of_docs('c103재무상태표q', 'c103재무상태표y') \
+            or not is_same_count_of_docs('c103현금흐름표y', 'c103현금흐름표q'):
+        return_dict[code].add('c103')
+
+    # 집합을 리스트로 바꿔서 다시 저장한다.
+    return_dict[code] = list(return_dict[code])
+    logger.debug(f'Going out test_corp_one : {return_dict}')
+    return return_dict
+
+
+def test_corp_one_is_modified(client: MongoClient, code: str, driver: WebDriver, waiting_time: int) -> Dict[str, bool]:
+    """
+    웹에서 스크랩한 c103손익계산서y와 데이터베이스에 있는 c103손익계산서y를 비교하여 다른지 확인하여 업데이트 유무를 반환한다.
+    리턴값 - (코드, bool-업데이트가필요한지)
+    """
+    df_online = nfsrun.scrape_c103_first_page(driver, code, waiting_time=waiting_time)
+    df_mongo = mongo.C103(client, code=code, page='c103손익계산서y').load_df()
+
+    logger.debug(df_online)
+    logger.debug(df_mongo)
+
+    return_dict = {code: not df_online.equals(df_mongo)}
+    return return_dict
+
+
+def working_with_parts(test_func: Callable[[MongoClient, str, WebDriver, int], dict], db_addr: str, divided_code_list: list, my_q: Queue, waiting_time: int):
+    # 각 코어별로 디비 클라이언트를 만들어야만 한다. 안그러면 에러발생
+    client = mongo.connect_mongo(db_addr)
+    driver = utils.get_driver()
+    t = len(divided_code_list)
+
+    failed_dict_part = {}
+
+    for i, code in enumerate(divided_code_list):
+        try:
+            failed_one_dict = test_func(client, code, driver, waiting_time)
+        except Exception as e:
+            print(f"{code} has a error : {e}", file=sys.stderr)
+            continue
+        print(f'{i + 1}/{t} {failed_one_dict}')
+        if failed_one_dict[code]:
+            # 빈리스트가 아니라면...또는 C103이 변화되었다면.. 큐에 추가한다.
+            failed_dict_part.update(failed_one_dict)
+    else:
+        # 큐에서 put은 함수 리턴처럼 함수에서 한번만 한다.
+        my_q.put(failed_dict_part)
+        driver.close()
+
+
+# 멀티프로세싱을 사용하기 위해서 독립된 함수로 제작하였음(피클링이 가능해야함)
+def chk_integrity_corps(client: MongoClient, code: str = 'all') -> Dict[str, list]:
+    """
+    몽고 디비의 corps들의 integrity 검사후 이상이 있는 코드 리스트 반환
+    이상을 찾는 방법 - 각 컬렉션이 다 있는가. 각 컬렉션에서 연도와 분기의 도큐먼트 갯수가 같은가
+    return - {'코드': ['cxxx',...], '코드': ['cxxx',...]...}
+    """
+    failed_codes = {}
+    codes_in_db = mongo.Corps.get_all_codes(client)
+    if code == 'all':
+        print('*' * 25, f"Check all Corp db integrity using multiprocess", '*' * 25)
+        print(f'Total {len(codes_in_db)} items..')
+        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=working_with_parts, args=(test_corp_one, addr, divided_list[i], q, 0)))
+        for i in range(n):
+            ths[i].start()
+
+        for i in range(n):
+            failed_codes.update(q.get())
+
+        for i in range(n):
+            ths[i].join()
+
+        logger.debug(f"failed_codes : {failed_codes}")
+        print(f'Total spent time : {round(time.time() - start_time, 2)} sec.')
+    else:
+        print('*' * 25, f"Check {code} db integrity", '*' * 25)
+        if code in codes_in_db:
+            result_dict = test_corp_one(client, code)
+            print(f'{code} : {result_dict[code]}')
+            if result_dict[code]:   # 빈리스트가 아니라면...
+                failed_codes.update(result_dict)
+
+        else:
+            Exception(f'{code} is not in db..')
+    return failed_codes
+
+
+def chk_modifying_corps(client, code: str = 'all', waiting_time: int = 60) -> Dict[str, bool]:
+    """
+    각 종목의 웹과 DB의 C103손익계산서y를 비교하여 변화가 있어 refresh가 필요한지를 반환한다.
+    """
+    failed_codes = {}
+    codes_in_db = mongo.Corps.get_all_codes(client)
+    if code == 'all':
+        print('*' * 25, f"Check all Corp db need for updating using multiprocess", '*' * 25)
+        print(f'Total {len(codes_in_db)} items..')
+        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=working_with_parts, args=(test_corp_one_is_modified, addr, divided_list[i], q, waiting_time)))
+        for i in range(n):
+            ths[i].start()
+
+        for i in range(n):
+            failed_codes.update(q.get())
+
+        for i in range(n):
+            ths[i].join()
+
+        logger.debug(f"failed_codes : {failed_codes}")
+        print(f'Total spent time : {round(time.time() - start_time, 2)} sec.')
+    else:
+        print('*' * 25, f"Check {code} db need for updating ", '*' * 25)
+        driver = utils.get_driver()
+        if code in codes_in_db:
+            result_dict = test_corp_one_is_modified(client, code, driver)
+            print(f'{code} : {result_dict[code]}')
+            if result_dict[code]:
+                failed_codes.update(result_dict)
+
+        else:
+            Exception(f'{code} is not in db..')
+    return failed_codes
+
+
+def sync_mongo_with_krx(client):
+    print('*' * 20, 'Sync with krx and mongodb', '*' * 20)
+    all_codes_in_db = mongo.Corps.get_all_codes(client)
+    print('*' * 20, 'Refreshing krx.db...', '*' * 20)
+    krx.make_db()
+    print('*' * 80)
+    all_codes_in_krx = krx.get_codes()
+    print('\tThe number of codes in krx: ', len(all_codes_in_krx))
+    logger.debug(all_codes_in_krx)
+    try:
+        print('\tThe number of dbs in mongo: ', len(all_codes_in_db))
+        logger.debug(all_codes_in_db)
+    except TypeError:
+        err_msg = "Error while sync mongo data...it's possible mongo db doesn't set yet.."
+        logger.error(err_msg)
+        noti.telegram_to(botname='manager', text=err_msg)
+        return
+    del_targets = list(set(all_codes_in_db) - set(all_codes_in_krx))
+    add_targets = list(set(all_codes_in_krx) - set(all_codes_in_db))
+    print('\tDelete target: ', del_targets)
+    print('\tAdd target: ', add_targets)
+
+    for target in del_targets:
+        mongo.Corps.del_db(client, target)
+
+    if add_targets:
+        print(f'Starting.. c10346 scraper.. items : {len(add_targets)}')
+        addr = mongo.extract_addr_from_client(client)
+        nfsrun.c103(add_targets, addr)
+        nfsrun.c104(add_targets, addr)
+        nfsrun.c106(add_targets, addr)

analyser_hj3415/analyser/db/evaltools.py

@@ -0,0 +1,257 @@
+import math
+from typing import Tuple
+from collections import OrderedDict
+
+from .mongo import C101, C103, C104, Corps
+
+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 extract_valid_one(*args):
+    """
+    유틸함수
+    딕셔너리 데이터를 입력받아 하나씩 pop 하여 빈데이터가 아닌 첫번째것을 반환한다.
+    """
+    logger.debug("In extract_valid_one func...")
+    # 입력받은 데이터를 중복되는 것을 제하기 위해 집합으로 변환한다.
+    d_set = {i for i in args}
+    for i in d_set:
+        logger.debug(i)
+        # 하나씩 꺼내서 빈문자가 아니면 반환한다.
+        if i != "" and i is not math.nan and i is not None:
+            return i
+    else:
+        return None
+
+
+def calc당기순이익(client, code: str) -> Tuple[str, float]:
+    """지배지분 당기순이익 계산
+
+    일반적인 경우로는 직전 지배주주지분 당기순이익을 찾아서 반환한다.\n
+    금융기관의 경우는 지배당기순이익이 없기 때문에\n
+    계산을 통해서 간접적으로 구한다.\n
+    """
+    logger.debug(f'In the calc당기순이익... code:{code}')
+    c103q = C103(client, code, 'c103재무상태표q')
+    try:
+        profit_dict = c103q.find(title='*(지배)당기순이익')
+        logger.info(f'*(지배)당기순이익 : {profit_dict}')
+        return c103q.latest_value('*(지배)당기순이익', nan_to_zero=True)
+    except:
+        # 금융관련은 재무상태표에 지배당기순이익이 없어서 손익계산서의 당기순이익에서 비지배당기순이익을 빼서 간접적으로 구한다.
+        c103q.page = 'c103손익계산서q'
+        최근당기순이익date, 최근당기순이익value = c103q.sum_recent_4q('당기순이익', nan_to_zero=True)
+        c103q.page = 'c103재무상태표q'
+        비지배당기순이익date, 비지배당기순이익value= c103q.latest_value('*(비지배)당기순이익', nan_to_zero=True, allow_empty=True)
+
+        date = extract_valid_one(최근당기순이익date, 비지배당기순이익date)
+        계산된지배당기순이익value = 최근당기순이익value - 비지배당기순이익value
+
+        return date, 계산된지배당기순이익value
+
+
+def calc유동자산(client, code: str) -> Tuple[str, float]:
+    """유효한 유동자산 계산
+
+    일반적인 경우로 유동자산을 찾아서 반환한다.\n
+    금융기관의 경우는 간접적으로 계산한다.\n
+    Red와 Blue에서 사용한다.\n
+    """
+    logger.debug(f'In the calc유동자산... code:{code}')
+    c103q = C103(client, code, 'c103재무상태표q')
+    try:
+        asset_dict = c103q.find(title='유동자산')
+        logger.info(f'유동자산 : {asset_dict}')
+        return c103q.sum_recent_4q('유동자산', nan_to_zero=True)
+    except:
+        # 금융관련업종...
+        d1, v1 = c103q.latest_value('현금및예치금', nan_to_zero=True, allow_empty=True)
+        d2, v2 = c103q.latest_value('단기매매금융자산', nan_to_zero=True, allow_empty=True)
+        d3, v3 = c103q.latest_value('매도가능금융자산', nan_to_zero=True, allow_empty=True)
+        d4, v4 = c103q.latest_value('만기보유금융자산', nan_to_zero=True, allow_empty=True)
+        logger.debug(f'현금및예치금 : {d1}, {v1}')
+        logger.debug(f'단기매매금융자산 : {d2}, {v2}')
+        logger.debug(f'매도가능금융자산 : {d3}, {v3}')
+        logger.debug(f'만기보유금융자산 : {d4}, {v4}')
+
+        date = extract_valid_one(d1, d2, d3, d4)
+        계산된유동자산value = v1 + v2 + v3 + v4
+
+        return date, 계산된유동자산value
+
+
+def calc유동부채(client, code: str) -> Tuple[str, float]:
+    """유효한 유동부채 계산
+
+    일반적인 경우로 유동부채를 찾아서 반환한다.\n
+    금융기관의 경우는 간접적으로 계산한다.\n
+    Red와 Blue에서 사용한다.\n
+    """
+    logger.debug(f'In the calc유동부채... code:{code}')
+    c103q = C103(client, code, 'c103재무상태표q')
+    try:
+        debt_dict = c103q.find(title='유동부채')
+        logger.debug(f'유동부채 : {debt_dict}')
+        return c103q.sum_recent_4q('유동부채', nan_to_zero=True)
+    except:
+        # 금융관련업종...
+        d1, v1 = c103q.latest_value('당기손익인식(지정)금융부채', nan_to_zero=True, allow_empty=True)
+        d2, v2 = c103q.latest_value('당기손익-공정가치측정금융부채', nan_to_zero=True, allow_empty=True)
+        d3, v3 = c103q.latest_value('매도파생결합증권', nan_to_zero=True, allow_empty=True)
+        d4, v4 = c103q.latest_value('단기매매금융부채', nan_to_zero=True, allow_empty=True)
+        logger.debug(f'당기손익인식(지정)금융부채 : {d1}, {v1}')
+        logger.debug(f'당기손익-공정가치측정금융부채 : {d2}, {v2}')
+        logger.debug(f'매도파생결합증권 : {d3}, {v3}')
+        logger.debug(f'단기매매금융부채 : {d4}, {v4}')
+
+        date = extract_valid_one(d1, d2, d3, d4)
+        계산된유동부채value = v1 + v2 + v3 + v4
+
+        return date, 계산된유동부채value
+
+
+def calc비유동부채(client, code: str) -> Tuple[str, float]:
+    """유효한 비유동부채 계산
+
+    일반적인 경우로 비유동부채를 찾아서 반환한다.\n
+    금융기관의 경우는 간접적으로 계산한다.\n
+    Red와 Blue에서 사용한다.\n
+    """
+    logger.debug(f'In the calc비유동부채... code:{code}')
+    c103q = C103(client, code, 'c103재무상태표q')
+    try:
+        debt_dict = c103q.find(title='비유동부채')
+        logger.debug(f'비유동부채 : {debt_dict}')
+        return c103q.sum_recent_4q('비유동부채', nan_to_zero=True)
+    except:
+        # 금융관련업종...
+        # 보험관련업종은 예수부채가 없는대신 보험계약부채가 있다...
+        d1, v1 = c103q.latest_value('예수부채', nan_to_zero=True, allow_empty=True)
+        d2, v2 = c103q.latest_value('보험계약부채(책임준비금)', nan_to_zero=True, allow_empty=True)
+        d3, v3 = c103q.latest_value('차입부채', nan_to_zero=True, allow_empty=True)
+        d4, v4 = c103q.latest_value('기타부채', nan_to_zero=True, allow_empty=True)
+        logger.debug(f'예수부채 : {d1}, {v1}')
+        logger.debug(f'보험계약부채(책임준비금) : {d2}, {v2}')
+        logger.debug(f'차입부채 : {d3}, {v3}')
+        logger.debug(f'기타부채 : {d4}, {v4}')
+
+        date = extract_valid_one(d1, d2, d3, d4)
+        계산된비유동부채value = v1 + v2 + v3 + v4
+
+        return date, 계산된비유동부채value
+
+
+def calc유동비율(client, code: str, pop_count: int) -> Tuple[str, float]:
+    """유동비율계산 - Blue에서 사용
+
+    c104q에서 최근유동비율 찾아보고 유효하지 않거나 \n
+    100이하인 경우에는수동으로 계산해서 다시 한번 평가해 본다.\n
+    """
+    logger.debug(f'In the calc유동비율... code:{code}')
+    c104q = C104(client, code, 'c104q')
+    유동비율date, 유동비율value = c104q.latest_value('유동비율', pop_count=pop_count, allow_empty=True)
+    logger.debug(f'{code} 유동비율 : {유동비율value}({유동비율date})')
+
+    if math.isnan(유동비율value) or 유동비율value < 100:
+        logger.warning('유동비율 is under 100 or nan..so we will recalculate..')
+        유동자산date, 유동자산value = calc유동자산(client, code)
+        유동부채date, 유동부채value = calc유동부채(client, code)
+
+        c103q = C103(client, code, 'c103현금흐름표q')
+        추정영업현금흐름date, 추정영업현금흐름value = c103q.sum_recent_4q('영업활동으로인한현금흐름')
+        logger.debug(f'{code} 계산전 유동비율 : {유동비율value}({유동비율date})')
+
+        계산된유동비율 = 0
+        try:
+            계산된유동비율 = round(((유동자산value + 추정영업현금흐름value) / 유동부채value) * 100, 2)
+        except ZeroDivisionError:
+            logger.debug(f'유동자산: {유동자산value} + 추정영업현금흐름: {추정영업현금흐름value} / 유동부채: {유동부채value}')
+            계산된유동비율 = float('inf')
+        finally:
+            logger.debug(f'{code} 계산된 유동비율 : {계산된유동비율}')
+            return extract_valid_one(유동자산date, 유동부채date, 추정영업현금흐름date), 계산된유동비율
+    else:
+        return 유동비율date, 유동비율value
+
+
+def findFCF(client, code: str) -> dict:
+    """FCF 계산
+
+    FCF = 영업활동현금흐름 - CAPEX\n
+    영업활동현금흐름에서 CAPEX 를 각 연도별로 빼주어 fcf 를 구하고 딕셔너리로 반환한다.\n
+
+    Returns:
+        dict: 계산된 fcf 딕셔너리 또는 영업현금흐름 없는 경우 - {}
+
+    Note:
+        CAPEX 가 없는 업종은 영업활동현금흐름을 그대로 사용한다.\n
+
+    """
+    c103y = C103(client, code, 'c103현금흐름표y')
+    영업활동현금흐름_dict = c103y.find(title='영업활동으로인한현금흐름', allow_empty=True)
+    c103y.page = 'c103재무상태표y'
+    capex = c103y.find(title='*CAPEX', allow_empty=True)
+
+    logger.debug(f'영업활동현금흐름 {영업활동현금흐름_dict}')
+    logger.debug(f'CAPEX {capex}')
+
+    if len(영업활동현금흐름_dict) == 0:
+        return {}
+
+    if len(capex) == 0:
+        # CAPEX 가 없는 업종은 영업활동현금흐름을 그대로 사용한다.
+        return 영업활동현금흐름_dict
+
+    # 영업 활동으로 인한 현금 흐름에서 CAPEX 를 각 연도별로 빼주어 fcf 를 구하고 리턴값으로 fcf 딕셔너리를 반환한다.
+    r_dict = {}
+    for i in range(len(영업활동현금흐름_dict)):
+        # 영업활동현금흐름에서 아이템을 하나씩 꺼내서 CAPEX 전체와 비교하여 같으면 차를 구해서 r_dict 에 추가한다.
+        영업활동현금흐름date, 영업활동현금흐름value = 영업활동현금흐름_dict.popitem()
+        # 해당 연도의 capex 가 없는 경우도 있어 일단 capex를 0으로 치고 먼저 추가한다.
+        r_dict[영업활동현금흐름date] = 영업활동현금흐름value
+        for CAPEXdate, CAPEXvalue in capex.items():
+            if 영업활동현금흐름date == CAPEXdate:
+                r_dict[영업활동현금흐름date] = round(영업활동현금흐름value - CAPEXvalue, 2)
+    logger.debug(f'r_dict {r_dict}')
+    # 연도순으로 정렬해서 딕셔너리로 반환한다.
+    return dict(sorted(r_dict.items(), reverse=False))
+
+
+def findPFCF(client, code: str) -> dict:
+    """Price to Free Cash Flow Ratio 계산
+
+    PFCF = 시가총액 / FCF
+
+    Note:
+        https://www.investopedia.com/terms/p/pricetofreecashflow.asp
+    """
+    # marketcap 계산 (fcf가 억 단위라 시가총액을 억으로 나눠서 단위를 맞춰 준다)
+    marketcap억 = get_marketcap(client, code) / 100000000
+    if math.isnan(marketcap억):
+        return {}
+
+    # pfcf 계산
+    fcf_dict = findFCF(client, code)
+    logger.debug(f'fcf_dict : {fcf_dict}')
+    pfcf_dict = {}
+    for FCFdate, FCFvalue in fcf_dict.items():
+        if FCFvalue == 0:
+            pfcf_dict[FCFdate] = math.nan
+        else:
+            pfcf_dict[FCFdate] = round(marketcap억 / FCFvalue, 2)
+    logger.debug(f'pfcf_dict : {pfcf_dict}')
+    return pfcf_dict
+
+
+def get_marketcap(client, code: str, nan_to_zero: bool = False) -> int:
+    c101 = C101(client, code)
+    try:
+        return int(c101.get_recent()['시가총액'])
+    except KeyError:
+        return 0 if nan_to_zero else math.nan