analyser_hj3415 2.10.5__py3-none-any.whl → 3.0.0__py3-none-any.whl

analyser_hj3415/analyser/eval/mil.py

@@ -0,0 +1,274 @@
+import os
+from dataclasses import dataclass, asdict
+from typing import Tuple
+import math
+
+from utils_hj3415 import tools, setup_logger
+from db_hj3415 import myredis, mymongo
+
+from analyser_hj3415.analyser.eval.common import Tools
+
+
+mylogger = setup_logger(__name__,'WARNING')
+expire_time = tools.to_int(os.getenv('DEFAULT_EXPIRE_TIME_H', 48)) * 3600
+
+
+@dataclass
+class MilData:
+    code: str
+    name: str
+
+    시가총액억: float
+
+    주주수익률: float
+    재무활동현금흐름: float
+
+    이익지표: float
+    영업활동현금흐름: float
+    지배주주당기순이익: float
+
+    #투자수익률
+    roic_r: float
+    roic_dict: dict
+    roe_r: float
+    roe_106: dict
+    roa_r: float
+
+    #가치지표
+    fcf_dict: dict
+    pfcf_dict: dict
+    pcr_dict: dict
+
+    score: list
+    date: list
+
+
+class Mil:
+    def __init__(self, code: str):
+        assert tools.is_6digit(code), f'Invalid value : {code}'
+        mylogger.debug(f"Mil : 종목코드 ({code})")
+
+        self.c101 = myredis.C101(code)
+        self.c103 = myredis.C103(code, 'c103현금흐름표q')
+        self.c104 = myredis.C104(code, 'c104q')
+        self.c106 = myredis.C106(code, 'c106q')
+
+        self.name = self.c101.get_name()
+        self._code = code
+
+    def __str__(self):
+        return f"Mil({self.code}/{self.name})"
+
+    @property
+    def code(self) -> str:
+        return self._code
+
+    @code.setter
+    def code(self, code: str):
+        assert tools.is_6digit(code), f'Invalid value : {code}'
+        mylogger.debug(f"Mil : 종목코드 변경({self.code} -> {code})")
+
+        self.c101.code = code
+        self.c103.code = code
+        self.c104.code = code
+        self.c106.code = code
+
+        self.name = self.c101.get_name()
+        self._code = code
+
+    def get_marketcap억(self, refresh: bool) -> float:
+        """
+        시가총액(억원) 반환
+        :return:
+        """
+        c101r = self.c101.get_recent(refresh)
+        시가총액 = tools.to_int(tools.to_float(c101r.get('시가총액', math.nan)) / 100000000)
+        mylogger.debug(f"시가총액: {시가총액}억원")
+        return 시가총액
+
+    def _calc주주수익률(self, 시가총액_억: float, refresh: bool) -> Tuple[str, float, float]:
+        self.c103.page = 'c103현금흐름표q'
+        d, 재무활동현금흐름 = self.c103.sum_recent_4q('재무활동으로인한현금흐름', refresh)
+        try:
+            주주수익률 = round((재무활동현금흐름 / 시가총액_억 * -100), 2)
+        except ZeroDivisionError:
+            주주수익률 = math.nan
+            mylogger.warning(f'{self} 주주수익률: {주주수익률} 재무활동현금흐름: {재무활동현금흐름}')
+        return d, 주주수익률, 재무활동현금흐름
+
+    def _calc이익지표(self, 시가총액_억: float, refresh: bool) -> Tuple[str, float, float, float]:
+        d1, 지배주주당기순이익 = Tools.calc당기순이익(self.c103, refresh)
+        self.c103.page = 'c103현금흐름표q'
+        d2, 영업활동현금흐름 = self.c103.sum_recent_4q('영업활동으로인한현금흐름', refresh)
+        try:
+            이익지표 = round(((지배주주당기순이익 - 영업활동현금흐름) / 시가총액_억) * 100, 2)
+        except ZeroDivisionError:
+            이익지표 = math.nan
+            mylogger.warning(f'{self} 이익지표: {이익지표} 영업활동현금흐름: {영업활동현금흐름} 지배주주당기순이익: {지배주주당기순이익}')
+        try:
+            date, *_ = Tools.date_set(d1, d2)
+        except ValueError:
+            # 날짜 데이터가 없는경우
+            date = ''
+        return date , 이익지표, 영업활동현금흐름, 지배주주당기순이익
+
+    def _calc투자수익률(self, refresh: bool) -> tuple:
+        self.c104.page = 'c104q'
+        self.c106.page = 'c106q'
+        d1, roic_r = self.c104.sum_recent_4q('ROIC', refresh)
+        _, roic_dict = self.c104.find('ROIC', remove_yoy=True, del_unnamed_key=True, refresh=refresh)
+        d2, roe_r = self.c104.latest_value_pop2('ROE', refresh)
+        roe106 = self.c106.find('ROE', refresh)
+        d3, roa_r = self.c104.latest_value_pop2('ROA', refresh)
+
+        try:
+            date, *_ = Tools.date_set(d1, d2, d3)
+        except ValueError:
+            # 날짜 데이터가 없는경우
+            date = ''
+
+        return date, roic_r, roic_dict, roe_r, roe106, roa_r
+
+    def _calcFCF(self, refresh: bool) -> dict:
+        """
+        FCF 계산
+        Returns:
+            dict: 계산된 fcf 딕셔너리 또는 영업현금흐름 없는 경우 - {}
+
+        Note:
+            CAPEX 가 없는 업종은 영업활동현금흐름을 그대로 사용한다.\n
+
+        """
+        self.c103.page = 'c103현금흐름표y'
+        _, 영업활동현금흐름_dict = self.c103.find('영업활동으로인한현금흐름', remove_yoy=True, del_unnamed_key=True, refresh=refresh)
+
+        self.c103.page = 'c103재무상태표y'
+        _, capex = self.c103.find('*CAPEX', remove_yoy=True, del_unnamed_key=True, refresh=refresh)
+
+        mylogger.debug(f'영업활동현금흐름 {영업활동현금흐름_dict}')
+        mylogger.debug(f'CAPEX {capex}')
+
+        if len(영업활동현금흐름_dict) == 0:
+            return {}
+
+        if len(capex) == 0:
+            # CAPEX 가 없는 업종은 영업활동현금흐름을 그대로 사용한다.
+            mylogger.warning(f"{self} - CAPEX가 없는 업종으로 영업현금흐름을 그대로 사용합니다..")
+            return 영업활동현금흐름_dict
+
+        # 영업 활동으로 인한 현금 흐름에서 CAPEX 를 각 연도별로 빼주어 fcf 를 구하고 리턴값으로 fcf 딕셔너리를 반환한다.
+        fcf_dict = {}
+        for i in range(len(영업활동현금흐름_dict)):
+            # 영업활동현금흐름에서 아이템을 하나씩 꺼내서 CAPEX 전체와 비교하여 같으면 차를 구해서 fcf_dict 에 추가한다.
+            영업활동현금흐름date, 영업활동현금흐름value = 영업활동현금흐름_dict.popitem()
+            # 해당 연도의 capex 가 없는 경우도 있어 일단 capex를 0으로 치고 먼저 추가한다.
+            fcf_dict[영업활동현금흐름date] = 영업활동현금흐름value
+            for CAPEXdate, CAPEXvalue in capex.items():
+                if 영업활동현금흐름date == CAPEXdate:
+                    fcf_dict[영업활동현금흐름date] = round(영업활동현금흐름value - CAPEXvalue, 2)
+
+        mylogger.debug(f'fcf_dict {fcf_dict}')
+        # 연도순으로 정렬해서 딕셔너리로 반환한다.
+        return dict(sorted(fcf_dict.items(), reverse=False))
+
+    def _calcPFCF(self, 시가총액_억: float, fcf_dict: dict) -> dict:
+        """Price to Free Cash Flow Ratio(주가 대비 자유 현금 흐름 비율)계산
+
+            PFCF = 시가총액 / FCF
+
+            Note:
+                https://www.investopedia.com/terms/p/pricetofreecashflow.asp
+            """
+        if math.isnan(시가총액_억):
+            mylogger.warning(f"{self} - 시가총액이 nan으로 pFCF를 계산할수 없습니다.")
+            return {}
+
+        # pfcf 계산
+        pfcf_dict = {}
+        for FCFdate, FCFvalue in fcf_dict.items():
+            if FCFvalue == 0:
+                pfcf_dict[FCFdate] = math.nan
+            else:
+                pfcf_dict[FCFdate] = round(시가총액_억 / FCFvalue, 2)
+
+        pfcf_dict = mymongo.C1034.del_unnamed_key(pfcf_dict)
+
+        mylogger.debug(f'pfcf_dict : {pfcf_dict}')
+        return pfcf_dict
+
+    def _calc가치지표(self, 시가총액_억: float, refresh: bool) -> tuple:
+        self.c104.page = 'c104q'
+
+        fcf_dict = self._calcFCF(refresh)
+        pfcf_dict = self._calcPFCF(시가총액_억, fcf_dict)
+
+        d, pcr_dict = self.c104.find('PCR', remove_yoy=True, del_unnamed_key=True, refresh=refresh)
+        return d, fcf_dict, pfcf_dict, pcr_dict
+
+    def _score(self) -> list:
+        return [0,]
+
+    def _generate_data(self, refresh: bool) -> MilData:
+        mylogger.info(f"In generate_data..refresh : {refresh}")
+        시가총액_억 = self.get_marketcap억(refresh)
+        mylogger.info(f"{self} 시가총액(억) : {시가총액_억}")
+
+        d1, 주주수익률, 재무활동현금흐름 = self._calc주주수익률(시가총액_억, refresh)
+        mylogger.info(f"{self} 주주수익률 : {주주수익률}, {d1}")
+
+        d2, 이익지표, 영업활동현금흐름, 지배주주당기순이익 = self._calc이익지표(시가총액_억, refresh)
+        mylogger.info(f"{self} 이익지표 : {이익지표}, {d2}")
+
+        d3, roic_r, roic_dict, roe_r, roe106, roa_r = self._calc투자수익률(refresh)
+        d4, fcf_dict, pfcf_dict, pcr_dict = self._calc가치지표(시가총액_억, refresh)
+
+        score = self._score()
+
+        try:
+            date_list = Tools.date_set(d1, d2, d3, d4)
+        except ValueError:
+            # 날짜 데이터가 없는경우
+            date_list = ['',]
+
+        return MilData(
+            code= self.code,
+            name= self.name,
+
+            시가총액억= 시가총액_억,
+
+            주주수익률= 주주수익률,
+            재무활동현금흐름= 재무활동현금흐름,
+
+            이익지표= 이익지표,
+            영업활동현금흐름= 영업활동현금흐름,
+            지배주주당기순이익= 지배주주당기순이익,
+
+            roic_r= roic_r,
+            roic_dict= roic_dict,
+            roe_r= roe_r,
+            roe_106= roe106,
+            roa_r= roa_r,
+
+            fcf_dict= fcf_dict,
+            pfcf_dict= pfcf_dict,
+            pcr_dict= pcr_dict,
+
+            score= score,
+            date = date_list,
+        )
+
+    def get(self, refresh = False, verbose = True) -> MilData:
+        """
+        MilData 형식의 데이터를 계산하여 리턴하고 레디스 캐시에 저장한다.
+        :param refresh:
+        :return:
+        """
+        redis_name = f"{self.code}_mil"
+        mylogger.info(f"{self} MilData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
+        if verbose:
+            print(f"{self} redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time/3600}h")
+
+        def fetch_generate_data(refresh_in: bool) -> dict:
+            return asdict(self._generate_data(refresh_in))
+
+        return MilData(**myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_generate_data, refresh, timer=expire_time))

analyser_hj3415/analyser/eval/red.py

@@ -0,0 +1,295 @@
+import os
+from dataclasses import dataclass, asdict
+from collections import OrderedDict
+from typing import Tuple
+import math
+
+from utils_hj3415 import tools, setup_logger
+from db_hj3415 import myredis
+
+from analyser_hj3415.analyser.eval.common import Tools
+
+
+mylogger = setup_logger(__name__,'WARNING')
+expire_time = tools.to_int(os.getenv('DEFAULT_EXPIRE_TIME_H', 48)) * 3600
+
+
+@dataclass
+class RedData:
+    """
+    A data structure for financial data representation and calculations.
+
+    This class is designed to encapsulate financial details related to a company,
+    including calculations for business value, property value, debt evaluation, and
+    associated metrics. It validates specific attributes upon initialization and is
+    useful for financial data analysis.
+
+    Attributes:
+        code (str): A 6-digit numeric string representing the company or entity's code.
+        name (str): The name of the company or entity.
+        사업가치 (float): Business value calculated as net income attributable to controlling
+            shareholders divided by expected return rate.
+        지배주주당기순이익 (float): Net income attributable to controlling shareholders.
+        expect_earn (float): Expected return rate.
+        재산가치 (float): Property value calculated as current assets minus 1.2
+            times current liabilities, plus fixed assets under investment properties.
+        유동자산 (float): Current assets of the company.
+        유동부채 (float): Current liabilities of the company.
+        투자자산 (float): Investment assets within fixed assets.
+        투자부동산 (float): Investment real estate property.
+        부채평가 (float): Debt evaluation, specifically focusing on non-current liabilities.
+        발행주식수 (int): Number of issued shares by the company.
+        date (list): List of dates relevant to the financial data.
+        red_price (float): Red price associated with the company or entity.
+        score (int): Score or rating given to the company or entity.
+
+    Raises:
+        ValueError: If the 'code' attribute is not a 6-digit numeric string.
+    """
+    code: str
+    name: str
+
+    # 사업가치 계산 - 지배주주지분 당기순이익 / 기대수익률
+    사업가치: float
+    지배주주당기순이익: float
+    expect_earn: float
+
+    # 재산가치 계산 - 유동자산 - (유동부채*1.2) + 고정자산중 투자자산
+    재산가치: float
+    유동자산: float
+    유동부채: float
+    투자자산: float
+    투자부동산: float
+
+    # 부채평가 - 비유동부채
+    부채평가: float
+
+    # 발행주식수
+    발행주식수: int
+
+    date: list
+
+    red_price: float
+    score: int
+
+    def __post_init__(self):
+        if not tools.is_6digit(self.code):
+            raise ValueError(f"code는 6자리 숫자형 문자열이어야합니다. (입력값: {self.code})")
+
+
+class Red:
+    """
+    Represents a financial analysis object with methods to calculate metrics
+    and gather data related to a specific code.
+
+    The Red class is designed to interact with specific data sources and provide
+    tools for financial calculations and analysis. This includes fetching and
+    processing information related to liabilities, assets, stock prices, and
+    other financial indicators. The class facilitates both specific calculations
+    such as 비유동부채(Non-current Liability) and the generation of comprehensive
+    financial datasets.
+    """
+
+
+    def __init__(self, code: str, expect_earn: float = 0.06):
+        assert tools.is_6digit(code), f'Invalid value : {code}'
+        mylogger.debug(f"Red : 초기화 ({code})")
+        self.c101 = myredis.C101(code)
+        self.c103 = myredis.C103(code, 'c103재무상태표q')
+
+        self.name = self.c101.get_name()
+        self._code = code
+
+        self.expect_earn = expect_earn
+
+    def __str__(self):
+        return f"Red({self.code}/{self.name})"
+
+    @property
+    def code(self) -> str:
+        return self._code
+
+    @code.setter
+    def code(self, code: str):
+        assert tools.is_6digit(code), f'Invalid value : {code}'
+        mylogger.debug(f"Red : 종목코드 변경({self.code} -> {code})")
+        self.c101.code = code
+        self.c103.code = code
+
+        self.name = self.c101.get_name()
+        self._code = code
+
+    def _calc비유동부채(self, refresh: bool) -> Tuple[str, float]:
+        """유효한 비유동부채 계산
+
+        일반적인 경우로 비유동부채를 찾아서 반환한다.\n
+        금융기관의 경우는 간접적으로 계산한다.\n
+        """
+        mylogger.info(f'In the calc비유동부채... refresh : {refresh}')
+        self.c103.page = 'c103재무상태표q'
+
+        d, 비유동부채 = self.c103.sum_recent_4q('비유동부채', refresh)
+        if math.isnan(비유동부채):
+            mylogger.warning(f"{self} - 비유동부채가 없는 종목. 수동으로 계산합니다.")
+            # 보험관련업종은 예수부채가 없는대신 보험계약부채가 있다...
+            d1, v1 = self.c103.latest_value_pop2('예수부채', refresh)
+            d2, v2 = self.c103.latest_value_pop2('보험계약부채(책임준비금)', refresh)
+            d3, v3 = self.c103.latest_value_pop2('차입부채', refresh)
+            d4, v4 = self.c103.latest_value_pop2('기타부채', refresh)
+            mylogger.debug(f'예수부채 : {d1}, {v1}')
+            mylogger.debug(f'보험계약부채(책임준비금) : {d2}, {v2}')
+            mylogger.debug(f'차입부채 : {d3}, {v3}')
+            mylogger.debug(f'기타부채 : {d4}, {v4}')
+
+            try:
+                date, *_ = Tools.date_set(d1, d2, d3, d4)
+            except ValueError:
+                # 날짜 데이터가 없는경우
+                date = ''
+            계산된비유동부채value = round(tools.nan_to_zero(v1) + tools.nan_to_zero(v2) + tools.nan_to_zero(v3) + tools.nan_to_zero(v4),1)
+            mylogger.info(f"{self} - 계산된 비유동부채 : {계산된비유동부채value}")
+            return date, 계산된비유동부채value
+        else:
+            return d, 비유동부채
+
+    def _score(self, red_price: int, refresh: bool) -> int:
+        """red price와 최근 주가의 괴리율 파악
+
+            Returns:
+                int : 주가와 red price 비교한 괴리율
+            """
+        try:
+            recent_price = tools.to_float(self.c101.get_recent(refresh)['주가'])
+        except KeyError:
+            return 0
+
+        deviation = Tools.cal_deviation(recent_price, red_price)
+        if red_price < 0 or (recent_price >= red_price):
+            score = 0
+        else:
+            score = tools.to_int(math.log10(deviation + 1) * 33)  # desmos그래프상 33이 제일 적당한듯(최대100점에 가깝게)
+
+        mylogger.debug(f"최근주가 : {recent_price} red가격 : {red_price} 괴리율 : {tools.to_int(deviation)} score : {score}")
+
+        return score
+
+    def _generate_data(self, refresh: bool) -> RedData:
+        d1, 지배주주당기순이익 = Tools.calc당기순이익(self.c103, refresh)
+        mylogger.debug(f"{self} 지배주주당기순이익: {지배주주당기순이익}")
+        d2, 유동자산 = Tools.calc유동자산(self.c103, refresh)
+        d3, 유동부채 = Tools.calc유동부채(self.c103, refresh)
+        d4, 부채평가 = self._calc비유동부채(refresh)
+
+        self.c103.page = 'c103재무상태표q'
+        d5, 투자자산 = self.c103.latest_value_pop2('투자자산', refresh)
+        d6, 투자부동산 = self.c103.latest_value_pop2('투자부동산', refresh)
+
+        # 사업가치 계산 - 지배주주지분 당기순이익 / 기대수익률
+        사업가치 = round(지배주주당기순이익 / self.expect_earn, 2)
+
+        # 재산가치 계산 - 유동자산 - (유동부채*1.2) + 고정자산중 투자자산
+        재산가치 = round(유동자산 - (유동부채 * 1.2) + tools.nan_to_zero(투자자산) + tools.nan_to_zero(투자부동산), 2)
+
+        _, 발행주식수 = self.c103.latest_value_pop2('발행주식수', refresh)
+        if math.isnan(발행주식수):
+            발행주식수 = tools.to_int(self.c101.get_recent(refresh).get('발행주식'))
+        else:
+            발행주식수 = 발행주식수 * 1000
+
+        try:
+            red_price = round(((사업가치 + 재산가치 - 부채평가) * 100000000) / 발행주식수)
+        except (ZeroDivisionError, ValueError):
+            red_price = math.nan
+
+        score = self._score(red_price, refresh)
+
+        try:
+            date_list = Tools.date_set(d1, d2, d3, d4)
+        except ValueError:
+            # 날짜 데이터가 없는경우
+            date_list = ['',]
+
+        return RedData(
+            code = self.code,
+            name = self.name,
+            사업가치 = 사업가치,
+            지배주주당기순이익 = 지배주주당기순이익,
+            expect_earn = self.expect_earn,
+            재산가치 = 재산가치,
+            유동자산 = 유동자산,
+            유동부채 = 유동부채,
+            투자자산 = 투자자산,
+            투자부동산 = 투자부동산,
+            부채평가 = 부채평가,
+            발행주식수 = 발행주식수,
+            date = date_list,
+            red_price = red_price,
+            score = score,
+        )
+
+    def get(self, refresh = False, verbose = True) -> RedData:
+        """
+        RedData 형식의 데이터를 계산하여 리턴하고 레디스 캐시에 저장한다.
+
+        redis_name = f"{self.code}_red_data"
+
+        Fetch or create RedData from Redis cache.
+
+        This function attempts to retrieve the RedData from a Redis cache. If the data is
+        not available or if a refresh is requested, it generates new data and caches
+        them back in Redis. The function logs its operations and can provide
+        verbose output when specified.
+
+        Parameters:
+        refresh : bool, optional
+            Whether to refresh and generate new data instead of using the cached data.
+        verbose : bool, optional
+            Whether to enable verbose logging/display of additional runtime information.
+
+        Returns:
+        RedData
+            The RedData object either retrieved from the cache or newly generated.
+
+        """
+        redis_name = f"{self.code}_red_data"
+        mylogger.info(f"{self} RedData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
+        if verbose:
+            print(f"{self} redisname: '{redis_name}' / expect_earn: {self.expect_earn} / refresh : {refresh} / expire_time : {expire_time/3600}h")
+
+        def fetch_generate_data(refresh_in: bool) -> dict:
+            return asdict(self._generate_data(refresh_in))
+
+        return RedData(**myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_generate_data, refresh, timer=expire_time))
+
+    @classmethod
+    def ranking(cls, expect_earn: float = 0.06, refresh = False) -> OrderedDict:
+        # 이전 expect earn 과 비교하여 다르거나 없으면 강제 refresh 설정
+        redis_name = 'red_ranking_prev_expect_earn'
+        pee = tools.to_float(myredis.Base.get_value(redis_name))
+        if pee != expect_earn:
+            # expect earn의 이전 계산값이 없거나 이전 값과 다르면 새로 계산
+            mylogger.warning(
+                f"expect earn : {expect_earn} / prev expect earn : {pee} 두 값이 달라 refresh = True"
+            )
+            myredis.Base.set_value(redis_name, str(expect_earn))
+            refresh = True
+
+        print("**** Start red_ranking... ****")
+        redis_name = 'red_ranking'
+        print(f"redisname: '{redis_name}' / expect_earn: {expect_earn} / refresh : {refresh} / expire_time : {expire_time/3600}h")
+
+        def fetch_ranking(refresh_in: bool) -> dict:
+            data = {}
+            red = Red(code='005930', expect_earn=expect_earn)
+            for i, code in enumerate(myredis.Corps.list_all_codes()):
+                red.code = code
+                red_score = red.get(refresh=refresh_in, verbose=False).score
+                if red_score > 0:
+                    data[code] = red_score
+                    print(f"{i}: {red} - {red_score}")
+            return data
+
+        data_dict = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_ranking, refresh, timer=expire_time)
+
+        return OrderedDict(sorted(data_dict.items(), key=lambda item: item[1], reverse=True))
+