def process_order(user, order_params, is_ready):
prv = python_bitbankcc.private(user.api_key, user.api_secret_key)
new_bitbank_order = BitbankOrder()
new_bitbank_order.user = user
new_bitbank_order.pair = order_params.get('pair')
new_bitbank_order.side = order_params.get('side')
new_bitbank_order.order_type = order_params.get('order_type')
new_bitbank_order.price = None if new_bitbank_order.order_type.find(
'limit') == -1 else order_params.get('price')
print(new_bitbank_order.price)
new_bitbank_order.price_for_stop = None if new_bitbank_order.order_type.find(
'stop') == -1 else order_params.get('price_for_stop')
new_bitbank_order.start_amount = order_params.get('start_amount')
new_bitbank_order.order_id = None
if is_ready:
new_bitbank_order.status = BitbankOrder.STATUS_READY_TO_ORDER
else:
new_bitbank_order.status = BitbankOrder.STATUS_WAIT_OTHER_ORDER_TO_FILL
new_bitbank_order.save()
if new_bitbank_order.order_type in {
BitbankOrder.TYPE_MARKET, BitbankOrder.TYPE_LIMIT
} and is_ready:
_util.place_order(prv, new_bitbank_order)
return new_bitbank_order
def _get_asset(market, user):
if market == 'bitbank':
if not user.bb_api_key or not user.bb_api_secret_key:
return {'error': 'bitbank api keyが登録されていません'}
try:
res_dict = python_bitbankcc.private(user.bb_api_key, user.bb_api_secret_key).get_asset()
except Exception as e:
raise
elif market == 'coincheck':
res_dict = json.loads(CoinCheck(user.cc_api_key, user.cc_api_secret_key).account.balance({}))
if 'error' in res_dict:
raise Exception('{}の資産の取得に失敗しました'.format(market))
return res_dict
def __init__(self, api_key, api_secret):
# API
self._public_api = python_bitbankcc.public()
self._private_api = python_bitbankcc.private(api_key, api_secret)
# Account balance
self.jpy_balance = 0.0
self.xrp_balance = 0.0
# Latest market info
self.best_ask = 0.0
self.best_bid = 0.0
self.xrp_value = 0.0
# Settings
self.PAIR = 'xrp_jpy'
self.TRADE_TYPE = 'limit'
def cancel(self):
logger = logging.getLogger('api')
# 未約定、部分約定以外のステータスの倍はステータスのみ変更
if self.status not in {
self.STATUS_UNFILLED, self.STATUS_PARTIALLY_FILLED
}:
self.status = self.STATUS_CANCELED_UNFILLED
self.save()
return True
prv_bitbank = python_bitbankcc.private(self.user.bb_api_key,
self.user.bb_api_secret_key)
prv_coincheck = CoinCheck(self.user.cc_api_key,
self.user.cc_api_secret_key)
if self.market == 'bitbank':
try:
ret = prv_bitbank.cancel_order(
self.pair, # ペア
self.order_id # 注文ID
)
except Exception as e:
raise OrderCancelFailedError(_trim_error_msg(e.args[0]))
else:
self.remaining_amount = ret.get('remaining_amount')
self.executed_amount = ret.get('executed_amount')
self.average_price = ret.get('average_price')
self.status = ret.get('status')
self.save()
return True
elif self.market == 'coincheck':
try:
ret = json.loads(
prv_coincheck.order.cancel({
'id': self.order_id # 注文ID
}))
except Exception as e:
raise OrderCancelFailedError(e.args[0])
else:
if not ret.get('success') and ret.get('error'):
raise OrderCancelFailedError(ret.get('error'))
self.status = self.STATUS_CANCELED_UNFILLED
self.save()
return True
def ajax_assets(request):
if request.user.is_anonymous or request.user.is_active == False:
return JsonResponse({'error': 'authentication failed'}, status=401)
if request.method == 'GET':
user = request.user
if user.api_key == "" or user.api_secret_key == "":
res_dict = {'error': 'API KEYが登録されていません'}
else:
try:
res_dict = python_bitbankcc.private(
user.api_key, user.api_secret_key).get_asset()
except Exception as e:
res_dict = {'error': e.args}
traceback.print_exc()
return JsonResponse(res_dict)
def __init__(self, pair=PAIR):
# プライベートなWebAPIメソッドの仕様にはAPIキーとSecretが必要
# 1. ファイルから読み込む
# with open('<file-path-to-your-api-key>', 'rb') as f:
# key = pickle.load(f)
#
# apiKey = key['apiKey']
# secret = key['secret']
# 2. コマンドラインから入力する
# apiKey = input('apiKeyを入力してください。\n> ')
# secret = input('secretを入力してください。\n> ')
# 3. プライベートなメソッドを使用しない
apiKey =''
secret = ''
self.pub = bitbank_public()
self.prv = python_bitbankcc.private(apiKey, secret)
self.pair = pair
import python_bitbankcc as pbcc
# Trade key
API_KEY = 'public key'
API_SECRET = 'your private key'
TIME = 100 # run-time (min)
BUDGET = 10000 # Initial available budget
RANGE = 0.0001 # Price range
PAIR = 'xrp_jpy' # Currency pair to order
CHECK_INTERVAL = 3 # Interval time of order check (sec)
MAKER_FEE_RATE = -0.0005
TAKER_FEE_RATE = 0.0015
# Get instance
prv = pbcc.private(API_KEY, API_SECRET)
pub = pbcc.public()
def make_order_info(pair, amount, price, orderside, ordertype='limit'):
order_info = {
"pair": pair, # ペア
"amount": amount, # 注文枚数
"price": price, # 注文価格
"orderside": orderside, # buy or sell
"ordertype": ordertype # 指値注文の場合はlimit
}
return order_info
def send(self, token, msg):
payload = {'message': msg}
headers = {'Authorization': 'Bearer ' + token} # 発行したトークン
line_notify = requests.post(self.line_notify_api,
data=payload,
headers=headers)
#main
if __name__ == '__main__':
conf = open('config.json', 'r')
con = json.load(conf)
co = con['BITBANK']
API_KEY = co['API_KEY']
API_SECRET = co['API_SECRET']
os.system('clear')
m = mail(co['gmail_add'], co['gmail_pass'], co['to_addr'])
line = line()
prv = python_bitbankcc.private(API_KEY, API_SECRET)
print('start wacth tarde')
while 1:
o = orders(prv, 'xrp_jpy')
o.getNewList()
o.CheckList()
#o.testsend()
sleep(2)
def ajax_orders(request):
if request.user.is_anonymous or request.user.is_active == False:
return JsonResponse({'error': 'authentication failed'}, status=401)
user = request.user
prv = python_bitbankcc.private(user.api_key, user.api_secret_key)
method = request.method
if method == 'GET':
print(request.GET.get('type'))
if request.GET.get('type') == 'active':
offset = int(request.GET.get('offset'))
to = int(request.GET.get('limit')) + offset
search_pair = request.GET.get('pair')
if search_pair == "all":
active_orders = OrderRelation.objects.filter(user=user).filter(
is_active=True).order_by('-pk')
else:
active_orders = OrderRelation.objects.filter(user=user).filter(
is_active=True).filter(pair=search_pair).order_by('-pk')
data = {
'total_count': active_orders.count(),
'data': OrderSerializer(active_orders[offset:to],
many=True).data
}
return JsonResponse(data)
elif request.GET.get('type') == 'history':
try:
offset = int(request.GET.get('offset'))
to = int(request.GET.get('limit')) + offset
search_pair = request.GET.get('pair')
if search_pair == 'all':
order_history = BitbankOrder.objects.filter(
user=user).filter(status__in=[
BitbankOrder.STATUS_CANCELED_PARTIALLY_FILLED,
BitbankOrder.STATUS_FULLY_FILLED,
BitbankOrder.STATUS_FAILED_TO_ORDER
]).order_by('-pk')
else:
order_history = BitbankOrder.objects.filter(
user=user).filter(status__in=[
BitbankOrder.STATUS_CANCELED_PARTIALLY_FILLED,
BitbankOrder.STATUS_FULLY_FILLED,
BitbankOrder.STATUS_FAILED_TO_ORDER
]).filter(pair=search_pair).order_by('-pk')
data = {
'total_count':
order_history.count(),
'data':
BitbankOrderSerializer(order_history[offset:to],
many=True).data
}
return JsonResponse(data)
except Exception as e:
return JsonResponse({'error': e.args})
elif method == 'POST':
if user.api_key == "" or user.api_secret_key == "":
res = {'error': 'API KEYが登録されていません'}
return JsonResponse(res)
op = request.POST.get('method')
if op == 'POST':
pair = request.POST.get('pair')
special_order = request.POST.get('special_order')
if special_order == 'SINGLE':
params_1 = json.loads(request.POST.get('order_1'))
validate_1 = validate_input(params_1)
if 'error' in validate_1:
return JsonResponse(validate_1)
new_order = OrderRelation()
new_order.user = user
new_order.pair = pair
new_order.special_order = special_order
o_1 = process_order(user, params_1, True)
if o_1.status == BitbankOrder.STATUS_FAILED_TO_ORDER:
new_order = None
return JsonResponse({'error': o_1.error_message})
new_order.order_1 = o_1
new_order.is_active = True
new_order.save()
return JsonResponse({'success': True})
elif special_order == 'IFD':
params_1 = json.loads(request.POST.get('order_1'))
params_2 = json.loads(request.POST.get('order_2'))
validate_1 = validate_input(params_1)
if 'error' in validate_1:
return JsonResponse(validate_1)
validate_2 = validate_input(params_2)
if 'error' in validate_2:
return JsonResponse(validate_2)
new_order = OrderRelation()
new_order.user = user
new_order.pair = pair
new_order.special_order = special_order
o_1 = process_order(user, params_1, True)
new_order.order_1 = o_1
if o_1.status == BitbankOrder.STATUS_FAILED_TO_ORDER:
return JsonResponse({'error': True})
o_2 = process_order(user, params_2, False)
new_order.order_2 = o_2
if o_2.status == BitbankOrder.STATUS_FAILED_TO_ORDER:
_util.cancel_order(prv, o_1)
return JsonResponse({'error': o_2.error_message})
new_order.is_active = True
new_order.save()
return JsonResponse({'success': True})
elif special_order == 'OCO':
params_2 = json.loads(request.POST.get('order_2'))
params_3 = json.loads(request.POST.get('order_3'))
validate_2 = validate_input(params_2)
if 'error' in validate_2:
return JsonResponse(validate_2)
validate_3 = validate_input(params_3)
if 'error' in validate_3:
return JsonResponse(validate_3)
new_order = OrderRelation()
new_order.user = user
new_order.pair = pair
new_order.special_order = special_order
o_2 = process_order(user, params_2, True)
new_order.order_2 = o_2
if o_2.status == BitbankOrder.STATUS_FAILED_TO_ORDER:
return JsonResponse({'error': o_2.error_message})
o_3 = process_order(user, params_3, True)
new_order.order_3 = o_3
if o_3.status == BitbankOrder.STATUS_FAILED_TO_ORDER:
_util.cancel_order(prv, o_2)
return JsonResponse({'error': o_3.error_message})
new_order.is_active = True
new_order.save()
return JsonResponse({'success': True})
elif special_order == 'IFDOCO':
params_1 = json.loads(request.POST.get('order_1'))
params_2 = json.loads(request.POST.get('order_2'))
params_3 = json.loads(request.POST.get('order_3'))
validate_1 = validate_input(params_1)
if 'error' in validate_1:
return JsonResponse(validate_1)
validate_2 = validate_input(params_2)
if 'error' in validate_2:
return JsonResponse(validate_2)
validate_3 = validate_input(params_3)
if 'error' in validate_3:
return JsonResponse(validate_3)
new_order = OrderRelation()
new_order.user = user
new_order.pair = pair
new_order.special_order = special_order
o_1 = process_order(user, params_1, True)
new_order.order_1 = o_1
if o_1.status == BitbankOrder.STATUS_FAILED_TO_ORDER:
return JsonResponse({'error': o_1.error_message})
o_2 = process_order(user, params_2, False)
new_order.order_2 = o_2
if o_2.status == BitbankOrder.STATUS_FAILED_TO_ORDER:
return JsonResponse({'error': o_2.error_message})
o_3 = process_order(user, params_3, False)
new_order.order_3 = o_3
if o_3.status == BitbankOrder.STATUS_FAILED_TO_ORDER:
_util.cancel_order(prv, o_2)
return JsonResponse({'error': o_3.error_message})
new_order.is_active = True
new_order.save()
return JsonResponse({'success': True})
elif op == 'DELETE':
pk = request.POST.get("pk")
cancel_succeeded = True
subj_order = BitbankOrder.objects.filter(pk=pk).get()
if subj_order.order_id != None:
cancel_succeeded = _util.cancel_order(prv, subj_order)
else:
# 未発注の場合はステータスをキャンセル済みに変更
subj_order.status = 'CANCELED_UNFILLED'
subj_order.save()
if cancel_succeeded:
if OrderRelation.objects.filter(
order_1=subj_order).count() > 0:
relation = OrderRelation.objects.get(order_1=subj_order)
relation.is_active = False
elif OrderRelation.objects.filter(
order_2=subj_order).count() > 0:
relation = OrderRelation.objects.get(order_2=subj_order)
# IFD
if relation.order_3 == None:
relation.order_2 = None
relation.special_order = 'SINGLE'
# OCO
elif relation.order_1 == None:
relation.order_1 = relation.order_3
relation.order_2 = None
relation.order_3 = None
relation.special_order = 'SINGLE'
# IFDOCO
else:
relation.order_2 = relation.order_3
relation.order_3 = None
relation.special_order = 'IFD'
elif OrderRelation.objects.filter(
order_3=subj_order).count() > 0:
relation = OrderRelation.objects.get(order_3=subj_order)
# OCO
if relation.order_1 == None:
relation.order_1 = relation.order_2
relation.order_2 = None
relation.order_3 = None
relation.special_order = 'SINGLE'
# IFDOCO
else:
relation.order_3 = None
relation.special_order = 'IFD'
relation.save()
return JsonResponse({'success': True})
else:
return JsonResponse({'error': 'この注文はキャンセルできません'})
def __init__(self, pair):
self.pair = pair
self.pub = python_bitbankcc.public()
self.prv = python_bitbankcc.private(API_KEY, API_SECRET)
def handle(self, *args, **options):
logger = logging.getLogger('batch_logger')
#logger.info('started')
time_started = time.time()
n = 0
while True:
time.sleep(1)
n = n + 1
time_elapsed = time.time() - time_started
if time_elapsed > 57.0:
break;
for user in User.objects.all():
#logger.info(user.full_name)
# API KEYが登録されているユーザのみ処理
if (user.api_key == "" or user.api_key == None) or (user.api_secret_key == "" or user.api_secret_key == None):
# キー情報セット
continue
try:
prv = python_bitbankcc.private(user.api_key, user.api_secret_key)
except Exception as e:
logger.error('user:'******' message: ' + str(e.args))
continue
active_orders = OrderRelation.objects.filter(user=user).filter(is_active=True)
for order in active_orders:
o_1 = order.order_1
o_2 = order.order_2
o_3 = order.order_3
# Order#1が存在し、未約定の場合
if o_1 != None and o_1.status in {BitbankOrder.STATUS_UNFILLED, BitbankOrder.STATUS_PARTIALLY_FILLED}:
status = _util.get_status(prv, o_1)
#logger.info('o_1 found ' + str(o_1.order_id) + ' status:' + str(status))
if status == BitbankOrder.STATUS_FULLY_FILLED:
order.order_1 = None
if o_2 != None and o_2.status in {BitbankOrder.STATUS_WAIT_OTHER_ORDER_TO_FILL}:
order.special_order = 'SINGLE'
if 'stop' in o_2.order_type:
o_2.status = BitbankOrder.STATUS_READY_TO_ORDER
else:
if not _util.place_order(prv, o_2):
if o_3 != None:
if o_3.status in {BitbankOrder.STATUS_PARTIALLY_FILLED, BitbankOrder.STATUS_UNFILLED}:
_util.cancel_order(prv, o_3)
else:
o_3.status = BitbankOrder.STATUS_CANCELED_UNFILLED
if o_3 != None and o_3.status in {BitbankOrder.STATUS_WAIT_OTHER_ORDER_TO_FILL}:
order.special_order = 'OCO'
if 'stop' in o_3.order_type:
o_3.status = BitbankOrder.STATUS_READY_TO_ORDER
else:
if not _util.place_order(prv, o_3):
if o_2 != None:
if o_2.status in {BitbankOrder.STATUS_PARTIALLY_FILLED, BitbankOrder.STATUS_UNFILLED}:
_util.cancel_order(prv, o_2)
else:
o_2.status = BitbankOrder.STATUS_CANCELED_UNFILLED
if user.notify_if_filled == 'ON':
# 約定通知メール
_util.notify_user(user, o_1)
# 本家でキャンセルされていた場合
elif status in {BitbankOrder.STATUS_CANCELED_PARTIALLY_FILLED, BitbankOrder.STATUS_CANCELED_UNFILLED, BitbankOrder.STATUS_FAILED_TO_ORDER}:
if o_2 != None and o_2.status in {BitbankOrder.STATUS_WAIT_OTHER_ORDER_TO_FILL}:
o_2.status = BitbankOrder.STATUS_CANCELED_UNFILLED
if o_3 != None and o_3.status in {BitbankOrder.STATUS_WAIT_OTHER_ORDER_TO_FILL}:
o_3.status = BitbankOrder.STATUS_CANCELED_UNFILLED
if o_2 != None and o_2.status in {BitbankOrder.STATUS_UNFILLED, BitbankOrder.STATUS_PARTIALLY_FILLED}:
status = _util.get_status(prv, o_2)
if status == BitbankOrder.STATUS_FULLY_FILLED:
# order_3のキャンセル
if o_3 != None:
if o_3.status in {BitbankOrder.STATUS_UNFILLED, BitbankOrder.STATUS_PARTIALLY_FILLED}:
_util.cancel_order(prv, o_3)
else:
o_3.status = BitbankOrder.STATUS_CANCELED_UNFILLED
if user.notify_if_filled == 'ON':
# 約定通知メール
_util.notify_user(user, o_2)
elif status in {BitbankOrder.STATUS_CANCELED_PARTIALLY_FILLED, BitbankOrder.STATUS_CANCELED_UNFILLED}:
if o_3 != None:
order.order_2 = o_3
order.order_3 = None
order.special_order = 'SINGLE'
if o_3 != None and o_3.status in {BitbankOrder.STATUS_UNFILLED, BitbankOrder.STATUS_PARTIALLY_FILLED}:
status = _util.get_status(prv, o_3)
if status == BitbankOrder.STATUS_FULLY_FILLED:
# order_2のキャンセル
if o_2 != None:
if o_2.status in {BitbankOrder.STATUS_PARTIALLY_FILLED, BitbankOrder.STATUS_UNFILLED}:
_util.cancel_order(prv, o_2)
else:
o_2.status = BitbankOrder.STATUS_CANCELED_UNFILLED
if user.notify_if_filled == 'ON':
# 約定通知メール
_util.notify_user(user, o_3)
elif status in {BitbankOrder.STATUS_CANCELED_PARTIALLY_FILLED, BitbankOrder.STATUS_CANCELED_UNFILLED}:
if o_2 != None:
order.order_3 = None
order.special_order = 'SINGLE'
if (o_1 == None or o_1.status in {BitbankOrder.STATUS_FULLY_FILLED, BitbankOrder.STATUS_CANCELED_UNFILLED, BitbankOrder.STATUS_CANCELED_PARTIALLY_FILLED, BitbankOrder.STATUS_FAILED_TO_ORDER}) \
and (o_2 == None or o_2.status in {BitbankOrder.STATUS_FULLY_FILLED, BitbankOrder.STATUS_CANCELED_UNFILLED, BitbankOrder.STATUS_CANCELED_PARTIALLY_FILLED, BitbankOrder.STATUS_FAILED_TO_ORDER}) \
and (o_3 == None or o_3.status in {BitbankOrder.STATUS_FULLY_FILLED, BitbankOrder.STATUS_CANCELED_UNFILLED, BitbankOrder.STATUS_CANCELED_PARTIALLY_FILLED, BitbankOrder.STATUS_FAILED_TO_ORDER}):
order.is_active = False
if o_1 != None:
o_1.save()
if o_2 != None:
o_2.save()
if o_3 != None:
o_3.save()
order.save()
def __init__(self):
API_KEY = BITBANK_API_KEY
API_SECRET = BITBANK_API_SECRET
self.prv = python_bitbankcc.private(API_KEY, API_SECRET)
import python_bitbankcc import json import os BITBANK_API_KEY = os.environ['BITBANK_API_KEY'] BITBANK_API_SECRET = os.environ['BITBANK_API_SECRET'] cc_pub = python_bitbankcc.public() cc_prv = python_bitbankcc.private(BITBANK_API_KEY, BITBANK_API_SECRET)
def __init__(self, key, secret):
self.prv = python_bitbankcc.private(key, secret)
return
def __init__(self, api_key: str = None, api_secret: str = None, timeout: float = None, **__):
super().__init__(api_key, api_secret, timeout)
self.public = python_bitbankcc.public()
self.private = python_bitbankcc.private(self.api_key, self.api_secret)
from common.utils import merge_list, daterange, parse_error
root_module = os.path.basename(sys.argv[0])
if root_module == 'tr.py':
logger = logging.getLogger('crypto')
elif root_module == 'sim.py':
logger = logging.getLogger('simulate')
else:
pass
inifile = configparser.ConfigParser()
inifile.read('config.ini', 'UTF-8')
api_key = inifile.get('config', 'api_key')
api_secret = inifile.get('config', 'api_secret')
prv = python_bitbankcc.private(api_key, api_secret)
pub = python_bitbankcc.public()
class APIBase():
@abstractmethod
def get_asset(self):
pass
@abstractmethod
def get_ticker(self, pair):
pass
@abstractmethod
def get_candle(self, pair, candle_type):
pass
def __init__(self):
self.public_api = bitcc.public()
self.private_api = bitcc.private(os.environ["API_KEY"],
os.environ["API_SECRET"])
def handle(self, *args, **options):
logger = logging.getLogger('sync_orders')
time_started = time.time()
n = 0
while True:
time.sleep(1)
n = n + 1
time_elapsed = time.time() - time_started
if time_elapsed > 57.0:
break
for user in User.objects.filter(is_active=True):
logger.info('bitbank注文の動機を開始します')
prv_bb = python_bitbankcc.private(user.bb_api_key,
user.bb_api_secret_key)
for pair in Relation.PAIR:
time.sleep(0.1)
to = datetime.now()
since = to - timedelta(seconds=10)
option = {
'count': 10,
'since': int(since.timestamp() * 1000),
'end': int(to.timestamp() * 1000)
}
# アクティブ注文の反映
try:
active = prv_bb.get_active_orders(pair, option)
except Exception as e:
logger.error('アクティブ注文の取得に失敗しました.{}'.format(str(
e.args)))
pass
else:
for o in active['orders']:
time.sleep(0.3)
# DBを検索
try:
exist = Order.objects.get(
order_id=o['order_id'])
# DBにない場合は反映
except Order.DoesNotExist:
logger.info('新規注文:{}をDBへ反映します'.format(
str(o['order_id'])))
o['market'] = 'bitbank'
o['order_type'] = o['type']
os = OrderSerializer(data=o,
context={'user': user})
if os.is_valid():
o1 = os.save()
else:
logger.error('パラメタの反映に失敗しました.{}'.format(
str(os.errors)))
continue
relation = Relation()
relation.user = user
relation.market = 'bitbank'
relation.pair = o['pair']
relation.special_order = 'SINGLE'
relation.order_1 = o1
relation.save()
else:
# DBに存在する場合は
pass
# 約定済み注文の反映
try:
history = prv_bb.get_trade_history(pair, option)
except Exception as e:
logger.error('注文履歴の取得に失敗しました.{}'.format(str(e.args)))
pass
else:
for o in history['trades']:
time.sleep(0.1)
try:
exist = Order.objects.filter(
order_id=o['order_id'])
except Order.DoesNotExist:
logger.info('注文履歴 {} をDBに反映します'.format(
str(o['order_id'])))
o['market'] = 'bitbank'
o['order_type'] = o['type']
o['status'] = Order.STATUS_FULLY_FILLED
o['ordered_at'] = o['executed_at']
o['start_amount'] = o['amount']
o['executed_amount'] = o['amount']
os = OrderSerializer(data=o,
context={'user': user})
if os.is_valid():
o1 = os.save()
else:
logger.error('パラメタエラー'.format(
str(os.errors)))
continue
else:
pass
logger.info('coincheckの同期を開始します')
prv_cc = CoinCheck(user.cc_api_key, user.cc_api_secret_key)
pair = 'btc_jpy'
pag = {'limit': 10, 'order': 'desc'}
ao = json.loads(prv_cc.order.opens({}))
if ao['success']:
for o in ao['orders']:
try:
exist = Order.objects.filter(order_id=o['id'])
except Order.DoesNotExist:
logger.info('新規注文 :{} を同期します'.format(str(o['id'])))
o['market'] = 'coincheck'
o['order_id'] = o['id']
o['side'] = 'sell' if 'sell' in o[
'order_type'] else 'buy'
o['order_type'] = 'market' if 'market' in o[
'order_type'] else 'limit'
o['price'] = o['rate']
o['start_amount'] = o['pending_amount']
o['status'] = Order.STATUS_UNFILLED
os = OrderSerializer(data=o,
context={'user': user})
if os.is_valid():
o1 = os.save()
else:
logger.error(str(os.errors))
continue
relation = Relation()
relation.user = user
relation.market = 'coincheck'
relation.pair = o['pair']
relation.special_order = 'SINGLE'
relation.order_1 = o1
relation.save()
else:
pass
elif ao['error']:
logger.error('coincheckのアクティブ注文の動機に失敗しました.{}'.format(
str(ao['error'])))
co = json.loads(prv_cc.order.transactions(pag))
if co['success']:
for o in co['transactions']:
exist = Order.objects.filter(order_id=o['order_id'])
if len(exist) == 0:
logger.info('注文履歴{}を同期します'.format(
str(o[('order_id')])))
o['market'] = 'coincheck'
o['status'] = Order.STATUS_FULLY_FILLED
amount = float(
o['funds']
['btc']) if o['side'] == 'buy' else -1 * float(
o['funds']['btc'])
for o2 in co['transactions']:
if o['id'] != o2['id'] and o['order_id'] == o2[
'order_id']:
amount += float(
o2['funds']['btc']
) if o2['side'] == 'buy' else -1 * float(
o2['funds']['btc'])
o['executed_amount'] = amount
o['start_amount'] = amount
o['order_type'] = Order.TYPE_LIMIT
os = OrderSerializer(data=o,
context={'user': user})
if os.is_valid():
o1 = os.save()
else:
logger.error(str(os.errors))
continue
elif co['errro']:
logger.error('coincheckの注文履歴の同期に失敗しました.'.format(
str(co['error'])))
logger.info('done')
MARGIN = 500 # JPY per BTC
LOW_MARGIN = 200
MIN_MARGIN = 0
LOW_RATIO = 2 # when are funds considered low
STABLE_VOL_FLOAT = 0.1
COLORS = ['blue', 'green', 'red', 'orange']
# import credentials
with open('config.yml', 'r') as ymlfile:
cfg = yaml.load(ymlfile)
auth = cfg['auth']
# instantiate clients
bf_client = pybitflyer.API(api_key=auth['bf']['key'],
api_secret=auth['bf']['secret'])
bb_client_pte = python_bitbankcc.private(auth['bb']['key'],
auth['bb']['secret'])
bb_client = python_bitbankcc.public()
zf_pclient = ZaifTradeApi(auth['zf']['key'], auth['zf']['secret'])
zf_client = ZaifPublicApi()
qn_client = Quoinex(auth['qn']['key'], auth['qn']['secret'])
def bb_trade(direction, price, size=SIZE):
bb_client_pte.order('btc_jpy', '', size, direction.lower(), 'market')
def bf_trade(direction, price, size=SIZE):
bf_client.sendchildorder(product_code='BTC_JPY',
child_order_type='MARKET',
side=direction,
size=size)
from common.chart_creator import ChartCreator as cc
import pandas as pd
import configparser
from urllib.parse import urlparse
from datetime import datetime, timedelta
import mysql.connector
# DB設定
inifile = configparser.ConfigParser()
inifile.read('config.ini', 'UTF-8')
user = inifile.get('mysql', 'user')
password = inifile.get('mysql', 'password')
alert_url = inifile.get('slack', 'alert_url')
prv = python_bitbankcc.private(get_api_key(), get_api_secret())
# DB設定
inifile = configparser.ConfigParser()
inifile.read('config.ini', 'UTF-8')
user = inifile.get('mysql', 'user')
password = inifile.get('mysql', 'password')
alert_url = inifile.get('slack', 'alert_url')
# PubNubの設定
pnconfig = PNConfiguration()
pnconfig.subscribe_key = get_subscribe_key()
pnconfig.ssl = True
pubnub = PubNub(pnconfig)
# logger
def update(self):
logger = logging.getLogger('api')
prv_bitbank = python_bitbankcc.private(self.user.bb_api_key,
self.user.bb_api_secret_key)
prv_coincheck = CoinCheck(self.user.cc_api_key,
self.user.cc_api_secret_key)
if self.market == 'bitbank':
try:
ret = prv_bitbank.get_order(self.pair, self.order_id)
except Exception as e:
raise OrderStatusUpdateError(_trim_error_msg(e.args[0]))
else:
self.remaining_amount = ret.get('remaining_amount')
self.executed_amount = ret.get('executed_amount')
self.average_price = ret.get('average_price')
status = ret.get('status')
self.status = status
self.save()
return status
elif self.market == 'coincheck':
try:
_open = json.loads(prv_coincheck.order.opens({}))
_close = json.loads(
prv_coincheck.order.transactions({
'limit':
1,
'starting_after':
self.order_id,
'ending_before':
self.order_id
}))
except Exception as e:
raise OrderStatusUpdateError(e.args[0])
else:
if not _open.get('success'):
if _open.get('error'):
raise OrderStatusUpdateError(_open.get('error'))
raise OrderStatusUpdateError('想定外の応答: ' + str(_open))
if not _close.get('success'):
if _close.get('error'):
raise OrderStatusUpdateError(_close.get('error'))
raise OrderStatusUpdateError('想定外の応答: ' + str(_close))
is_open = False
for oo in _open.get('orders'):
if oo.get('id') == self.order_id:
is_open = True
return self.STATUS_UNFILLED
if not is_open:
if len(_close.get('transactions')) != 0:
# filled
self.status = self.STATUS_FULLY_FILLED
self.executed_amount = self.start_amount
self.remaining_amount = 0
self.average_price = float(
_close.get('transactions')[0].get('rate'))
else:
# canceled
self.status = self.STATUS_CANCELED_UNFILLED
self.save()
return self.STATUS_FULLY_FILLED
def place(self):
logger = logging.getLogger('api')
prv_bitbank = python_bitbankcc.private(self.user.bb_api_key,
self.user.bb_api_secret_key)
prv_coincheck = CoinCheck(self.user.cc_api_key,
self.user.cc_api_secret_key)
if self.market == 'bitbank':
try:
ret = prv_bitbank.order(
self.pair, # ペア
self.price, # 価格
self.start_amount, # 注文枚数
self.side, # 注文サイド
'market' if self.order_type.find("limit") == -1 else
'limit' # 注文タイプ
)
except Exception as e:
logger.error('place bitbank order: ' + str(e.args))
self.status = Order.STATUS_FAILED_TO_ORDER
self.error_message = _trim_error_msg(e.args[0])
self.save()
return False
else:
self.remaining_amount = ret.get('remaining_amount')
self.executed_amount = ret.get('executed_amount')
self.average_price = ret.get('average_price')
self.status = ret.get('status')
self.ordered_at = ret.get('ordered_at')
self.order_id = ret.get('order_id')
self.save()
return True
elif self.market == 'coincheck':
try:
current_rate = float(
json.loads(prv_coincheck.ticker.all())['last'])
ret = json.loads(
prv_coincheck.order.create({
'rate':
self.price if 'limit' in self.order_type else None,
'amount':
self.start_amount
if not (self.order_type == 'market'
and self.side == 'buy') else None,
'market_buy_amount':
current_rate * self.start_amount if
(self.order_type == 'market'
and self.side == 'buy') else None,
'order_type':
self.side if 'limit' in self.order_type else
'market_' + self.side,
'pair':
self.pair
}))
except Exception as e:
self.status = Order.STATUS_FAILED_TO_ORDER
self.error_message = e.args[0]
self.save()
raise OrderFailedError(self.error_message)
else:
if ret.get('success'):
self.order_id = ret.get('id')
self.remaining_amount = ret.get('amount')
ordered_date = datetime.strptime(
ret.get('created_at'),
'%Y-%m-%dT%H:%M:%S.%fZ') + timedelta(hours=9)
self.ordered_at = int(ordered_date.timestamp() * 1000)
self.status = self.STATUS_UNFILLED
self.save()
return True
elif ret.get('error'):
self.status = self.STATUS_FAILED_TO_ORDER
self.error_message = ret.get('error')
self.save()
raise OrderFailedError(self.error_message)
else:
raise Exception('想定外のレスポンス:' + str(ret))
def __init__(self, api_key=None, api_secret=None):
self.__pub = python_bitbankcc.public()
self.__pri = None
if api_key is not None and api_secret is not None:
self.__pri = python_bitbankcc.private(api_key=api_key,
api_secret=api_secret)
import python_bitbankcc
import login
from pprint import pprint
prv = python_bitbankcc.private(login.API_KEY, login.API_SECRET)
pprint(prv.get_asset())
value = prv.order(
'xrp_jpy', # ペア
'1', # 価格
'1', # 注文枚数
'buy', # 注文サイド
'limit' # 注文タイプ
)
print(value)
"""
{'order_id': 13117487312, 'pair': 'xrp_jpy', 'side': 'buy', 'type': 'limit', 'start_amount': '1.0000', 'remaining_amount': '1.0000', 'executed_amount': '0.0000', 'price': '1.000', 'average_price': '0.000', 'ordered_at': 1615912027287, 'status': 'UNFILLED'}
"""
def handle(self, *args, **options):
logger = logging.getLogger('batch_logger')
#logger.info('started')
time_started = time.time()
n = 0
while True:
time.sleep(1)
n = n + 1
time_elapsed = time.time() - time_started
if time_elapsed > 57.0:
break
pub = python_bitbankcc.public()
for user in User.objects.all():
# API KEYが登録されているユーザのみ処理
if user.api_key == "" or user.api_secret_key == "":
continue
# キー情報セット
try:
prv = python_bitbankcc.private(user.api_key,
user.api_secret_key)
except Exception as e:
logger.error('user:'******' message: ' +
str(e.args))
continue
# 通貨ペアをイテレーション
for pair in OrderRelation.PAIR:
# Tickerの取得
try:
ticker_dict = pub.get_ticker(pair)
except Exception as e:
logger.error('user:'******' pair:' + pair +
' error:' + str(e.args))
continue
# 通知処理
alerts_by_pair = Alert.objects.filter(pair=pair).filter(
is_active=True)
for alert in alerts_by_pair:
try:
if (alert.over_or_under == '以上' and float(ticker_dict.get('last')) >= alert.threshold) or \
(alert.over_or_under == '以上' and float(ticker_dict.get('last')) >= alert.threshold):
if user.use_alert == 'ON':
context = {
"user": user,
"ticker_dict": ticker_dict,
"pair": pair
}
subject = get_template(
'bitbank/mail_template/rate_notice/subject.txt'
).render(context)
message = get_template(
'bitbank/mail_template/rate_notice/message.txt'
).render(context)
user.email_user(subject, message)
#logger.info('rate notice sent to:' + user.email_for_notice)
alert.alerted_at = timezone.now()
alert.is_active = False
alert.save()
except Exception as e:
alert.is_active = False
alert.save()
logger.error('user:'******' pair:' +
pair + ' alert:' + str(alert.pk) +
' error:' + str(e.args))
# 逆指値の注文取得
stop_market_orders_by_pair = BitbankOrder.objects.filter(
user=user).filter(pair=pair).filter(
order_type=BitbankOrder.TYPE_STOP_MARKET
).filter(order_id__isnull=True).filter(
status__in=[BitbankOrder.STATUS_READY_TO_ORDER])
# 各注文を処理
for stop_market_order in stop_market_orders_by_pair:
# 売りの場合
logger.info('Stop market order found. side:' +
stop_market_order.side + ' stop price:' +
str(stop_market_order.price_for_stop) +
' market sell:' + ticker_dict.get('sell') +
' market buy:' + ticker_dict.get('buy'))
if (stop_market_order.side == 'sell' and (float(ticker_dict.get('sell')) <= stop_market_order.price_for_stop)) or \
(stop_market_order.side == 'buy' and (float(ticker_dict.get('buy')) >= stop_market_order.price_for_stop)):
_util.place_order(prv, stop_market_order)
# ストップリミットの注文取得
stop_limit_orders_by_pair = BitbankOrder.objects.filter(
user=user).filter(pair=pair).filter(
order_type=BitbankOrder.TYPE_STOP_LIMIT
).filter(order_id__isnull=True).filter(
status__in=[BitbankOrder.STATUS_READY_TO_ORDER])
# 各注文を処理
for stop_limit_order in stop_limit_orders_by_pair:
logger.info('Stop limit order found. side:' +
stop_limit_order.side + ' stop price:' +
str(stop_limit_order.price_for_stop) +
' market sell:' + ticker_dict.get('sell') +
' market buy:' + ticker_dict.get('buy'))
if (stop_limit_order.side == 'sell' and (float(ticker_dict.get('sell')) <= stop_limit_order.price_for_stop)) or \
(stop_limit_order.side == 'buy' and (float(ticker_dict.get('buy')) >= stop_limit_order.price_for_stop)):
_util.place_order(prv, stop_limit_order)
logger.info('completed')
