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

analyser_hj3415/{db/evaltools.py → tools.py}

@@ -1,10 +1,9 @@
 import math
 from typing import Tuple
-from collections import OrderedDict
-
-from .mongo import C101, C103, C104, Corps
+from db_hj3415.myredis import C101, C103, C104
 
 import logging
+
 logger = logging.getLogger(__name__)
 formatter = logging.Formatter('%(levelname)s: [%(name)s] %(message)s')
 ch = logging.StreamHandler()
@@ -13,24 +12,16 @@ logger.addHandler(ch)
 logger.setLevel(logging.WARNING)
 
 
-def extract_valid_one(*args):
+def set_data(*args) -> list:
     """
-    유틸함수
-    딕셔너리 데이터를 입력받아 하나씩 pop 하여 빈데이터가 아닌 첫번째것을 반환한다.
+    비유효한 내용 제거(None,nan)하고 중복된 항목 제거하고 리스트로 반환한다.
+    :param args:
+    :return:
     """
-    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
+    return [i for i in {*args} if i != "" and i is not math.nan and i is not None]
 
 
-def calc당기순이익(client, code: str) -> Tuple[str, float]:
+def calc당기순이익(code: str) -> Tuple[str, float]:
     """지배지분 당기순이익 계산
 
     일반적인 경우로는 직전 지배주주지분 당기순이익을 찾아서 반환한다.\n
@@ -38,25 +29,24 @@ def calc당기순이익(client, code: str) -> Tuple[str, float]:
     계산을 통해서 간접적으로 구한다.\n
     """
     logger.debug(f'In the calc당기순이익... code:{code}')
-    c103q = C103(client, code, 'c103재무상태표q')
+    c103q = C103(code, 'c103재무상태표q')
     try:
-        profit_dict = c103q.find(title='*(지배)당기순이익')
-        logger.info(f'*(지배)당기순이익 : {profit_dict}')
-        return c103q.latest_value('*(지배)당기순이익', nan_to_zero=True)
+        return c103q.latest_value_pop2('*(지배)당기순이익')
     except:
-        # 금융관련은 재무상태표에 지배당기순이익이 없어서 손익계산서의 당기순이익에서 비지배당기순이익을 빼서 간접적으로 구한다.
+        logger.warning(f"{code} - (지배)당기순이익이 없는 종목. 수동으로 계산합니다(금융관련업종일 가능성있음).")
         c103q.page = 'c103손익계산서q'
-        최근당기순이익date, 최근당기순이익value = c103q.sum_recent_4q('당기순이익', nan_to_zero=True)
+        최근당기순이익date, 최근당기순이익value = c103q.sum_recent_4q('당기순이익')
         c103q.page = 'c103재무상태표q'
-        비지배당기순이익date, 비지배당기순이익value= c103q.latest_value('*(비지배)당기순이익', nan_to_zero=True, allow_empty=True)
+        비지배당기순이익date, 비지배당기순이익value = c103q.latest_value_pop2('*(비지배)당기순이익')
 
-        date = extract_valid_one(최근당기순이익date, 비지배당기순이익date)
+        # 가변리스트 언패킹으로 하나의 날짜만 사용하고 나머지는 버린다.
+        date, *_ = set_data(최근당기순이익date, 비지배당기순이익date)
         계산된지배당기순이익value = 최근당기순이익value - 비지배당기순이익value
 
         return date, 계산된지배당기순이익value
 
 
-def calc유동자산(client, code: str) -> Tuple[str, float]:
+def calc유동자산(code: str) -> Tuple[str, float]:
     """유효한 유동자산 계산
 
     일반적인 경우로 유동자산을 찾아서 반환한다.\n
@@ -64,29 +54,27 @@ def calc유동자산(client, code: str) -> Tuple[str, float]:
     Red와 Blue에서 사용한다.\n
     """
     logger.debug(f'In the calc유동자산... code:{code}')
-    c103q = C103(client, code, 'c103재무상태표q')
+    c103q = C103(code, 'c103재무상태표q')
     try:
-        asset_dict = c103q.find(title='유동자산')
-        logger.info(f'유동자산 : {asset_dict}')
-        return c103q.sum_recent_4q('유동자산', nan_to_zero=True)
+        return c103q.sum_recent_4q('유동자산')
     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.warning(f"{code} - 유동자산이 없는 종목. 수동으로 계산합니다(금융관련업종일 가능성있음).")
+        d1, v1 = c103q.latest_value_pop2('현금및예치금')
+        d2, v2 = c103q.latest_value_pop2('단기매매금융자산')
+        d3, v3 = c103q.latest_value_pop2('매도가능금융자산')
+        d4, v4 = c103q.latest_value_pop2('만기보유금융자산')
         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)
+        date, *_ = set_data(d1, d2, d3, d4)
         계산된유동자산value = v1 + v2 + v3 + v4
 
         return date, 계산된유동자산value
 
 
-def calc유동부채(client, code: str) -> Tuple[str, float]:
+def calc유동부채(code: str) -> Tuple[str, float]:
     """유효한 유동부채 계산
 
     일반적인 경우로 유동부채를 찾아서 반환한다.\n
@@ -94,29 +82,27 @@ def calc유동부채(client, code: str) -> Tuple[str, float]:
     Red와 Blue에서 사용한다.\n
     """
     logger.debug(f'In the calc유동부채... code:{code}')
-    c103q = C103(client, code, 'c103재무상태표q')
+    c103q = C103(code, 'c103재무상태표q')
     try:
-        debt_dict = c103q.find(title='유동부채')
-        logger.debug(f'유동부채 : {debt_dict}')
-        return c103q.sum_recent_4q('유동부채', nan_to_zero=True)
+        return c103q.sum_recent_4q('유동부채')
     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.warning(f"{code} - 유동부채가 없는 종목. 수동으로 계산합니다(금융관련업종일 가능성있음).")
+        d1, v1 = c103q.latest_value_pop2('당기손익인식(지정)금융부채')
+        d2, v2 = c103q.latest_value_pop2('당기손익-공정가치측정금융부채')
+        d3, v3 = c103q.latest_value_pop2('매도파생결합증권')
+        d4, v4 = c103q.latest_value_pop2('단기매매금융부채')
         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)
+        date, *_ = set_data(d1, d2, d3, d4)
         계산된유동부채value = v1 + v2 + v3 + v4
 
         return date, 계산된유동부채value
 
 
-def calc비유동부채(client, code: str) -> Tuple[str, float]:
+def calc비유동부채(code: str) -> Tuple[str, float]:
     """유효한 비유동부채 계산
 
     일반적인 경우로 비유동부채를 찾아서 반환한다.\n
@@ -124,46 +110,44 @@ def calc비유동부채(client, code: str) -> Tuple[str, float]:
     Red와 Blue에서 사용한다.\n
     """
     logger.debug(f'In the calc비유동부채... code:{code}')
-    c103q = C103(client, code, 'c103재무상태표q')
+    c103q = C103(code, 'c103재무상태표q')
     try:
-        debt_dict = c103q.find(title='비유동부채')
-        logger.debug(f'비유동부채 : {debt_dict}')
-        return c103q.sum_recent_4q('비유동부채', nan_to_zero=True)
+        return c103q.sum_recent_4q('비유동부채')
     except:
-        # 금융관련업종...
+        logger.warning(f"{code} - 비유동부채가 없는 종목. 수동으로 계산합니다(금융관련업종일 가능성있음).")
         # 보험관련업종은 예수부채가 없는대신 보험계약부채가 있다...
-        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)
+        d1, v1 = c103q.latest_value_pop2('예수부채')
+        d2, v2 = c103q.latest_value_pop2('보험계약부채(책임준비금)')
+        d3, v3 = c103q.latest_value_pop2('차입부채')
+        d4, v4 = c103q.latest_value_pop2('기타부채')
         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)
+        date, *_ = set_data(d1, d2, d3, d4)
         계산된비유동부채value = v1 + v2 + v3 + v4
 
         return date, 계산된비유동부채value
 
 
-def calc유동비율(client, code: str, pop_count: int) -> Tuple[str, float]:
+def calc유동비율(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)
+    c104q = C104(code, 'c104q')
+    유동비율date, 유동비율value = c104q.mymongo_c1034.latest_value('유동비율', pop_count=pop_count)
     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)
+        유동자산date, 유동자산value = calc유동자산(code)
+        유동부채date, 유동부채value = calc유동부채(code)
 
-        c103q = C103(client, code, 'c103현금흐름표q')
+        c103q = C103(code, 'c103현금흐름표q')
         추정영업현금흐름date, 추정영업현금흐름value = c103q.sum_recent_4q('영업활동으로인한현금흐름')
         logger.debug(f'{code} 계산전 유동비율 : {유동비율value}({유동비율date})')
 
@@ -175,17 +159,36 @@ def calc유동비율(client, code: str, pop_count: int) -> Tuple[str, float]:
             계산된유동비율 = float('inf')
         finally:
             logger.debug(f'{code} 계산된 유동비율 : {계산된유동비율}')
-            return extract_valid_one(유동자산date, 유동부채date, 추정영업현금흐름date), 계산된유동비율
+            date, *_ = set_data(유동자산date, 유동부채date, 추정영업현금흐름date)
+            return date, 계산된유동비율
     else:
         return 유동비율date, 유동비율value
 
 
-def findFCF(client, code: str) -> dict:
-    """FCF 계산
+"""
+FCF는 “Free Cash Flow”의 약자로, 한국어로는 “자유 현금 흐름”이라고 합니다. FCF는 기업이 운영 활동을 통해 창출한 현금 중에서 영업 및 자본적 지출을
+ 제외하고 남은 현금을 의미합니다. 이는 기업의 재무 건전성을 평가하는 중요한 지표로 사용됩니다. 자유 현금 흐름은 기업이 부채를 상환하고, 배당금을 지급하며,
+  추가적인 투자를 할 수 있는 자금을 나타냅니다.
+  
+FCF의 중요성
 
-    FCF = 영업활동현금흐름 - CAPEX\n
-    영업활동현금흐름에서 CAPEX 를 각 연도별로 빼주어 fcf 를 구하고 딕셔너리로 반환한다.\n
+1.	재무 건전성 평가: FCF는 기업이 실제로 얼마나 많은 현금을 창출하고 있는지를 보여줍니다. 이는 기업의 재무 건전성을 평가하는 데 중요한 지표입니다.
+2.	투자 결정: 투자자들은 FCF를 통해 기업의 성장 가능성을 평가하고, 투자 결정을 내리는 데 참고합니다.
+3.	배당 지급 능력: FCF는 기업이 주주들에게 배당금을 지급할 수 있는 능력을 나타냅니다.
+4.	부채 상환: 기업은 FCF를 이용해 부채를 상환하고, 재무 구조를 개선할 수 있습니다.
 
+CAPEX는 “Capital Expenditures”의 약자로, 한국어로는 “자본적 지출”이라고 합니다. CAPEX는 기업이 장기 자산을 구입하거나 유지하는 데 사용하는 
+비용을 의미합니다. 이는 기업이 장기적인 성장을 위해 자산을 확장, 업그레이드 또는 유지하는 데 필요한 비용입니다. 이러한 자산에는 부동산, 건물, 기계,
+ 장비 등이 포함됩니다.
+ 
+ CAPEX가 거의 없거나 아예 없는 업종에서도 자유 현금 흐름(Free Cash Flow, FCF)을 계산할 수 있습니다. CAPEX가 없는 경우,
+  계산식에서 CAPEX 부분을 0으로 처리하면 됩니다.
+"""
+
+
+def findFCF(code: str) -> dict:
+    """
+    FCF 계산
     Returns:
         dict: 계산된 fcf 딕셔너리 또는 영업현금흐름 없는 경우 - {}
 
@@ -193,10 +196,10 @@ def findFCF(client, code: str) -> dict:
         CAPEX 가 없는 업종은 영업활동현금흐름을 그대로 사용한다.\n
 
     """
-    c103y = C103(client, code, 'c103현금흐름표y')
-    영업활동현금흐름_dict = c103y.find(title='영업활동으로인한현금흐름', allow_empty=True)
+    c103y = C103(code, 'c103현금흐름표y')
+    _, 영업활동현금흐름_dict = c103y.find_without_yoy('영업활동으로인한현금흐름')
     c103y.page = 'c103재무상태표y'
-    capex = c103y.find(title='*CAPEX', allow_empty=True)
+    _, capex = c103y.find_without_yoy('*CAPEX')
 
     logger.debug(f'영업활동현금흐름 {영업활동현금흐름_dict}')
     logger.debug(f'CAPEX {capex}')
@@ -206,6 +209,7 @@ def findFCF(client, code: str) -> dict:
 
     if len(capex) == 0:
         # CAPEX 가 없는 업종은 영업활동현금흐름을 그대로 사용한다.
+        logger.warning(f"{code} - CAPEX가 없는 업종으로 영업현금흐름을 그대로 사용합니다..")
         return 영업활동현금흐름_dict
 
     # 영업 활동으로 인한 현금 흐름에서 CAPEX 를 각 연도별로 빼주어 fcf 를 구하고 리턴값으로 fcf 딕셔너리를 반환한다.
@@ -223,8 +227,22 @@ def findFCF(client, code: str) -> dict:
     return dict(sorted(r_dict.items(), reverse=False))
 
 
-def findPFCF(client, code: str) -> dict:
-    """Price to Free Cash Flow Ratio 계산
+"""
+PFCF의 중요성
+1.	기업 가치 평가: PFCF는 기업이 창출하는 현금 흐름에 비해 주가가 적정한지 평가하는 데 사용됩니다. 낮은 PFCF는 주가가 상대적으로 저평가되었음을 나타낼
+ 수 있고, 높은 PFCF는 주가가 상대적으로 고평가되었음을 나타낼 수 있습니다.
+2.	투자 결정: 투자자들은 PFCF를 사용하여 현금 흐름 창출 능력 대비 주가가 매력적인지를 판단하고, 투자 결정을 내리는 데 참고합니다.
+3.	비교 분석: 같은 산업 내 다른 기업들과 비교하여, 어느 기업이 더 효율적으로 현금 흐름을 창출하는지를 평가할 수 있습니다.
+
+PFCF의 한계
+
+•산업 특성: PFCF는 산업마다 적정한 수준이 다를 수 있습니다. 예를 들어, 기술 산업과 제조 산업의 적정 PFCF는 다를 수 있습니다.
+•일회성 항목: 특정 연도의 일회성 비용이나 수익이 FCF에 영향을 미칠 수 있으며, 이는 PFCF 계산에 왜곡을 가져올 수 있습니다.
+"""
+
+
+def findPFCF(code: str) -> dict:
+    """Price to Free Cash Flow Ratio(주가 대비 자유 현금 흐름 비율)계산
 
     PFCF = 시가총액 / FCF
 
@@ -232,12 +250,12 @@ def findPFCF(client, code: str) -> dict:
         https://www.investopedia.com/terms/p/pricetofreecashflow.asp
     """
     # marketcap 계산 (fcf가 억 단위라 시가총액을 억으로 나눠서 단위를 맞춰 준다)
-    marketcap억 = get_marketcap(client, code) / 100000000
+    marketcap억 = get_marketcap(code) / 100000000
     if math.isnan(marketcap억):
         return {}
 
     # pfcf 계산
-    fcf_dict = findFCF(client, code)
+    fcf_dict = findFCF(code)
     logger.debug(f'fcf_dict : {fcf_dict}')
     pfcf_dict = {}
     for FCFdate, FCFvalue in fcf_dict.items():
@@ -249,9 +267,14 @@ def findPFCF(client, code: str) -> dict:
     return pfcf_dict
 
 
-def get_marketcap(client, code: str, nan_to_zero: bool = False) -> int:
-    c101 = C101(client, code)
+def get_marketcap(code: str) -> float:
+    """
+    시가총액(원) 반환
+    :param code:
+    :return:
+    """
+    c101 = C101(code)
     try:
         return int(c101.get_recent()['시가총액'])
     except KeyError:
-        return 0 if nan_to_zero else math.nan
+        return math.nan

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.1.dist-info → analyser_hj3415-2.1.0.dist-info}/METADATA

@@ -1,15 +1,12 @@
 Metadata-Version: 2.1
 Name: analyser_hj3415
-Version: 2.0.1
+Version: 2.1.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>=0.4.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.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+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/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=DoLac-PXQrA-GfkEHRD52R-8FFJD-eYLCPTg3oEkNGA,16213
+analyser_hj3415-2.1.0.dist-info/entry_points.txt,sha256=dHaCM3eOAGONmxTWuRVqo9Zyq2C7J5TZmpH0PD6FW5k,103
+analyser_hj3415-2.1.0.dist-info/LICENSE,sha256=QVKTp0dTnB5xG8RLgG17LwSWCKNEzYoVVM6KjoCPKc0,1079
+analyser_hj3415-2.1.0.dist-info/WHEEL,sha256=Sgu64hAMa6g5FdzHxXv9Xdse9yxpGGMeagVtPMWpJQY,99
+analyser_hj3415-2.1.0.dist-info/METADATA,sha256=h7E4uyJhGWiRAOVfZ-ApChWxDfm8pOi8Iu-iz1Byqpg,6417
+analyser_hj3415-2.1.0.dist-info/RECORD,,