dsyoon/DeepStock
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
dsyoon
2023-01-10 02:41:36 +09:00
parent 221c9a0075
commit ab0195a84c
5 changed files with 662 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@@ -1,5 +1,5 @@
# ---> Python
.idea
*.json
*.html
resources/stock*.db

195
HTS_252670_daily.py Normal file
View File

@@ -0,0 +1,195 @@
import time
import os
from datetime import datetime
from hts.DailyStatus import DailyStatus
from hts.HTS import HTS
from hts.OrderType import OrderType
from hts.BuySellChecker import BuySellChecker
from hts.OrderChecker import OrderChecker
from stock.util.LabelChecker import LabelChecker
class HTS_252670_DAILY (HTS):
RESOURCE_PATH = None
stock_code = None
buy_count = None
orderChecker = None
buySellChecker = None
labelChecker = None
dailyStatus = None
def __init__(self, RESOURCE_PATH, stock_code, buy_count):
super().__init__(RESOURCE_PATH)
self.RESOURCE_PATH = RESOURCE_PATH
self.stock_code = stock_code
self.buy_count = buy_count
self.orderChecker = OrderChecker(self.RESOURCE_PATH, self.stock_code)
self.buySellChecker = BuySellChecker()
self.labelChecker = LabelChecker(RESOURCE_PATH)
self.dailyStatus = DailyStatus(RESOURCE_PATH)
return
def getSellingPrice(self, log_time, stock_code, final_price, check=False):
# final_price와 diff를 받으면, 해당 가격으로 그냥 매도한다는 의미
# final_price와 diff가 None이면 장부가와 final 중 max로 팔겠다는 의미
# final_price가 0이고 diff가 None이면 장부가로 팔겠다는 의미임
sell_price = -1
jangoDic = self.requstJango()
if jangoDic and len(jangoDic.keys()) > 0:
for code in jangoDic:
if jangoDic[code]['매도가능'] > 0:
if check:
if jangoDic[code]['장부가']*0.05 < jangoDic[code]['장부가'] - final_price:
sell_price = jangoDic[code]['장부가']
if code == "A" + stock_code:
orderNum = self.requestOrder(OrderType.sell, stock_code, jangoDic[code]['매도가능'], sell_price)
print("ORDER_SELL", stock_code, log_time.strftime('%Y%m%d %H%M%S'), jangoDic[code]['매도가능'], sell_price)
else:
max_price = max(jangoDic[code]['장부가'], final_price)
sell_price = (int(max_price) - int(max_price) % 5) + 5
if code == "A"+stock_code:
orderNum = self.requestOrder(OrderType.sell, stock_code, jangoDic[code]['매도가능'], sell_price)
print("ORDER_SELL", stock_code, log_time.strftime('%Y%m%d %H%M%S'), jangoDic[code]['매도가능'], sell_price)
return
def buyRealTime(self, today):
print ("START...")
THIS_TIME = datetime.now()
final_sell_check = False
LAST_DATA = self.dailyStatus.getLastData(self.stock_code, today)
while datetime.strptime(today + " 070000", '%Y%m%d %H%M%S') < THIS_TIME < datetime.strptime(today + " 153100", '%Y%m%d %H%M%S'):
if datetime.strptime(today + " 090000", '%Y%m%d %H%M%S') < THIS_TIME < datetime.strptime(today + " 151500", '%Y%m%d %H%M%S'):
# 3시 까지만 매수를 시도한다.
if THIS_TIME < datetime.strptime(today + " 145000", '%Y%m%d %H%M%S'):
if THIS_TIME.strftime('%S') in ("06", "16", "26", "36", "46", "56"):
# 데이터를 가지고 온다.
result = self.getRealTime(self.stock_code, today, LAST_DATA)
final_price = result["close"][len(result["close"])-1]
# 10초마다 체크하여 체결된 내역이 있으면 50원 높게 매도를 주문한다.
self.getSellingPrice(THIS_TIME, self.stock_code, final_price, check=True)
if THIS_TIME.strftime('%S') == "03":
# 매분 3초마다 실행한다.
# 데이터를 가지고 온다.
result = self.getRealTime(self.stock_code, today, LAST_DATA)
# 규칙 기반의 분석을 통해서 볼린저밴드 상/하단을 계산한다.
data = self.buySellChecker.analyze(result)
# 만약 미체결 내역이 있는데, 지표가 꺽여 내려온다면, 매수 주문을 취소 시킨다.
last_index = len(data['close']) - 1
if data['slow_k'][last_index-1]>=80 and data['slow_k'][last_index-1] > data['slow_k'][last_index]:
# 미체결 기록을 가져온다.
ORDER_LIST = self.requestOrderList()
orderListToCancel = self.orderChecker.remove(self.stock_code, OrderType.sell, ORDER_LIST)
self.cancelOrderList(orderListToCancel)
print("CANCEL", THIS_TIME.strftime('%Y%m%d %H%M%S'), len(orderListToCancel), len(ORDER_LIST))
# 사야 할 시점/가격과 팔아야 할 시점/가격을 체크한다.
bsLine, data = self.buySellChecker.checkTransaction(data, self.stock_code, isRealTime=True)
bs_buy_price = bsLine['buy'][0]
bs_buy_weight = bsLine['buy_weight'][0]
bs_sell_price = bsLine['sell'][0]
data_size = len(data["close"])
final_price = data["close"][data_size-1]
if bs_buy_price > 0:
# 기본 100 주에 가중치를 추가해서 매수한다.
BUY_COUNT = int(self.buy_count * bs_buy_weight)
# 매수를 주문한다.
orderNum = self.requestOrder(OrderType.buy, self.stock_code, BUY_COUNT , bs_buy_price)
# 미체결 기록을 가져온다.
ORDER_LIST = self.requestOrderList()
# 매수 주문을 기록한다.
orderListToCancel = self.orderChecker.add(self.stock_code, OrderType.buy, orderNum, BUY_COUNT, bs_buy_price, ORDER_LIST)
# 1 시간 이전 미체결을 모두 취소한다.
self.cancelOrderList(orderListToCancel)
# 로그 출력
print("BUY", THIS_TIME.strftime('%Y%m%d %H%M%S'), BUY_COUNT, bs_buy_price, len(orderListToCancel), len(ORDER_LIST))
if bs_sell_price > 0:
# 미체결 기록을 가져온다.
ORDER_LIST = self.requestOrderList()
# 매도 주문을 기록을 가져온다.
orderListToCancel = self.orderChecker.remove(self.stock_code, OrderType.sell, ORDER_LIST)
# 매도 미체결을 모두 취소한다.
self.cancelOrderList(orderListToCancel)
# 매도한다.
self.getSellingPrice(THIS_TIME, self.stock_code, final_price)
# 로그 출력
print("TIMECHECK: %s, price: %d, avg3: %.2f, avg5: %.2f, avg10: %.2f, slow_k: %.2f, open: %d, high: %d, low: %d" %
(str(THIS_TIME), final_price,
data["avg3"][data_size - 1], data["avg6"][data_size - 1], data["avg9"][data_size - 1], data["slow_k"][data_size - 2],
data["open"][data_size - 1], data["high"][data_size - 1], data["low"][data_size - 1],))
elif datetime.strptime(today + " 151530", '%Y%m%d %H%M%S') < THIS_TIME < datetime.strptime(today + " 151600", '%Y%m%d %H%M%S'):
# 3시 15분 30초부터 3시 16분 사이는 잔량을 매도한다.
if not final_sell_check:
####
# 손해 보지 않는 가격에 매도한다.
####
# 주문 리스트를 가져온다.
orderList = self.requestOrderList()
# 15:10:00 이후라면 모든 미체결 취소한다.
self.cancelOrderList(orderList)
# 매도 가격을 가져온다.
result = self.getRealTime(self.stock_code, today, LAST_DATA)
final_price = result["close"][len(result["close"]) - 1]
self.getSellingPrice(THIS_TIME, self.stock_code, final_price)
final_sell_check = True
time.sleep(0.9)
THIS_TIME = datetime.now()
return
def updteTodayStock(self, db_filename, stock_code, today_str):
bsLine, data = self.labelChecker.makeCandidate(stock_code, today_str)
self.labelChecker.updateLabel(db_filename, stock_code, bsLine, data, today_str)
return
if __name__ == "__main__":
today = datetime.today()
PROJECT_HOME = os.getcwd()
RESOURCE_PATH = os.path.join(PROJECT_HOME, "resources")
# KODEX 인버스 * 2
stock_code = "252670"
stock_name = "KODEX 200선물인버스2X"
buy_count = 900
hts = HTS_252670_DAILY(RESOURCE_PATH, stock_code, buy_count)
today_str = today.strftime('%Y%m%d')
#today_str = "20220916"
hts.buyRealTime(today_str)
db_filename = os.path.join(RESOURCE_PATH, "hts.db")
hts.insertStockData(db_filename, stock_code, stock_name, today_str)
#hts.updteTodayStock(db_filename, stock_code, today_str)
print ("done...")

164
Simulation_Daily.py Normal file
View File

@@ -0,0 +1,164 @@
import numpy as np
from math import nan
import pandas as pd
import plotly.graph_objects as go
from plotly import subplots
import os
from datetime import datetime
from hts.HTS import HTS
from hts.DailyStatus import DailyStatus
from hts.BuySellChecker import BuySellChecker
class Simulation (HTS):
buySellChecker = None
stockPredictor = None
dailyStatus = None
def __init__(self, RESOURCE_PATH):
super().__init__(RESOURCE_PATH)
self.RESOURCE_PATH = RESOURCE_PATH
self.buySellChecker = BuySellChecker()
self.dailyStatus = DailyStatus(RESOURCE_PATH)
return
def draw(self, stock_code, given_day, data, bsLine):
if bsLine is None:
return
# 어제 데이터는 지운다.
buy_line = bsLine['buy']
buy_weight_line = bsLine['buy_weight']
sell_line = bsLine['sell']
# 그래프 설정을 위한 변수를 생성한다.
data = data.astype(
{
'open': 'int',
'high': 'int',
'low': 'int',
'close': 'int',
'slow_k': 'float',
'slow_d': 'float',
'macd': 'float',
'macds': 'float',
'envelope_upper': 'float',
'envelope_lower': 'float',
'envelope_middle': 'float',
'rsi': 'float',
'rsis': 'float'
}
)
buy_size = []
buy_colors = []
for i in range(len(buy_line)):
if buy_line[i] < 0:
buy_colors.append("#ffffff")
buy_line[i] = nan
buy_size.append(0)
else:
buy_colors.append("#B2028C")
buy_size.append(10 + (5 * buy_weight_line[i]))
sell_colors = []
for i in range(len(sell_line)):
if sell_line[i] < 0:
sell_colors.append("#ffffff")
sell_line[i] = nan
else:
sell_colors.append("#00ced1")
# 그래프를 설정한다.
buy_check = go.Scatter(x=data['ymd'], y=buy_line, mode='markers', name="buy", marker=dict(size=buy_size, color=buy_colors, line_width=0))
sell_check = go.Scatter(x=data['ymd'], y=sell_line, mode='markers', name="sell", marker=dict(size=14, color=sell_colors, line_width=0))
envelope_upper = go.Scatter(x=data['ymd'], y=data["envelope_upper"], name="upper", line_color='#000000')
envelope_middle = go.Scatter(x=data['ymd'], y=data["envelope_middle"], name="upper", line_color='#927786')
envelope_lower = go.Scatter(x=data['ymd'], y=data["envelope_lower"], name="lower", line_color='#000000')
candle_stick = go.Candlestick(x=data['ymd'], open=data['open'], high=data['high'], low=data['low'], close=data['close'], increasing_line_color='red', decreasing_line_color='blue', showlegend=False)
macd_line = go.Scatter(x=data['ymd'], y=data["macd"], line=dict(color='red', width=2), name='macd')
macd_s_line = go.Scatter(x=data['ymd'], y=data["macds"], line=dict(dash='dashdot', color='black', width=2), name='macds')
# fast_k_line = go.Scatter(x=hts['date'], y=hts["fast_k"], mode='lines', name='fast_k')
slow_k_line = go.Scatter(x=data['ymd'], y=data["slow_k"], line=dict(color='red', width=2), name='slow_k')
slow_d_line = go.Scatter(x=data['ymd'], y=data["slow_d"], line=dict(dash='dashdot', color='black', width=2), name='slow_d')
rsi_line = go.Scatter(x=data['ymd'], y=data["rsi"], line=dict(color='red', width=2), name='rsi')
rsis_line = go.Scatter(x=data['ymd'], y=data["rsis"], line=dict(dash='dashdot', color='black', width=2), name='rsis')
candle_data = [candle_stick, envelope_upper, envelope_middle, envelope_lower, buy_check, sell_check]
macd_data = [macd_line, macd_s_line]
stochastic_data = [slow_k_line, slow_d_line]
rsi_data = [rsi_line, rsis_line]
# 그래프를 그린다.
"""
fig = go.Figure(data=candle_data)
fig.update_layout(title=stock_code + "_" + given_day)
fig.show()
"""
fig = subplots.make_subplots(
rows=4, cols=1,
subplot_titles=("MACD", "RSI", "스토캐스틱", '캔들'),
#specs=[[{}], [{}], [{}], [{}], [{}], [{}]],
shared_xaxes=True, horizontal_spacing=0.03, vertical_spacing=0.01,
row_heights=[200, 200, 200, 750]
)
for trace in macd_data:
fig.append_trace(trace, 1, 1)
for trace in rsi_data:
fig.append_trace(trace, 2, 1)
for trace in stochastic_data:
fig.append_trace(trace, 3, 1)
for trace in candle_data:
fig.append_trace(trace, 4, 1)
#fig.update_xaxes(nticks=5)
#fig.update_layout(height=1800, title=stock_code + "_" + given_day, xaxis_rangeslider_visible=False)
df = pd.DataFrame(bsLine)
df = df.fillna(-1)
buy_count = len(df.loc[df["buy"] > 0])
sell_count = len(df.loc[df["sell"] > 0])
fig.update_layout(height=1700, title=stock_code + "_" + given_day + "_" + str(buy_count)+","+str(sell_count))
#fig.update_layout(title=stock_code + "_" + given_day + "_" + str(buy_count) + "," + str(sell_count))
fig.show()
return
def simulate(self, stock_code, n=100):
today = datetime.today().strftime('%Y%m%d')
data = self.dailyStatus.getLastData(stock_code, today, n)
# 사야 할 시점과 팔아야 할 시점을 체크한다.
bsLine, data = self.buySellChecker.checkEnvelopeTiming(data, stock_code, isRealTime=False)
# 그래프를 그린다.
self.draw(stock_code, today, data, bsLine)
return
if __name__ == "__main__":
PROJECT_HOME = os.getcwd()
RESOURCE_PATH = os.path.join(PROJECT_HOME, "resources")
# to check bying
stock_codes = ["252670", "122630"]
#stock_codes = ["252670"]
#stock_codes = ["122630"]
for stock_code in stock_codes:
simulation = Simulation(RESOURCE_PATH)
simulation.simulate(stock_code, 2000)
print ("done...")

201
hts/BuySellChecker.py
View File

@@ -1,5 +1,4 @@
import pandas as pd
import numpy as np
from stock.analysis.Common import Common
from stock.analysis.Stochastic import Stochastic
from stock.analysis.RSI import RSI
@@ -838,4 +837,202 @@ class BuySellChecker:
bsLine['buy'][i] = int((data["open"][i] + data["close"][i]) / 2)
bsLine['buy_weight'][i] = 1
return bsLine, data
return bsLine, data
def getBuyPriceAndWeight_Envelope_trend(self, data, i):
buy, weight, type = -1, -1, -1
if data['close'][i-1] < data['envelope_lower'][i-1] and data['envelope_lower'][i] < data['close'][i]:
buy = data["close"][i]
weight = 1
type = 1
if data['close'][i] < data['envelope_lower'][i]:
if data['rsis'][i] < data['rsi'][i]:
buy = data["close"][i]
weight = 1
type = 2
if data['close'][i-1] < data['envelope_middle'][i-1] and data['envelope_middle'][i] < data['close'][i]:
if data['slow_k'][i] < 25:
buy = data["close"][i]
weight = 1
type = 3
check1 = False
check2 = False
if data['slow_k'][i] < 40:
if data['close'][i-1] < data['envelope_middle'][i-1] and data['envelope_middle'][i] < data['close'][i]:
idx = -1
for t1 in range(i-1, i-10, -1):
if data['close'][t1] < data['envelope_middle'][t1]:
check1 = True
idx = t1
break
if check1:
for t1 in range(idx-1, i - 10, -1):
if data['envelope_middle'][t1] < data['close'][t1]:
check2 = True
break
if check2:
buy = data["close"][i]
weight = 1
type = 4
if data.index[i].strftime("%Y.%m.%d") == "2021.12.21":
print(1)
check = True
if data['slow_k'][i] < 40:
if data['close'][i - 1] < data['envelope_middle'][i - 1] and data['envelope_middle'][i] < data['close'][i]:
for t1 in range(i-1, i-10, -1):
if data['envelope_middle'][t1] < data['close'][t1]:
check = False
if check:
buy = data["close"][i]
weight = 1
type = 4
return buy, weight, type
def getSellPriceAndWeight_Envelope_trend(self, data, i):
sell, weight, type = -1, -1, -1
if data.index[i].strftime("%Y.%m.%d") == "2022.12.01":
print (1)
# upper lined에서 처리
if data['close'][i-1] < data['envelope_upper'][i - 1] and data['envelope_upper'][i] < data['close'][i]:
if data['slow_d'][i-1] <= data['slow_k'][i - 1] and data['slow_k'][i] <= data['slow_d'][i]:
sell = data["close"][i]
weight = 1
type = 1
if data['envelope_upper'][i-1] < data['close'][i - 1] and data['envelope_upper'][i] < data['close'][i]:
if data['slow_d'][i-1] <= data['slow_k'][i - 1] and data['slow_k'][i] <= data['slow_d'][i]:
sell = data["close"][i]
weight = 1
type = 2
if data['envelope_upper'][i-1] < data['close'][i - 1] and data['envelope_upper'][i] < data['close'][i]:
if data['slow_d'][i-1] +2 <= data['slow_k'][i - 1] and data['slow_d'][i]+1 == data['slow_k'][i]:
sell = data["close"][i]
weight = 1
type = 3
if data['envelope_upper'][i]<data['high'][i] and data['open'][i] < data['close'][i]:
if data['close'][i] - data['open'][i] < data['high'][i] - data['close'][i]:
sell = data["close"][i]
weight = 1
type = 4
return sell, weight, type
def getBuyPriceAndWeight_Envelope(self, data, i):
buy, weight, type = -1, -1, -1
if data['close'][i-1] < data['envelope_lower'][i-1] and data['envelope_lower'][i] < data['close'][i]:
buy = data["close"][i]
weight = 1
type = 1
if data['close'][i] < data['envelope_lower'][i]:
if data['rsis'][i] < data['rsi'][i]:
buy = data["close"][i]
weight = 1
type = 2
return buy, weight, type
def getSellPriceAndWeight_Envelope(self, data, i):
sell, weight, type = -1, -1, -1
if data.index[i].strftime("%Y.%m.%d") == "2022.12.01":
print (1)
# upper lined에서 처리
if data['close'][i-1] < data['envelope_upper'][i - 1] and data['envelope_upper'][i] < data['close'][i]:
if data['slow_d'][i-1] <= data['slow_k'][i - 1] and data['slow_k'][i] <= data['slow_d'][i]:
sell = data["close"][i]
weight = 1
type = 1
if data['envelope_upper'][i-1] < data['close'][i - 1] and data['envelope_upper'][i] < data['close'][i]:
if data['slow_d'][i-1] <= data['slow_k'][i - 1] and data['slow_k'][i] <= data['slow_d'][i]:
sell = data["close"][i]
weight = 1
type = 2
if data['envelope_upper'][i-1] < data['close'][i - 1] and data['envelope_upper'][i] < data['close'][i]:
if data['slow_d'][i-1] +2 <= data['slow_k'][i - 1] and data['slow_d'][i]+1 == data['slow_k'][i]:
sell = data["close"][i]
weight = 1
type = 3
# middle lined에서 처리
middle_up = False
if data['envelope_middle'][i-1] < data['close'][i-1] or data['envelope_middle'][i] < data['open'][i]:
if data['envelope_middle'][i-2] < data['close'][i-2] or data['envelope_middle'][i-1] < data['close'][i-1] or data['envelope_middle'][i] < data['close'][i]:
for t in range(i-1, i-20, -1):
if data['envelope_upper'][t] <= data['close'][t]:
middle_up = False
break
if data['close'][t] < data['envelope_middle'][t]:
middle_up = True
break
if middle_up:
if data['slow_d'][i-1] < data['slow_k'][i-1] and data['slow_k'][i] < data['slow_d'][i]:
sell = data["close"][i]
weight = 1
type = 4
return sell, weight, type
def checkEnvelopeTiming(self, data, stock_code, isRealTime=True):
# 어제 오늘 데이터로 분석
bsLine = {}
size = len(data["close"])
if isRealTime:
# isRealTime=True, 실시간 적용
last_index = size - 1
if stock_code == "252670":
buy, buy_weight, buy_type = self.getBuyPriceAndWeight_Envelope(data, last_index)
sell, sell_weight, sell_type = self.getSellPriceAndWeight_Envelope(data, last_index)
else:
buy, buy_weight, buy_type = self.getBuyPriceAndWeight_Envelope(data, last_index)
sell, sell_weight, sell_type = self.getSellPriceAndWeight_Envelope(data, last_index)
bsLine['buy'] = [buy]
bsLine['buy_weight'] = [buy_weight]
bsLine['sell'] = [sell]
bsLine['sell_weight'] = [sell_weight]
else:
# Type=False, 시뮬레이션 적용
bsLine['buy'] = [-1 for i in range(size)]
bsLine['buy_weight'] = [-1 for i in range(size)]
bsLine['sell'] = [-1 for i in range(size)]
bsLine['sell_weight'] = [-1 for i in range(size)]
for i in range(size):
if stock_code == "252670":
buy, buy_weight, buy_type = self.getBuyPriceAndWeight_Envelope_trend(data, i)
sell, sell_weight, sell_type = self.getSellPriceAndWeight_Envelope_trend(data, i)
else:
buy, buy_weight, buy_type = self.getBuyPriceAndWeight_Envelope(data, i)
sell, sell_weight, sell_type = self.getSellPriceAndWeight_Envelope(data, i)
bsLine['buy'][i] = buy
bsLine['buy_weight'][i] = buy_weight
bsLine['sell'][i] = sell
bsLine['sell_weight'][i] = sell_weight
if i > 0:
if bsLine['sell'][i-1] > -1:
bsLine['sell'][i] = -1
bsLine['sell_weight'][i] = -1
return bsLine, data

103
hts/DailyStatus.py Normal file
View File

@@ -0,0 +1,103 @@
import os.path
import pandas as pd
import platform
if platform.system().lower().find("window") >= 0 and platform.architecture()[0] != "64bit" :
import win32com.client
import sqlite3
from datetime import datetime, timedelta
class DailyStatus:
tableName = None
dbFileName = None
RESOURCE_PATH = None
def __init__(self, RESOURCE_PATH):
self.RESOURCE_PATH = RESOURCE_PATH
self.tableName = 'stock_analysis'
self.dbFileName = "stock.db"
return
def getDBData(self, stock_code, day, result):
conn = sqlite3.connect(os.path.join(self.RESOURCE_PATH, self.dbFileName))
cursor = conn.cursor()
cursor.execute('SELECT ymd, close, open, high, low, envelope_upper, envelope_lower, envelope_middle, rsi, rsis, macd, macds, stochastic_slow_k, stochastic_slow_d FROM ' + self.tableName + ' WHERE CODE=? and ymd=? order by ymd', (stock_code, day,))
db_result = cursor.fetchall()
for rows in db_result:
ymd = rows[0]
close = rows[1]
open = rows[2]
high = rows[3]
low = rows[4]
envelope_upper = rows[5]
envelope_lower = rows[6]
envelope_middle = rows[7]
rsi = 0 if rows[8] is None else rows[8]
rsis = 0 if rows[9] is None else rows[9]
macd = rows[10]
macds = rows[11]
stochastic_slow_k = 0 if rows[12] is None else rows[12]
stochastic_slow_d = 0 if rows[13] is None else rows[13]
result["ymd"].append(ymd)
result["open"].append(int(open))
result["close"].append(int(close))
result["high"].append(int(high))
result["low"].append(int(low))
result["envelope_upper"].append(int(envelope_upper))
result["envelope_lower"].append(int(envelope_lower))
result["envelope_middle"].append(int(envelope_middle))
result["rsi"].append(int(rsi))
result["rsis"].append(int(rsis))
result["macd"].append(int(macd))
result["macds"].append(int(macds))
result["slow_k"].append(int(stochastic_slow_k))
result["slow_d"].append(int(stochastic_slow_d))
return
def isValidYMD(self, stock_code, day):
conn = sqlite3.connect(os.path.join(self.RESOURCE_PATH, self.dbFileName))
cursor = conn.cursor()
cursor.execute('SELECT ymd, count(*) as cnt FROM ' + self.tableName + ' WHERE CODE=? and ymd=?', (stock_code, day,))
db_result = cursor.fetchone()
if db_result[1] > 0:
return True
return False
def getLastData(self, stock_code, today, n=10):
result = {
"ymd": [],
"open": [],
"close": [],
"high": [],
"low": [],
"envelope_upper": [],
"envelope_lower": [],
"envelope_middle": [],
"rsi": [],
"rsis": [],
"macd": [],
"macds": [],
"slow_k": [],
"slow_d": []
}
days = []
for i in range(1, n):
last_day = (datetime.strptime(today, '%Y%m%d') - timedelta(i)).strftime('%Y.%m.%d')
isValid = self.isValidYMD(stock_code, last_day)
if isValid:
days.append(last_day)
days = sorted(days)
for day in days:
self.getDBData(stock_code, day, result)
data = pd.DataFrame(result)
df_final_time = pd.DatetimeIndex(result['ymd'])
data.index = df_final_time
return data