def get_rsi_value(symbol, time_frame):
try:
k_lines = json.loads(DATABASE.get(symbol + time_frame.upper()))
res = rsi(list(float(x[4]) for x in k_lines), RSI_PERIOD)
return round(float(res[-1]), 2)
except (TypeError, KeyError):
to_err_log(symbol, f'{time_frame}', traceback.format_exc())
def get_ma_value(symbol, time_frame, period):
try:
k_lines = json.loads(DATABASE.get(symbol + time_frame.upper()))
res = list(sma(list(float(x[4]) for x in k_lines), period))
return round(float(res[-1]), 8)
except (TypeError, KeyError):
to_err_log(symbol, f'{time_frame} {period}', traceback.format_exc())
def get_balance2(asset):
balances = DATABASE.get(BALANCE)
if balances is not None:
balances = json.loads(balances)
# print(balances)
for balance in balances:
if balance['asset'] == asset:
return float(balance['free'])
def get_test_data():
bid1 = random.randrange(9600, 9700)
ask1 = random.randrange(9700, 9800)
bid2 = random.randrange(12000, 12400)
ask2 = random.randrange(12450, 12800)
bid3 = random.randrange(309000, 310000)
ask3 = random.randrange(310000, 311000)
bid4 = random.randrange(12000, 12400)
ask4 = random.randrange(12450, 12800)
bid_amount1 = round(random.uniform(0, 1), 2)
ask_amount1 = round(random.uniform(0, 1), 2)
bid_amount2 = round(random.uniform(0, 1), 2)
ask_amount2 = round(random.uniform(0, 1), 2)
bid_amount3 = round(random.uniform(0, 1), 2)
ask_amount3 = round(random.uniform(0, 1), 2)
bid_amount4 = round(random.uniform(0, 1), 2)
ask_amount4 = round(random.uniform(0, 1), 2)
bank_rate = float(str(DATABASE.get(BANK_RATE)))
return [{
"exchange": "ITBIT",
"symbol": "XBT_USD",
"bid": str(bid1),
"bid_amount": str(bid_amount1),
"ask": str(ask1),
"ask_amount": str(ask_amount1),
"bank_rate": str(bank_rate),
"diff": str(round(bid3 / bank_rate / ask1 * 100 - 100, 2))
}, {
"exchange": "ITBIT",
"symbol": "ETH_USD",
"bid": str(bid2),
"bid_amount": str(bid_amount2),
"ask": str(ask2),
"ask_amount": str(ask_amount2),
"bank_rate": str(bank_rate),
"diff": str(round(bid4 / bank_rate / ask2 * 100 - 100, 2))
}, {
"exchange": "BXIN",
"symbol": "THB_BTC",
"bid": str(bid3),
"bid_amount": str(bid_amount3),
"ask": str(ask3),
"ask_amount": str(ask_amount3),
"bank_rate": str(bank_rate),
"diff": str(round(bid1 / bank_rate / ask3 * 100 - 100, 2))
}, {
"exchange": "BXIN",
"symbol": "THB_ETH",
"bid": str(bid4),
"bid_amount": str(bid_amount4),
"ask": str(ask4),
"ask_amount": str(ask_amount4),
"bank_rate": str(bank_rate),
"diff": str(round(bid2 / bank_rate / ask4 * 100 - 100, 2))
}]
def get_pip(symbol):
exchange_info = DATABASE.get(EXCHANGE_INFO)
if exchange_info is None:
return
exchange_info = json.loads(exchange_info)
symbols = exchange_info['symbols']
for symbol_info in symbols:
if symbol_info['symbol'] == symbol:
return float(symbol_info['filters'][0]['tickSize'])
def normalize_symbol(asset1, asset2):
exchange_info = DATABASE.get(EXCHANGE_INFO)
if exchange_info is None:
return
exchange_info = json.loads(exchange_info)
symbols = list(x['symbol'] for x in exchange_info['symbols'])
if asset1 + asset2 in symbols:
return asset1 + asset2
if asset2 + asset1 in symbols:
return asset2 + asset1
def get_24_volume(symbol):
tickers = DATABASE.get(TICKERS)
if tickers is None:
return
tickers = json.loads(tickers)
for ticker in tickers:
if ticker['symbol'] == symbol:
if split_symbol(symbol)['base'] == PREF_WALL:
return float(ticker['volume'])
return float(ticker['quoteVolume'])
def split_symbol(symbol):
exchange_info = DATABASE.get(EXCHANGE_INFO)
if exchange_info is not None:
symbols_info = json.loads(exchange_info)['symbols']
for symbol_info in symbols_info:
if symbol_info['symbol'] == symbol:
return {
'base': symbol_info['baseAsset'],
'quote': symbol_info['quoteAsset']
}
def get_min_notional(symbol):
exchange_info = DATABASE.get(EXCHANGE_INFO)
if exchange_info is None:
return
exchange_info = json.loads(exchange_info)
symbols = exchange_info['symbols']
for s in symbols:
if s['symbol'] == symbol:
for f in s['filters']:
if f['filterType'] == 'MIN_NOTIONAL':
return float(f['minNotional'])
def generate():
log = DATABASE.get(GENERAL_LOG)
if log is not None:
log = json.loads(log)
f = open(LOG_PATH + 'general.log', "w")
for text in log:
f.write(text + '\n')
print(text)
f.close()
print('Done\nCheck {}'.format(LOG_PATH + 'general.log'))
else:
print('Log is empty')
def to_general_log(symbol, text):
log = DATABASE.get(GENERAL_LOG)
if log is None:
log = '[]'
log = json.loads(log)
if len(log) > LOG_LENGTH:
log = log[-(len(log) - 1):]
dt = datetime.now().replace(microsecond=0).isoformat().replace('T', ' ')
log.append(dt + ' ' + symbol + ': ' + text)
DATABASE.set(GENERAL_LOG, json.dumps(log))
print(dt + ' ' + symbol + ': ' + text)
def get_precision(symbol):
exchange_info = DATABASE.get(EXCHANGE_INFO)
if exchange_info is None:
return
exchange_info = json.loads(exchange_info)
symbols = exchange_info['symbols']
for s in symbols:
if s['symbol'] == symbol:
for f in s['filters']:
if f['filterType'] == 'LOT_SIZE':
step_size = Decimal(f['stepSize']).normalize()
return len(str(step_size).split('.')[1]) if '.' in str(
step_size) else 0
def update_price_change_percent(symbol, value):
price_change_percents = json.loads(
DATABASE.get(symbol + ':' + PRICE_CHANGE_PERCENT))
remove = []
for price_change_percent in price_change_percents:
if int(price_change_percent
) + PRICE_CHANGE_PERCENT_DIFFERENCE_TIME_RANGE < int(
time.time()):
remove.append(price_change_percent)
for x in remove:
price_change_percents.pop(x)
price_change_percents.update({int(time.time()): value})
set_price_change_percent(symbol, price_change_percents)
def db_engine():
engine = DATABASE.get('ENGINE')
name = DATABASE.get('NAME')
if engine == 'sqlite':
return create_engine(f'{engine}:///{name}')
else:
host = DATABASE.get('HOST')
user = DATABASE.get('USER')
passwd = DATABASE.get('PASSWORD')
charset = DATABASE.get('CHARSET') or 'utf8'
return create_engine(f'{engine}://{user}:{passwd}@{host}/{name}',
encoding=charset)
def update_history(symbol, time_frame, kline):
try:
time_now = datetime.datetime.utcfromtimestamp(time.time()).strftime('%H:%M:%S')
history = DATABASE.get(symbol + time_frame.upper())
if history is not None:
history = json.loads(history)
history.pop(0)
kline = [kline['t'], kline['o'], kline['h'],
kline['l'], kline['c'], kline['v'],
kline['T'], kline['q'], kline['n'],
kline['V'], kline['Q'], kline['B']]
history.append(kline)
print(symbol, time_now, time_frame.upper())
DATABASE.set(symbol + time_frame.upper(), json.dumps(history))
except:
to_general_log(symbol, 'Connect timeout. Reconnection...')
def get_data():
bidask1 = json.loads(DATABASE.get('itbit_XBT_USD'))
bidask2 = json.loads(DATABASE.get('itbit_ETH_USD'))
bidask3 = json.loads(DATABASE.get('bxin_THB_BTC'))
bidask4 = json.loads(DATABASE.get('bxin_THB_ETH'))
bank_rate = float(str(DATABASE.get(BANK_RATE)))
return [{
"exchange":
"ITBIT",
"symbol":
"XBT_USD",
"bid":
str(bidask1['bid']),
"bid_amount":
'{0:.8f}'.format(bidask1['bid_amount']),
"ask":
str(bidask1['ask']),
"ask_amount":
'{0:.8f}'.format(bidask1['ask_amount']),
"bank_rate":
str(bank_rate),
"diff":
str(round(bidask3['bid'] / bank_rate / bidask1['ask'] * 100 - 100, 2))
}, {
"exchange": "BXIN",
"symbol": "THB_BTC",
"bid": str(bidask3['bid']),
"bid_amount": str(bidask3['bid_amount']),
"ask": str(bidask3['ask']),
"ask_amount": str(bidask3['ask_amount']),
"bank_rate": str(bank_rate),
"diff": ""
}, {
"exchange":
"ITBIT",
"symbol":
"ETH_USD",
"bid":
str(bidask2['bid']),
"bid_amount":
str(bidask2['bid_amount']),
"ask":
str(bidask2['ask']),
"ask_amount":
str(bidask2['ask_amount']),
"bank_rate":
str(bank_rate),
"diff":
str(round(bidask4['bid'] / bank_rate / bidask2['ask'] * 100 - 100, 2))
}, {
"exchange": "BXIN",
"symbol": "THB_ETH",
"bid": str(bidask4['bid']),
"bid_amount": str(bidask4['bid_amount']),
"ask": str(bidask4['ask']),
"ask_amount": str(bidask4['ask_amount']),
"bank_rate": str(bank_rate),
"diff": ""
}]
from flask import Flask
app = Flask(__name__, instance_relative_config=True)
from config import (
DATABASE,
SECRET_KEY,
DEBUG,
CSRF_ENABLED,
UPLOAD_IMAGES_FOLDER,
UPLOAD_FILES_FOLDER,
)
app.secret_key = SECRET_KEY
app.config["SQLALCHEMY_DATABASE_URI"] = DATABASE.get("SQLALCHEMY_DATABASE_URI")
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = DATABASE.get(
"SQLALCHEMY_TRACK_MODIFICATIONS")
app.config["DEBUG"] = DEBUG
app.config["CSRF_ENABLED"] = CSRF_ENABLED
app.config["UPLOAD_IMAGES_FOLDER"] = UPLOAD_IMAGES_FOLDER
app.config["UPLOAD_FILES_FOLDER"] = UPLOAD_FILES_FOLDER
# Load the views
import db
from app import views, models
from datetime import datetime
from peewee import *
from playhouse.db_url import connect
from config import Engine, DATABASE
db_engine = DATABASE.get('DB_ENGINE')
db_name = DATABASE.get('DB_NAME')
db_user = DATABASE.get('DB_USER')
db_password = DATABASE.get('DB_PASSWORD')
db_host = DATABASE.get('DB_HOST')
db_port = DATABASE.get('DB_PORT')
print('db_engine: %s\nEngine.SQLITE: %s\n' % (db_engine, Engine.SQLITE))
if db_engine == Engine.SQLITE:
db = connect('%s:///%s' % (db_engine.value, db_name))
elif db_engine in (Engine.MYSQL, Engine.POSTGRESQL):
db = connect(
'%s:///%s:%s@%s:%d/%d' %
(db_engine.value, db_user, db_password, db_host, db_port, db_name))
class BaseModel(Model):
class Meta:
database = db
class User(BaseModel):
username = CharField(unique=True)
def get_current_price(symbol, s):
price = DATABASE.get(symbol)
return float(json.loads(price)[s])
def get_candles(symbol, time_frame):
try:
return json.loads(DATABASE.get(symbol + time_frame))
except (TypeError, KeyError):
to_err_log(symbol, f'{time_frame}', traceback.format_exc())
def get_price_change_percent(symbol):
return json.loads(DATABASE.get(symbol + ':' + PRICE_CHANGE_PERCENT))
def get_orders_info(exchange):
return json.loads(DATABASE.get(exchange + ':' + ORDERS_INFO))
