def buy_crypto_currency(ticker, buy_won):
# krw = bithumb.get_balance(ticker)[2]
orderbook = pybithumb.get_orderbook(ticker)
sell_price = orderbook['asks'][0]['price']
# unit = krw / float(sell_price)
unit = buy_won / float(sell_price)
bithumb.buy_market_order(ticker, unit)
def buy_crypto_currency(bithumb, ticker):
krw = bithumb.get_balance(ticker)[2]
orderbook = Bithumb.get_orderbook(ticker)
sell_price = orderbook['asks'][0]['price']
unit = krw / float(sell_price) * 0.7
unit = math.floor(unit * 10000) / 10000
return bithumb.buy_market_order(ticker, unit)
def buy_crypto_currency(ticker):
krw = bithumb.get_balance("XRP")[2]
orderbook = pybithumb.get_orderbook("XRP")
sell_price = orderbook['asks'][0]['price']
unit = krw / int(sell_price)
bithumb.buy_market_order("XRP", unit)
def buy_bitcoin():
if current_price > target_price: # 변동성 돌파 전략에 의해, 0.5배 이상 상승한 상태에서 바로 매수
krw = bithumb.get_balance("BTC")[2] # 보유중인 원화 조회
order_book = pybithumb.get_orderbook("BTC") # 비트코인 호가 정보 조회
sell_price = order_book['asks'][0][
'price'] # 최상단 매도 호가 조회 (가장 저렴하게 매수할 수 있는 가격)
unit = krw / float(sell_price) # 현재 잔액으로 매수 가능한 비트코인 갯수
bithumb.buy_market_order("BTC", unit) # 매수
def buy_crypto_currency(bithumb, ticker):
krw = bithumb.get_balance(ticker)[2] # 보유 중인 원화를 얻어온다.
orderbook = pybithumb.get_orderbook(ticker) # 호가창을 조회해서 최우선 매도 호가를 조회한다.
sell_price = orderbook['asks'][0]['price']
# 빗썸의 시장가 API는 수수료 이외에도 30%의 여유가 존재해야 주문이 가능하다. 보유 현금의 100%를 채워서 주문하면
# "주문량이 사용 가능 KRW를 초과하였습니다" 에러 메시지를 반환한다.
unit = krw / float(sell_price) * 0.7
return bithumb.buy_market_order(ticker, unit) # unit 만큼 매수한다.
def buy_bitcoin():
"""
변동성 돌파전략과 이동평균에 상승장일때만 매수주문을 체결
"""
if (current_price > target_price) and (current_price > ma5):
krw = bithumb.get_balance("BTC")[2] # 보유중인 원화 조회
order_book = pybithumb.get_orderbook("BTC") # 비트코인 호가 정보 조회
sell_price = order_book['asks'][0][
'price'] # 최상단 매도 호가 조회 (가장 저렴하게 매수할 수 있는 가격)
unit = krw / float(sell_price) # 현재 잔액으로 매수 가능한 비트코인 갯수
bithumb.buy_market_order("BTC", unit) # 매수
def buy_crypto_currency(ticker):
# 잔고조회
krw = bithumb.get_balance(ticker)[2]
# 호가창 조회
orderbook = pybithumb.get_orderbook(ticker)
# 최우선 매도 호가 조회
sell_price = orderbook['asks'][0]['price']
# 원화잔고를 최우선 매도가로 나눠서 구매 가능한 수량 계산
unit = krw / float(sell_price)
# 시장가 주문으로 비트코인 매수
bithumb.buy_market_order(ticker, unit)
def buy_crypto_currency(ticker):
orderbook = pybithumb.get_orderbook(ticker)
buy_price = orderbook['asks'][0]['price']
buy_unit = krw_by_coin[ticker] / float(buy_price)
order_buy = bithumb.buy_market_order(ticker, buy_unit)
print(order_buy)
# print(buy_price, buy_unit)# 테스트용, 실사용시 위 2줄 사용
# 구매후 지갑상태, 가격 갱신
wallet_bull[ticker] = False
krw_by_coin[ticker] = krw_by_coin[ticker] - buy_unit * buy_price
return buy_price
def buy_crypto_currencyA(bithumb, ticker, krw, start):
orderbook = Bithumb.get_orderbook(ticker)
sell_price = orderbook['asks'][0]['price']
unit = krw / float(sell_price) * 0.7
unit = math.floor(unit * 10000) / 10000
bithumb.buy_market_order(ticker, unit)
print(ticker, krw, unit)
start = start + 1
if start < 3:
krw = krw * 0.3
buy_crypto_currencyA(bithumb, ticker, krw, start)
else:
pass
def realtime_hogachart(Coin, display=3):
Hogachart = pybithumb.get_orderbook(Coin)
print("##### 실시간 호가창 #####")
print("{:^10} {:^20}".format('가격', '거래량'))
for i in reversed(range(display)):
print(
"%10.2f %20.3f" %
(Hogachart['asks'][i]['price'], Hogachart['asks'][i]['quantity']))
print('-' * 30)
for j in range(display):
print(
"%10.2f %20.3f" %
(Hogachart['bids'][j]['price'], Hogachart['bids'][j]['quantity']))
def sell_crypto_currency(ticker):
sell_unit = bithumb.get_balance(ticker)[0]
orderbook = pybithumb.get_orderbook(ticker)
sell_price = orderbook['bids'][0]['price']
order_sell = bithumb.sell_market_order(ticker, sell_unit)
print(order_sell)
# print(sell_unit, sell_price)# 테스트용, 실사용시 위 2줄 사용
# 판매후 지갑상태, 가격 갱신
wallet_bull[ticker] = True
krw_by_coin[ticker] = krw_by_coin[ticker] + sell_unit * sell_price
if krw_by_coin[ticker] <= 1000:
wallet_bull[ticker] = False
return sell_price
def try_buy(tickers, prices, targets, noises, mas, budget_per_coin, holdings,
high_prices):
'''
모든 가상화폐에 대해 매수 조건 확인 후 매수 시도
:param tickers: 티커 리스트
:param prices: 현재가 리스트
:param targets: 목표가 리스트
:param noises: noise 리스트
:param mas: 이동평균 리스트
:param budget_per_coin: 코인 당 투자 금액
:param holdings: 보유 여부 리스트
:param high_prices: 당일 고가 리스트
:return:
'''
try:
for ticker in tickers:
price = prices[ticker] # 현재가
target = targets[ticker] # 목표가
noise = noises[ticker] # noise
ma = mas[ticker] # N일 이동평균
high = high_prices[ticker] # 당일 고가
# 매수 조건
# 0) noise가 0.75 이하이고
# 1) 현재가가 목표가 이상이고
# 2) 당일 고가가 목표가 대비 2% 이상 오르지 않았으며 (프로그램을 장중에 실행했을 때 고점찍고 하락중인 종목을 사지 않기 위해)
# 3) 현재가가 5일 이동평균 이상이고
# 4) 해당 코인을 보유하지 않았을 때
# 5) 현재가가 100원 이상
if holdings[ticker] is False:
if price >= 100 and noise <= DUAL_NOISE_LIMIT1 and price >= target and target >= ma and high <= target * 1.02:
orderbook = pybithumb.get_orderbook(ticker)
asks = orderbook['asks']
sell_price = asks[0]['price']
unit = budget_per_coin / float(sell_price)
if DEBUG is False:
bithumb.buy_market_order(ticker, unit)
else:
logger.info("BUY API CALLED {} {}".format(
ticker, unit))
time.sleep(INTERVAL)
holdings[ticker] = True
except:
logger.info("try buy error")
pass
def try_buy(now, price, target, ma):
try:
krw = bithumb.get_balance("BTC")[2]
orderbook = pybithumb.get_orderbook("BTC")
asks = orderbook['asks']
sell_price = asks[0]['price'] # 최우선 매도가
unit = krw / float(sell_price)
logger.info("원화잔고: {0} 매수수량: {1}".format(krw, unit))
if price > target and price > ma and (price / target) < 1.005:
logger.info(" 매수 API 호출")
bithumb.buy_market_order("BTC", unit)
else:
logger.info(" 매수조건 미달")
logger.info(" 조건1 {}".format(price > target))
logger.info(" 조건2 {}".format(price > ma))
logger.info(" 조건3 {0} {1}".format((price / target) < 1.005,
price / target))
except:
pass
def try_buy(tickers, prices, targets, multiple_mas, budget_per_coin, holdings, profit_cut):
'''
매수 조건 확인 및 매수 시도
:param tickers: 빗썸에서 거래되는 모든 티커 목록
:param prices: 각 코인에 대한 현재가
:param targets: 각 코인에 대한 목표가
:param multiple_mas: 각 코인에 대한 3~20일 이동평균
:param budget_per_coin: 코인별 최대 투자 금액
:param holdings: 보유 여부
:param profit_cut: 익절 여부
:return:
'''
try:
for ticker in tickers:
price = prices[ticker] # 현재가
target = targets[ticker] # 목표가
if price > target and (price / target) < 1.005 and holdings[ticker] is False and profit_cut[ticker] is False:
logger.info(" {} 매수 API 호출".format(ticker))
# 배팅비율에 따른 budget 계산
# 3 ~ 20일 이동평균값 중 몇개를 넘었는지를 계산 후 이에 따라 배팅 금액 조절
s = Series(multiple_mas[ticker])
bull_count = sum(price > s)
score = bull_count * 0.055
batting_budget = int(budget_per_coin * score)
orderbook = pybithumb.get_orderbook(ticker)
asks = orderbook['asks']
sell_price = asks[0]['price'] # 최우선 매도가
unit = batting_budget/float(sell_price) # 매수 가능한 코인 개수 계산
if DEBUG is False:
bithumb.buy_market_order(ticker, unit)
else:
logger.info("매수 API 호출 {} {}".format(tickers, unit))
time.sleep(INTERVAL)
holdings[ticker] = True
except:
pass
def hogachart(self, Coin):
try:
display = 3
Hogachart = pybithumb.get_orderbook(Coin)
Realtime_asks_price = query(Hogachart['asks'][0:display]).select(lambda item: item['price']).to_list()
Realtime_asks_volume = query(Hogachart['asks'][0:display]).select(lambda item: item['quantity']).to_list()
Realtime_bids_price = query(Hogachart['bids'][0:display]).select(lambda item: item['price']).to_list()
Realtime_bids_volume = query(Hogachart['bids'][0:display]).select(lambda item: item['quantity']).to_list()
for i in range(display):
self.tableWidget_hoga_ask.setItem(i, 0, QTableWidgetItem(str(Realtime_asks_price[display - 1 - i])))
self.tableWidget_hoga_ask.setItem(i, 1, QTableWidgetItem(str(Realtime_asks_volume[display - 1 - i])))
self.tableWidget_hoga_ask.setItem(i + 3, 0, QTableWidgetItem(str(Realtime_bids_price[i])))
self.tableWidget_hoga_ask.setItem(i + 3, 1, QTableWidgetItem(str(Realtime_bids_volume[i])))
except Exception as e:
print("Error in hogachart")
print(e)
print()
def try_buy(tickers, prices, targets, ma5s, budget_per_coin, holdings,
high_prices):
'''
매수 조건 확인 및 매수 시도
:param tickers
:param prices: 각 코인에 대한 현재가
:param targets: 각 코인에 대한 목표가
:param ma5s: 5일 이동평균
:param budget_per_coin: 코인별 최대 투자 금액
:param holdings: 보유 여부
:return:
'''
try:
for ticker in tickers:
price = prices[ticker] # 현재가
target = targets[ticker] # 목표가
ma5 = ma5s[ticker] # 5일 이동평균
high = high_prices[ticker]
# 매수 조건
# 1) 현재가가 목표가 이상이고
# 2) 당일 고가가 목표가 대비 2% 이상 오르지 않았으며 (프로그램을 장중에 실행했을 때 고점찍고 하락중인 종목을 사지 않기 위해)
# 3) 현재가가 5일 이동평균 이상이고
# 4) 해당 코인을 보유하지 않았을 때
if price >= target and high <= target * 1.02 and price >= ma5 and holdings[
ticker] is False:
orderbook = pybithumb.get_orderbook(ticker)
asks = orderbook['asks']
sell_price = asks[0]['price']
unit = budget_per_coin / float(sell_price)
if DEBUG is False:
bithumb.buy_market_order(ticker, unit)
else:
print("BUY API CALLED", ticker, unit)
time.sleep(INTERVAL)
holdings[ticker] = True
except:
pass
def sell_crypto_currency(ticker):
sell_unit = bithumb.get_balance(ticker)[0]
orderbook = pybithumb.get_orderbook(ticker)
sell_price[ticker] = orderbook['bids'][0]['price']
order_sell = bithumb.sell_market_order(ticker, sell_unit)
print(order_sell)
# print(sell_unit, sell_price[ticker]) # 테스트용, 실사용시 위 2줄 사용
# 판매후 지갑상태, 가격 갱신
wallet_bull[ticker] = True
krw_by_coin[
ticker] = krw_by_coin[ticker] + sell_unit * sell_price[ticker]
if krw_by_coin[ticker] <= 1000:
wallet_bull[ticker] = False
ror[ticker] = sell_price[ticker] * 0.995 / buy_price[ticker]
hpr[ticker] = hpr[ticker] * ror[ticker]
data[ticker] = "판매", sell_price[ticker], now, hpr[ticker]
return sell_price[ticker]
def parse_detail(self):
tickers = pybithumb.get_tickers()
for ticker in tickers:
# price = pybithumb.get_current_price(ticker) # 현재가 조회
detail = pybithumb.get_market_detail(
ticker) # 저가, 고가, 평균 거래 금액, 거래량
print(ticker, detail)
orderbook = pybithumb.get_orderbook(
ticker) # 시점, 거래화폐, 코인명, 매도호가, 매수호가
print(
orderbook["order_currency"] + " / " +
orderbook["payment_currency"],
datetime.datetime.fromtimestamp(
int(orderbook["timestamp"]) / 1000))
for bid in orderbook['bids']:
print("매수호가: ", bid['price'], "매수잔량: ", bid['quantity'])
for ask in orderbook['asks']:
print("매도호가: ", bid['price'], "매도잔량: ", bid['quantity'])
time.sleep(0.1)
def buy_order(ticker, ticker_name):
a = pybithumb.get_current_price(ticker_name) # 현재가
b = 0.5 * get_ATR(ticker) + day_ago(2, 'close',
ticker).values # 전일종가 + 0.5ATR
if a > b:
f = open(str(os.getcwd()) + '/money', 'r')
krw = float(f.readline())
f.close
orderbook = pybithumb.get_orderbook(ticker_name) #해당 코인 호가 조회
sell_price = orderbook['asks'][0]['price'] #최우선 매도 호가 계산
unit = krw * 0.1 / sell_price #매수 수량
print("매수:" + ticker_name + ", 단가 :", sell_price, '수량:', unit)
f = open(str(os.getcwd()) + '/money', 'w')
money = str(float(krw) - (sell_price * unit))
f.write(money)
f.close
print(datetime.datetime.now())
with open(str(os.getcwd()) + '/data.pickle', 'rb') as f:
data = pickle.load(f)
data[ticker_name] = unit
with open(str(os.getcwd()) + '/data.pickle', 'wb') as f:
pickle.dump(data, f, pickle.HIGHEST_PROTOCOL)
def buy_crypto_currency(ticker):
krw = bithumb.get_balance("BTC")[2] # 보유 중인 원화를 얻어온다.
orderbook = pybithumb.get_orderbook("BTC") # 호가창을 조회해서 최우선 매도 호가를 조회한다.
sell_price = orderbook['asks'][0]['price']
unit = krw / float(sell_price)
bithumb.buy_market_order("BTC", unit) # 시장가로 살수 있는 만큼 모두 매수한다.
def try_buy(price, target, ma5, ticker_list,
noise_df): # now = 현재시각 , price = 코인 현재가격 target = 목표가격 ma = 이동평균선
#데이터베이스 rows 인자 별 의미 -> 0:PID 4:balance 5:unit1 6:unit2 7:unit3 8:unit4 9:unit5
#여기에 데이터베이스 식별을 위한 유저 개인 정보를 더 받아와야 함
try:
###mysql 데이터 로드 시작
conn = pymysql.connect(host='localhost',
user='******',
password='******',
db='mockcoiner',
charset='utf8')
curs = conn.cursor()
sql_open = "SELECT * FROM mockcoiner.user WHERE email = '*****@*****.**'"
curs.execute(sql_open)
rows = curs.fetchall()
balance = rows[0][4]
balance_temp = float(balance) * 0.15
pid = rows[0][0]
unit = []
for i in range(5):
a = float(rows[0][i + 5])
unit.append(a)
###mysql 데이터 로드 끝
asks = []
sell_price = []
#현재 시장 매수,매도상황
for i in range(5):
orderbook = pybithumb.get_orderbook(ticker_list[i])
asks = orderbook['asks']
a = asks[0]['price']
sell_price.append(a)
print(sell_price[i], "sell_price")
print("현재가 : ", price[i], "목표가 : ", target[i], "이동평균선", ma5[i])
price[4] = 500000
price[3] = 1000000
target[4] = 400000
target[3] = 900000
ma5[4] = 100000
ma5[3] = 100000
#매수 조건 활성화
if price[i] > target[i] and price[i] > ma5[i] and noise_df.iloc[
i].bool() == True: # 목표가격 및 이동 평균선 수치보다 높다면
print(i, "번째 코인 매수신호발생!", price[i], target[i])
##### 거래 코인 갯수 및 잔고 계산
#unit_coin = 돈 -> 코인 개수로 환산
unit_coin = float(balance_temp) / float(sell_price[i])
unit_coin = round(unit_coin, 4)
#거래가 일어 났으니 그 코인 개수만큼 내 계좌에서 차감 시키는 작업
balance_update = float(balance) - float(
sell_price[i] * unit_coin)
balance_update = round(balance_update, 4) #소수점 반올림
#####
# 이전에 이미 잔고를 코인으로 전환 하였다면, 거래가 일어나지 않아야 함, 이 모델은 하루에 두번 이상 매수,매도가 일어나지 않기 때문
if unit[i] > float(0):
print("이미 매수하였습니다.")
pass
else:
if balance_update < 0: #현재 가격과 최우선 매도가 가격과의 gap,슬리피지로 인한 잔고 부족 사태가 생기는 경우를 의미
print("잔액부족으로 거래가 일어나지 않았습니다.")
pass
#일반적인 경우, 즉 최초로 거래가 일어났다면 코인과 잔고를 갱신시키는 작업이 필요함.
else:
#데이터 베이스에 코인과 잔고를 갱신 시키는 작업
balance = balance_update
print("저장될 코인 개수 : ", unit_coin, " 잔고 : ", balance)
#####
print("Save to DataBase...")
sql_unit = "UPDATE mockcoiner.user SET unit" + str(
i + 1) + " = " + str(
unit_coin) + " WHERE (pid = " + str(pid) + ");"
print(sql_unit)
curs.execute(sql_unit)
conn.commit()
sql_balance = "UPDATE mockcoiner.user SET balance = " + str(
balance) + " WHERE (pid = " + str(pid) + ");"
print(sql_balance)
curs.execute(sql_balance)
conn.commit()
else:
print(i, "번째 코인 매수조건아님", price[i], target[i])
except:
print("try buy Error")
pass
finally:
###mysql
print("finally pass")
conn.close() ##최종적으로 연결을 닫음
def run(self):
while self.alive:
data = pybithumb.get_orderbook(self.ticker, limit=10)
time.sleep(0.05)
self.dataSent.emit(data)
import pybithumb
orderbook = pybithumb.get_orderbook("BTC") # 각각이 호가(수량과 가격)
bids = orderbook['bids'] # 매수 호가 및 잔량 반복문
for bid in bids:
price = bid['price'] # 딕셔너리에서 'price'라는 키로 인덱싱
quant = bid['quantity'] # 딕셔너리에서 'quantity'라는 키로 인덱싱
print("비트코인 매수호가:", price, "비트코인 매수잔량:", quant)
print("\n")
asks = orderbook['asks'] # 매도 호가 및 잔량
for ask in asks:
price = bid['price'] # 딕셔너리에서 'price'라는 키로 인덱싱
quant = bid['quantity'] # 딕셔너리에서 'quantity'라는 키로 인덱싱
print("비트코인 매도호가:", price, "비트코인 매도잔량:", quant)
def buy_crypto_currency(ticker):
krw = bithumb.get_balance(ticker)[2]
orderbook = pybithumb.get_orderbook(ticker)
sell_price = orderbook['asks'][0]['price']
unit = krw / float(sell_price)
# 빗썸에 모든 코인 현재가격 가져오기
"""
tickers = pybithumb.get_tickers()
for ticker in tickers:
price = pybithumb.get_current_price(ticker)
print(price)
time.sleep(0.1)
"""
# 5.1.4 거래소 거래 정보 (시가, 고가, 저가, 종가, 거래량)
detail = pybithumb.get_market_detail("BTC")
print(detail)
# 5.1.5 호가
print("orderbook==============================")
orderbook = pybithumb.get_orderbook("BTC", 'KRW', 20)
print(orderbook)
for k in orderbook:
print(orderbook[k])
print('ordertimestampd::' + orderbook['timestamp'])
ms = int(orderbook['timestamp'])
df = datetime.datetime.fromtimestamp(ms / 1000)
print(df)
# 매수/매도 호가 접근하기
print("매수/매도 호가 접근하기")
bids = orderbook['bids']
asks = orderbook['asks']
bithumb = pybithumb.Bithumb(con_key, sec_key)
def get_target_price(ticker):
df = pybithumb.get_ohlcv(ticker)
yesterday = df.iloc[-2]
today_open = yesterday['close']
yesterday_high = yesterday['high']
yesterday_low = yesterday['low']
target = today_open + (yesterday_high - yesterday_low) * 0.5
return target
now = datetime.datetime.now()
mid = datetime.datetime(now.year, now.month, now.day) + datetime.timedelta(1)
target_price = get_target_price("BTC")
while True:
now = datetime.datetime.now()
if mid < now < mid + datetime.delta(seconds=10):
target_price = get_target_price("BTC")
mid = datetime.datetime(now.year, now.month, now.day) + datetime.timedelta(1)
current_price = pybithumb.get_current_price("BTC")
if current_price > target_price:
krw = bithumb.get_balance("BTC")[2]
orderbook = pybithumb.get_orderbook("BTC")
sell_price = orderbook['asks'][0]['price']
unit = krw/float(sell_price)
bithumb.buy_market_order("BTC", unit)
time.sleep(1)
try:
# 원화 자산 조회
if (count_lookup_balance == 10):
balance = bithumb.get_balance("BTC")
if balance is None:
balance = bithumb.get_balance("BTC")
if balance is None: bithumb.get_balance("BTC")
krw = balance[2] - balance[3]
print("현재 잔고는", int(krw), "원입니다.\n")
print("현재 잔고는", int(krw), "원입니다.\n")
print("===================================\n")
count_lookup_balance = -1
count_lookup_balance += 1
# 호가 불러오기
all = pybithumb.get_orderbook("ALL")
if all is None:
all = pybithumb.get_orderbook("ALL")
if all is None:
all = pybithumb.get_orderbook("ALL")
# 저점 달성시 매수 [저점을 변수로 설정할까 고민중]
soda_price = all['data']['SOC']['bids'][0]['price']
soda_price = float(soda_price)
print("소다코인의 현재 가격 : ", soda_price)
if (order_soda == 0 and soda_price <= buy_soda_price * 1.003):
order_soda = bithumb.buy_limit_order("SOC", buy_soda_price,
(krw / soda_price) * 0.5)
if (soda_price < buy_soda_price):
is_buy_soda = 1
if (order_soda != 0 and soda_price >= buy_soda_price * 1.012):
def buy_crypto_currency(ticker):
krw = math.floor(bithumb.get_balance(ticker)[2] / COIN_CNT)
orderbook = pybithumb.get_orderbook(ticker)
sell_price = orderbook['asks'][0]['price']
unit = round(krw / float(sell_price), 5)
return bithumb.buy_market_order(ticker, unit)
