def get_percent(value, num):
"""
:param value:
:param num:
:return: rounded percentage value of num
"""
return d(d(value) / d(num) * 100, 2)
def epic_to(value, target):
"""
Convert amount (value) of Epic-Cash to given target - USD or Bitcoin.
"""
if target == 'btc':
return round(d(filters()['epic']['data'][target].avg_price) * d(value), 8)
else:
return round(d(filters()['epic']['data'][target].avg_price) * d(value), 3)
def halving(coin):
block_time = d(coin.explorer.order_by('updated').last().average_blocktime)
block_height = d(coin.explorer.order_by('updated').last().height)
def check_height():
if block_height < 480_960:
halving_height = 480_960
else:
halving_height = 1_157_760
return halving_height
time_left = ((check_height() - block_height) * block_time)
date = timezone.now() + timedelta(seconds=int(time_left))
return {'date': date, 'height': check_height()}
def volumes():
vols = {
'citex_btc':
d(filters()['exchanges']['citex']['tickers']['btc'].order_by(
'updated').last().volume),
'vitex_btc':
d(filters()['exchanges']['vitex']['tickers']['btc'].order_by(
'updated').last().volume),
'citex_usdt':
d(filters()['exchanges']['citex']['tickers']['usdt'].order_by(
'updated').last().volume)
}
total = vols['citex_btc'] + vols['citex_usdt'] + vols['vitex_btc']
usdt = vols['citex_usdt']
btc = vols["vitex_btc"] + vols['citex_btc']
citex = vols['citex_btc'] + vols['citex_usdt']
vitex = vols["vitex_btc"]
btc_vs_total = d(btc / total * 100, 0)
usdt_vs_total = d(usdt / total * 100, 0)
citex_vs_total = d(citex / total * 100, 0)
vitex_vs_total = d(vitex / total * 100, 0)
data = {
'total': {
'all': total,
'usdt': usdt,
'btc': btc
},
'citex': {
'total': citex,
'usdt': vols['citex_usdt'],
'btc': vols['citex_btc']
},
'vitex': {
'total': vitex,
'btc': vols['vitex_btc']
},
'percent': {
'btc': [btc, btc_vs_total],
'usdt': [usdt, usdt_vs_total],
'CITEX': [citex, citex_vs_total],
'ViteX': [vitex, vitex_vs_total]
}
}
return data
def daily_mined(coin):
block_time = d(coin.explorer.last().average_blocktime)
block_reward = d(coin.explorer.last().reward)
return {'coins': d((86400 / block_time) * block_reward, 0),
'blocks': d(86400 / block_time, 0)}
def times(value, num):
return d(value) * d(num)
def add(value, num):
return d(value) + d(num)
def minus_back(value, num):
return d(num) - d(value)
def check_color(value):
if d(value) <= 0:
return 'red'
else:
return 'green'
def check_arrow(value):
if d(value) <= 0:
return '<i class="fa fa-arrow-down color-red"></i>'
else:
return '<i class="fa fa-arrow-up color-green"></i>'
def btc_to_usd(value):
"""
Convert amount (value) of BTC to USD.
"""
return d(value) * d(Coin.objects.get(symbol="BTC").coingecko.latest('updated').data['price'])
def usd_to_btc(value):
"""
Convert amount (value) of USD to BTC.
"""
return d(value) / d(Coin.objects.get(symbol="BTC").coingecko.latest('updated').data['price'])
def epic_data():
start_time = monotonic()
coin = models()['epic']
tickers = {
target: {
ex: Ticker.objects.filter(coin=coin, exchange=ex,
pair=target).last()
for ex in EXCHANGES
if Ticker.objects.filter(coin=coin, exchange=ex, pair=target)
}
for target in PAIRS
}
def avg_price(currency):
source = {
target: [
float(
Ticker.objects.filter(coin=coin, exchange=ex,
pair=target).last().last_price)
for ex in EXCHANGES
if Ticker.objects.filter(coin=coin, exchange=ex, pair=target)
]
for target in PAIRS
}
prices = []
for target in PAIRS:
if target == currency:
prices.append(avg(source[target]))
else:
if currency == 'usdt':
prices.append(btc_to_usd(avg(source[target])))
elif currency == "btc":
prices.append(usd_to_btc(avg(source[target])))
return avg(prices)
for target in PAIRS:
data = {
'coin':
coin,
'pair':
target,
'updated':
timezone.now(),
'avg_price':
d(avg_price(target)),
'vol_24h':
sum([d(x.volume) for x in tickers[target].values()]),
'percentage_change_24h':
change(Data.objects.filter(coin=coin, pair=target), 'avg_price'),
'percentage_change_7d':
get_gecko(models()['epic']).data['change_7d'],
'market_cap':
d(filters()['epic']['explorer'].circulating) *
avg([x.last_price for x in tickers[target].values()]),
'ath':
d(get_gecko(models()['epic']).data['ath'][target]['price']),
'ath_date':
get_gecko(models()['epic']).data['ath'][target]['date'],
'ath_change':
d(get_gecko(models()['epic']).data['ath'][target]['change'], 2),
'block_value':
d(filters()['epic']['explorer'].reward) * d(avg_price(target)),
}
last_saved = Data.objects.filter(coin=models()['epic'],
pair=target,
to_save=True).last()
last_updated = Data.objects.filter(coin=models()['epic'],
pair=target,
to_save=False).last()
save = check_saving(last_saved)
if save:
Data.objects.create(to_save=save, **data)
print(f"save=True, record saved")
else:
if last_updated:
updater(last_updated, data)
else:
Data.objects.create(to_save=save, **data)
end_time = monotonic()
return f"Epic-Cash Data saved in db {timedelta(seconds=(end_time - start_time)).total_seconds()} seconds"
def vitex_data():
start_time = monotonic()
queries = {
'depth': 'depth?symbol=',
'orderbook': 'ticker/bookTicker?symbol=',
'ticker': 'ticker/24hr?symbols=',
'market': 'market?symbol=',
'trades': 'trades?symbol=',
'candles': 'klines?symbol=',
}
symbol = 'EPIC-001_BTC-000'
target = 'btc'
exchange = models()['vitex']
coin = models()['epic']
def vitex_api(query, breaks=False, extra='&interval=hour&limit=20'):
start_url = "https://api.vitex.net/api/v2/"
if query == "klines?symbol=":
url = start_url + query + symbol + extra
else:
url = start_url + query + symbol
# print(f"{url}...")
if breaks:
sleep(1.5)
return json.loads(requests.get(url).content)
data = {query: vitex_api(queries[query]) for query in queries}
update = {
'updated':
timezone.now(),
'coin':
coin,
'exchange':
exchange,
'pair':
target,
'trading_url':
'https://x.vite.net/trade?symbol=' + symbol,
'last_price':
d(data['market']['data']['lastPrice']),
'bid':
d(data['market']['data']['bidPrice']),
'ask':
d(data['market']['data']['askPrice']),
'spread':
spread(data['market']['data']['askPrice'],
data['market']['data']['bidPrice']),
'high':
d(data['market']['data']['highPrice']),
'low':
d(data['market']['data']['lowPrice']),
'last_trade':
t_s(data['trades']['data'][0]['timestamp']),
'volume':
d(data['market']['data']['volume']),
'orders':
data['depth']['data'],
'candles':
data['candles']['data'],
'trades':
data['trades']['data']
}
last_saved = Ticker.objects.filter(coin=coin,
pair=target,
exchange=exchange,
to_save=True).last()
last_updated = Ticker.objects.filter(coin=coin,
pair=target,
exchange=exchange,
to_save=False).last()
save = check_saving(last_saved)
if save:
Ticker.objects.create(to_save=save, **update)
print(f"save=True, record saved")
else:
if last_updated:
updater(last_updated, update)
else:
Ticker.objects.create(to_save=save, **update)
end_time = monotonic()
return f"ViteX Data saved in db {timedelta(seconds=(end_time - start_time)).total_seconds()} seconds"
def citex_data():
start_time = monotonic()
exchange = models()['citex']
def citex_api(que, sym='epic_usdt', si='', ty='', breaks=False):
""" Create proper urls for API end points """
start_url = "https://api.citex.co.kr/v1/"
query = que + '?'
symbol = 'symbol=' + sym
size = '&size=' + si
typ = '&type=' + ty
url = start_url + query + symbol + size + typ
if breaks:
sleep(1.4)
print(f"{url}...")
return json.loads(requests.get(url).content)
data = {target: {} for target in PAIRS}
for coin in all_coins()[:1]:
source = copy.deepcopy(citex_api('alltickers')['ticker'])
for target in PAIRS:
vol = [
d(x[::5][1]) for x in citex_api('candles',
sym='epic_' + target,
si="24",
ty="60",
breaks=True)
]
vol = sum(vol)
for tick in source:
if tick['symbol'] == coin.symbol.lower() + '_' + target:
data[target].update(tick)
sleep(1.4)
update = {
'updated':
timezone.now(),
'coin':
coin,
'exchange':
models()['citex'],
'pair':
target,
'trading_url':
'https://trade.citex.me/trade/' + coin.symbol + '_' +
target.upper(),
'last_price':
d(data[target]['last']),
'bid':
d(data[target]['buy']),
'ask':
d(data[target]['sell']),
'spread':
spread(data[target]['sell'], data[target]['buy']),
'high':
d(data[target]['high']),
'low':
d(data[target]['low']),
'last_trade':
t_s(
citex_api('trades',
sym='epic_' + target,
si="1",
breaks=True)[0]['timestamp']),
'volume':
d(vol),
'orders':
citex_api('depth', sym='epic_' + target, si="10", breaks=True),
'candles': {
'candles':
citex_api('candles',
sym='epic_' + target,
si="1",
ty="60",
breaks=True),
'c7x1440': [[t_s(x[::5][0]),
float(x[::5][1])]
for x in citex_api('candles',
sym='epic_' + "usdt",
si="7",
ty="1440",
breaks=True)],
},
'trades':
citex_api('trades', sym='epic_' + target, si="10",
breaks=True),
}
sleep(1.5)
last_saved = Ticker.objects.filter(coin=coin,
pair=target,
exchange=exchange,
to_save=True).last()
last_updated = Ticker.objects.filter(coin=coin,
pair=target,
exchange=exchange,
to_save=False).last()
save = check_saving(last_saved)
if save:
Ticker.objects.create(to_save=save, **update)
print(f"save=True, record saved")
else:
if last_updated:
updater(last_updated, update)
else:
Ticker.objects.create(to_save=save, **update)
end_time = monotonic()
return f"Citex Data saved in db {timedelta(seconds=(end_time - start_time)).total_seconds()} seconds"
def coingecko_data():
start_time = monotonic()
for coin in all_coins():
print(f"{coin}...")
source = copy.deepcopy(cg.get_coin_by_id(coin.name))
data = {
'updated': timezone.now(),
'coin': coin,
'data': {
'name':
source['name'].capitalize(),
'symbol':
source['symbol'].upper(),
'img':
source['image']['large'],
'market_cap':
d(source['market_data']['market_cap']['usd'], 2),
'volume':
d(source['market_data']['total_volume']['usd'], 2),
'price':
d(cg.get_price(coin.name, 'usd')[coin.name]['usd'], 4),
'price_7d':
cg.get_coin_market_chart_by_id(coin.name, 'usd', 7)['prices'],
'price_7d_btc':
cg.get_coin_market_chart_by_id(coin.name, 'btc', 7)['prices'],
'change_24h':
d(source['market_data']['price_change_percentage_24h'], 2),
'change_7d':
d(source['market_data']['price_change_percentage_7d'], 2),
'ath': {
'usdt': {
'price':
source['market_data']['ath']['usd'],
'date':
source['market_data']['ath_date']['usd'],
'change':
source['market_data']['ath_change_percentage']['usd']
},
'btc': {
'price':
source['market_data']['ath']['btc'],
'date':
source['market_data']['ath_date']['btc'],
'change':
source['market_data']['ath_change_percentage']['btc']
}
}
}
}
last_saved = CoinGecko.objects.filter(coin=coin, to_save=True).last()
last_updated = CoinGecko.objects.filter(coin=coin,
to_save=False).last()
save = check_saving(last_saved)
if save:
CoinGecko.objects.create(to_save=save, **data)
print(f"save=True, record saved")
else:
if last_updated:
updater(last_updated, data)
else:
CoinGecko.objects.create(to_save=save, **data)
end_time = monotonic()
return f"CoinGecko data saved in db {timedelta(seconds=(end_time - start_time)).total_seconds()} seconds"
