analyser_hj3415 2.6.0__tar.gz → 2.6.1__tar.gz

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

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: analyser_hj3415
-Version: 2.6.0
+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.6.0 → analyser_hj3415-2.6.1}/analyser_hj3415/cli.py

@@ -35,7 +35,7 @@ class AnalyserSettingsManager(SettingsManager):
 
 def analyser_manager():
     settings_manager = AnalyserSettingsManager(SETTINGS_FILE)
-    expect_earn = settings_manager.get_value('EXPECT_EARN')
+    expect_earn_from_setting = settings_manager.get_value('EXPECT_EARN')
 
     parser = argparse.ArgumentParser(description="Analyser Commands")
     type_subparsers = parser.add_subparsers(dest='type', help='분석 타입')
@@ -45,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 타입')
@@ -57,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')
@@ -76,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, expect_earn)
+                    red_n_score(code, expect_earn, refresh)
             else:
                 assert utils.is_6digit(args.code), "code 인자는 6자리 숫자이어야 합니다."
-                print(args.code, red_n_score(args.code, expect_earn))
+                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(expect_earn)
+            # 기대 수익률과 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, expect_earn)
+                    mil_n_score(code, expect_earn, refresh)
             else:
                 assert utils.is_6digit(args.code), "code 인자는 6자리 숫자이어야 합니다."
-                print(args.code, mil_n_score(args.code, expect_earn))
+                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':

{analyser_hj3415-2.6.0 → 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(expect_earn: float) -> 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, expect_earn)
-            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, expect_earn: float) -> 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, expect_earn)
-        data['score'] = score.red(code, expect_earn)
-        # 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, expect_earn: float) -> 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, expect_earn: float) -> 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, expect_earn)
-        # 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.6.0 → analyser_hj3415-2.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "analyser_hj3415"
-version = "2.6.0"
+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]