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-12-17 17:41:43 +09:00
parent c995d5e3e2
commit 308a01fc13
2 changed files with 219 additions and 226 deletions
Download Patch File Download Diff File Expand all files Collapse all files

215
HTS_etf.py
View File

@@ -37,11 +37,15 @@ class HTS_etf(HTS):
ichimokuCloud = None
def __init__(self, RESOURCE_PATH):
def __init__(self, RESOURCE_PATH, stock_code, stock_name, SELL_GAP):
super().__init__(RESOURCE_PATH)
self.RESOURCE_PATH = RESOURCE_PATH
self.SELL_GAP = SELL_GAP
self.stock_code = stock_code
self.stock_name = stock_name
self.orderChecker = OrderChecker(self.RESOURCE_PATH, self.stock_code)
self.bot = TelegramBot()
self.stockStatus = StockStatus(RESOURCE_PATH)
@@ -51,7 +55,7 @@ class HTS_etf(HTS):
self.macd = MACD()
self.ichimokuCloud = IchimokuCloud()
self.buySellChecker = BuySellChecker(self.RESOURCE_PATH)
self.buySellChecker = BuySellChecker(self.RESOURCE_PATH, self.stock_code)
return
@@ -64,7 +68,7 @@ class HTS_etf(HTS):
return jangoDic[code]['장부가'], jangoDic[code]['평가금액'], jangoDic[code]['평가손익']
return 0, 0, 0
def sellStocks(self, stock_code=None, stock_name=None, bs_sell_price=None):
def sellStocks(self, stock_code=None, stock_name=None, bs_sell_price=None, sell_count=0):
check = False
jangoDic = self.requstJango()
if jangoDic and len(jangoDic.keys()) > 0:
@@ -73,62 +77,36 @@ class HTS_etf(HTS):
if code == "A" + stock_code:
if bs_sell_price is not None:
if jangoDic[code]['매도가능'] > 0:
#if jangoDic[code]['평가손익'] < -1.0 or jangoDic[code]['장부가'] + 10 <= jangoDic[code]['현재가']:
if jangoDic[code]['장부가'] + 10 <= jangoDic[code]['현재가']:
if jangoDic[code]['평가손익'] < -0.6 or 1.0 < jangoDic[code]['평가손익'] or self.SELL_GAP < jangoDic[code]['평가금액']-jangoDic[code]['매입금액']:
# 1.5% 손해 혹은 2% 이상 시 수익 매도
self.requestOrder(OrderType.sell, code[1:], jangoDic[code]['매도가능'], bs_sell_price)
if sell_count == 0:
self.requestOrder(OrderType.sell, code[1:], jangoDic[code]['매도가능'], bs_sell_price)
else:
self.requestOrder(OrderType.sell, code[1:], sell_count, bs_sell_price)
self.bot.sendMsg("Profit {:.2f}, {} ({})".format(jangoDic[code]['평가손익'], stock_code, stock_name))
check = True
else:
if jangoDic[code]['매도가능'] > 0:
#if jangoDic[code]['평가손익'] < -1.0 or jangoDic[code]['장부가'] + 10 <= jangoDic[code]['현재가']:
if jangoDic[code]['장부가'] + 10 <= jangoDic[code]['현재가']:
if jangoDic[code]['평가손익'] < -0.6 or 1.0 < jangoDic[code]['평가손익'] or self.SELL_GAP < jangoDic[code]['평가금액']-jangoDic[code]['매입금액']:
# 1.5% 손해 혹은 2% 이상 시 수익 매도
self.requestOrder(OrderType.sell, code[1:], jangoDic[code]['매도가능'], jangoDic[code]['현재가'])
if sell_count == 0:
self.requestOrder(OrderType.sell, code[1:], jangoDic[code]['매도가능'], jangoDic[code]['현재가'])
else:
self.requestOrder(OrderType.sell, code[1:], sell_count, jangoDic[code]['현재가'])
self.bot.sendMsg("Profit {:.2f}, {} ({})".format(jangoDic[code]['평가손익'], stock_code, stock_name))
check = True
else:
if jangoDic[code]['매도가능'] > 0:
#if jangoDic[code]['평가손익'] < -1.0 or jangoDic[code]['장부가'] + 10 <= jangoDic[code]['현재가']:
if jangoDic[code]['장부가'] + 10 <= jangoDic[code]['현재가']:
if jangoDic[code]['평가손익'] < -0.6 or 1.0 < jangoDic[code]['평가손익'] or self.SELL_GAP < jangoDic[code]['평가금액']-jangoDic[code]['매입금액']:
# 1.5% 손해 혹은 2% 이상 시 수익 매도
self.requestOrder(OrderType.sell, code[1:], jangoDic[code]['매도가능'], jangoDic[code]['현재가'])
if sell_count == 0:
self.requestOrder(OrderType.sell, code[1:], jangoDic[code]['매도가능'], jangoDic[code]['현재가'])
else:
self.requestOrder(OrderType.sell, code[1:], sell_count, jangoDic[code]['현재가'])
self.bot.sendMsg("Profit {:.2f}, {} ({})".format(jangoDic[code]['평가손익'], stock_code, stock_name))
check = True
return check
"""
def sellStocks(self, stock_code=None, stock_name=None, bs_sell_price=None):
check = False
jangoDic = self.requstJango()
if jangoDic and len(jangoDic.keys()) > 0:
for code in jangoDic:
if stock_code is not None:
if code == "A" + stock_code:
if bs_sell_price is not None:
if jangoDic[code]['매도가능'] > 0:
if jangoDic[code]['평가손익'] < -1.0 or 1.5 < jangoDic[code]['평가손익'] or self.SELL_GAP < jangoDic[code]['평가금액']-jangoDic[code]['매입금액']:
# 1.5% 손해 혹은 2% 이상 시 수익 매도
self.requestOrder(OrderType.sell, code[1:], jangoDic[code]['매도가능'], bs_sell_price)
self.bot.sendMsg("Profit {:.2f}, {} ({})".format(jangoDic[code]['평가손익'], stock_code, stock_name))
check = True
else:
if jangoDic[code]['매도가능'] > 0:
if jangoDic[code]['평가손익'] < -1.0 or 1.5 < jangoDic[code]['평가손익'] or self.SELL_GAP < jangoDic[code]['평가금액']-jangoDic[code]['매입금액']:
# 1.5% 손해 혹은 2% 이상 시 수익 매도
self.requestOrder(OrderType.sell, code[1:], jangoDic[code]['매도가능'], jangoDic[code]['현재가'])
self.bot.sendMsg("Profit {:.2f}, {} ({})".format(jangoDic[code]['평가손익'], stock_code, stock_name))
check = True
else:
if jangoDic[code]['매도가능'] > 0:
if jangoDic[code]['평가손익'] < -1.0 or 1.5 < jangoDic[code]['평가손익'] or self.SELL_GAP < jangoDic[code]['평가금액']-jangoDic[code]['매입금액']:
# 1.5% 손해 혹은 2% 이상 시 수익 매도
self.requestOrder(OrderType.sell, code[1:], jangoDic[code]['매도가능'], jangoDic[code]['현재가'])
self.bot.sendMsg("Profit {:.2f}, {} ({})".format(jangoDic[code]['평가손익'], stock_code, stock_name))
check = True
return check
"""
def getSellingPrice(self, log_time, stock_code, final_price, without_loss=False):
# final_price와 diff를 받으면, 해당 가격으로 그냥 매도한다는 의미
# final_price와 diff가 None이면 장부가와 final 중 max로 팔겠다는 의미
@@ -411,101 +389,98 @@ class HTS_etf(HTS):
return result
def buyRealTime(self, stocks, today, MAX_PRICE=30000):
#self.orderChecker = OrderChecker(self.RESOURCE_PATH, stock_code)
BUY_LIST = {
'122630': {'buy_count': 0, 'buy_avg': 0, 'buy_list': []},
'233740': {'buy_count': 0, 'buy_avg': 0, 'buy_list': []},
'251340': {'buy_count': 0, 'buy_avg': 0, 'buy_list': []},
'252670': {'buy_count': 0, 'buy_avg': 0, 'buy_list': []}
}
def buyRealTime(self, today, MAX_PRICE=30000):
BUY_LIST = {'buy_count': 0, 'buy_avg': 0, 'buy_list': []}
print("START...")
THIS_TIME = datetime.now()
#LAST_DATA = self.getLastData(stock_code, today)
isFirst = 0
LAST_DATA = self.getLastData(self.stock_code, today)
while datetime.strptime(today + " 060000", '%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 + " 090100", '%Y%m%d %H%M%S'):
self.bot.sendMsg("START... {} ({}) SLOW_K: {}".format(self.stock_code, self.stock_name, MAX_PRICE))
if datetime.strptime(today + " 090100", '%Y%m%d %H%M%S') < THIS_TIME < datetime.strptime(today + " 151500", '%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'):
for stock in stocks:
stock_code = stock['stock_code']
stock_name = stock['stock_name']
# 매도를 체크한다.
check = self.sellStocks(self.stock_code, self.stock_name)
# 매도를 체크한다.
check = self.sellStocks(stock_code, stock_name)
# jangoDic[code]['장부가'], jangoDic[code]['평가금액'], jangoDic[code]['평가손익'],
buy_avg, amount, profit = self.getBallance(self.stock_code)
if check or buy_avg == 0:
BUY_LIST['buy_avg'] = 0
BUY_LIST['buy_count'] = 0
BUY_LIST['buy_list'].clear()
# jangoDic[code]['장부가'], jangoDic[code]['평가금액'], jangoDic[code]['평가손익'],
buy_avg, amount, profit = self.getBallance(stock_code)
if check or buy_avg == 0:
BUY_LIST[stock_code]['buy_avg'] = 0
BUY_LIST[stock_code]['buy_count'] = 0
BUY_LIST[stock_code]['buy_list'].clear()
time.sleep(0.1)
if isFirst < 4:
if 0 < buy_avg:
BUY_LIST[stock_code]['buy_avg'] = buy_avg
if BUY_LIST is not None and len(BUY_LIST[stock_code]['buy_list']) == 0:
BUY_LIST[stock_code]['buy_list'].append({'buy_ymd': datetime.now(), 'buy_price': buy_avg, 'buy_count': 0, 'buy_cut': 0, 'buy_type': ''})
try:
# 데이터를 가지고 온다.
result_m1 = self.getRealTime(self.stock_code, today, LAST_DATA)
except:
print("#ERROR:", self.stock_code)
continue
self.bot.sendMsg("START... {} ({}) MAX_PRICE: {}".format(stock_code, stock_name, MAX_PRICE))
isFirst += 1
result_tic_m1 = self.makeTickData1(result_m1, mins=1)
data = self.analyze(result_tic_m1)
result_tic_m30 = self.makeTickData2(result_tic_m1, mins=30)
data_signal = self.analyze(result_tic_m30)
time.sleep(0.1)
#data.drop(data.index[:len(data) - analyzed_day], inplace=True)
#result_m1 = self.getRealTime(stock_code, today, LAST_DATA)
result_m1 =self.getRealTime(stock_code, today)
result_tic_m1 = self.makeTickData1(result_m1, mins=1)
data = self.analyze(result_tic_m1)
result_tic_m30 = self.makeTickData2(result_tic_m1, mins=30)
data_signal = self.analyze(result_tic_m30)
#data.drop(data.index[:len(data) - analyzed_day], inplace=True)
# 사야 할 시점과 팔아야 할 시점을 체크한다.
bsLine1 = self.buySellChecker.checkTransaction1(self.stock_code, MAX_PRICE, data, data_signal, BUY_LIST, isRealTime=True)
# 사야 할 시점과 팔아야 할 시점을 체크한다.
bsLine1 = self.buySellChecker.checkTransaction1(stock_code, MAX_PRICE, data, data_signal, BUY_LIST[stock_code], isRealTime=True)
if 'sell_price' in bsLine1:
sell_price = bsLine1['sell_price'][-1]
if 0 < sell_price:
profit_rate = 1.002
if buy_avg * profit_rate < data['close'][-1]:
check = self.sellStocks(stock_code, sell_price)
if 'sell_price' in bsLine1:
sell_price = bsLine1['sell_price'][-1]
sell_count = bsLine1['sell_count'][-1]
sell_type = bsLine1['sell_type'][-1]
if 0 < sell_price:
profit_rate = 1.002
if buy_avg * profit_rate < data['close'][-1]:
if sell_type == 'slow_k' and 0 < sell_count:
check = self.sellStocks(self.stock_code, sell_price, sell_count)
if check:
#self.orderChecker.sell(datetime.today().strftime('%Y%m%d'), stock_code)
BUY_LIST[stock_code]['buy_avg'] = 0
BUY_LIST[stock_code]['buy_count'] = 0
BUY_LIST[stock_code]['buy_list'].clear()
self.bot.sendMsg( "[SELL] Profit {:.2f}, {} ({})".format(profit, stock_code, stock_name))
self.orderChecker.sell(datetime.today().strftime('%Y%m%d'), self.stock_code)
BUY_LIST['buy_avg'] = 0
BUY_LIST['buy_count'] = 0
BUY_LIST['buy_list'].clear()
self.bot.sendMsg("Profit {:.2f}, {} ({})".format(profit, self.stock_code, self.stock_name))
else:
check = self.sellStocks(self.stock_code, sell_price)
if check:
self.orderChecker.sell(datetime.today().strftime('%Y%m%d'), self.stock_code)
BUY_LIST['buy_avg'] = 0
BUY_LIST['buy_count'] = 0
BUY_LIST['buy_list'].clear()
self.bot.sendMsg("Profit {:.2f}, {} ({})".format(profit, self.stock_code, self.stock_name))
if 'buy_price' in bsLine1:
buy_price = bsLine1['buy_price'][-1]
buy_count = int(bsLine1['buy_count'][-1])
if buy_price > 0:
# 매수를 요청 한다.
orderNum = self.requestOrder(OrderType.buy, stock_code, buy_count, buy_price)
#self.orderChecker.buy(today, "A" + stock_code, buy_count, buy_price, orderNum)
if 'buy_price' in bsLine1:
buy_price = bsLine1['buy_price'][-1]
buy_count = int(bsLine1['buy_count'][-1])
if buy_price > 0:
# 매수를 요청 한다.
orderNum = self.requestOrder(OrderType.buy, self.stock_code, buy_count, buy_price)
self.orderChecker.buy(today, "A" + self.stock_code, buy_count, buy_price, orderNum)
#self.orderChecker.buy(datetime.today().strftime('%Y%m%d'), stock_code, buy_count, buy_price)
self.bot.post(stock_code, stock_name, "[BUY] ", buy_price, buy_count, data['rsi'][-1], -1)
self.orderChecker.buy(datetime.today().strftime('%Y%m%d'), self.stock_code, buy_count, buy_price)
self.bot.post(self.stock_code, self.stock_name, "[BUY] ", buy_price, buy_count, data['rsi'][-1], -1)
# 미체결 기록을 가져와서 10분 이상 된 매수 주문을 취소 한다.
ORDER_LIST = self.requestOrderList()
orderListToCancel = self.orderChecker.cancel(today, "A" + self.stock_code, ORDER_LIST, mins=3)
if len(orderListToCancel) > 0:
self.cancelOrderList(orderListToCancel)
"""
# 미체결 기록을 가져와서 10분 이상 된 매수 주문을 취소 한다.
ORDER_LIST = self.requestOrderList()
orderListToCancel = self.orderChecker.cancel(today, "A" + stock_code, ORDER_LIST, mins=3)
if len(orderListToCancel) > 0:
self.cancelOrderList(orderListToCancel)
"""
if ((int(THIS_TIME.strftime("%M")) == 4) and 0 <= int(THIS_TIME.strftime("%S")) <= 59):
#self.bot.alarm_live(stock_code, stock_name)
vm = psutil.virtual_memory()
vm_item = dict()
vm_item['free'] = vm.available // (1024 * 1024)
vm_item['idle'] = vm.available / vm.total * 100
self.bot.sendMsg("Alive... {} ({}) avg: {:.2f}, close: {:.2f}, mem: {:.1f}".format(stock_code, stock_name, buy_avg, data['close'][-1], vm_item['idle']))
if (int(THIS_TIME.strftime("%M")) % 50 == 0 or int(THIS_TIME.strftime("%M")) % 20 == 0):
#self.bot.alarm_live(self.stock_code, self.stock_name)
vm = psutil.virtual_memory()
vm_item = dict()
vm_item['free'] = vm.available // (1024 * 1024)
vm_item['idle'] = vm.available / vm.total * 100
self.bot.sendMsg("Alive... {} ({}) avg: {:.2f}, close: {:.2f}, mem: {:.1f}".format(self.stock_code, self.stock_name, buy_avg, data['close'][-1], vm_item['idle']))
time.sleep(60)
THIS_TIME = datetime.now()

230
hts/BuySellChecker.py
View File

@@ -10,7 +10,7 @@ class BuySellChecker():
PATTERNS = None
RESOURCE_PATH = None
def __init__(self, RESOURCE_PATH):
def __init__(self, RESOURCE_PATH, s):
self.RESOURCE_PATH = RESOURCE_PATH
return
@@ -91,6 +91,28 @@ class BuySellChecker():
macd_dup = list(set(macd_limit))
return macd_dup
def is_Support(self, df, i, observation_time=300):
# c1 = df.Low[i] < df.Low[i - 1] < df.Low[i - 2] < df.Low[i - 3]
# c2 = df.Low[i] < df.Low[i + 1] < df.Low[i + 2] < df.Low[i + 3]
# return c1 & c2
#if df['low'][i] == np.min(df['low'][i - self.observation_time:i + self.observation_time + 1]):
if df['low'][i] == np.min(df['low'][i - observation_time:i+1]):
return True
else:
return False
def is_Resistance(self, df, i, observation_time = 300):
# c1 = df.High[i] > df.High[i - 1] > df.High[i - 2] > df.High[i - 3]
# c2 = df.High[i] > df.High[i + 1] > df.High[i + 2] > df.High[i + 3]
# return c1 & c2
#if df['high'][i] == np.max(df['high'][i - self.observation_time:i + self.observation_time + 1]):
if df['high'][i] == np.max(df['high'][i - observation_time:i+1]):
return True
else:
return False
def getBuyPriceAndWeight1(self, ticker, MAX_BUY_PRICE, i, data, data_signal, BUY_LIST, isRealTime=True):
buy_ymd, buy_price, buy_count, buy_cut, buy_type = None, -1, -1, -1, ''
@@ -98,120 +120,107 @@ class BuySellChecker():
df_signal = data_signal.loc[df_tmp]
si = len(df_signal) - 1
duration = 3
if sum(data['trend_avg'][i - duration:i]) / duration < data['trend_avg'][i]:
# 상승 트렌드
if data_signal['avg20'][si] < data_signal['avg5'][si]:
"""
# 방법 1:
if max(data['volume_up'][i-180:i]) < data['volume_up'][i]:
if data_signal['slow_k'][si] < 70:
if BUY_LIST is not None and 0 < len(BUY_LIST['buy_list']) and BUY_LIST['buy_list'][-1]['buy_price'] < data['close'][i]):
buy_price = data['close'][i]
buy_type = 'volume_up'
buy_ymd = data['ymd'][i]
if data['slow_k'][si] < 30:
buy_count = MAX_BUY_PRICE / (1 * data['close'][i])
elif data['slow_k'][si] < 50:
buy_count = MAX_BUY_PRICE / (1.5 * data['close'][i])
else:
buy_count = MAX_BUY_PRICE / (2 * data['close'][i])
return buy_ymd, buy_price, buy_count, buy_cut, buy_type
if BUY_LIST is None:
buy_price = data['close'][i]
buy_type = 'golden'
buy_ymd = data['ymd'][i]
if data['slow_k'][si] < 30:
buy_count = MAX_BUY_PRICE / (1 * data['close'][i])
elif data['slow_k'][si] < 50:
buy_count = MAX_BUY_PRICE / (1.5 * data['close'][i])
else:
buy_count = MAX_BUY_PRICE / (2 * data['close'][i])
return buy_ymd, buy_price, buy_count, buy_cut, buy_type
"""
"""
duration = 5
if duration < i:
if sum(data['avg20'][i - duration:i])/len(data['avg20'][i - duration:i]) < data['avg20'][i]:
min_value1 = min(data['close'][i - 1], data['close'][i - 1])
min_value2 = min(data['close'][i - 2], data['close'][i - 2])
min_value3 = min(data['close'][i - 3], data['close'][i - 3])
min_sum = min_value1 + min_value2 + min_value3
if min_sum / 3 < data['close'][i] and data['close'][i] == data['high'][i]:
if data['avg60'][i] < data['avg20'][i] and data['avg5'][i-1] < data['avg5'][i]:
if data['middle'][i-1] < data['middle'][i]:
if 0 < len(BUY_LIST['buy_list']):
if BUY_LIST['buy_list'][-1]['buy_price'] < data['close'][i]:
buy_price = data['close'][i]
buy_type = 'avg20_close_up'
buy_ymd = data['ymd'][i]
buy_cut = -1
if data['slow_k'][si] < 30:
buy_count = MAX_BUY_PRICE / (1 * data['close'][i])
elif data['slow_k'][si] < 50:
buy_count = MAX_BUY_PRICE / (1.5 * data['close'][i])
else:
buy_count = MAX_BUY_PRICE / (2 * data['close'][i])
# 방법 2:
if data['avg480'][i] < data['avg120'][i] < data['avg60'][i] < data['avg20'][i] < data['avg5'][i] < data['close'][i]:
if data['avg240'][i] < min(data['avg5'][i], data['avg20'][i], data['avg60'][i], data['avg120'][i]):
if BUY_LIST is not None and 0 < len(BUY_LIST['buy_list']) and data['ymd'][i] < BUY_LIST['buy_list'][-1]['buy_ymd'] + timedelta(minutes=10):
if BUY_LIST['buy_list'][-1]['buy_price'] < data['close'][i]:
return buy_ymd, buy_price, buy_count, buy_cut, buy_type
else:
buy_price = data['close'][i]
buy_type = 'golden'
buy_type = 'avg20_close_up'
buy_ymd = data['ymd'][i]
buy_cut = -1
if data['slow_k'][si] < 30:
buy_count = MAX_BUY_PRICE / (1 * data['close'][i])
elif data['slow_k'][si] < 50:
buy_count = MAX_BUY_PRICE / (1.5 * data['close'][i])
else:
buy_count = MAX_BUY_PRICE / (2 * data['close'][i])
return buy_ymd, buy_price, buy_count, buy_cut, buy_type
if BUY_LIST is None:
return buy_ymd, buy_price, buy_count, buy_cut, buy_type
"""
duration = 5
if duration < i:
if np.average(data['trend_avg'][i - duration:i]) < data['trend_avg'][i]:
if self.is_Support(data, i-10, observation_time = 300):
if data['open'][i] < data['close'][i]:
if np.max(data['high'][i-2:i]) < data['close'][i]:
buy_price = data['close'][i]
buy_type = 'golden'
buy_type = 'support_300'
buy_ymd = data['ymd'][i]
buy_cut = data['close'][i] * 0.995
BUY_LIST['buy_limit'] = 0
if data['slow_k'][si] < 30:
buy_count = MAX_BUY_PRICE / (1 * data['close'][i])
buy_count = MAX_BUY_PRICE*5 / (data['close'][i])
elif data['slow_k'][si] < 50:
buy_count = MAX_BUY_PRICE / (1.5 * data['close'][i])
buy_count = MAX_BUY_PRICE*4 / (data['close'][i])
else:
buy_count = MAX_BUY_PRICE / (2 * data['close'][i])
buy_count = MAX_BUY_PRICE*3 / (data['close'][i])
return buy_ymd, buy_price, buy_count, buy_cut, buy_type
# 방법 3:
#if sum(data['avg480'][i - 5:i]) < data['avg480'][i] and sum(data['avg60'][i - 5:i]) < data['avg60'][i] and sum(data['avg20'][i - 5:i]) < data['avg20'][i] and sum(data['avg5'][i - 5:i]) < data['avg5'][i]:
if data['avg480'][i] < data['avg20'][i] < data['avg5'][i] and data['avg60'][i] < data['avg20'][i] < data['avg5'][i]:
if BUY_LIST is not None and 0 < len(BUY_LIST['buy_list']) and BUY_LIST['buy_list'][-1]['buy_price'] < data['close'][i]:
buy_price = data['close'][i]
buy_type = 'trend_up'
buy_ymd = data['ymd'][i]
if data['slow_k'][si] < 30:
buy_count = MAX_BUY_PRICE / (1 * data['close'][i])
elif data['slow_k'][si] < 50:
buy_count = MAX_BUY_PRICE / (1.5 * data['close'][i])
else:
buy_count = MAX_BUY_PRICE / (2 * data['close'][i])
return buy_ymd, buy_price, buy_count, buy_cut, buy_type
if BUY_LIST is None:
buy_price = data['close'][i]
buy_type = 'golden'
buy_ymd = data['ymd'][i]
if data['slow_k'][si] < 30:
buy_count = MAX_BUY_PRICE / (1 * data['close'][i])
elif data['slow_k'][si] < 50:
buy_count = MAX_BUY_PRICE / (1.5 * data['close'][i])
else:
buy_count = MAX_BUY_PRICE / (2 * data['close'][i])
return buy_ymd, buy_price, buy_count, buy_cut, buy_type
if data['slow_k'][i] < 15:
if data['slow_k'][i-1] < data['slow_d'][i-1] and data['slow_d'][i] < data['slow_k'][i]:
buy_price = data['close'][i]
buy_type = 'slow_k'
buy_ymd = data['ymd'][i]
buy_cut = data['close'][i] * 0.995
BUY_LIST['buy_limit'] = 0
buy_count = MAX_BUY_PRICE * 2 / (data['close'][i])
return buy_ymd, buy_price, buy_count, buy_cut, buy_type
return buy_ymd, buy_price, buy_count, buy_cut, buy_type
def getSellPriceAndWeight1(self, ticker, i, data, data_signal, BUY_LIST=None):
sell_price, sell_count = -1, -1
sell_price, sell_count, sell_type = -1, -1, ''
if BUY_LIST is not None and 0 < len(BUY_LIST['buy_list']):
# 방법1에 대해서는 1% 이익시 매도 한다. (Upbit.py 파일에서)
df_tmp = data_signal['ymd'] <= data['ymd'][i]
df_signal = data_signal.loc[df_tmp]
si = len(df_signal) - 1
# 방법2에 대한 매도
if data['close'][i-1] < data['open'][i-1] and data['close'][i] < data['open'][i]:
count = sum([price['buy_count'] for price in BUY_LIST['buy_list'] if price['buy_type'] == 'golden'])
if 0 < count:
if 0 < len(BUY_LIST['buy_list']):
duration = 5
if duration < i:
if data['trend_avg'][i] < np.average(data['trend_avg'][i - duration:i]):
if self.is_Resistance(data, i - 10, observation_time=300):
sell_price = data['close'][i]
sell_count = sum([price['buy_count'] for price in BUY_LIST['buy_list']])
if 75 < np.max(data_signal['rsi'][si-5:si]):
if self.is_Resistance(data, i - 10, observation_time=300):
sell_price = data['close'][i]
sell_count = sum([price['buy_count'] for price in BUY_LIST['buy_list']])
down_count = [1 for c in range(i - 3, i + 1) if data['close'][c - 1] < data['open'][c]]
if 3 <= sum(down_count):
count = sum([price['buy_count'] for price in BUY_LIST['buy_list']])
if 0 < count:
sell_price = data['close'][i]
sell_count = sum([price['buy_count'] for price in BUY_LIST['buy_list']])
return sell_price, sell_count
if 70 < data['slow_k'][i]:
if data['slow_d'][i-1] < data['slow_k'][i-1] and data['slow_k'][i] <= data['slow_d'][i]:
sell_price = data['close'][i]
sell_count = sum([price['buy_count'] for price in BUY_LIST['buy_list'] if price['buy_type'] == 'slow_k'])
sell_type = 'slow_k'
return sell_price, sell_count, sell_type
def checkTransaction1(self, ticker, MAX_BUY_PRICE, data, data_signal, BUY_LIST=None, isRealTime=True):
@@ -225,19 +234,24 @@ class BuySellChecker():
# isRealTime=True, 실시간 적용
last_index = size - 1
sell_price, sell_weight = self.getSellPriceAndWeight1(ticker, last_index, data, data_signal, BUY_LIST)
sell_price, sell_count, sell_type = self.getSellPriceAndWeight1(ticker, last_index, data, data_signal, BUY_LIST)
bsLine['sell_price'] = [sell_price]
bsLine['sell_weight'] = [sell_weight]
bsLine['sell_count'] = [sell_count]
bsLine['sell_type'] = [sell_type]
buy_ymd, buy_price, buy_count, buy_cut, buy_type = self.getBuyPriceAndWeight1(ticker, MAX_BUY_PRICE, last_index, data, data_signal, BUY_LIST, isRealTime)
bsLine['buy_ymd'] = [buy_ymd]
bsLine['buy_price'] = [buy_price]
bsLine['buy_count'] = [buy_count]
bsLine['buy_cut'] = [buy_cut]
bsLine['buy_type'] = [buy_type]
if 0 < sell_price:
BUY_LIST['buy_limit'] = 0
BUY_LIST['buy_list'].clear()
else:
buy_ymd, buy_price, buy_count, buy_cut, buy_type = self.getBuyPriceAndWeight1(ticker, MAX_BUY_PRICE, last_index, data, data_signal, BUY_LIST, isRealTime)
bsLine['buy_ymd'] = [buy_ymd]
bsLine['buy_price'] = [buy_price]
bsLine['buy_count'] = [buy_count]
bsLine['buy_cut'] = [buy_cut]
bsLine['buy_type'] = [buy_type]
if BUY_LIST is not None and 0 < buy_price:
BUY_LIST['buy_list'].append({'buy_ymd': buy_ymd, 'buy_price': buy_price, 'buy_count': buy_count, 'buy_cut': buy_cut, 'buy_type': buy_type})
if 0 < buy_price:
BUY_LIST['buy_list'].append({'buy_ymd': buy_ymd, 'buy_price': buy_price, 'buy_count': buy_count, 'buy_cut': buy_cut, 'buy_type': buy_type})
else:
# Type=False, 시뮬레이션 적용
bsLine['buy_ymd'] = [-1 for i in range(size)]
@@ -246,22 +260,27 @@ class BuySellChecker():
bsLine['buy_cut'] = [-1 for i in range(size)]
bsLine['buy_type'] = ['' for i in range(size)]
bsLine['sell_price'] = [-1 for i in range(size)]
bsLine['sell_weight'] = [-1 for i in range(size)]
bsLine['sell_count'] = [-1 for i in range(size)]
bsLine['sell_type'] = ['' for i in range(size)]
for last_index in range(size):
sell_price, sell_weight = self.getSellPriceAndWeight1(ticker, last_index, data, data_signal, BUY_LIST)
sell_price, sell_count, sell_type = self.getSellPriceAndWeight1(ticker, last_index, data, data_signal, BUY_LIST)
bsLine['sell_price'][last_index] = sell_price
bsLine['sell_weight'][last_index] = sell_weight
bsLine['sell_count'][last_index] = sell_count
bsLine['sell_type'] = [sell_type]
if sell_price < 0:
if 0 < sell_price:
BUY_LIST['buy_limit'] = 0
BUY_LIST['buy_list'].clear()
else:
buy_ymd, buy_price, buy_count, buy_cut, buy_type = self.getBuyPriceAndWeight1(ticker, MAX_BUY_PRICE, last_index, data, data_signal, BUY_LIST, isRealTime)
bsLine['buy_price'][last_index] = buy_price
bsLine['buy_count'][last_index] = buy_count
bsLine['buy_cut'][last_index] = buy_cut
bsLine['buy_type'][last_index] = buy_type
if BUY_LIST is not None and 0 < buy_price:
if 0 < buy_price:
BUY_LIST['buy_list'].append({'buy_ymd': buy_ymd, 'buy_price': buy_price, 'buy_count': buy_count, 'buy_cut': buy_cut, 'buy_type': buy_type})
else:
@@ -270,7 +289,6 @@ class BuySellChecker():
bsLine['buy_cut'] = [-1]
bsLine['buy_type'] = ['']
bsLine['sell_price'] = [-1]
bsLine['sell_weight'] = [-1]
return bsLine
bsLine['sell_count'] = [-1]
return bsLine