analyser_hj3415 2.0.2__py2.py3-none-any.whl → 2.2.0__py2.py3-none-any.whl

analyser_hj3415/trash.py

@@ -0,0 +1,210 @@
+
+
+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

{analyser_hj3415-2.0.2.dist-info → analyser_hj3415-2.2.0.dist-info}/METADATA

@@ -1,15 +1,12 @@
 Metadata-Version: 2.1
 Name: analyser_hj3415
-Version: 2.0.2
+Version: 2.2.0
 Summary: Stock analyser and database processing programs
 Author-email: Hyungjin Kim <hj3415@gmail.com>
 Description-Content-Type: text/markdown
 Classifier: License :: OSI Approved :: MIT License
-Requires-Dist: pandas>=2.2.2
-Requires-Dist: pymongo>=4.8.0
-Requires-Dist: sqlalchemy>=2.0.31
-Requires-Dist: utils-hj3415>=2.0.1
-Requires-Dist: scraper2-hj3415>=2.0.0
+Requires-Dist: utils-hj3415>=2.6.0
+Requires-Dist: db-hj3415>=3.3.2
 Project-URL: Home, https://www.hyungjin.kr
 
 ### analyser-hj3415
@@ -20,12 +17,11 @@ analyser_hj3415 manage the database.
 ---
 #### Requirements
 
-scrapy>=2.11.2
 pandas>=2.2.2
+pymongo>=4.8.0
 sqlalchemy>=2.0.31
-selenium>=4.22.0
 utils-hj3415>=2.0.1
-analyser_hj3415>=0.3.5
+scraper-hj3415>=2.0.0
 
 ---
 #### API

analyser_hj3415-2.2.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+analyser_hj3415/.DS_Store,sha256=OQfTSOHL-zjUtnNyBpNRVUJUstR4j6I7jihKDFQQmME,6148
+analyser_hj3415/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+analyser_hj3415/cli.py,sha256=qzRnpDRJvQnQevSKHBpKbTsBjmSWllZjzTV4z_alg2A,4891
+analyser_hj3415/myredis.py,sha256=zgsXO4G2VsXt4LID4VF-Y7AqkPjV8Th66a2czuma_bM,8738
+analyser_hj3415/run.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+analyser_hj3415/tools.py,sha256=SNsrnL5CKmKAdFkmlwgREMIkWDRi6N9LngCdhhhop3Y,13606
+analyser_hj3415/trash.py,sha256=vHrv8Q61QOkcwhmWfrj_yVdsdd5MoAxs9gXMOJEjMHM,8360
+analyser_hj3415/analysers/eval.py,sha256=mlHi6EPc8l8O6vKnWyX4Cz1BaeGhUpWM8gVZRNhm-JU,13299
+analyser_hj3415/analysers/report.py,sha256=whggmLXl7yF-BjQ6JKgxmhILT2T4uFP-rit_BSes9xM,9189
+analyser_hj3415/analysers/score.py,sha256=C_Xiqo44o2OAXHaHiHYLa60HwKwpUt_H18uO5Iff1TM,16308
+analyser_hj3415-2.2.0.dist-info/entry_points.txt,sha256=dHaCM3eOAGONmxTWuRVqo9Zyq2C7J5TZmpH0PD6FW5k,103
+analyser_hj3415-2.2.0.dist-info/LICENSE,sha256=QVKTp0dTnB5xG8RLgG17LwSWCKNEzYoVVM6KjoCPKc0,1079
+analyser_hj3415-2.2.0.dist-info/WHEEL,sha256=Sgu64hAMa6g5FdzHxXv9Xdse9yxpGGMeagVtPMWpJQY,99
+analyser_hj3415-2.2.0.dist-info/METADATA,sha256=OJhj-1acjb5Ht817i0tzqYdLUkA94NpGVZ-dclMstKo,6417
+analyser_hj3415-2.2.0.dist-info/RECORD,,

analyser_hj3415/db/chk_db.py

@@ -1,240 +0,0 @@
-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)