analyser_hj3415 2.6.8__py2.py3-none-any.whl → 2.7.1__py2.py3-none-any.whl

analyser_hj3415/workroom/lstm.py

@@ -0,0 +1,113 @@
+import yfinance as yf
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import MinMaxScaler
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import LSTM, Dense, Dropout
+import matplotlib.pyplot as plt
+
+# 1. 데이터 다운로드 (애플 주식 데이터를 사용)
+#stock_data = yf.download('AAPL', start='2020-01-01', end='2023-01-01')
+# 삼성전자 주식 데이터 가져오기 (KOSPI 상장)
+#stock_data = yf.download('005930.KS', start='2019-01-01', end='2024-10-10')
+# 크래프톤 주식 데이터 가져오기 (KOSPI 상장)
+#stock_data = yf.download('259960.KS', start='2020-01-01', end='2024-10-08')
+# 하이닉스 주식 데이터 가져오기 (KOSPI 상장)
+stock_data = yf.download('000660.KS', start='2019-01-01', end='2024-10-10')
+
+
+# 2. 필요한 열만 선택 (종가만 사용)
+data = stock_data['Close'].values.reshape(-1, 1)
+
+# 3. 데이터 정규화 (0과 1 사이로 스케일링)
+scaler = MinMaxScaler(feature_range=(0, 1))
+scaled_data = scaler.fit_transform(data)
+
+# 4. 학습 데이터 생성
+# 주가 데이터를 80%는 학습용, 20%는 테스트용으로 분리하는 코드
+train_size = int(len(scaled_data) * 0.8)
+train_data = scaled_data[:train_size]
+test_data = scaled_data[train_size:]
+
+
+# 학습 데이터에 대한 입력(X)과 출력(y)를 생성
+def create_dataset(data, time_step=60):
+    X, y = [], []
+    for i in range(len(data) - time_step):
+        X.append(data[i:i + time_step, 0])
+        y.append(data[i + time_step, 0])
+    return np.array(X), np.array(y)
+
+
+X_train, y_train = create_dataset(train_data)
+X_test, y_test = create_dataset(test_data)
+
+# LSTM 모델 입력을 위해 데이터를 3차원으로 변환
+X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)
+X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], 1)
+
+# 5. LSTM 모델 생성
+model = Sequential()
+model.add(LSTM(units=200, return_sequences=True, input_shape=(X_train.shape[1], 1)))
+model.add(Dropout(0.2))
+model.add(LSTM(units=100, return_sequences=False))
+model.add(Dropout(0.2))
+model.add(Dense(units=50))
+model.add(Dropout(0.3))
+model.add(Dense(units=1))
+
+# 6. 모델 컴파일 및 학습
+model.compile(optimizer='adam', loss='mean_squared_error')
+model.fit(X_train, y_train, epochs=20, batch_size=32)
+
+# 7. 테스트 데이터 예측
+predictions = model.predict(X_test)
+predictions = scaler.inverse_transform(predictions)  # 스케일링 복원
+
+# 8. 미래 30일 예측
+# 마지막 60일간의 데이터를 기반으로 미래 30일을 예측
+future_days = 30
+last_60_days = test_data[-60:]
+last_60_days = last_60_days.reshape(1, -1, 1)
+
+future_predictions = []
+for _ in range(future_days):
+    predicted_price = model.predict(last_60_days)
+    future_predictions.append(predicted_price[0][0])
+
+    # 예측값을 다시 입력으로 사용하여 새로운 예측을 만듦
+    predicted_price_reshaped = np.reshape(predicted_price, (1, 1, 1))  # 3D 배열로 변환
+    last_60_days = np.append(last_60_days[:, 1:, :], predicted_price_reshaped, axis=1)
+
+# 예측된 주가를 다시 스케일링 복원
+future_predictions = np.array(future_predictions).reshape(-1, 1)
+future_predictions = scaler.inverse_transform(future_predictions)
+
+# 9. 날짜 생성 (미래 예측 날짜)
+last_date = stock_data.index[-1]
+future_dates = pd.date_range(last_date, periods=future_days + 1).tolist()[1:]
+
+# 10. 시각화
+plt.figure(figsize=(10, 6))
+
+# 실제 주가
+plt.plot(stock_data.index, stock_data['Close'], label='Actual Price')
+
+# 미래 주가 예측
+plt.plot(future_dates, future_predictions, label='Future Predicted Price', linestyle='--')
+
+plt.xlabel('Date')
+plt.ylabel('Stock Price')
+plt.legend()
+plt.title('Apple Stock Price Prediction with LSTM')
+plt.show()
+
+# 8. 시각화
+plt.figure(figsize=(10, 6))
+plt.plot(stock_data.index[train_size + 60:], data[train_size + 60:], label='Actual Price')
+plt.plot(stock_data.index[train_size + 60:], predictions, label='Predicted Price')
+plt.xlabel('Date')
+plt.ylabel('Price')
+plt.legend()
+plt.title('Apple Stock Price Prediction with LSTM')
+plt.show()

analyser_hj3415/workroom/myprophet.py

@@ -0,0 +1,58 @@
+# prophet 사용 공부
+
+import yfinance as yf
+import pandas as pd
+from prophet import Prophet
+import matplotlib.pyplot as plt  # Matplotlib 수동 임포트
+
+
+# 애플 주식 데이터를 다운로드
+#stock_data = yf.download('AAPL', start='2020-01-01', end='2024-10-09')
+# 삼성전자 주식 데이터 가져오기 (KOSPI 상장)
+#stock_data = yf.download('005930.KS', start='2020-01-01', end='2024-08-01')
+# 크래프톤 주식 데이터 가져오기 (KOSPI 상장)
+#stock_data = yf.download('259960.KS', start='2020-01-01', end='2024-10-08')
+# 하이닉스 주식 데이터 가져오기 (KOSPI 상장)
+stock_data = yf.download('000660.KS', start='2020-01-01', end='2024-10-08')
+
+
+# Prophet이 사용할 수 있도록 데이터 준비
+df = stock_data[['Close', 'Volume']].reset_index()
+df.columns = ['ds', 'y', 'volume']  # Prophet의 형식에 맞게 열 이름 변경
+
+from sklearn.preprocessing import StandardScaler
+
+# 추가 변수를 정규화
+scaler = StandardScaler()
+df['volume_scaled'] = scaler.fit_transform(df[['volume']])
+
+# Prophet 모델 생성 및 학습
+model = Prophet()
+
+# 정규화된 'volume_scaled' 변수를 외부 변수로 추가
+model.add_regressor('volume_scaled')
+
+model.fit(df)
+
+# 향후 180일 동안의 주가 예측
+future = model.make_future_dataframe(periods=180)
+
+# 미래 데이터에 거래량 추가 (평균 거래량을 사용해 정규화)
+future_volume = pd.DataFrame({'volume': [stock_data['Volume'].mean()] * len(future)})
+future['volume_scaled'] = scaler.transform(future_volume[['volume']])
+
+
+forecast = model.predict(future)
+
+
+
+# 예측 결과 출력
+print(forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail())
+
+# 예측 결과 시각화 (Matplotlib 사용)
+fig = model.plot(forecast)
+
+# 추세 및 계절성 시각화
+fig2 = model.plot_components(forecast)
+
+plt.show()  # 시각화 창 띄우기

analyser_hj3415/workroom/mysklearn.py

@@ -0,0 +1,50 @@
+import yfinance as yf
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression
+import matplotlib.pyplot as plt
+
+# 1. 데이터 다운로드 (애플 주식 데이터를 사용)
+# 데이터 기간: 2020년 1월 1일부터 2023년 1월 1일까지
+#stock_data = yf.download('AAPL', start='2020-01-01', end='2023-01-01')
+# 삼성전자 주식 데이터 가져오기 (KOSPI 상장)
+stock_data = yf.download('005930.KS', start='2020-01-01', end='2024-08-01')
+# 크래프톤 주식 데이터 가져오기 (KOSPI 상장)
+#stock_data = yf.download('259960.KS', start='2020-01-01', end='2024-10-08')
+
+# 2. 필요한 열만 선택 (종가만 사용)
+df = stock_data[['Close']]
+
+# 3. 주가 데이터를 시계열 데이터로 변환하여 예측
+# 일자를 숫자로 변환 (날짜 자체는 예측 모델에 사용하기 어렵기 때문에 숫자로 변환)
+df['Date'] = np.arange(len(df))
+
+# 4. 독립 변수(X)와 종속 변수(y) 분리
+X = df[['Date']]  # 독립 변수 (날짜)
+y = df['Close']  # 종속 변수 (주가)
+
+# 5. 데이터를 학습용과 테스트용으로 분리 (80% 학습, 20% 테스트)
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# 6. 선형 회귀 모델 생성 및 학습
+model = LinearRegression()
+model.fit(X_train, y_train)
+
+# 7. 테스트 데이터를 사용하여 예측 수행
+y_pred = model.predict(X_test)
+
+# 8. 결과 시각화
+plt.figure(figsize=(10, 6))
+plt.scatter(X_train, y_train, color='blue', label='Training data')  # 학습 데이터
+plt.scatter(X_test, y_test, color='green', label='Test data')  # 실제 테스트 데이터
+plt.plot(X_test, y_pred, color='red', label='Predicted price')  # 예측된 주가
+plt.xlabel('Date (numeric)')
+plt.ylabel('Stock Price (Close)')
+plt.legend()
+plt.title('Apple Stock Price Prediction')
+plt.show()
+
+# 9. 모델 평가 (R^2 스코어)
+r2_score = model.score(X_test, y_test)
+print(f"모델의 R^2 스코어: {r2_score:.2f}")

analyser_hj3415/workroom/mysklearn2.py

@@ -0,0 +1,39 @@
+# 필요한 라이브러리 불러오기
+import numpy as np
+from sklearn.linear_model import LinearRegression
+from sklearn.model_selection import train_test_split
+import matplotlib.pyplot as plt
+
+# 1. 데이터 준비 (주택 면적, 가격)
+# 예를 들어 면적에 따른 주택 가격 데이터 (면적: X, 가격: y)
+X = np.array([[1500], [2000], [2500], [3000], [3500], [4000]])  # 면적 (단위: square feet)
+y = np.array([300000, 400000, 500000, 600000, 700000, 800000])  # 가격 (단위: dollars)
+
+# 2. 학습 데이터와 테스트 데이터를 나누기 (80% 학습, 20% 테스트)
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# 3. 선형 회귀 모델 생성
+model = LinearRegression()
+
+# 4. 모델을 학습시키기 (train 데이터를 사용)
+model.fit(X_train, y_train)
+
+# 5. 테스트 데이터로 예측 수행
+y_pred = model.predict(X_test)
+
+# 6. 예측 결과 출력
+print("실제 값:", y_test)
+print("예측 값:", y_pred)
+
+# 7. 시각화를 통해 학습 결과 확인
+plt.scatter(X_train, y_train, color='blue', label='Training data')  # 학습 데이터
+plt.scatter(X_test, y_test, color='green', label='Test data')  # 실제 값
+plt.plot(X_test, y_pred, color='red', label='Prediction')  # 예측된 값
+plt.xlabel('House Size (square feet)')
+plt.ylabel('Price (dollars)')
+plt.legend()
+plt.show()
+
+# 9. 모델 평가 (R^2 스코어)
+r2_score = model.score(X_test, y_test)
+print(f"모델의 R^2 스코어: {r2_score:.2f}")

analyser_hj3415/{analysers → workroom}/score.py

@@ -5,7 +5,6 @@ import copy
 from typing import Tuple
 
 from db_hj3415 import myredis, mymongo
-from analyser_hj3415.analysers import eval
 from utils_hj3415 import utils
 
 import logging
@@ -18,43 +17,6 @@ logger.addHandler(ch)
 logger.setLevel(logging.WARNING)
 
 
-def cal_deviation(v1: float, v2: float) -> float:
-    """
-    괴리율 구하는 공식
-    :param v1:
-    :param v2:
-    :return:
-    """
-    try:
-        deviation = abs((v1 - v2) / v1) * 100
-    except ZeroDivisionError:
-        deviation = math.nan
-    return deviation
-
-
-def red(code: str, expect_earn: float) -> int:
-    """red price와 최근 주가의 괴리율 파악
-
-    Returns:
-        int : 주가와 red price 비교한 괴리율
-    """
-    try:
-        recent_price = utils.to_int(myredis.C101(code).get_recent()['주가'])
-    except KeyError:
-        recent_price = float('nan')
-        return 0
-
-    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
-    else:
-        score = math.log10(deviation + 1) * 33  # desmos그래프상 33이 제일 적당한듯(최대100점에 가깝게)
-
-    #print(f"최근주가 : {recent_price}", f"red가격 : {red_price}", f"괴리율 : {utils.to_int(deviation)}", f"score : {utils.to_int(score)}")
-
-    return utils.to_int(score)
-
 
 def mil(code: str, expect_earn: float) -> Tuple[int, int, int, int]:
     """

{analyser_hj3415-2.6.8.dist-info → analyser_hj3415-2.7.1.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: analyser_hj3415
-Version: 2.6.8
+Version: 2.7.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.8.0
-Requires-Dist: db-hj3415>=3.8.1
+Requires-Dist: utils-hj3415>=2.9.2
+Requires-Dist: db-hj3415>=4.0.3
 Project-URL: Home, https://www.hyungjin.kr
 
 ### analyser-hj3415

analyser_hj3415-2.7.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+analyser_hj3415/.DS_Store,sha256=qr9-0FPn5CFKe6kEu8_dWCNhzQ0sN7bwQgffKsaJEEo,6148
+analyser_hj3415/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+analyser_hj3415/cli.py,sha256=hJMUKBMeVr42QFdlCRpmMDPAUC1xX-OiZdDdxILmA9Y,10945
+analyser_hj3415/eval.py,sha256=LNOa6ryDuC1lylEh5dNjOUvtS6yD9qdlGadKugZ9S-k,38258
+analyser_hj3415/workroom/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+analyser_hj3415/workroom/lstm.py,sha256=O_VYURGNsLw6q_7Yi0nH4Y6nKbVBwzMojDN446cyJKM,4078
+analyser_hj3415/workroom/myprophet.py,sha256=xGbs4_cCeSNAX62H6rG-bUz6_rUOyO6787WAjLexMkw,1855
+analyser_hj3415/workroom/mysklearn.py,sha256=wJXKz5MqqTzADdG2mqRMMzc_G9RzwYjj5_j4gyOopxQ,2030
+analyser_hj3415/workroom/mysklearn2.py,sha256=1lIy6EWEQHkOzDS-av8U0zQH6DuCLKWMI73dnJx5KRs,1495
+analyser_hj3415/workroom/score.py,sha256=P6nHBJYmyhigGtT4qna4BmNtvt4B93b7SKyzdstJK24,17376
+analyser_hj3415/workroom/trash.py,sha256=zF-W0piqkGr66UP6-iybo9EXh2gO0RP6R1FnIpsGkl8,12262
+analyser_hj3415-2.7.1.dist-info/entry_points.txt,sha256=ZfjPnJuH8SzvhE9vftIPMBIofsc65IAWYOhqOC_L5ck,65
+analyser_hj3415-2.7.1.dist-info/LICENSE,sha256=QVKTp0dTnB5xG8RLgG17LwSWCKNEzYoVVM6KjoCPKc0,1079
+analyser_hj3415-2.7.1.dist-info/WHEEL,sha256=Sgu64hAMa6g5FdzHxXv9Xdse9yxpGGMeagVtPMWpJQY,99
+analyser_hj3415-2.7.1.dist-info/METADATA,sha256=vuoa55U72kpqBBesew0x7x-llcXXEruM9Nzqr--yjmo,6417
+analyser_hj3415-2.7.1.dist-info/RECORD,,

analyser_hj3415/analysers/eval.py

@@ -1,276 +0,0 @@
-"""red, mil, blue 3가지 분야에서 자료를 계산하여 리턴하는 함수 모음
-"""
-import math
-
-from analyser_hj3415 import tools
-from utils_hj3415 import utils
-from db_hj3415 import myredis
-
-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.WARNING)
-
-
-def red(code: str, expect_earn: float) -> dict:
-    """
-    리턴값
-    {
-        'red_price': red_price,
-        '사업가치': 사업가치,
-        '재산가치': 재산가치,
-        '부채평가': 부채평가,
-        '발행주식수': 발행주식수,
-        'date': [각 유효한 값의 년월값 리스트(ex- 2020/09)],
-    }
-    """
-    c103q = myredis.C103(code, 'c103재무상태표q')
-
-    d1, 지배주주당기순이익 = tools.calc당기순이익(code)
-    # print("지배주주당기순이익: ", 지배주주당기순이익)
-    d2, 유동자산 = tools.calc유동자산(code)
-    d3, 유동부채 = tools.calc유동부채(code)
-    d4, 부채평가 = tools.calc비유동부채(code)
-
-    c103q.page = 'c103재무상태표q'
-    d5, 투자자산 = c103q.latest_value_pop2('투자자산')
-    d6, 투자부동산 = c103q.latest_value_pop2('투자부동산')
-
-    # 사업가치 계산 - 지배주주지분 당기순이익 / 기대수익률
-    사업가치 = round(utils.nan_to_zero(지배주주당기순이익) / expect_earn, 2)
-
-    # 재산가치 계산 - 유동자산 - (유동부채*1.2) + 고정자산중 투자자산
-    재산가치 = round(유동자산 - (유동부채 * 1.2) + utils.nan_to_zero(투자자산) + utils.nan_to_zero(투자부동산), 2)
-
-    _, 발행주식수 = c103q.latest_value_pop2('발행주식수')
-    if math.isnan(발행주식수):
-        발행주식수 = utils.to_int(myredis.C101(code).get_recent().get('발행주식'))
-    else:
-        발행주식수 = 발행주식수 * 1000
-
-    try:
-        red_price = round(((사업가치 + 재산가치 - 부채평가) * 100000000) / 발행주식수)
-    except (ZeroDivisionError, ValueError) as e:
-        red_price = math.nan
-
-    logger.debug(f'Red Price : {red_price}원')
-    return {
-        'red_price': red_price,
-        '지배주주당기순이익': 지배주주당기순이익,
-        '사업가치': 사업가치,
-        '유동자산': 유동자산,
-        '유동부채': 유동부채,
-        '투자자산': 투자자산,
-        '투자부동산': 투자부동산,
-        '재산가치': 재산가치,
-        '부채평가': 부채평가,
-        '발행주식수': 발행주식수,
-        'EXPECT_EARN': expect_earn,
-        'date': tools.set_data(d1, d2, d3, d4, d5, d6),  # ''값을 제거하고 리스트로 바꾼다.
-    }
-
-
-def mil(code: str) -> dict:
-    """
-    리턴값
-    {
-        '주주수익률': 주주수익률,
-        '이익지표': 이익지표,
-        '투자수익률': {'ROIC': roic, 'ROE': roe , 'ROE106': {}},
-        '가치지표': {'FCF': fcf_dict, 'PFCF': pfcf_dict, 'PCR': pcr_dict},
-        'date': [각 유효한 값의 년월값 리스트(ex- 2020/09)],
-    }
-    """
-    c103q = myredis.C103(code, 'c103현금흐름표q')
-    c104q = myredis.C104(code, 'c104q')
-    c106q = myredis.C106(code, 'c106q')
-
-    marketcap억 = tools.get_marketcap(code) / 100000000
-    logger.debug(f'{code} market cap: {marketcap억}')
-    fcf_dict = tools.findFCF(code)
-    pfcf_dict = tools.findPFCF(code)
-    d1, 지배주주당기순이익 = tools.calc당기순이익(code)
-
-    d2, 재무활동현금흐름 = c103q.sum_recent_4q('재무활동으로인한현금흐름')
-    d3, 영업활동현금흐름 = c103q.sum_recent_4q('영업활동으로인한현금흐름')
-
-    d4, roic = c104q.sum_recent_4q('ROIC')
-    _, roic_dict = c104q.find_without_yoy('ROIC')
-    d5, roe = c104q.latest_value_pop2('ROE')
-    roe106 = c106q.find('ROE')
-    d6, roa = c104q.latest_value_pop2('ROA')
-
-    _, pcr_dict = c104q.find_without_yoy('PCR')
-
-    try:
-        주주수익률 = round((재무활동현금흐름 / marketcap억 * -100), 2)
-        이익지표 = round(((지배주주당기순이익 - 영업활동현금흐름) / marketcap억) * 100, 2)
-    except ZeroDivisionError:
-        주주수익률 = math.nan
-        이익지표 = math.nan
-
-    if math.isnan(주주수익률) or math.isnan(이익지표):
-        logger.warning(f'주주수익률: {주주수익률} 이익지표: {이익지표}')
-        logger.warning(f'재무활동현금흐름: {재무활동현금흐름} / 지배주주당기순이익: {지배주주당기순이익} / 영업활동현금흐름: {영업활동현금흐름}')
-
-    logger.debug(f'{code} fcf_dict : {fcf_dict}')
-    logger.debug(f"{code} market_cap : {marketcap억}")
-    logger.debug(f'{code} pfcf_dict : {pfcf_dict}')
-    logger.debug(f'{code} pcr_dict : {pcr_dict}')
-
-    return {
-        '주주수익률': 주주수익률,
-        '이익지표': 이익지표,
-        '재무활동현금흐름': 재무활동현금흐름,
-        '지배주주당기순이익': 지배주주당기순이익,
-        '영업활동현금흐름': 영업활동현금흐름,
-        '시가총액억': marketcap억,
-        '투자수익률': {'ROIC': roic, 'ROIC_dict': roic_dict, 'ROE': roe, 'ROE106': roe106, 'ROA': roa},
-        '가치지표': {'FCF': fcf_dict, 'PFCF': pfcf_dict, 'PCR': pcr_dict},
-        'date': tools.set_data(d1, d2, d3, d4, d5, d6),
-    }
-
-
-def blue(code: str) -> dict:
-    """
-    리턴값
-    {
-    'date': [각 유효한 값의 최근분기 값 리스트(ex- 2020/09)],
-    '순부채비율': (29.99, {'2018/12': 19.45, '2019/12': 19.52, '2020/12': 12.07, '2021/12': 82.2, '2022/12': 29.99, '2023/12': nan}),
-    '순운전자본회전율': (1.04, {'2018/12': 21.91, '2019/12': 23.12, '2020/12': 5.88, '2021/12': 5.6, '2022/12': 6.04, '2023/12': nan}),
-    '유동비율': 64.29,
-    '이자보상배율': (-3.64, {'2018/12': 4.01, '2019/12': 1.3, '2020/12': -5.05, '2021/12': 0.56, '2022/12': -1.28, '2023/12': nan}),
-    '재고자산회전율': (1.66, {'2018/12': 12.41, '2019/12': 12.44, '2020/12': 9.18, '2021/12': 9.76, '2022/12': 8.79, '2023/12': nan})
-    }
-
-    <유동비율>
-    100미만이면 주의하나 현금흐름창출력이 좋으면 괜찮을수 있다.
-    만약 100%이하면 유동자산에 추정영업현금흐름을 더해서 다시계산해보아 기회를 준다.
-    <이자보상배율>
-    이자보상배율 영업이익/이자비용으로 1이면 자금사정빡빡 5이상이면 양호
-    <순운전자금회전율>
-    순운전자금 => 기업활동을 하기 위해 필요한 자금 (매출채권 + 재고자산 - 매입채무)
-    순운전자본회전율은 매출액/순운전자본으로 일정비율이 유지되는것이 좋으며 너무 작아지면 순운전자본이 많아졌다는 의미로 재고나 외상이 쌓인다는 뜻
-    <재고자산회전율>
-    재고자산회전율은 매출액/재고자산으로 회전율이 낮을수록 재고가 많다는 이야기이므로 불리 전년도등과 비교해서 큰차이 발생하면 알람.
-    재고자산회전율이 작아지면 재고가 쌓인다는뜻
-    <순부채비율>
-    부채비율은 업종마다 달라 일괄비교 어려우나 순부채 비율이 20%이하인것이 좋고 꾸준히 늘어나지 않는것이 좋다.
-    순부채 비율이 30%이상이면 좋치 않다.
-    <매출액>
-    매출액은 어떤경우에도 성장하는 기업이 좋다.매출이 20%씩 늘어나는 종목은 유망한 종목
-    <영업이익률>
-    영업이익률은 기업의 경쟁력척도로 경쟁사에 비해 높으면 경제적해자를 갖춘셈
-    """
-
-    d1, 유동비율 = tools.calc유동비율(code, pop_count=3)
-    logger.debug(f'유동비율 {유동비율} / [{d1}]')
-
-    c104y = myredis.C104(code, 'c104y')
-    c106q_재고자산회전율 = myredis.C106.make_like_c106(code, 'c104q', '재고자산회전율')
-    _, dict이자보상배율y = c104y.find_without_yoy('이자보상배율')
-    _, dict순운전자본회전율y = c104y.find_without_yoy('순운전자본회전율')
-    _, dict재고자산회전율y = c104y.find_without_yoy('재고자산회전율')
-    _, dict순부채비율y = c104y.find_without_yoy('순부채비율')
-
-    c104q = myredis.C104(code, 'c104q')
-    d6, 이자보상배율q = c104q.latest_value_pop2('이자보상배율')
-    d7, 순운전자본회전율q = c104q.latest_value_pop2('순운전자본회전율')
-    d8, 재고자산회전율q = c104q.latest_value_pop2('재고자산회전율')
-    d9, 순부채비율q = c104q.latest_value_pop2('순부채비율')
-
-    if len(dict이자보상배율y) == 0:
-        logger.warning(f'empty dict - 이자보상배율 : {이자보상배율q} {dict이자보상배율y}')
-
-    if len(dict순운전자본회전율y) == 0:
-        logger.warning(f'empty dict - 순운전자본회전율 : {순운전자본회전율q} {dict순운전자본회전율y}')
-
-    if len(dict재고자산회전율y) == 0:
-        logger.warning(f'empty dict - 재고자산회전율 : {재고자산회전율q} {dict재고자산회전율y}')
-
-    if len(dict순부채비율y) == 0:
-        logger.warning(f'empty dict - 순부채비율 : {순부채비율q} {dict순부채비율y}')
-
-    ################################################################
-
-    return {
-        '유동비율': 유동비율,
-        '이자보상배율': (이자보상배율q, dict이자보상배율y),
-        '순운전자본회전율': (순운전자본회전율q, dict순운전자본회전율y),
-        '재고자산회전율': (재고자산회전율q, dict재고자산회전율y),
-        'c106q_재고자산회전율': c106q_재고자산회전율,
-        '순부채비율': (순부채비율q, dict순부채비율y),
-        'date': tools.set_data(d1, d6, d7, d8, d9),  # ''값을 제거하고 리스트로 바꾼다.
-    }
-
-
-def growth(code: str) -> dict:
-    """
-    리턴값
-    {'date': [각 유효한 값의 최근분기 값 리스트(ex- 2020/09)],
-    '매출액증가율': (-14.37, {'2018/12': -24.56, '2019/12': -20.19, '2020/12': -12.64, '2021/12': 38.65, '2022/12': -8.56, '2023/12': nan}),
-    '영업이익률': {'뉴프렉스': '17.36', '동일기연': '13.58', '비에이치': '16.23', '에이엔피': '-9.30', '이브이첨단소재': '-4.93'}}
-
-    <매출액>
-    매출액은 어떤경우에도 성장하는 기업이 좋다.매출이 20%씩 늘어나는 종목은 유망한 종목
-    <영업이익률>
-    영업이익률은 기업의 경쟁력척도로 경쟁사에 비해 높으면 경제적해자를 갖춘셈
-    """
-    c104y = myredis.C104(code, 'c104y')
-    c106y = myredis.C106(code, 'c106y')
-
-    _, dict매출액증가율y = c104y.find_without_yoy('매출액증가율')
-
-    c104q = myredis.C104(code, 'c104q')
-    d2, 매출액증가율q = c104q.latest_value_pop2('매출액증가율')
-
-    logger.debug(f'매출액증가율 : {매출액증가율q} {dict매출액증가율y}')
-
-    ################################################################
-
-    # c106 에서 타 기업과 영업이익률 비교
-    dict영업이익률 = c106y.find('영업이익률')
-
-    return {
-        '매출액증가율': (매출액증가율q, dict매출액증가율y),
-        '영업이익률': dict영업이익률,
-        'date': [d2, ]}
-
-
-"""
-- 각분기의 합이 연이 아닌 타이틀(즉 sum_4q를 사용하면 안됨)
-'*(지배)당기순이익'
-'*(비지배)당기순이익'
-'장기차입금'
-'현금및예치금'
-'매도가능금융자산'
-'매도파생결합증권'
-'만기보유금융자산'
-'당기손익-공정가치측정금융부채'
-'당기손익인식(지정)금융부채'
-'단기매매금융자산'
-'단기매매금융부채'
-'예수부채'
-'차입부채'
-'기타부채'
-'보험계약부채(책임준비금)'
-'*CAPEX'
-'ROE'
-"""
-
-"""
-- sum_4q를 사용해도 되는 타이틀
-'자산총계'
-'당기순이익'
-'유동자산'
-'유동부채'
-'비유동부채'
-
-'영업활동으로인한현금흐름'
-'재무활동으로인한현금흐름'
-'ROIC'
-"""