130 lines
3.2 KiB
Python
130 lines
3.2 KiB
Python
import datetime
|
|
import json
|
|
import python_bitbankcc
|
|
import random
|
|
import sys
|
|
import time
|
|
|
|
import algorithm as algo
|
|
|
|
|
|
FETCH_INTERVAL = 5
|
|
|
|
status = {}
|
|
|
|
def init():
|
|
try:
|
|
sec = json.load(open("secret.json"))
|
|
sec = sec["bitbank"]
|
|
pub = python_bitbankcc.public()
|
|
pri = python_bitbankcc.private(sec["key"], sec["secret"])
|
|
except Exception as e:
|
|
print("failed to initialize bitbank features: ", e)
|
|
return []
|
|
|
|
procs = []
|
|
procs.append(Fetcher(pub, "btc_jpy", 30))
|
|
procs.append(Proc(pri, "btc_jpy", 2000, algo.MA_Cross(algo.SMA(), "1m"), 30))
|
|
return procs
|
|
|
|
|
|
class Fetcher:
|
|
def __init__(self, pub, pair, interval):
|
|
self._interval = interval
|
|
self._last_update = 0
|
|
|
|
self._pub = pub
|
|
self._pair = pair
|
|
|
|
self._candle_prev = {}
|
|
|
|
def tick(self):
|
|
now = time.time()
|
|
if now-self._last_update < self._interval:
|
|
return
|
|
self._last_update = now
|
|
try:
|
|
st = algo.Status()
|
|
|
|
st.candles["1m"] = self._get_candle("1min", 60)
|
|
st.price = st.candles["1m"][0][3]
|
|
|
|
global status
|
|
status[self._pair] = st
|
|
except Exception as e:
|
|
print("fetce error:", e)
|
|
|
|
def _get_candle(self, unit, n, t = datetime.datetime.now(tz=datetime.timezone.utc)):
|
|
data = self._pub.get_candlestick(
|
|
self._pair,
|
|
unit,
|
|
t.strftime("%Y%m%d"))
|
|
data = data["candlestick"][0]["ohlcv"]
|
|
|
|
ret = []
|
|
for i in range(min(n, len(data))):
|
|
j = len(data)-i-1
|
|
ret.append([float(data[j][0]), float(data[j][1]), float(data[j][2]), float(data[j][3])])
|
|
|
|
if len(ret) < n:
|
|
t = t - datetime.timedelta(days=1)
|
|
data = self._get_candle(unit, n-len(ret), t)
|
|
ret = [*ret, *data]
|
|
return ret
|
|
|
|
|
|
class Proc:
|
|
def __init__(self, pri, pair, lot, algo, interval):
|
|
self._pri = pri
|
|
self._pair = pair
|
|
|
|
self._last_update = 0
|
|
self._now = 0
|
|
|
|
self._bsi = -1
|
|
self._algo = algo
|
|
self._interval = interval
|
|
|
|
self._last_order = None
|
|
self._buy_price = 0
|
|
|
|
self._lot = lot
|
|
|
|
def tick(self):
|
|
self._now = time.time()
|
|
if self._now-self._last_update > self._interval:
|
|
self._last_update = self._now
|
|
self._update()
|
|
|
|
def _update(self):
|
|
global status
|
|
st = status[self._pair]
|
|
|
|
pbsi = self._bsi
|
|
bsi = self._algo.judge(status[self._pair])
|
|
if bsi != 0:
|
|
self._bsi = bsi
|
|
|
|
print(f"[bitbank: {self._pair}] BSI {pbsi} -> {bsi}")
|
|
if bsi*pbsi < 0:
|
|
if bsi > 0:
|
|
try:
|
|
amount = self._lot/st.price
|
|
self._order_market(amount, "buy")
|
|
self._buy_price = st.price
|
|
print(f"[bitbank: {self._pair}] <BUY> +{amount} / -{self._lot}")
|
|
except Exception as e:
|
|
print(f"[bitbank: {self._pair}] buy error", e)
|
|
self._buy_price = 0
|
|
elif self._buy_price > 0:
|
|
try:
|
|
amount = self._lot/self._buy_price
|
|
self._order_market(amount, "sell")
|
|
print(f"[bitbank: {self._pair}] <SELL> -{amount} / +{amount*st.price}")
|
|
except Exception as e:
|
|
print(f"[bitbank: {self._pair}] sell error", e)
|
|
|
|
def _order_market(self, amount, sell_or_buy):
|
|
order = self._pri.order(self._pair, None, str(amount), sell_or_buy, "market")
|
|
self._last_order = order
|