analyser_hj3415 2.5.7__tar.gz → 2.6.1__tar.gz

{analyser_hj3415-2.5.7 → analyser_hj3415-2.6.1}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: analyser_hj3415
-Version: 2.5.7
+Version: 2.6.1
 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: utils-hj3415>=2.7.0
-Requires-Dist: db-hj3415>=3.7.2
+Requires-Dist: db-hj3415>=3.7.3
 Project-URL: Home, https://www.hyungjin.kr
 
 ### analyser-hj3415

{analyser_hj3415-2.5.7 → analyser_hj3415-2.6.1}/analyser_hj3415/analysers/eval.py

@@ -16,7 +16,7 @@ logger.addHandler(ch)
 logger.setLevel(logging.WARNING)
 
 
-def red(code: str) -> dict:
+def red(code: str, expect_earn: float) -> dict:
     """
     리턴값
     {
@@ -41,10 +41,7 @@ def red(code: str) -> dict:
     d6, 투자부동산 = c103q.latest_value_pop2('투자부동산')
 
     # 사업가치 계산 - 지배주주지분 당기순이익 / 기대수익률
-    from analyser_hj3415 import cli
-    EXPECT_EARN = utils.to_float(cli.AnalyserSettingsManager(cli.SETTINGS_FILE).get_value('EXPECT_EARN'))
-    print('EXPECT_EARN', EXPECT_EARN)
-    사업가치 = round(utils.nan_to_zero(지배주주당기순이익) / EXPECT_EARN, 2)
+    사업가치 = round(utils.nan_to_zero(지배주주당기순이익) / expect_earn, 2)
 
     # 재산가치 계산 - 유동자산 - (유동부채*1.2) + 고정자산중 투자자산
     재산가치 = round(유동자산 - (유동부채 * 1.2) + utils.nan_to_zero(투자자산) + utils.nan_to_zero(투자부동산), 2)
@@ -72,7 +69,7 @@ def red(code: str) -> dict:
         '재산가치': 재산가치,
         '부채평가': 부채평가,
         '발행주식수': 발행주식수,
-        'EXPECT_EARN': EXPECT_EARN,
+        'EXPECT_EARN': expect_earn,
         'date': tools.set_data(d1, d2, d3, d4, d5, d6),  # ''값을 제거하고 리스트로 바꾼다.
     }
 

{analyser_hj3415-2.5.7 → analyser_hj3415-2.6.1}/analyser_hj3415/analysers/score.py

@@ -32,7 +32,7 @@ def cal_deviation(v1: float, v2: float) -> float:
     return deviation
 
 
-def red(code: str) -> int:
+def red(code: str, expect_earn: float) -> int:
     """red price와 최근 주가의 괴리율 파악
 
     Returns:
@@ -44,7 +44,7 @@ def red(code: str) -> int:
         recent_price = float('nan')
         return 0
 
-    red_price = eval.red(code)['red_price']
+    red_price = eval.red(code, expect_earn)['red_price']
     deviation = cal_deviation(recent_price, red_price)
     if red_price < 0 or (recent_price >= red_price):
         score = 0
@@ -56,7 +56,7 @@ def red(code: str) -> int:
     return utils.to_int(score)
 
 
-def mil(code: str) -> Tuple[int, int, int, int]:
+def mil(code: str, expect_earn: float) -> Tuple[int, int, int, int]:
     """
     - 재무활동현금흐름이 마이너스라는 것은 배당급 지급했거나, 자사주 매입했거나, 부채를 상환한 상태임.
     - 반대는 채권자로 자금을 조달했거나 신주를 발행했다는 의미
@@ -93,9 +93,7 @@ def mil(code: str) -> Tuple[int, int, int, int]:
     if math.isnan(mil_dict['주주수익률']):
         score1 = 0
     else:
-        from analyser_hj3415 import cli
-        EXPECT_EARN = utils.to_float(cli.AnalyserSettingsManager(cli.SETTINGS_FILE).get_value('EXPECT_EARN'))
-        주주수익률평가 = math.ceil(mil_dict['주주수익률'] - (EXPECT_EARN * 100))
+        주주수익률평가 = math.ceil(mil_dict['주주수익률'] - (expect_earn * 100))
         score1 = 0 if 0 > 주주수익률평가 else 주주수익률평가
 
     # 이익지표 평가

{analyser_hj3415-2.5.7 → analyser_hj3415-2.6.1}/analyser_hj3415/cli.py

@@ -23,7 +23,7 @@ class AnalyserSettingsManager(SettingsManager):
         self.save_settings()
         print(f"{title}: {value}가 저장되었습니다")
 
-    def get_value(self, title: str) -> str:
+    def get_value(self, title: str):
         assert title in self.TITLES, f"title 인자는 {self.TITLES} 중에 있어야 합니다."
         return self.settings_dict.get(title, self.DEFAULT_SETTINGS[title])
 
@@ -35,6 +35,7 @@ class AnalyserSettingsManager(SettingsManager):
 
 def analyser_manager():
     settings_manager = AnalyserSettingsManager(SETTINGS_FILE)
+    expect_earn_from_setting = settings_manager.get_value('EXPECT_EARN')
 
     parser = argparse.ArgumentParser(description="Analyser Commands")
     type_subparsers = parser.add_subparsers(dest='type', help='분석 타입')
@@ -44,11 +45,15 @@ def analyser_manager():
     red_subparser = red_parser.add_subparsers(dest='command', help='red 관련된 명령')
     # red - ranking 파서
     ranking_parser = red_subparser.add_parser('ranking', help='red 랭킹 책정 및 레디스 저장')
-    ranking_parser.add_argument('--noti', action='store_true', help='작업 완료 후 메시지 전송 여부')
-    # mil - score 파서
+    ranking_parser.add_argument('-e', '--expect_earn', type=float, help='기대수익률 (실수 값 입력)')
+    ranking_parser.add_argument('-r', '--refresh', action='store_true', help='래디스 캐시를 사용하지 않고 강제로 재계산 할지')
+    ranking_parser.add_argument('-n', '--noti', action='store_true', help='작업 완료 후 메시지 전송 여부')
+    # red - score 파서
     score_parser = red_subparser.add_parser('score', help='red score 책정 및 레디스 저장')
     score_parser.add_argument('code', type=str, help='종목코드 or all')
-    score_parser.add_argument('--noti', action='store_true', help='작업 완료 후 메시지 전송 여부')
+    score_parser.add_argument('-e', '--expect_earn', type=float, help='기대수익률 (실수 값 입력)')
+    score_parser.add_argument('-r', '--refresh', action='store_true', help='래디스 캐시를 사용하지 않고 강제로 재계산 할지')
+    score_parser.add_argument('-n', '--noti', action='store_true', help='작업 완료 후 메시지 전송 여부')
 
     # mil 명령어 서브파서
     mil_parser = type_subparsers.add_parser('mil', help='millennial 타입')
@@ -56,7 +61,9 @@ def analyser_manager():
     # mil - score 파서
     score_parser = mil_subparser.add_parser('score', help='mil score 책정 및 레디스 저장')
     score_parser.add_argument('code', type=str, help='종목코드 or all')
-    score_parser.add_argument('--noti', action='store_true', help='작업 완료 후 메시지 전송 여부')
+    score_parser.add_argument('-e', '--expect_earn', type=float, help='기대수익률 (실수 값 입력)')
+    score_parser.add_argument('-r', '--refresh', action='store_true', help='래디스 캐시를 사용하지 않고 강제로 재계산 할지')
+    score_parser.add_argument('-n', '--noti', action='store_true', help='작업 완료 후 메시지 전송 여부')
 
     # setting 명령어 서브파서
     setting_parser = type_subparsers.add_parser('setting', help='Set and Get settings')
@@ -75,31 +82,47 @@ def analyser_manager():
 
     if args.type == 'red':
         if args.command == 'score':
+            # 기대 수익률과 refresh 값 처리
+            expect_earn = args.expect_earn if args.expect_earn is not None else expect_earn_from_setting
+            refresh = args.refresh if args.refresh else False
+
+            # print(expect_earn, refresh)
             if args.code == 'all':
                 print("**** red_n_score all code ****")
                 for i, code in enumerate(myredis.Corps.list_all_codes()):
                     print(f'{i} / {code}')
-                    red_n_score(code)
+                    red_n_score(code, expect_earn, refresh)
             else:
                 assert utils.is_6digit(args.code), "code 인자는 6자리 숫자이어야 합니다."
-                print(args.code, red_n_score(args.code))
+                print(args.code, red_n_score(args.code, expect_earn, refresh))
             if args.noti:
                 noti.telegram_to('manager', f"오늘의 red and score({args.code})를 레디스캐시에 저장했습니다.(유효 12시간)")
+
         elif args.command == 'ranking':
-            result = red_ranking()
+            # 기대 수익률과 refresh 값 처리
+            expect_earn = args.expect_earn if args.expect_earn is not None else expect_earn_from_setting
+            refresh = args.refresh if args.refresh else False
+
+            # red_ranking 함수 호출
+            result = red_ranking(expect_earn, refresh)
             print(result)
             if args.noti:
                 noti.telegram_to('manager', "오늘의 red ranking을 레디스캐시에 저장했습니다.(유효 12시간)")
+
     elif args.type == 'mil':
         if args.command == 'score':
+            # 기대 수익률과 refresh 값 처리
+            expect_earn = args.expect_earn if args.expect_earn is not None else expect_earn_from_setting
+            refresh = args.refresh if args.refresh else False
+
             if args.code == 'all':
                 print("**** mil_n_score all code ****")
                 for i, code in enumerate(myredis.Corps.list_all_codes()):
                     print(f'{i} / {code}')
-                    mil_n_score(code)
+                    mil_n_score(code, expect_earn, refresh)
             else:
                 assert utils.is_6digit(args.code), "code 인자는 6자리 숫자이어야 합니다."
-                print(args.code, mil_n_score(args.code))
+                print(args.code, mil_n_score(args.code, expect_earn, refresh))
             if args.noti:
                 noti.telegram_to('manager', f"오늘의 mil and score({args.code})를 레디스캐시에 저장했습니다.(유효 12시간)")
     elif args.type == 'setting':
@@ -112,6 +135,3 @@ def analyser_manager():
             print(settings_manager.load_settings())
     else:
         parser.print_help()
-
-
-

{analyser_hj3415-2.5.7 → analyser_hj3415-2.6.1}/analyser_hj3415/myredis.py

@@ -1,83 +1,77 @@
 from analyser_hj3415.analysers import eval, score
-from db_hj3415.myredis import Base
-import json
+from typing import Dict, Tuple
 from collections import OrderedDict
 from db_hj3415 import myredis as db_myredis
-
+from utils_hj3415 import utils
 
 page = '.analyser'
+myredis_base = db_myredis.Base()
 
+def get_redis_expect_earn(redis_name:str) -> float:
+    redis_name_e = f'{redis_name}_expect_earn'
+    byte_expect_earn = db_myredis.Base.redis_client.get(redis_name_e)
+    if byte_expect_earn is not None:
+        e = float(byte_expect_earn.decode('utf-8'))
+    else:
+        e = float('nan')
+    return e
 
-def red_ranking() -> OrderedDict:
+def red_ranking(expect_earn: float, refresh=False) -> Tuple[OrderedDict, str]:
     """
     redis를 사용하며 red score를 계산해서 0이상의 값을 가지는 종목을 순서대로 저장하여 반환한다.
+    :param expect_earn: 기대수익률(일반적으로 0.06 - 0.10)
+    :param refresh: 캐시를 사용하지 않고 강제로 다시 계산
     :return: OrderedDict([('023590', 101),
-             ('009970', 99),
-             ('010060', 91),...])
+             ('010060', 91),...]), 레디스이름
     """
+
+    print("**** Start red_ranking... ****")
     redis_name = 'red_ranking'
+    redis_name_e = f'{redis_name}_expect_earn'
+    if get_redis_expect_earn(redis_name) != expect_earn:
+        # 레디스 저장값과 기대수익률이 다르다면 무조건 리프레시 한다.
+        refresh = True
+    db_myredis.Base.redis_client.setex(redis_name_e, db_myredis.Base.DEFAULT_CACHE_EXPIRATION_SEC, expect_earn)
 
-    try:
-        cached_data = Base.redis_client.get(redis_name).decode('utf-8')
-    except AttributeError:
-        # redis에 해당하는 값이 없는 경우
+    def fetch_red_scores(expect_earn_i: float) -> Dict:
         data = {}
         for i, code in enumerate(db_myredis.Corps.list_all_codes()):
-            red_score = score.red(code)
-            if red_score <= 0:
-                continue
-            data[code] = red_score
-            # print(i, code, s)
-
-        # print(data)
-        if data:
-            # 데이터를 Redis에 캐싱
-            Base.redis_client.set(redis_name, json.dumps(data))
-            # 12시간 후 키가 자동으로 제거됨
-            Base.redis_client.expire(redis_name, 3600 * 12)
-        print("analysers.eval 데이터 계산하기 - myredis.red_ranking")
-        # ordereddict를 이용해서 딕셔너리의 값을 기준으로 내림차순 정렬함.
-        return OrderedDict(sorted(data.items(), key=lambda item: item[1], reverse=True))
-    else:
-        print(f"Redis 캐시에서 데이터 가져오기(남은시간:{round(Base.redis_client.ttl(redis_name)/3600, 1)}시간) - myredis.red_ranking")
-        # ordereddict를 이용해서 딕셔너리의 값을 기준으로 내림차순 정렬함.
-        return OrderedDict(sorted(json.loads(cached_data).items(), key=lambda item: item[1], reverse=True))
+            red_score = score.red(code, expect_earn_i)
+            if red_score > 0:
+                data[code] = red_score
+                print(f"{i}: {code} - {red_score}")
+        return data
+
+    data = myredis_base.fetch_and_cache_data(redis_name, refresh, fetch_red_scores, expect_earn)
+    return OrderedDict(sorted(data.items(), key=lambda item: item[1], reverse=True)), redis_name
 
 
-def red_n_score(code: str) -> dict:
+
+def red_n_score(code: str, expect_earn: float, refresh=False) -> Tuple[dict, str]:
     """
-    redis 사용 - 소멸타이머 사용
-    리턴값
-    {
-        'red_price': red_price,
-        '사업가치': 사업가치,
-        '재산가치': 재산가치,
-        '부채평가': 부채평가,
-        '발행주식수': 발행주식수,
-        'date': [각 유효한 값의 년월값 리스트(ex- 2020/09)],
-    }
+    red 평가후 스코어 계산후 red 딕셔너리에 첨가후 반환
+    :param code: 종목코드
+    :param expect_earn: 기대수익률(일반적으로 0.06 - 0.10)
+    :param refresh: 캐시를 사용하지 않고 강제로 다시 계산
+    :return:
     """
-    redis_name = code + page + '_eval_' + 'red'
-    try:
-        cached_data = Base.redis_client.get(redis_name).decode('utf-8')
-    except AttributeError:
-        # redis에 해당하는 값이 없는 경우
-        data = eval.red(code)
-        data['score'] = score.red(code)
-        # print(data)
-        if data:
-            # 데이터를 Redis에 캐싱
-            Base.redis_client.set(redis_name, json.dumps(data))
-            # 12시간 후 키가 자동으로 제거됨
-            Base.redis_client.expire(redis_name, 3600 * 12)
-        print("analysers.eval 데이터 계산하기 - myredis.red")
+    redis_name = f"{code}_{page}_red_n_score"
+    redis_name_e = f'{redis_name}_expect_earn'
+    if get_redis_expect_earn(redis_name) != expect_earn:
+        # 레디스 저장값과 기대수익률이 다르다면 무조건 리프레시 한다.
+        refresh = True
+    # print(get_redis_expect_earn(redis_name))
+    db_myredis.Base.redis_client.setex(redis_name_e, db_myredis.Base.DEFAULT_CACHE_EXPIRATION_SEC, expect_earn)
+
+    def fetch_red_n_score(code_i: str, expect_earn_i: float) -> dict:
+        data = eval.red(code_i, expect_earn_i)
+        data['score'] = score.red(code_i, expect_earn_i)
         return data
-    else:
-        print(f"Redis 캐시에서 데이터 가져오기(남은시간:{round(Base.redis_client.ttl(redis_name)/3600, 1)}시간) - myredis.red")
-        return json.loads(cached_data)
+
+    return myredis_base.fetch_and_cache_data(redis_name, refresh, fetch_red_n_score, code, expect_earn), redis_name
 
 
-def mil_n_score(code: str) -> dict:
+def mil_n_score(code: str, expect_earn: float, refresh=False) -> Tuple[dict, str]:
     """
     redis 사용 - 소멸타이머 사용
     리턴값
@@ -113,27 +107,22 @@ def mil_n_score(code: str) -> dict:
     https://www.investopedia.com/terms/p/pricetofreecashflow.asp
     pcr보다 정확하게 주식의 가치를 평가할수 있음. 10배이하 추천
     """
-    redis_name = code + page + '_eval_' + 'mil'
-    try:
-        cached_data = Base.redis_client.get(redis_name).decode('utf-8')
-    except AttributeError:
-        # redis에 해당하는 값이 없는 경우
-        data = eval.mil(code)
-        data['score'] = score.mil(code)
-        # print(data)
-        if data:
-            # 데이터를 Redis에 캐싱
-            Base.redis_client.set(redis_name, json.dumps(data))
-            # 12시간 후 키가 자동으로 제거됨
-            Base.redis_client.expire(redis_name, 3600 * 12)
-        print("analysers.eval 데이터 계산하기 - myredis.mil")
+    redis_name = f"{code}_{page}_mil_n_score"
+    redis_name_e = f'{redis_name}_expect_earn'
+    if get_redis_expect_earn(redis_name) != expect_earn:
+        # 레디스 저장값과 기대수익률이 다르다면 무조건 리프레시 한다.
+        refresh = True
+    db_myredis.Base.redis_client.setex(redis_name_e, db_myredis.Base.DEFAULT_CACHE_EXPIRATION_SEC, expect_earn)
+
+    def fetch_mil_n_score(code_i: str) -> dict:
+        data = eval.mil(code_i)
+        data['score'] = score.mil(code_i, expect_earn)
         return data
-    else:
-        print(f"Redis 캐시에서 데이터 가져오기(남은시간:{round(Base.redis_client.ttl(redis_name)/3600, 1)}시간) - myredis.mil")
-        return json.loads(cached_data)
+
+    return myredis_base.fetch_and_cache_data(redis_name, refresh, fetch_mil_n_score, code), redis_name
 
 
-def blue_n_score(code: str) -> dict:
+def blue_n_score(code: str, refresh=False) -> Tuple[dict, str]:
     """
     redis 사용 - 소멸타이머 사용
     리턴값
@@ -165,27 +154,17 @@ def blue_n_score(code: str) -> dict:
     <영업이익률>
     영업이익률은 기업의 경쟁력척도로 경쟁사에 비해 높으면 경제적해자를 갖춘셈
     """
-    redis_name = code + page + '_eval_' + 'blue'
-    try:
-        cached_data = Base.redis_client.get(redis_name).decode('utf-8')
-    except AttributeError:
-        # redis에 해당하는 값이 없는 경우
-        data = eval.blue(code)
-        data['score'] = score.blue(code)
-        # print(data)
-        if data:
-            # 데이터를 Redis에 캐싱
-            Base.redis_client.set(redis_name, json.dumps(data))
-            # 12시간 후 키가 자동으로 제거됨
-            Base.redis_client.expire(redis_name, 3600 * 12)
-        print("analysers.eval 데이터 계산하기 - myredis.blue")
+    redis_name = f"{code}_{page}_blue_n_score"
+
+    def fetch_blue_n_score(code_i: str) -> dict:
+        data = eval.blue(code_i)
+        data['score'] = score.blue(code_i)
         return data
-    else:
-        print(f"Redis 캐시에서 데이터 가져오기(남은시간:{round(Base.redis_client.ttl(redis_name)/3600, 1)}시간) - myredis.blue")
-        return json.loads(cached_data)
+
+    return myredis_base.fetch_and_cache_data(redis_name, refresh, fetch_blue_n_score, code), redis_name
 
 
-def growth_n_score(code: str) -> dict:
+def growth_n_score(code: str, refresh=False) -> Tuple[dict, str]:
     """
     redis 사용 - 소멸타이머 사용
     리턴값
@@ -198,21 +177,11 @@ def growth_n_score(code: str) -> dict:
     <영업이익률>
     영업이익률은 기업의 경쟁력척도로 경쟁사에 비해 높으면 경제적해자를 갖춘셈
     """
-    redis_name = code + page + '_eval_' + 'growth'
-    try:
-        cached_data = Base.redis_client.get(redis_name).decode('utf-8')
-    except AttributeError:
-        # redis에 해당하는 값이 없는 경우
-        data = eval.growth(code)
-        data['score'] = score.growth(code)
-        # print(data)
-        if data:
-            # 데이터를 Redis에 캐싱
-            Base.redis_client.set(redis_name, json.dumps(data))
-            # 12시간 후 키가 자동으로 제거됨
-            Base.redis_client.expire(redis_name, 3600 * 12)
-        print("analysers.eval 데이터 계산하기 - myredis.growth")
+    redis_name = f"{code}_{page}_growth_n_score"
+
+    def fetch_growth_n_score(code_i: str) -> dict:
+        data = eval.growth(code_i)
+        data['score'] = score.growth(code_i)
         return data
-    else:
-        print(f"Redis 캐시에서 데이터 가져오기(남은시간:{round(Base.redis_client.ttl(redis_name)/3600, 1)}시간) - myredis.growth")
-        return json.loads(cached_data)
+
+    return myredis_base.fetch_and_cache_data(redis_name, refresh, fetch_growth_n_score, code), redis_name

{analyser_hj3415-2.5.7 → analyser_hj3415-2.6.1}/analyser_hj3415/tools.py

@@ -15,6 +15,7 @@ logger.setLevel(logging.WARNING)
 def set_data(*args) -> list:
     """
     비유효한 내용 제거(None,nan)하고 중복된 항목 제거하고 리스트로 반환한다.
+    여기서 set의 의미는 집합을 뜻함
     :param args:
     :return:
     """

{analyser_hj3415-2.5.7 → analyser_hj3415-2.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "analyser_hj3415"
-version = "2.5.7"
+version = "2.6.1"
 authors = [{name = "Hyungjin Kim", email = "hj3415@gmail.com"}]
 description = "Stock analyser and database processing programs"
 readme = "README.md"
@@ -12,7 +12,7 @@ license = {file = "LICENSE"}
 classifiers = ["License :: OSI Approved :: MIT License"]
 dependencies = [
     "utils-hj3415>=2.7.0",
-    "db-hj3415>=3.7.2",
+    "db-hj3415>=3.7.3",
 ]
 
 [project.scripts]