from ctypes import sizeof from os import readlink from django.shortcuts import render from django.http import HttpResponseRedirect from django.urls import reverse import requests import json from .models import * from .forms import * import datetime from datetime import date, timedelta from dateutil.relativedelta import relativedelta from requests.exceptions import ConnectionError, Timeout, TooManyRedirects import math import locale import pandas as pd from . import asynchronous from . import synchronous from operator import truediv from datetime import timezone import aiohttp import asyncio import pygsheets from django.contrib.auth.decorators import login_required from requests import Session from django.contrib.staticfiles.storage import staticfiles_storage from charts.synchronous import get_history_function #################################################################################### # Set some parameters #################################################################################### locale.setlocale(locale.LC_ALL, 'en_US.utf8') #################################################################################### # Useful functions for admins #################################################################################### # Add manually a new entrance for coin # To be used when there's a problem with the API @login_required def add_coin(request): if request.user.username != "Administrador" and request.user.username != "Morpheus": return render(request, 'users/error.html') if request.method != 'POST': #create new page with blank form form = CoinForm() else: #process data and submit article form = CoinForm(data=request.POST) if form.is_valid(): add_coin = form.save(commit=False) coin = Coin.objects.filter(name=add_coin.name).filter(date=add_coin.date) if coin: for item in coin: item.delete() print('coin found and deleted') else: print('coin not found') add_coin.stocktoflow = (100/add_coin.inflation)**1.65 print(add_coin.name) print(add_coin.date) print(add_coin.priceusd) print(add_coin.pricebtc) print(add_coin.inflation) print(add_coin.transactions) print(add_coin.hashrate) print(add_coin.stocktoflow) print(add_coin.supply) print(add_coin.fee) print(add_coin.revenue) print(add_coin.blocksize) print(add_coin.difficulty) add_coin.save() print('coin saved') message = 'Coin added to the database!' coin = Coin.objects.filter(name=add_coin.name).get(date=add_coin.date) print('GET: ' + str(coin.name) + ' ' +str(coin.date) + ' ' +str(coin.priceusd) + ' ' +str(coin.pricebtc) + ' ' +str(coin.inflation) + ' ' +str(coin.transactions) + ' ' +str(coin.hashrate) + ' ' +str(coin.stocktoflow) + ' ' +str(coin.supply) + ' ' + ' ' +str(coin.fee) + ' ' + ' ' +str(coin.revenue)) print('updating p2pool') synchronous.update_p2pool() context = {'form': form, 'message': message} return render(request, 'charts/add_coin.html', context) else: message = 'An error has happened. Try again.' context = {'form': form, 'message': message} return render(request, 'charts/add_coin.html', context) context = {'form': form} return render(request, 'charts/add_coin.html', context) # Get all history for metrics of a certain coin named as 'symbol' # Only authorized users can download all price data via URL request @login_required def get_history(request, symbol, start_time=None, end_time=None): if request.user.username != "Administrador" and request.user.username != "Morpheus": return render(request, 'users/error.html') count = get_history_function(symbol, start_time, end_time) if type(count) in [int, 'int']: message = 'Total of ' + str(count) + ' data imported' context = {'message': message} else: message = 'Failed to load the data' context = {'message': message} return render(request, 'charts/maintenance.html', context) # Populate database with rank history # Only authorized users can do this @login_required def load_rank(request, symbol): if request.user.username != "Administrador" and request.user.username != "Morpheus": return render(request, 'users/error.html') gc = pygsheets.authorize(service_file='service_account_credentials.json') sh = gc.open('zcash_bitcoin') wks = sh.worksheet_by_title('Sheet8') count = 0 values_mat = wks.get_values(start=(3,1), end=(9999,2), returnas='matrix') print(len(values_mat)) Rank.objects.all().delete() for k in range(0,len(values_mat)): if values_mat[k][0] and values_mat[k][1]: rank = Rank() rank.name = symbol rank.date = values_mat[k][0] rank.rank = int(values_mat[k][1].replace(',', '.')) if not(rank.rank) and not(rank.date): break else: rank.save() count += 1 else: break message = 'Total of ' + str(count) + ' data imported' context = {'message': message} return render(request, 'charts/maintenance.html', context) # Populate database with p2pool history # Only authorized users can do this @login_required def load_p2pool(request): if request.user.username != "Administrador" and request.user.username != "Morpheus": return render(request, 'users/error.html') count = 0 gc = pygsheets.authorize(service_file='service_account_credentials.json') sh = gc.open('zcash_bitcoin') wks = sh.worksheet_by_title('p2pool') values_mat = wks.get_values(start=(3,1), end=(9999,6), returnas='matrix') P2Pool.objects.all().delete() for k in range(0,len(values_mat)): if values_mat[k][0] and values_mat[k][1]: p2pool_stat = P2Pool() p2pool_stat.date = values_mat[k][0] p2pool_stat.miners = float(values_mat[k][1].replace(',', '.')) p2pool_stat.hashrate = float(values_mat[k][2].replace(',', '.')) p2pool_stat.percentage = float(values_mat[k][3].replace(',', '.')) p2pool_stat.totalhashes = float(values_mat[k][4].replace(',', '.')) p2pool_stat.totalblocksfound = float(values_mat[k][5].replace(',', '.')) p2pool_stat.mini = False p2pool_stat.save() count += 1 #print('p2poolmini data saved - ' + str(p2pool_stat.date) + ' - ' + str(p2pool_stat.percentage) + ' - ' + str(p2pool_stat.miners)) else: break wks = sh.worksheet_by_title('p2poolmini') values_mat = wks.get_values(start=(3,1), end=(9999,6), returnas='matrix') for k in range(0,len(values_mat)): if values_mat[k][0] and values_mat[k][1]: p2pool_stat = P2Pool() p2pool_stat.date = values_mat[k][0] p2pool_stat.miners = float(values_mat[k][1].replace(',', '.')) p2pool_stat.hashrate = float(values_mat[k][2].replace(',', '.')) p2pool_stat.percentage = float(values_mat[k][3].replace(',', '.')) p2pool_stat.totalhashes = float(values_mat[k][4].replace(',', '.')) p2pool_stat.totalblocksfound = float(values_mat[k][5].replace(',', '.')) p2pool_stat.mini = True p2pool_stat.save() count += 1 #print('p2poolmini data saved - ' + str(p2pool_stat.date) + ' - ' + str(p2pool_stat.percentage) + ' - ' + str(p2pool_stat.miners)) else: break message = 'Total of ' + str(count) + ' data imported' context = {'message': message} return render(request, 'charts/maintenance.html', context) # Populate database with dominance history # Only authorized users can do this @login_required def load_dominance(request, symbol): if request.user.username != "Administrador" and request.user.username != "Morpheus": return render(request, 'users/error.html') gc = pygsheets.authorize(service_file='service_account_credentials.json') sh = gc.open('zcash_bitcoin') wks = sh.worksheet_by_title('Sheet7') count = 0 values_mat = wks.get_values(start=(3,1), end=(9999,2), returnas='matrix') Dominance.objects.all().delete() for k in range(0,len(values_mat)): if values_mat[k][0] and values_mat[k][1]: dominance = Dominance() dominance.name = symbol dominance.date = values_mat[k][0] dominance.dominance = float(values_mat[k][1].replace(',', '.')) if not(dominance.dominance) and not(dominance.date): break else: dominance.save() count += 1 else: break message = 'Total of ' + str(count) + ' data imported' context = {'message': message} return render(request, 'charts/maintenance.html', context) # Import Reddit history from file on static folder # Only authorized users can do this @login_required def importer(request): if request.user.username != "Administrador" and request.user.username != "Morpheus": return render(request, 'users/error.html') count = 0 Social.objects.all().delete() filename = staticfiles_storage.path('import.txt') with open(filename) as f: content = f.readlines() for line in content: data = json.loads(line) symbol = data['name'] item = data['subscriberCountTimeSeries'] dates = [] subscriberCount = [] commentsPerHour = [] postsPerHour = [] for unit in item: date_now = datetime.datetime.strptime('1970-01-01', '%Y-%m-%d') date_now += timedelta(int(unit['utcDay'])) dates.append(datetime.datetime.strftime(date_now, '%Y-%m-%d')) value = float(unit['count']) subscriberCount.append(value) item = data['commentsPerHourTimeSeries'] for unit in item: value = float(unit['commentsPerHour']) commentsPerHour.append(value) item = data['postsPerHourTimeSeries'] for unit in item: value = float(unit['postsPerHour']) postsPerHour.append(value) for i in range(len(dates)-1): social = Social() social.name = symbol social.date = dates[i] if i >= len(dates) - len(subscriberCount): social.subscriberCount = subscriberCount[i-len(subscriberCount)] else: social.subscriberCount = 0 if i >= len(dates) - len(commentsPerHour): social.commentsPerHour = commentsPerHour[i-(len(dates) - len(commentsPerHour))] else: social.commentsPerHour = 0 if i >= len(dates) - len(postsPerHour): social.postsPerHour = postsPerHour[i-(len(dates) - len(postsPerHour))] else: social.postsPerHour = 0 social.save() count += 1 message = 'Total of ' + str(count) + ' data imported' context = {'message': message} return render(request, 'charts/maintenance.html', context) # Erase all data for a certain coin # Only authorized users can do this @login_required def reset(request, symbol): if request.user.username != "Administrador" and request.user.username != "Morpheus": return render(request, 'users/error.html') Coin.objects.filter(name=symbol).all().delete() message = 'All data for ' + str(symbol) + ' erased' context = {'message': message} return render(request, 'charts/maintenance.html', context) # Populate database with especific chart variables # Only authorized users can do this @login_required def populate_database(request): if request.user.username != "Administrador" and request.user.username != "Morpheus": return render(request, 'users/error.html') count = 0 ################################################################### # SF model charts ################################################################### print('Populating database for sfmodel.html, sfmodelin.html and pricesats.html, wait a moment...') Sfmodel.objects.all().delete() timevar = 1283 v0 = 0.002 delta = (0.015 - 0.002)/(6*365) previous_supply = 0 supply = 0 sf_aux = 0 count_aux = 0 coins = Coin.objects.order_by('date').filter(name='xmr') for coin in coins: if coin.priceusd < 0.1: coin.priceusd = 0.1 coin.pricebtc = 0.000001 if coin.stocktoflow > sf_aux*1.3+100: coin.stocktoflow = sf_aux sf_aux = coin.stocktoflow if coin.supply > 0: supply = int(coin.supply)*10**12 else: supply = previous_supply count += 1 count_aux += 1 data = Sfmodel() data.date = coin.date data.priceusd = coin.priceusd data.pricebtc = coin.pricebtc data.stocktoflow = coin.stocktoflow data.color = 30*coin.pricebtc/(count*delta + v0) date_aux1 = datetime.datetime.strptime('2017-12-29', '%Y-%m-%d') date_aux2 = datetime.datetime.strftime(coin.date, '%Y-%m-%d') date_aux2 = datetime.datetime.strptime(date_aux2, '%Y-%m-%d') if date_aux2 < date_aux1: lastprice = coin.priceusd current_inflation = coin.inflation data.greyline = 0 count_aux = 0 else: day = date_aux2 - timedelta(timevar) coin_aux1 = Coin.objects.filter(name='xmr').get(date=day) day = date_aux2 - timedelta(timevar+1) coin_aux2 = Coin.objects.filter(name='xmr').get(date=day) date_aux3 = datetime.datetime.strptime('2017-12-29', '%Y-%m-%d') if date_aux3 + timedelta(int(count_aux*2)) < datetime.datetime.strptime('2021-07-03', '%Y-%m-%d'): day = date_aux3 + timedelta(int(count_aux*2)) coin_aux3 = Coin.objects.filter(name='xmr').get(date=day) if coin_aux3: if (coin_aux3.inflation/current_inflation) > 1.2 or (coin_aux3.inflation/current_inflation) < 0.8: coin_aux3.inflation = current_inflation else: current_inflation = coin_aux3.inflation supply2 = supply else: reward2 = (2**64 -1 - supply2) >> 19 if reward2 < 0.6*(10**12): reward2 = 0.6*(10**12) supply2 += int(720*reward2) current_inflation = 100*reward2*720*365/supply2 if coin_aux1 and coin_aux2: lastprice += (coin_aux1.priceusd/coin_aux2.priceusd-1)*lastprice actualprice = lastprice*(math.sqrt(coin.inflation/current_inflation)) data.greyline = actualprice else: data.greyline = 0 previous_supply = supply data.save() count_aux = 0 for count_aux in range(700): date_now = date.today() + timedelta(count_aux) reward = (2**64 -1 - supply) >> 19 if reward < 0.6*(10**12): reward = 0.6*(10**12) supply += int(720*reward) data = Sfmodel() data.date = datetime.datetime.strftime(date_now, '%Y-%m-%d') data.stocktoflow = (100/(100*reward*720*365/supply))**1.65 data.priceusd = 0 data.pricebtc = 0 data.greyline = 0 data.color = 0 data.priceusd = 0 data.greyline = 0 data.save() count += 1 ################################################################### # Daily Emissions, inflation charts and coins against bitcoin ################################################################### print('Populating database for dailyemission.html and dailyemissionntv.html, wait a moment...') DailyData.objects.all().delete() supply_btc = 0 supply_xmr = 0 count_aux = 0 coins_btc = Coin.objects.order_by('date').filter(name='btc') for coin_btc in coins_btc: count_aux += 1 data = DailyData() data.date = datetime.datetime.strftime(coin_btc.date, '%Y-%m-%d') if coin_btc.blocksize > 0: data.btc_blocksize = coin_btc.blocksize data.btc_transactions = coin_btc.transactions else: data.btc_blocksize = 0 data.btc_transactions = 0 if coin_btc.difficulty > 0: data.btc_difficulty = coin_btc.difficulty else: data.btc_difficulty = 0 if coin_btc.transactions == 0: data.btc_transcostusd = 0 data.btc_transcostntv = 0 else: if coin_btc.fee*coin_btc.priceusd/coin_btc.transactions < 0.0001: data.btc_transcostusd = 0 data.btc_transcostntv = 0 else: data.btc_transcostusd = coin_btc.fee*coin_btc.priceusd/coin_btc.transactions data.btc_transcostntv = coin_btc.fee/coin_btc.transactions if coin_btc.revenue < 0.000001 or coin_btc.priceusd < 0.001: data.btc_minerrevntv = 0 data.btc_minerrevusd = 0 data.btc_commitntv = 0 data.btc_commitusd = 0 data.btc_priceusd = 0 data.btc_marketcap = 0 else: data.btc_minerrevntv = coin_btc.revenue data.btc_minerrevusd = coin_btc.revenue*coin_btc.priceusd data.btc_commitntv = coin_btc.hashrate/(coin_btc.revenue) data.btc_commitusd = coin_btc.hashrate/(coin_btc.revenue*coin_btc.priceusd) data.btc_priceusd = coin_btc.priceusd data.btc_marketcap = coin_btc.priceusd*coin_btc.supply if coin_btc.supply == 0: data.btc_minerrevcap = 0 else: data.btc_minerrevcap = 365*100*coin_btc.revenue/coin_btc.supply if coin_btc.priceusd: if coin_btc.priceusd/30 > 0.02: data.btc_return = coin_btc.priceusd/30 else: data.btc_return = 0 else: data.btc_return = 0 if coin_btc.inflation > 0: data.btc_inflation = coin_btc.inflation else: data.btc_inflation = 0 if coin_btc.supply > 0: data.btc_supply = coin_btc.supply else: data.btc_supply = 0 if coin_btc.supply - supply_btc < 0.000001: data.btc_minerfeesntv = 0 data.btc_minerfeesusd = 0 data.btc_emissionntv = 0 else: data.btc_minerfeesntv = coin_btc.revenue - coin_btc.supply + supply_btc data.btc_minerfeesusd = (coin_btc.revenue - coin_btc.supply + supply_btc)*coin_btc.priceusd data.btc_emissionntv = coin_btc.supply - supply_btc if (coin_btc.supply - supply_btc)*coin_btc.priceusd < 1000: data.btc_emissionusd = 0 else: data.btc_emissionusd = (coin_btc.supply - supply_btc)*coin_btc.priceusd supply_btc = coin_btc.supply if count_aux > 1750: coins_xmr = Coin.objects.filter(name='xmr').filter(date=coin_btc.date) if coins_xmr: for coin_xmr in coins_xmr: if coin_xmr.blocksize > 0: data.xmr_blocksize = coin_xmr.blocksize else: data.xmr_blocksize = 0 if coin_xmr.difficulty > 0: data.xmr_difficulty = coin_xmr.difficulty else: data.xmr_difficulty = 0 if coin_xmr.priceusd < 0.001: data.xmr_pricebtc = 0 data.xmr_priceusd = 0 data.xmr_marketcap = 0 else: data.xmr_pricebtc = coin_xmr.pricebtc data.xmr_priceusd = coin_xmr.priceusd data.xmr_marketcap = coin_xmr.priceusd*coin_xmr.supply if coin_btc.supply > 0 and coin_btc.transactions > 0: data.xmr_transactions = coin_xmr.transactions data.xmr_metcalfeusd = coin_btc.priceusd*coin_xmr.transactions*coin_xmr.supply/(coin_btc.supply*coin_btc.transactions) data.xmr_metcalfebtc = coin_xmr.transactions*coin_xmr.supply/(coin_btc.supply*coin_btc.transactions) else: data.xmr_metcalfeusd = 0 data.xmr_metcalfebtc = 0 data.xmr_transactions = 0 if data.xmr_metcalfeusd < 0.23: data.xmr_metcalfeusd = 0 data.xmr_metcalfebtc = 0 if coin_xmr.transactions == 0: data.xmr_transacpercentage = 0 data.xmr_transcostusd = 0 data.xmr_transcostntv = 0 else: if coin_xmr.fee*coin_xmr.priceusd/coin_xmr.transactions < 0.0001: data.xmr_transcostusd = 0 data.xmr_transcostntv = 0 else: data.xmr_transcostusd = coin_xmr.fee*coin_xmr.priceusd/coin_xmr.transactions data.xmr_transcostntv = coin_xmr.fee/coin_xmr.transactions if coin_btc.transactions == 0: data.xmr_transacpercentage = 0 else: data.xmr_transacpercentage = coin_xmr.transactions/coin_btc.transactions if coin_xmr.revenue < 0.000001 or coin_xmr.priceusd < 0.001: data.xmr_minerrevntv = 0 data.xmr_minerrevusd = 0 data.xmr_commitntv = 0 data.xmr_commitusd = 0 else: data.xmr_minerrevntv = coin_xmr.revenue data.xmr_minerrevusd = coin_xmr.revenue*coin_xmr.priceusd data.xmr_commitntv = coin_xmr.hashrate/(coin_xmr.revenue) data.xmr_commitusd = coin_xmr.hashrate/(coin_xmr.revenue*coin_xmr.priceusd) if coin_xmr.supply == 0: data.xmr_minerrevcap = 0 else: data.xmr_minerrevcap = 365*100*coin_xmr.revenue/coin_xmr.supply if coin_xmr.priceusd/5.01 > 0.02: data.xmr_return = coin_xmr.priceusd/5.01 else: data.xmr_return = 0 if coin_xmr.inflation > 0: data.xmr_inflation = coin_xmr.inflation else: data.xmr_inflation = 0 if coin_xmr.supply > 0: data.xmr_supply = coin_xmr.supply else: data.xmr_supply = 0 if coin_xmr.supply - supply_xmr < 0.000001: data.xmr_minerfeesntv = 0 data.xmr_minerfeesusd = 0 data.xmr_emissionntv = 0 else: data.xmr_minerfeesntv = coin_xmr.revenue - coin_xmr.supply + supply_xmr data.xmr_minerfeesusd = (coin_xmr.revenue - coin_xmr.supply + supply_xmr)*coin_xmr.priceusd data.xmr_emissionntv = coin_xmr.supply - supply_xmr if (coin_xmr.supply - supply_xmr)*coin_xmr.priceusd < 1000: data.xmr_emissionusd = 0 else: data.xmr_emissionusd = (coin_xmr.supply - supply_xmr)*coin_xmr.priceusd supply_xmr = coin_xmr.supply else: data.xmr_emissionntv = 0 data.xmr_emissionusd = 0 data.xmr_inflation = 0 data.xmr_supply = 0 data.xmr_return = 0 data.xmr_minerrevntv = 0 data.xmr_minerrevusd = 0 data.xmr_minerfeesntv = 0 data.xmr_minerfeesusd = 0 data.xmr_transcostntv = 0 data.xmr_transcostusd = 0 data.xmr_commitntv = 0 data.xmr_commitusd = 0 data.xmr_metcalfeusd = 0 data.xmr_metcalfebtc = 0 data.xmr_pricebtc = 0 data.xmr_priceusd = 0 data.xmr_transacpercentage = 0 data.xmr_marketcap = 0 data.xmr_minerrevcap = 0 data.xmr_transactions = 0 data.xmr_blocksize = 0 data.xmr_difficulty = 0 coins_dash = Coin.objects.filter(name='dash').filter(date=coin_btc.date) if coins_dash: for coin_dash in coins_dash: if coin_dash.transactions > 0: data.dash_transactions = coin_dash.transactions else: data.dash_transactions = 0 if coin_dash.inflation > 0: data.dash_inflation = coin_dash.inflation else: data.dash_inflation = 0 if coin_dash.priceusd > 0: data.dash_marketcap = coin_dash.priceusd*coin_dash.supply else: data.dash_marketcap = 0 else: data.dash_inflation = 0 data.dash_marketcap = 0 data.dash_transactions = 0 else: data.xmr_emissionntv = 0 data.xmr_emissionusd = 0 data.xmr_inflation = 0 data.xmr_supply = 0 data.xmr_return = 0 data.dash_inflation = 0 data.dash_marketcap = 0 data.dash_transactions = 0 data.xmr_marketcap = 0 data.xmr_minerrevntv = 0 data.xmr_minerrevusd = 0 data.xmr_minerfeesntv = 0 data.xmr_minerfeesusd = 0 data.xmr_transcostntv = 0 data.xmr_transcostusd = 0 data.xmr_commitntv = 0 data.xmr_commitusd = 0 data.xmr_metcalfeusd = 0 data.xmr_metcalfebtc = 0 data.xmr_pricebtc = 0 data.xmr_priceusd = 0 data.xmr_transacpercentage = 0 data.xmr_minerrevcap = 0 data.xmr_transactions = 0 data.xmr_blocksize = 0 data.xmr_difficulty = 0 if count_aux > 2800: coins_zcash = Coin.objects.filter(name='zec').filter(date=coin_btc.date) if coins_zcash: for coin_zcash in coins_zcash: if coin_zcash.transactions > 0: data.zcash_transactions = coin_zcash.transactions else: data.zcash_transactions = 0 if coin_zcash.inflation > 0: data.zcash_inflation = coin_zcash.inflation else: data.zcash_inflation = 0 if coin_zcash.priceusd > 0: data.zcash_marketcap = coin_zcash.priceusd*coin_zcash.supply else: data.zcash_marketcap = 0 else: data.zcash_inflation = 0 data.zcash_marketcap = 0 data.zcash_transactions = 0 else: data.zcash_inflation = 0 data.zcash_marketcap = 0 data.zcash_transactions = 0 if count_aux > 3600: coins_grin = Coin.objects.filter(name='grin').filter(date=coin_btc.date) if coins_grin: for coin_grin in coins_grin: if coin_grin.transactions > 0: data.grin_transactions = coin_grin.transactions else: data.grin_transactions = 0 if coin_grin.inflation > 0: data.grin_inflation = coin_grin.inflation else: data.grin_inflation = 0 if coin_grin.priceusd > 0: data.grin_marketcap = coin_grin.priceusd*coin_grin.supply else: data.grin_marketcap = 0 else: data.grin_inflation = 0 data.grin_marketcap = 0 data.grin_transactions = 0 else: data.grin_inflation = 0 data.grin_marketcap = 0 data.grin_transactions = 0 socials = Social.objects.filter(name='Bitcoin').filter(date=coin_btc.date) if socials: for social in socials: data.btc_subscriberCount = social.subscriberCount data.btc_commentsPerHour = social.commentsPerHour data.btc_postsPerHour = social.postsPerHour else: data.btc_subscriberCount = 0 data.btc_commentsPerHour = 0 data.btc_postsPerHour = 0 socials = Social.objects.filter(name='Monero').filter(date=coin_btc.date) if socials: for social in socials: data.xmr_subscriberCount = social.subscriberCount data.xmr_commentsPerHour = social.commentsPerHour data.xmr_postsPerHour = social.postsPerHour else: data.xmr_subscriberCount = 0 data.xmr_commentsPerHour = 0 data.xmr_postsPerHour = 0 socials = Social.objects.filter(name='CryptoCurrency').filter(date=coin_btc.date) if socials: for social in socials: data.crypto_subscriberCount = social.subscriberCount data.crypto_commentsPerHour = social.commentsPerHour data.crypto_postsPerHour = social.postsPerHour else: data.crypto_subscriberCount = 0 data.crypto_commentsPerHour = 0 data.crypto_postsPerHour = 0 data.save() count += 1 message = 'Total of ' + str(count) + ' data generated' context = {'message': message} return render(request, 'charts/maintenance.html', context) # Update database with between certain dates # Only authorized users can do this @login_required def update_database_admin(request, date_from, date_to): if request.user.username != "Administrador" and request.user.username != "Morpheus": return render(request, 'users/error.html') synchronous.update_database(date_from, date_to) message = 'Database updated from ' + str(date_from) + ' to ' + str(date_to) context = {'message': message} return render(request, 'charts/maintenance.html', context) if request.user.username != "Administrador" and request.user.username != "Morpheus": return render(request, 'users/error.html') count = 0 ################################################################### # SF model charts ################################################################### print('Populating database for sfmodel.html, sfmodelin.html and pricesats.html, wait a moment...') Sfmodel.objects.all().delete() timevar = 1283 v0 = 0.002 delta = (0.015 - 0.002)/(6*365) previous_supply = 0 supply = 0 sf_aux = 0 count_aux = 0 coins = Coin.objects.order_by('date').filter(name='xmr') for coin in coins: if coin.priceusd < 0.1: coin.priceusd = 0.1 coin.pricebtc = 0.000001 if coin.stocktoflow > sf_aux*1.3+100: coin.stocktoflow = sf_aux sf_aux = coin.stocktoflow if coin.supply > 0: supply = int(coin.supply)*10**12 else: supply = previous_supply count += 1 count_aux += 1 data = Sfmodel() data.date = coin.date data.priceusd = coin.priceusd data.pricebtc = coin.pricebtc data.stocktoflow = coin.stocktoflow data.color = 30*coin.pricebtc/(count*delta + v0) date_aux1 = datetime.datetime.strptime('2017-12-29', '%Y-%m-%d') date_aux2 = datetime.datetime.strftime(coin.date, '%Y-%m-%d') date_aux2 = datetime.datetime.strptime(date_aux2, '%Y-%m-%d') if date_aux2 < date_aux1: lastprice = coin.priceusd current_inflation = coin.inflation data.greyline = 0 count_aux = 0 else: day = date_aux2 - timedelta(timevar) coin_aux1 = Coin.objects.filter(name='xmr').get(date=day) day = date_aux2 - timedelta(timevar+1) coin_aux2 = Coin.objects.filter(name='xmr').get(date=day) date_aux3 = datetime.datetime.strptime('2017-12-29', '%Y-%m-%d') if date_aux3 + timedelta(int(count_aux*2)) < datetime.datetime.strptime('2021-07-03', '%Y-%m-%d'): day = date_aux3 + timedelta(int(count_aux*2)) coin_aux3 = Coin.objects.filter(name='xmr').get(date=day) if coin_aux3: if (coin_aux3.inflation/current_inflation) > 1.2 or (coin_aux3.inflation/current_inflation) < 0.8: coin_aux3.inflation = current_inflation else: current_inflation = coin_aux3.inflation supply2 = supply else: reward2 = (2**64 -1 - supply2) >> 19 if reward2 < 0.6*(10**12): reward2 = 0.6*(10**12) supply2 += int(720*reward2) current_inflation = 100*reward2*720*365/supply2 if coin_aux1 and coin_aux2: lastprice += (coin_aux1.priceusd/coin_aux2.priceusd-1)*lastprice actualprice = lastprice*(math.sqrt(coin.inflation/current_inflation)) data.greyline = actualprice else: data.greyline = 0 previous_supply = supply data.save() count_aux = 0 for count_aux in range(700): date_now = date.today() + timedelta(count_aux) reward = (2**64 -1 - supply) >> 19 if reward < 0.6*(10**12): reward = 0.6*(10**12) supply += int(720*reward) data = Sfmodel() data.date = datetime.datetime.strftime(date_now, '%Y-%m-%d') data.stocktoflow = (100/(100*reward*720*365/supply))**1.65 data.priceusd = 0 data.pricebtc = 0 data.greyline = 0 data.color = 0 data.priceusd = 0 data.greyline = 0 data.save() count += 1 ################################################################### # Daily Emissions, inflation charts and coins against bitcoin ################################################################### print('Populating database for dailyemission.html and dailyemissionntv.html, wait a moment...') DailyData.objects.all().delete() supply_btc = 0 supply_xmr = 0 count_aux = 0 coins_btc = Coin.objects.order_by('date').filter(name='btc') for coin_btc in coins_btc: count_aux += 1 data = DailyData() data.date = datetime.datetime.strftime(coin_btc.date, '%Y-%m-%d') if coin_btc.blocksize > 0: data.btc_blocksize = coin_btc.blocksize data.btc_transactions = coin_btc.transactions else: data.btc_blocksize = 0 data.btc_transactions = 0 if coin_btc.difficulty > 0: data.btc_difficulty = coin_btc.difficulty else: data.btc_difficulty = 0 if coin_btc.transactions == 0: data.btc_transcostusd = 0 data.btc_transcostntv = 0 else: if coin_btc.fee*coin_btc.priceusd/coin_btc.transactions < 0.0001: data.btc_transcostusd = 0 data.btc_transcostntv = 0 else: data.btc_transcostusd = coin_btc.fee*coin_btc.priceusd/coin_btc.transactions data.btc_transcostntv = coin_btc.fee/coin_btc.transactions if coin_btc.revenue < 0.000001 or coin_btc.priceusd < 0.001: data.btc_minerrevntv = 0 data.btc_minerrevusd = 0 data.btc_commitntv = 0 data.btc_commitusd = 0 data.btc_priceusd = 0 data.btc_marketcap = 0 else: data.btc_minerrevntv = coin_btc.revenue data.btc_minerrevusd = coin_btc.revenue*coin_btc.priceusd data.btc_commitntv = coin_btc.hashrate/(coin_btc.revenue) data.btc_commitusd = coin_btc.hashrate/(coin_btc.revenue*coin_btc.priceusd) data.btc_priceusd = coin_btc.priceusd data.btc_marketcap = coin_btc.priceusd*coin_btc.supply if coin_btc.supply == 0: data.btc_minerrevcap = 0 else: data.btc_minerrevcap = 365*100*coin_btc.revenue/coin_btc.supply if coin_btc.priceusd: if coin_btc.priceusd/30 > 0.02: data.btc_return = coin_btc.priceusd/30 else: data.btc_return = 0 else: data.btc_return = 0 if coin_btc.inflation > 0: data.btc_inflation = coin_btc.inflation else: data.btc_inflation = 0 if coin_btc.supply > 0: data.btc_supply = coin_btc.supply else: data.btc_supply = 0 if coin_btc.supply - supply_btc < 0.000001: data.btc_minerfeesntv = 0 data.btc_minerfeesusd = 0 data.btc_emissionntv = 0 else: data.btc_minerfeesntv = coin_btc.revenue - coin_btc.supply + supply_btc data.btc_minerfeesusd = (coin_btc.revenue - coin_btc.supply + supply_btc)*coin_btc.priceusd data.btc_emissionntv = coin_btc.supply - supply_btc if (coin_btc.supply - supply_btc)*coin_btc.priceusd < 1000: data.btc_emissionusd = 0 else: data.btc_emissionusd = (coin_btc.supply - supply_btc)*coin_btc.priceusd supply_btc = coin_btc.supply if count_aux > 1750: coins_xmr = Coin.objects.filter(name='xmr').filter(date=coin_btc.date) if coins_xmr: for coin_xmr in coins_xmr: if coin_xmr.blocksize > 0: data.xmr_blocksize = coin_xmr.blocksize else: data.xmr_blocksize = 0 if coin_xmr.difficulty > 0: data.xmr_difficulty = coin_xmr.difficulty else: data.xmr_difficulty = 0 if coin_xmr.priceusd < 0.001: data.xmr_pricebtc = 0 data.xmr_priceusd = 0 data.xmr_marketcap = 0 else: data.xmr_pricebtc = coin_xmr.pricebtc data.xmr_priceusd = coin_xmr.priceusd data.xmr_marketcap = coin_xmr.priceusd*coin_xmr.supply if coin_btc.supply > 0 and coin_btc.transactions > 0: data.xmr_transactions = coin_xmr.transactions data.xmr_metcalfeusd = coin_btc.priceusd*coin_xmr.transactions*coin_xmr.supply/(coin_btc.supply*coin_btc.transactions) data.xmr_metcalfebtc = coin_xmr.transactions*coin_xmr.supply/(coin_btc.supply*coin_btc.transactions) else: data.xmr_metcalfeusd = 0 data.xmr_metcalfebtc = 0 data.xmr_transactions = 0 if data.xmr_metcalfeusd < 0.23: data.xmr_metcalfeusd = 0 data.xmr_metcalfebtc = 0 if coin_xmr.transactions == 0: data.xmr_transacpercentage = 0 data.xmr_transcostusd = 0 data.xmr_transcostntv = 0 else: if coin_xmr.fee*coin_xmr.priceusd/coin_xmr.transactions < 0.0001: data.xmr_transcostusd = 0 data.xmr_transcostntv = 0 else: data.xmr_transcostusd = coin_xmr.fee*coin_xmr.priceusd/coin_xmr.transactions data.xmr_transcostntv = coin_xmr.fee/coin_xmr.transactions if coin_btc.transactions == 0: data.xmr_transacpercentage = 0 else: data.xmr_transacpercentage = coin_xmr.transactions/coin_btc.transactions if coin_xmr.revenue < 0.000001 or coin_xmr.priceusd < 0.001: data.xmr_minerrevntv = 0 data.xmr_minerrevusd = 0 data.xmr_commitntv = 0 data.xmr_commitusd = 0 else: data.xmr_minerrevntv = coin_xmr.revenue data.xmr_minerrevusd = coin_xmr.revenue*coin_xmr.priceusd data.xmr_commitntv = coin_xmr.hashrate/(coin_xmr.revenue) data.xmr_commitusd = coin_xmr.hashrate/(coin_xmr.revenue*coin_xmr.priceusd) if coin_xmr.supply == 0: data.xmr_minerrevcap = 0 else: data.xmr_minerrevcap = 365*100*coin_xmr.revenue/coin_xmr.supply if coin_xmr.priceusd/5.01 > 0.02: data.xmr_return = coin_xmr.priceusd/5.01 else: data.xmr_return = 0 if coin_xmr.inflation > 0: data.xmr_inflation = coin_xmr.inflation else: data.xmr_inflation = 0 if coin_xmr.supply > 0: data.xmr_supply = coin_xmr.supply else: data.xmr_supply = 0 if coin_xmr.supply - supply_xmr < 0.000001: data.xmr_minerfeesntv = 0 data.xmr_minerfeesusd = 0 data.xmr_emissionntv = 0 else: data.xmr_minerfeesntv = coin_xmr.revenue - coin_xmr.supply + supply_xmr data.xmr_minerfeesusd = (coin_xmr.revenue - coin_xmr.supply + supply_xmr)*coin_xmr.priceusd data.xmr_emissionntv = coin_xmr.supply - supply_xmr if (coin_xmr.supply - supply_xmr)*coin_xmr.priceusd < 1000: data.xmr_emissionusd = 0 else: data.xmr_emissionusd = (coin_xmr.supply - supply_xmr)*coin_xmr.priceusd supply_xmr = coin_xmr.supply else: data.xmr_emissionntv = 0 data.xmr_emissionusd = 0 data.xmr_inflation = 0 data.xmr_supply = 0 data.xmr_return = 0 data.xmr_minerrevntv = 0 data.xmr_minerrevusd = 0 data.xmr_minerfeesntv = 0 data.xmr_minerfeesusd = 0 data.xmr_transcostntv = 0 data.xmr_transcostusd = 0 data.xmr_commitntv = 0 data.xmr_commitusd = 0 data.xmr_metcalfeusd = 0 data.xmr_metcalfebtc = 0 data.xmr_pricebtc = 0 data.xmr_priceusd = 0 data.xmr_transacpercentage = 0 data.xmr_marketcap = 0 data.xmr_minerrevcap = 0 data.xmr_transactions = 0 data.xmr_blocksize = 0 data.xmr_difficulty = 0 coins_dash = Coin.objects.filter(name='dash').filter(date=coin_btc.date) if coins_dash: for coin_dash in coins_dash: if coin_dash.transactions > 0: data.dash_transactions = coin_dash.transactions else: data.dash_transactions = 0 if coin_dash.inflation > 0: data.dash_inflation = coin_dash.inflation else: data.dash_inflation = 0 if coin_dash.priceusd > 0: data.dash_marketcap = coin_dash.priceusd*coin_dash.supply else: data.dash_marketcap = 0 else: data.dash_inflation = 0 data.dash_marketcap = 0 data.dash_transactions = 0 else: data.xmr_emissionntv = 0 data.xmr_emissionusd = 0 data.xmr_inflation = 0 data.xmr_supply = 0 data.xmr_return = 0 data.dash_inflation = 0 data.dash_marketcap = 0 data.dash_transactions = 0 data.xmr_marketcap = 0 data.xmr_minerrevntv = 0 data.xmr_minerrevusd = 0 data.xmr_minerfeesntv = 0 data.xmr_minerfeesusd = 0 data.xmr_transcostntv = 0 data.xmr_transcostusd = 0 data.xmr_commitntv = 0 data.xmr_commitusd = 0 data.xmr_metcalfeusd = 0 data.xmr_metcalfebtc = 0 data.xmr_pricebtc = 0 data.xmr_priceusd = 0 data.xmr_transacpercentage = 0 data.xmr_minerrevcap = 0 data.xmr_transactions = 0 data.xmr_blocksize = 0 data.xmr_difficulty = 0 if count_aux > 2800: coins_zcash = Coin.objects.filter(name='zec').filter(date=coin_btc.date) if coins_zcash: for coin_zcash in coins_zcash: if coin_zcash.transactions > 0: data.zcash_transactions = coin_zcash.transactions else: data.zcash_transactions = 0 if coin_zcash.inflation > 0: data.zcash_inflation = coin_zcash.inflation else: data.zcash_inflation = 0 if coin_zcash.priceusd > 0: data.zcash_marketcap = coin_zcash.priceusd*coin_zcash.supply else: data.zcash_marketcap = 0 else: data.zcash_inflation = 0 data.zcash_marketcap = 0 data.zcash_transactions = 0 else: data.zcash_inflation = 0 data.zcash_marketcap = 0 data.zcash_transactions = 0 if count_aux > 3600: coins_grin = Coin.objects.filter(name='grin').filter(date=coin_btc.date) if coins_grin: for coin_grin in coins_grin: if coin_grin.transactions > 0: data.grin_transactions = coin_grin.transactions else: data.grin_transactions = 0 if coin_grin.inflation > 0: data.grin_inflation = coin_grin.inflation else: data.grin_inflation = 0 if coin_grin.priceusd > 0: data.grin_marketcap = coin_grin.priceusd*coin_grin.supply else: data.grin_marketcap = 0 else: data.grin_inflation = 0 data.grin_marketcap = 0 data.grin_transactions = 0 else: data.grin_inflation = 0 data.grin_marketcap = 0 data.grin_transactions = 0 socials = Social.objects.filter(name='Bitcoin').filter(date=coin_btc.date) if socials: for social in socials: data.btc_subscriberCount = social.subscriberCount data.btc_commentsPerHour = social.commentsPerHour data.btc_postsPerHour = social.postsPerHour else: data.btc_subscriberCount = 0 data.btc_commentsPerHour = 0 data.btc_postsPerHour = 0 socials = Social.objects.filter(name='Monero').filter(date=coin_btc.date) if socials: for social in socials: data.xmr_subscriberCount = social.subscriberCount data.xmr_commentsPerHour = social.commentsPerHour data.xmr_postsPerHour = social.postsPerHour else: data.xmr_subscriberCount = 0 data.xmr_commentsPerHour = 0 data.xmr_postsPerHour = 0 socials = Social.objects.filter(name='CryptoCurrency').filter(date=coin_btc.date) if socials: for social in socials: data.crypto_subscriberCount = social.subscriberCount data.crypto_commentsPerHour = social.commentsPerHour data.crypto_postsPerHour = social.postsPerHour else: data.crypto_subscriberCount = 0 data.crypto_commentsPerHour = 0 data.crypto_postsPerHour = 0 data.save() count += 1 message = 'Total of ' + str(count) + ' data generated' context = {'message': message} return render(request, 'charts/maintenance.html', context) #################################################################################### # Views #################################################################################### async def index(request): coins = Coin.objects.filter(name='xmr').order_by('-date') count = 0 for coin in coins: count += 1 if count< 200: if coin.supply < 18000000: coin.supply += 499736 print(coin.date) coin.save() coin = list(Coin.objects.order_by('-date'))[0] if not(coin): message = 'Website under maintenance. Check back in a few minutes' context = {'message': message} return render(request, 'charts/maintenance.html', context) now = int(datetime.datetime.now().strftime("%H")) yesterday = datetime.datetime.strftime(date.today() - timedelta(1), '%Y-%m-%d') date_aux = datetime.datetime.strftime(date.today() - timedelta(2), '%Y-%m-%d') update_xmr = False update_btc = False update_socials = False update_data = False if now > 2 and now < 12: try: coin_xmr = Coin.objects.filter(name='xmr').get(date=yesterday) if coin_xmr: print('xmr found yesterday') if coin_xmr.priceusd > 1 and coin_xmr.transactions > 0 and coin_xmr.inflation > 0: print('no need to update xmr') update_xmr = False else: print('will update xmr') coin_xmr.delete() update_xmr = True else: print('no xmr found yesterday - 1') update_xmr = True except: print('no xmr found yesterday - 2') update_xmr = True if now > 6 and now < 12: try: coin_btc = list(Coin.objects.filter(name='btc').filter(date=yesterday))[0] coin_zec = list(Coin.objects.filter(name='zec').filter(date=yesterday))[0] coin_dash = list(Coin.objects.filter(name='dash').filter(date=yesterday))[0] coin_grin = list(Coin.objects.filter(name='grin').filter(date=yesterday))[0] if coin_btc and coin_zec and coin_dash and coin_grin: print('coins found yesterday') if coin_btc.transactions > 0 and coin_btc.inflation > 0 and coin_zec.supply > 0 and coin_dash.supply > 0 and coin_grin.supply > 0: print('no need to update coins') update_btc = False else: print('will update coins') coin_btc.delete() coin_zec.delete() coin_dash.delete() coin_grin.delete() update_btc = True else: print('no coins found yesterday - 1') update_btc = True except: print('no coins found yesterday - 2') update_btc = True try: data = list(DailyData.objects.filter(date=yesterday))[0] if data: print('data found yesterday') update_data = False else: print('no data found yesterday - 1') update_data = True except: print('no data found yesterday - 2') update_data = True try: coin_xmr = Coin.objects.filter(name='xmr').get(date=date_aux) except: coin_xmr = list(Coin.objects.filter(name='xmr').order_by('-date'))[0] if update_xmr: count = get_history_function('xmr', yesterday, yesterday) await asynchronous.update_xmr_data(yesterday, coin_xmr) if update_btc: await asynchronous.update_others_data(yesterday) if update_data: synchronous.update_database(yesterday, yesterday) if True: enabled = synchronous.get_binance_withdrawal('Monero') return HttpResponseRedirect(reverse('trocadorapp:sfmodel')) def social(request): data = DailyData.objects.order_by('date') dates = [] dates2 = [] social_xmr = [] social_crypto = [] social_btc = [] last_xmr = 0 last_btc = 0 last_crypto = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) dates2.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_subscriberCount > last_btc: social_btc.append(item.btc_subscriberCount) last_btc = item.btc_subscriberCount else: social_btc.append(last_btc) if item.xmr_subscriberCount > last_xmr: social_xmr.append(item.xmr_subscriberCount) last_xmr = item.xmr_subscriberCount else: social_xmr.append(last_xmr) if item.crypto_subscriberCount > last_crypto: social_crypto.append(item.crypto_subscriberCount) last_crypto = item.crypto_subscriberCount else: social_crypto.append(last_crypto) last_xmr = locale.format('%.0f', last_xmr, grouping=True) last_btc = locale.format('%.0f', last_btc, grouping=True) last_crypto = locale.format('%.0f', last_crypto, grouping=True) context = {'dates': dates, 'dates2': dates2, 'social_xmr': social_xmr, 'social_crypto': social_crypto, 'social_btc': social_btc, 'last_xmr': last_xmr, 'last_btc': last_btc, 'last_crypto': last_crypto} return render(request, 'charts/social.html', context) def social2(request): data = DailyData.objects.order_by('date') dates = [] social_btc = [] last_btc = 0 dates2 = [] social_xmr = [] last_xmr = 0 N = 1 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) dates2.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_subscriberCount > 0: if item.btc_marketcap > 10000: last_btc = ((item.btc_marketcap)**N)/item.btc_subscriberCount social_btc.append(last_btc) else: social_btc.append('') else: social_btc.append(last_btc) if item.xmr_subscriberCount > 0: if item.xmr_marketcap > 10000: last_xmr = ((item.xmr_marketcap)**N)/item.xmr_subscriberCount social_xmr.append(last_xmr) else: social_xmr.append('') else: social_xmr.append(last_xmr) last_xmr = '$' + locale.format('%.0f', last_xmr, grouping=True) last_btc = '$' + locale.format('%.0f', last_btc, grouping=True) context = {'dates': dates, 'dates2': dates2, 'social_btc': social_btc, 'social_xmr': social_xmr, 'last_xmr': last_xmr, 'last_btc': last_btc} return render(request, 'charts/social2.html', context) def social3(request): data = DailyData.objects.order_by('date') dates = [] social_xmr = [] social_crypto = [] last_xmr = 0 last_crypto = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_subscriberCount > 0 and item.xmr_subscriberCount > 0: last_xmr = 100*(item.xmr_subscriberCount/item.btc_subscriberCount) social_xmr.append(last_xmr) else: social_xmr.append(last_xmr) if item.btc_subscriberCount > 0 and item.crypto_subscriberCount > 0: last_crypto = 100*(item.crypto_subscriberCount/item.btc_subscriberCount) social_crypto.append(last_crypto) else: social_crypto.append(last_crypto) last_xmr = locale.format('%.1f', last_xmr, grouping=True)+ '%' last_crypto = locale.format('%.1f', last_crypto, grouping=True)+ '%' context = {'dates': dates, 'social_xmr': social_xmr, 'social_crypto': social_crypto, 'last_xmr': last_xmr, 'last_crypto': last_crypto} return render(request, 'charts/social3.html', context) def social4(request): data = DailyData.objects.order_by('date') dates = [] dates2 = [] social_xmr = [] social_crypto = [] social_btc = [] last_xmr = 0 last_btc = 0 last_crypto = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) dates2.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_subscriberCount > last_btc: social_btc.append(item.btc_subscriberCount) last_btc = item.btc_subscriberCount else: social_btc.append(last_btc) if item.xmr_subscriberCount > last_xmr: social_xmr.append(item.xmr_subscriberCount) last_xmr = item.xmr_subscriberCount else: social_xmr.append(last_xmr) if item.crypto_subscriberCount > last_crypto: social_crypto.append(item.crypto_subscriberCount) last_crypto = item.crypto_subscriberCount else: social_crypto.append(last_crypto) N = 30 last_btc = '' speed_btc = [] for i in range(len(social_btc)): if i < N: speed_btc.append(last_btc) else: if social_btc[i-N] != 0 and social_btc[i] - social_btc[i-N] != 0: last_btc = 100*(social_btc[i] - social_btc[i-N])/social_btc[i-N] if last_btc < 0.2: last_btc = 0.2 if last_btc > 1000: last_btc = '' else: last_btc = '' speed_btc.append(last_btc) last_btc = '' newcomers_btc = [] for i in range(len(social_btc)): if i < N: newcomers_btc.append(last_btc) else: last_btc = (social_btc[i] - social_btc[i-N]) if last_btc < 10: last_btc = '' newcomers_btc.append(last_btc) last_crypto = '' speed_crypto = [] for i in range(len(social_crypto)): if i < N: speed_crypto.append(last_crypto) else: if social_crypto[i-N] != 0 and social_crypto[i] - social_crypto[i-N] != 0: last_crypto = 100*(social_crypto[i] - social_crypto[i-N])/social_crypto[i-N] if last_crypto < 0.2: last_crypto = 0.2 if last_crypto > 1000: last_crypto = '' else: last_crypto = '' speed_crypto.append(last_crypto) last_crypto = '' newcomers_crypto = [] for i in range(len(social_crypto)): if i < N: newcomers_crypto.append(last_crypto) else: last_crypto = (social_crypto[i] - social_crypto[i-N]) if last_crypto < 2: last_crypto = '' newcomers_crypto.append(last_crypto) last_xmr = '' speed_xmr = [] for i in range(len(social_xmr)): if i < N: speed_xmr.append(last_xmr) else: if social_xmr[i-N] != 0 and social_xmr[i] - social_xmr[i-N] != 0: last_xmr = 100*(social_xmr[i] - social_xmr[i-N])/social_xmr[i-N] if last_xmr < 0.2: last_xmr = 0.2 if last_xmr > 1000: last_xmr = '' else: last_xmr = '' speed_xmr.append(last_xmr) last_xmr = '' newcomers_xmr = [] for i in range(len(social_xmr)): if i < N: newcomers_xmr.append(last_xmr) else: last_xmr = (social_xmr[i] - social_xmr[i-N]) if last_xmr < 0: last_xmr = '' newcomers_xmr.append(last_xmr) try: last_xmr = locale.format('%.0f', last_xmr, grouping=True) last_btc = locale.format('%.0f', last_btc, grouping=True) last_crypto = locale.format('%.0f', last_crypto, grouping=True) except: last_xmr = 0 last_btc = 0 last_crypto = 0 context = {'dates': dates, 'speed_xmr': speed_xmr, 'speed_crypto': speed_crypto, 'speed_btc': speed_btc, 'newcomers_xmr': newcomers_xmr, 'newcomers_btc': newcomers_btc, 'newcomers_crypto': newcomers_crypto, 'last_xmr': last_xmr, 'last_btc': last_btc, 'last_crypto': last_crypto} return render(request, 'charts/social4.html', context) def social5(request): data = DailyData.objects.order_by('date') transactions = [] dates = [] social_xmr = [] now_transactions = 0 last_xmr = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.xmr_subscriberCount > last_xmr: social_xmr.append(item.xmr_subscriberCount) last_xmr = item.xmr_subscriberCount else: social_xmr.append(last_xmr) if item.xmr_transactions > 300: now_transactions = item.xmr_transactions transactions.append(now_transactions) else: transactions.append('') last_xmr = locale.format('%.0f', last_xmr, grouping=True) now_transactions = locale.format('%.0f', now_transactions, grouping=True) context = {'dates': dates, 'social_xmr': social_xmr, 'last_xmr': last_xmr, 'now_transactions': now_transactions, 'transactions': transactions} return render(request, 'charts/social5.html', context) def social6(request): data = DailyData.objects.order_by('date') dates = [] social_xmr = [] social_crypto = [] social_btc = [] last_xmr = 0 last_btc = 0 last_crypto = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_commentsPerHour*24 < last_btc/4: social_btc.append(last_btc) else: last_btc = item.btc_commentsPerHour*24 social_btc.append(last_btc) if item.xmr_commentsPerHour*24 < last_xmr/4: social_xmr.append(last_xmr) else: last_xmr = item.xmr_commentsPerHour*24 social_xmr.append(last_xmr) if item.crypto_commentsPerHour*24 < last_crypto/4: social_crypto.append(last_crypto) else: last_crypto = item.crypto_commentsPerHour*24 social_crypto.append(last_crypto) last_xmr = locale.format('%.0f', last_xmr, grouping=True) last_btc = locale.format('%.0f', last_btc, grouping=True) last_crypto = locale.format('%.0f', last_crypto, grouping=True) context = {'dates': dates, 'social_xmr': social_xmr, 'social_crypto': social_crypto, 'social_btc': social_btc, 'last_xmr': last_xmr, 'last_btc': last_btc, 'last_crypto': last_crypto} return render(request, 'charts/social6.html', context) def social7(request): data = DailyData.objects.order_by('date') dates = [] social_xmr = [] social_crypto = [] social_btc = [] last_xmr = 0 last_btc = 0 last_crypto = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_postsPerHour > 0: last_btc = item.btc_postsPerHour*24 social_btc.append(last_btc) else: social_btc.append(last_btc) if item.xmr_postsPerHour > 0: last_xmr = item.xmr_postsPerHour*24 social_xmr.append(last_xmr) else: social_xmr.append(last_xmr) if item.crypto_postsPerHour > 0: last_crypto = item.crypto_postsPerHour*24 social_crypto.append(last_crypto) else: social_crypto.append(last_crypto) last_xmr = locale.format('%.0f', last_xmr, grouping=True) last_btc = locale.format('%.0f', last_btc, grouping=True) last_crypto = locale.format('%.0f', last_crypto, grouping=True) context = {'dates': dates, 'social_xmr': social_xmr, 'social_crypto': social_crypto, 'social_btc': social_btc, 'last_xmr': last_xmr, 'last_btc': last_btc, 'last_crypto': last_crypto} return render(request, 'charts/social7.html', context) def pricelog(request): symbol = 'xmr' now_price = 0 now_sf = 0 now_inflation = 0 v0 = 0.002 delta = (0.015 - 0.002)/(6*365) count = 0 maximum = 0 supply = 0 dates = [] color = [] values = [] coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d')) values.append(coin.priceusd) if coin.priceusd < 0.01: coin.priceusd = 0.01 if coin.stocktoflow < 0.1: coin.stocktoflow = 0.1 now_inflation = coin.inflation now_price = coin.priceusd now_sf = coin.stocktoflow if now_price > maximum: maximum = now_price new_color = 30*coin.pricebtc/(count*delta + v0) color.append(new_color) supply = int(coin.supply)*10**12 count += 1 count = 0 for count in range(650): date_now = date.today() + timedelta(count) dates.append(datetime.datetime.strftime(date_now, '%Y-%m-%d')) reward = (2**64 -1 - supply) >> 19 if reward < 0.6*(10**12): reward = 0.6*( 10**12) supply += int(720*reward) now_price = "$"+ locale.format('%.2f', now_price, grouping=True) now_sf = "$"+ locale.format('%.2f', now_sf, grouping=True) maximum = "$"+ locale.format('%.2f', maximum, grouping=True) now_inflation = locale.format('%.2f', now_inflation, grouping=True)+'%' context = {'values': values, 'dates': dates, 'maximum': maximum, 'now_price': now_price, 'now_inflation': now_inflation, 'now_sf': now_sf, 'color': color} return render(request, 'charts/pricelog.html', context) def movingaverage(request): symbol = 'xmr' v0 = 0.002 delta = (0.015 - 0.002)/(6*365) count = 0 dates = [] color = [] values = [] average1 = [] average2 = [] total = 0 coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d')) if coin.priceusd < 0.2: coin.priceusd = 0.2 total += coin.priceusd values.append(coin.priceusd) if count < 1460: aux = total/(730 + count/2) if aux < 0.2: aux = 0.2 average1.append(aux) average2.append(aux*5) if coin.priceusd > 5*aux: new_color = 1 if coin.priceusd < aux: new_color = 0 else: new_color = coin.priceusd/(5*aux) color.append(new_color) else: color.append(new_color) count += 1 n = 1460 median = pd.Series(values).rolling(window=n).mean().iloc[n-1:].values #for count in range(1460): # average1.append('') # average2.append('') for item in median: average1.append(item) average2.append(item*5) context = {'values': values, 'dates': dates, 'color': color, 'average1': average1, 'average2': average2} return render(request, 'charts/movingaverage.html', context) def powerlaw(request): symbol = 'xmr' now_price = 0 now_sf = 0 now_inflation = 0 v0 = 0.002 delta = (0.015 - 0.002)/(6*365) count = 0 maximum = 0 dates = [] counter = [] years = [] line3 = [] line2 = [] line1 = [] a3 = 0.00000000000000000009 a2 = 0.0000000000000000000000008 a1 = 0.00000000000000000000000002 b3 = ((math.log(477,10)-math.log(5.01,10))/(math.log(2511,10)-math.log(1231,10))) b2 = ((math.log(92,10)-math.log(0.23,10))/(math.log(3297,10)-math.log(1468,10))) b1 = ((math.log(93,10)-math.log(0.39,10))/(math.log(3570,10)-math.log(1755,10))) color = [] values = [] yearnumber = 2014 days = 1200 coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: if coin.priceusd < 0.01: continue days += 1 price3 = a3*(days**b3) price2 = a2*(days**b2) price1 = a1*(days**b1) line3.append(price3) line2.append(price2) line1.append(price1) counter.append(days) if coin.date.year > yearnumber: yearnumber += 1 years.append(yearnumber) dates.append(days) values.append(coin.priceusd) if coin.priceusd < 0.01: coin.priceusd = 0.01 if coin.stocktoflow < 0.1: coin.stocktoflow = 0.1 now_inflation = coin.inflation now_price = coin.priceusd now_sf = coin.stocktoflow if now_price > maximum: maximum = now_price new_color = 30*coin.pricebtc/(count*delta + v0) color.append(new_color) count += 1 for count in range(1, 3650): date_now = date.today() + timedelta(count) values.append('') days += 1 price3 = a3*(days**b3) price2 = a2*(days**b2) price1 = a1*(days**b1) line3.append(price3) line2.append(price2) line1.append(price1) counter.append(days) if date_now.year > yearnumber: yearnumber += 1 years.append(yearnumber) dates.append(days) now_price = "$"+ locale.format('%.2f', now_price, grouping=True) now_sf = "$"+ locale.format('%.2f', now_sf, grouping=True) maximum = "$"+ locale.format('%.2f', maximum, grouping=True) now_inflation = locale.format('%.2f', now_inflation, grouping=True)+'%' context = {'values': values, 'dates': dates, 'maximum': maximum, 'now_price': now_price, 'now_inflation': now_inflation, 'now_sf': now_sf, 'color': color, 'years': years, 'counter': counter, 'line1': line1, 'line2': line2, 'line3': line3} return render(request, 'charts/powerlaw.html', context) def pricelin(request): symbol = 'xmr' now_price = 0 now_sf = 0 now_inflation = 0 v0 = 0.002 delta = (0.015 - 0.002)/(6*365) count = 0 maximum = 0 supply = 0 dates = [] color = [] values = [] coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d')) values.append(coin.priceusd) if coin.priceusd < 0.01: coin.priceusd = 0.01 if coin.stocktoflow < 0.1: coin.stocktoflow = 0.1 now_inflation = coin.inflation now_price = coin.priceusd now_sf = coin.stocktoflow if now_price > maximum: maximum = now_price new_color = 30*coin.pricebtc/(count*delta + v0) color.append(new_color) supply = int(coin.supply)*10**12 count += 1 count = 0 for count in range(650): date_now = date.today() + timedelta(count) dates.append(datetime.datetime.strftime(date_now, '%Y-%m-%d')) reward = (2**64 -1 - supply) >> 19 if reward < 0.6*(10**12): reward = 0.6*( 10**12) supply += int(720*reward) stock = (100/(100*reward*720*365/supply))**1.65 now_price = "$"+ locale.format('%.2f', now_price, grouping=True) now_sf = "$"+ locale.format('%.2f', now_sf, grouping=True) maximum = "$"+ locale.format('%.2f', maximum, grouping=True) now_inflation = locale.format('%.2f', now_inflation, grouping=True)+'%' context = {'values': values, 'dates': dates, 'maximum': maximum, 'now_price': now_price, 'now_inflation': now_inflation, 'now_sf': now_sf, 'color': color} return render(request, 'charts/pricelin.html', context) def pricesats(request): dates = [] color = [] values = [] now_price = 0 maximum = 0 bottom = 1 data = Sfmodel.objects.order_by('date') for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.color != 0: color.append(item.color) else: color.append('') if item.pricebtc > 0.0001: values.append(item.pricebtc) now_price = item.pricebtc if bottom > item.pricebtc: bottom = item.pricebtc if maximum < item.pricebtc: maximum = item.pricebtc else: values.append('') now_price = locale.format('%.4f', now_price, grouping=True) + ' BTC' maximum = locale.format('%.4f', maximum, grouping=True) + ' BTC' bottom = locale.format('%.4f', bottom, grouping=True) + ' BTC' context = {'values': values, 'dates': dates, 'maximum': maximum, 'now_price': now_price, 'color': color, 'bottom': bottom} return render(request, 'charts/pricesats.html', context) def pricesatslog(request): dates = [] color = [] values = [] now_price = 0 maximum = 0 bottom = 1 data = Sfmodel.objects.order_by('date') for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.color != 0: color.append(item.color) else: color.append('') if item.pricebtc > 0.0001: values.append(item.pricebtc) now_price = item.pricebtc if bottom > item.pricebtc: bottom = item.pricebtc if maximum < item.pricebtc: maximum = item.pricebtc else: values.append('') now_price = locale.format('%.4f', now_price, grouping=True) + ' BTC' maximum = locale.format('%.4f', maximum, grouping=True) + ' BTC' bottom = locale.format('%.4f', bottom, grouping=True) + ' BTC' context = {'values': values, 'dates': dates, 'maximum': maximum, 'now_price': now_price, 'color': color, 'bottom': bottom} return render(request, 'charts/pricesatslog.html', context) def fractal(request): symbol = 'xmr' dates1 = [] dates2 = [] cycle1 = [] cycle2 = [] now_multiple = 0 maximum = 0 count1 = 1 count2 = 1 date1_aux = datetime.datetime(2017, 12, 29) date2_aux = datetime.datetime(2014, 6, 21) coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: date3_aux = datetime.datetime.combine(coin.date, datetime.time(0, 0)) if date3_aux < date1_aux and date3_aux > date2_aux: cycle1.append(coin.priceusd/5) dates1.append(count1/12.7) if (coin.priceusd/5) > maximum: maximum = coin.priceusd/5 count1 += 1 elif date3_aux > date1_aux: cycle2.append(coin.priceusd/477.12) dates2.append(count2/20.7) #24 now_multiple = coin.priceusd/477.12 count2 += 0.86 now_multiple = locale.format('%.2f', now_multiple, grouping=True) + 'x' maximum = locale.format('%.2f', maximum, grouping=True) + 'x' context = {'cycle1': cycle1, 'cycle2': cycle2, 'dates1': dates1, 'dates2': dates2, 'now_multiple': now_multiple, 'maximum': maximum} return render(request, 'charts/fractal.html', context) def inflationfractal(request): symbol = 'xmr' dates1 = [] dates2 = [] cycle1 = [] cycle2 = [] now_multiple = 0 maximum = 0 current_inflation = 0 start_inflation = 0 count1 = 1 count2 = 1 date1_aux = datetime.datetime(2017, 12, 29) date2_aux = datetime.datetime(2014, 6, 21) coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: date3_aux = datetime.datetime.combine(coin.date, datetime.time(0, 0)) if date3_aux < date1_aux and date3_aux > date2_aux: start_inflation = coin.inflation current_inflation = start_inflation cycle1.append(coin.priceusd/5) dates1.append(count1/12.7) if (coin.priceusd/5) > maximum: maximum = coin.priceusd/5 count1 += 1 elif date3_aux > date1_aux: if (coin.inflation/current_inflation) > 1.15 or (coin.inflation/current_inflation) < 0.85: coin.inflation = current_inflation else: current_inflation = coin.inflation delta = math.sqrt(coin.inflation/start_inflation) cycle2.append(delta*coin.priceusd/477.12) dates2.append(count2/20.55) #24 now_multiple = delta*coin.priceusd/477.12 count2 += 0.86 now_multiple = locale.format('%.2f', now_multiple, grouping=True) + 'x' maximum = locale.format('%.2f', maximum, grouping=True) + 'x' context = {'cycle1': cycle1, 'cycle2': cycle2, 'dates1': dates1, 'dates2': dates2, 'now_multiple': now_multiple, 'maximum': maximum} return render(request, 'charts/inflationfractal.html', context) def golden(request): symbol = 'xmr' dates = [] prices = [] coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: firstdate = coin.date break day = firstdate - timedelta(350) for i in range(350): dates.append(datetime.datetime.strftime(day, '%Y-%m-%d')) prices.append(0.2) for coin in coins: dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d')) if coin.priceusd > 0.2: prices.append(coin.priceusd) else: prices.append(0.2) n = 350 median = pd.Series(prices).rolling(window=n).mean().iloc[n-1:].values m_350 = [] m_350_0042 = [] m_350_0060 = [] m_350_0200 = [] m_350_0300 = [] m_350_0500 = [] m_350_0800 = [] m_350_1300 = [] for i in range(350): m_350.append('') m_350_0042.append('') m_350_0060.append('') m_350_0200.append('') m_350_0300.append('') m_350_0500.append('') m_350_0800.append('') m_350_1300.append('') for item in median: m_350.append(float(item)) m_350_0042.append(float(item)*0.42) m_350_0060.append(float(item)*0.60) m_350_0200.append(float(item)*2.00) m_350_0300.append(float(item)*3.00) m_350_0500.append(float(item)*5.00) m_350_0800.append(float(item)*8.00) m_350_1300.append(float(item)*13.00) n = 120 median = pd.Series(prices).rolling(window=n).mean().iloc[n-1:].values m_111 = [] for i in range(120): m_111.append('') for item in median: m_111.append(float(item)) i = 0 down = True price_cross = [] for price in prices: if m_111[i] != '' and m_350_0200[i] != '': if down == True and m_111[i] > m_350_0200[i]: down = False price_cross.append(price) elif price > m_350_0500[i]: price_cross.append(price) elif down == False and m_111[i] < m_350_0200[i]: down = True else: price_cross.append('') else: price_cross.append('') i += 1 context = {'dates': dates, 'prices': prices, 'm_350': m_350, 'm_350_0042': m_350_0042, 'm_350_0060': m_350_0060, 'm_350_0200': m_350_0200, 'm_350_0300': m_350_0300, 'm_350_0500': m_350_0500, 'm_350_0800': m_350_0800, 'm_350_1300': m_350_1300, 'median': median, 'm_111': m_111, 'price_cross': price_cross} return render(request, 'charts/golden.html', context) def competitors(request): dates = [] xmr = [] dash = [] grin = [] zcash = [] count = 0 now_xmr = 0 now_dash = 0 now_grin = 0 now_zcash = 0 count = 0 coins_xmr = Coin.objects.order_by('date').filter(name='xmr') for coin_xmr in coins_xmr: if coin_xmr.priceusd: if count > 30: xmr.append(coin_xmr.priceusd/5.01) now_xmr = coin_xmr.priceusd/5.01 dates.append(count) count += 1 elif count <= 63: continue else: xmr.append('') count = 0 coins_dash = Coin.objects.order_by('date').filter(name='dash') for coin_dash in coins_dash: count += 1 if coin_dash.priceusd and count > 130: dash.append(coin_dash.priceusd/14.7) now_dash = coin_dash.priceusd/14.7 elif count <= 130: continue else: dash.append('') dates.append(count) count = 0 coins_grin = Coin.objects.order_by('date').filter(name='grin') for coin_grin in coins_grin: count += 1 if coin_grin.priceusd and count > 155: grin.append(coin_grin.priceusd/6.37) now_grin = coin_grin.priceusd/6.37 elif count <= 155: continue else: grin.append('') dates.append(count) count = 0 coins_zcash = Coin.objects.order_by('date').filter(name='zec') for coin_zcash in coins_zcash: count += 1 if coin_zcash.priceusd and count > 434: zcash.append(coin_zcash.priceusd/750) now_zcash = coin_zcash.priceusd/750 elif count <= 434: continue else: zcash.append('') dates.append(count) now_dash = locale.format('%.2f', now_dash, grouping=True) now_grin = locale.format('%.2f', now_grin, grouping=True) now_zcash = locale.format('%.2f', now_zcash, grouping=True) now_xmr = locale.format('%.2f', now_xmr, grouping=True) context = {'xmr': xmr, 'dash': dash, 'grin': grin, 'zcash': zcash, 'now_xmr': now_xmr, 'now_dash': now_dash, 'now_grin': now_grin, 'now_zcash': now_zcash, 'dates': dates} return render(request, 'charts/competitors.html', context) def competitorslin(request): dates = [] xmr = [] dash = [] grin = [] zcash = [] count = 0 now_xmr = 0 now_dash = 0 now_grin = 0 now_zcash = 0 count = 0 coins_xmr = Coin.objects.order_by('date').filter(name='xmr') for coin_xmr in coins_xmr: if coin_xmr.priceusd: if count > 30: xmr.append(coin_xmr.priceusd/5.01) now_xmr = coin_xmr.priceusd/5.01 dates.append(count) count += 1 elif count <= 63: continue else: xmr.append('') count = 0 coins_dash = Coin.objects.order_by('date').filter(name='dash') for coin_dash in coins_dash: count += 1 if coin_dash.priceusd and count > 130: dash.append(coin_dash.priceusd/14.7) now_dash = coin_dash.priceusd/14.7 elif count <= 130: continue else: dash.append('') dates.append(count) count = 0 coins_grin = Coin.objects.order_by('date').filter(name='grin') for coin_grin in coins_grin: count += 1 if coin_grin.priceusd and count > 155: grin.append(coin_grin.priceusd/6.37) now_grin = coin_grin.priceusd/6.37 elif count <= 155: continue else: grin.append('') dates.append(count) count = 0 coins_zcash = Coin.objects.order_by('date').filter(name='zec') for coin_zcash in coins_zcash: count += 1 if coin_zcash.priceusd and count > 434: zcash.append(coin_zcash.priceusd/750) now_zcash = coin_zcash.priceusd/750 elif count <= 434: continue else: zcash.append('') dates.append(count) now_dash = locale.format('%.2f', now_dash, grouping=True) now_grin = locale.format('%.2f', now_grin, grouping=True) now_zcash = locale.format('%.2f', now_zcash, grouping=True) now_xmr = locale.format('%.2f', now_xmr, grouping=True) context = {'xmr': xmr, 'dash': dash, 'grin': grin, 'zcash': zcash, 'now_xmr': now_xmr, 'now_dash': now_dash, 'now_grin': now_grin, 'now_zcash': now_zcash, 'dates': dates} return render(request, 'charts/competitorslin.html', context) def marketcap(request): data = DailyData.objects.order_by('date') dates = [] xmr = [] dash = [] grin = [] zcash = [] now_xmr = 0 now_dash = 0 now_grin = 0 now_zcash = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.zcash_marketcap > 1000000: zcash.append(item.zcash_marketcap) now_zcash = item.zcash_marketcap else: zcash.append('') if item.dash_marketcap > 1000000: dash.append(item.dash_marketcap) now_dash = item.dash_marketcap else: dash.append('') if item.xmr_marketcap > 1000000: xmr.append(item.xmr_marketcap) now_xmr = item.xmr_marketcap else: xmr.append('') if item.grin_marketcap > 1000000: grin.append(item.grin_marketcap) now_grin = item.grin_marketcap else: grin.append('') now_dash = '$'+locale.format('%.0f', now_dash, grouping=True) now_grin = '$'+locale.format('%.0f', now_grin, grouping=True) now_zcash = '$'+locale.format('%.0f', now_zcash, grouping=True) now_xmr = '$'+locale.format('%.0f', now_xmr, grouping=True) context = {'xmr': xmr, 'dash': dash, 'grin': grin, 'zcash': zcash, 'now_xmr': now_xmr, 'now_dash': now_dash, 'now_grin': now_grin, 'now_zcash': now_zcash, 'dates': dates} return render(request, 'charts/marketcap.html', context) def inflationreturn(request): count = 0 xmr = [] dash = [] grin = [] zcash = [] btc = [] now_xmr = 0 now_dash = 0 now_grin = 0 now_zcash = 0 now_btc = 0 inflation_xmr = [] inflation_dash = [] inflation_grin = [] inflation_zcash = [] inflation_btc = [] lastxmrA = 0 lastxmrB = 0 count = 0 coins = Coin.objects.order_by('date').filter(name='xmr') for coin in coins: count += 1 if coin.priceusd and count > 30 and coin.inflation > 0: now_xmr = coin.priceusd/5.01 #correcao de um erro nos dados if 100/coin.inflation > 110 and now_xmr < 10: xmr.append(lastxmrA) inflation_xmr.append(lastxmrB) else: xmr.append(now_xmr) inflation_xmr.append(100/coin.inflation) lastxmrA = now_xmr lastxmrB = 100/coin.inflation count = 0 coins = Coin.objects.order_by('date').filter(name='dash') for coin in coins: count += 1 if coin.priceusd and count > 130 and coin.inflation > 0: now_dash = coin.priceusd/14.7 dash.append(now_dash) inflation_dash.append(100/coin.inflation) count = 0 coins = Coin.objects.order_by('date').filter(name='grin') for coin in coins: count += 1 if coin.priceusd and count > 155 and coin.inflation > 0: now_grin = coin.priceusd/6.37 grin.append(now_grin) inflation_grin.append(100/coin.inflation) count = 0 coins = Coin.objects.order_by('date').filter(name='zec') for coin in coins: count += 1 if coin.priceusd and count > 434 and coin.inflation > 0: now_zcash = coin.priceusd/750 zcash.append(now_zcash) inflation_zcash.append(100/coin.inflation) count = 0 coins = Coin.objects.order_by('date').filter(name='btc') for coin in coins: count += 1 if coin.priceusd and count > 325 and coin.inflation > 0: now_btc = coin.priceusd/30 btc.append(now_btc) inflation_btc.append(100/coin.inflation) now_dash = locale.format('%.2f', now_dash, grouping=True) now_grin = locale.format('%.2f', now_grin, grouping=True) now_zcash = locale.format('%.2f', now_zcash, grouping=True) now_xmr = locale.format('%.2f', now_xmr, grouping=True) now_btc = locale.format('%.2f', now_btc, grouping=True) context = {'inflation_btc': inflation_btc,'inflation_xmr': inflation_xmr, 'inflation_dash': inflation_dash, 'inflation_grin': inflation_grin, 'inflation_zcash': inflation_zcash, 'now_xmr': now_xmr, 'now_dash': now_dash, 'now_grin': now_grin, 'now_zcash': now_zcash, 'now_btc': now_btc, 'btc': btc, 'xmr': xmr, 'dash': dash, 'zcash': zcash, 'grin': grin} return render(request, 'charts/inflationreturn.html', context) def bitcoin(request): dates = [] dates3 = [] dates4 = [] btc = [] xmr3 = [] count1 = 0 count3 = 0 now_xmr = 0 now_btc = 0 coins_btc = Coin.objects.order_by('date').filter(name='btc') for coin_btc in coins_btc: if coin_btc.priceusd: if count1 > 890: #450 btc.append(coin_btc.priceusd/30) now_btc = coin_btc.priceusd/30 dates.append(count1) count1 += 1 #1.4 elif count1 <= 890: #450 continue else: btc.append('') coins_xmr = Coin.objects.order_by('date').filter(name='xmr') for coin_xmr in coins_xmr: if coin_xmr.priceusd: if count3 > 30: xmr3.append(coin_xmr.priceusd/5.01) dates4.append(count3) count3 += 0.92 elif count3 <= 30: continue else: xmr3.append('') data = DailyData.objects.order_by('date') dates2 = [] xmr2 = [] btc2 = [] for item in data: dates2.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_return > 0.0001: btc2.append(item.btc_return) else: btc2.append('') if item.xmr_return > 0.0001: xmr2.append(item.xmr_return) else: xmr2.append('') now_btc = locale.format('%.2f', now_btc, grouping=True) now_xmr = locale.format('%.2f', now_xmr, grouping=True) context = {'btc': btc, 'xmr2': xmr2, 'btc2': btc2, 'xmr3': xmr3, 'dates': dates, 'dates2': dates2, 'dates3': dates3, 'dates4': dates4} return render(request, 'charts/bitcoin.html', context) def translin(request): symbol = 'xmr' transactions = [] pricexmr = [] dates = [] now_transactions = 0 maximum = 0 coins = Coin.objects.order_by('date') for coin in coins: print(str(coin.name) + ' ' + str(coin.date)) coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: if coin.transactions > 200: transactions.append(coin.transactions) now_transactions = coin.transactions if now_transactions > maximum: maximum = now_transactions else: transactions.append('') if coin.priceusd > 0.001: pricexmr.append(coin.priceusd) else: pricexmr.append('') coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d') dates.append(coin.date) now_transactions = int(now_transactions) maximum = int(maximum) context = {'transactions': transactions, 'dates': dates, 'maximum': maximum, 'now_transactions': now_transactions, 'pricexmr': pricexmr} return render(request, 'charts/translin.html', context) def transmonth(request): symbol = 'xmr' transactions = [] pricexmr = [] dates = [] now_transactions = 0 maximum = 0 month_previous = '2014-01' month = 0 total = 0 coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: aux = str(coin.date) month = aux.split("-")[0] + '-' + aux.split("-")[1] if month != month_previous: dates.append(month_previous) transactions.append(total) if total > maximum: maximum = total total = 0 month_previous = month if coin.transactions > 0: total += coin.transactions now_transactions = int(total) maximum = int(maximum) now_transactions = locale.format('%.0f', now_transactions, grouping=True) maximum = locale.format('%.0f', maximum, grouping=True) context = {'transactions': transactions, 'dates': dates, 'maximum': maximum, 'now_transactions': now_transactions, 'pricexmr': pricexmr} return render(request, 'charts/transmonth.html', context) def percentmonth(request): symbol = 'xmr' transactions = [] pricexmr = [] dates = [] now_transactions = 0 maximum = 0 month_previous = '2014-01' month = 0 total = 0 total_btc = 0 total_xmr = 0 coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: aux = str(coin.date) month = aux.split("-")[0] + '-' + aux.split("-")[1] try: coin_btc = Coin.objects.filter(name='btc').get(date=coin.date) except: pass if month != month_previous: dates.append(month_previous) if total_btc > 0: total = 100*total_xmr/total_btc else: total = 0 transactions.append(total) if total > maximum: maximum = total total_xmr = 0 total_btc = 0 month_previous = month if coin.transactions > 0: total_xmr += coin.transactions if coin_btc.transactions > 0: total_btc += coin_btc.transactions if total_btc > 0: total = 100*total_xmr/total_btc else: total = 0 now_transactions = locale.format('%.1f', total, grouping=True) + ' %' maximum = locale.format('%.1f', maximum, grouping=True) + ' %' context = {'transactions': transactions, 'dates': dates, 'maximum': maximum, 'now_transactions': now_transactions, 'pricexmr': pricexmr} return render(request, 'charts/percentmonth.html', context) def deviation(request): symbol = 'xmr' pricexmr = [] dates = [] coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: if coin.priceusd > 0.001: pricexmr.append(coin.priceusd) else: pricexmr.append(0.20) coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d') dates.append(coin.date) n = 180 median_long_price = pd.Series(pricexmr).rolling(window=n).mean().iloc[n-1:].values m_long_price = [] for i in range(n): m_long_price.append(0) for item in median_long_price: m_long_price.append(float(item)) n = 3 median_short_price = pd.Series(pricexmr).rolling(window=n).mean().iloc[n-1:].values m_short_price = [] for i in range(n): m_short_price.append(0) for item in median_short_price: m_short_price.append(float(item)) deviation_percentage = [] deviation_price = [] for count in range(0, len(m_short_price)): if float(m_long_price[count]) < 0.001: deviation_price.append('') deviation_percentage.append('') else: deviation_price.append((float(m_short_price[count])-float(m_long_price[count]))/(1)) deviation_percentage.append(100*(float(m_short_price[count])-float(m_long_price[count]))/(float(m_long_price[count]))) context = {'deviation_percentage': deviation_percentage, 'deviation_price': deviation_price, 'dates': dates, 'pricexmr': pricexmr} return render(request, 'charts/deviation.html', context) def deviation_tx(request): symbol = 'xmr' transactions = [] pricexmr = [] dates = [] coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: transactions.append(coin.transactions) if coin.priceusd > 0.001: pricexmr.append(coin.priceusd) else: pricexmr.append(0.20) coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d') dates.append(coin.date) n = 180 median_long = pd.Series(transactions).rolling(window=n).mean().iloc[n-1:].values m_long = [] for i in range(n): m_long.append(0) for item in median_long: m_long.append(float(item)) n = 3 median_short = pd.Series(transactions).rolling(window=n).mean().iloc[n-1:].values m_short = [] for i in range(n): m_short.append(0) for item in median_short: m_short.append(float(item)) n = 180 median_long_price = pd.Series(pricexmr).rolling(window=n).mean().iloc[n-1:].values m_long_price = [] for i in range(n): m_long_price.append(0) for item in median_long_price: m_long_price.append(float(item)) n = 3 median_short_price = pd.Series(pricexmr).rolling(window=n).mean().iloc[n-1:].values m_short_price = [] for i in range(n): m_short_price.append(0) for item in median_short_price: m_short_price.append(float(item)) deviation_percentage = [] for count in range(0, len(m_short)): if float(m_long[count]) < 0.001 or float(m_long_price[count]) < 0.001: deviation_percentage.append('') else: calculation = (float(m_short_price[count])-float(m_long_price[count]))*abs(float(m_short[count])-float(m_long[count]))/(float(m_long[count])) if calculation > 100: calculation = 100 if calculation < -100: calculation = -100 deviation_percentage.append(calculation) context = {'deviation_percentage': deviation_percentage, 'dates': dates, 'pricexmr': pricexmr} return render(request, 'charts/deviation_tx.html', context) def percentage(request): data = DailyData.objects.order_by('date') transactions = [] dates = [] now_transactions = 0 maximum = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.xmr_transacpercentage > 0.00001: transactions.append(100*item.xmr_transacpercentage) now_transactions = 100*item.xmr_transacpercentage if now_transactions > maximum: maximum = now_transactions else: transactions.append('') now_transactions = locale.format('%.1f', now_transactions, grouping=True) + '%' maximum = locale.format('%.1f', maximum, grouping=True) + '%' context = {'transactions': transactions, 'dates': dates, 'now_transactions': now_transactions, 'maximum': maximum} return render(request, 'charts/percentage.html', context) def translog(request): symbol = 'xmr' transactions = [] pricexmr = [] dates = [] now_transactions = 0 maximum = 0 coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: if coin.transactions > 200: transactions.append(coin.transactions) now_transactions = coin.transactions if now_transactions > maximum: maximum = now_transactions else: transactions.append('') if coin.priceusd > 0.001: pricexmr.append(coin.priceusd) else: pricexmr.append('') coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d') dates.append(coin.date) now_transactions = int(now_transactions) maximum = int(maximum) context = {'transactions': transactions, 'dates': dates, 'maximum': maximum, 'now_transactions': now_transactions, 'pricexmr': pricexmr} return render(request, 'charts/translog.html', context) def hashrate(request): symbol = 'xmr' hashrate = [] dates = [] now_hashrate = 0 coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d') dates.append(coin.date) if coin.hashrate > 0: now_hashrate = coin.hashrate hashrate.append(coin.hashrate) else: hashrate.append('') now_hashrate = locale.format('%.0f', now_hashrate, grouping=True) context = {'hashrate': hashrate, 'dates': dates, 'now_hashrate': now_hashrate} return render(request, 'charts/hashrate.html', context) def hashprice(request): symbol = 'xmr' hashrate = [] dates = [] buy = [] sell = [] now_hashrate = 0 color = [] v0 = 0.002 delta = (0.015 - 0.002)/(6*365) count = 0 coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: if count > 50: buy.append(0.00000003) sell.append(0.00000100) coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d') dates.append(coin.date) if coin.hashrate > 0 and coin.priceusd > 0: now_hashrate = coin.priceusd/coin.hashrate hashrate.append(now_hashrate) else: hashrate.append('') new_color = 30*coin.pricebtc/(count*delta + v0) color.append(new_color) count += 1 now_hashrate = locale.format('%.8f', now_hashrate, grouping=True) context = {'hashrate': hashrate, 'dates': dates, 'now_hashrate': now_hashrate, 'color': color, 'buy': buy, 'sell': sell} return render(request, 'charts/hashprice.html', context) def hashvsprice(request): symbol = 'xmr' hashrate = [] prices = [] dates = [] now_hashrate = 0 now_priceusd = 0 now_pricebtc = 0 color = [] v0 = 0.002 delta = (0.015 - 0.002)/(6*365) count = 0 coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: if count > 55: coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d') dates.append(coin.date) if coin.priceusd > 0 and coin.hashrate: now_hashrate = coin.hashrate now_priceusd = coin.priceusd now_pricebtc = coin.pricebtc hashrate.append(now_hashrate) prices.append(now_priceusd) else: hashrate.append('') prices.append('') new_color = 30*coin.pricebtc/(count*delta + v0) color.append(new_color) count += 1 now_hashrate = locale.format('%.0f', now_hashrate, grouping=True) now_priceusd = '$' + locale.format('%.2f', now_priceusd, grouping=True) now_pricebtc = locale.format('%.5f', now_pricebtc, grouping=True) + ' BTC' context = {'hashrate': hashrate, 'dates': dates, 'now_hashrate': now_hashrate, 'color': color, 'prices': prices, 'now_pricebtc': now_pricebtc, 'now_priceusd': now_priceusd} return render(request, 'charts/hashvsprice.html', context) def metcalfesats(request): data = DailyData.objects.order_by('date') color = [] metcalfe = [] prices = [] dates = [] now_metcalfe = 0 now_price = 0 maximum = 0 v0 = 0.002 delta = (0.015 - 0.002)/(6*365) count = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.xmr_metcalfebtc < 0.0007: metcalfe.append('') color.append('') prices.append('') else: metcalfe.append(item.xmr_metcalfebtc) now_price = item.xmr_pricebtc now_metcalfe = item.xmr_metcalfebtc if now_metcalfe > maximum: maximum = now_metcalfe color.append(30*item.xmr_pricebtc/(count*delta + v0)) prices.append(now_price) count += 1 now_price = locale.format('%.4f', now_price, grouping=True) + ' BTC' now_metcalfe = locale.format('%.4f', now_metcalfe, grouping=True) + ' BTC' maximum = locale.format('%.4f', maximum, grouping=True) + ' BTC' context = {'metcalfe': metcalfe, 'dates': dates, 'maximum': maximum, 'now_metcalfe': now_metcalfe, 'color': color, 'prices': prices, 'now_price': now_price} return render(request, 'charts/metcalfesats.html', context) def metcalfesats_deviation(request): data = DailyData.objects.order_by('date') metcalfe_percentage = [] metcalfe = [] dates = [] now_metcalfe = 0 now_metcalfe_percentage = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.xmr_metcalfebtc < 0.0007 and item.xmr_pricebtc <= 0: metcalfe.append('') metcalfe_percentage.append('') else: now_metcalfe = item.xmr_metcalfebtc - item.xmr_pricebtc now_metcalfe_percentage = 100*((item.xmr_metcalfebtc/item.xmr_pricebtc) - 1) metcalfe.append(now_metcalfe) metcalfe_percentage.append(now_metcalfe_percentage) now_metcalfe = locale.format('%.4f', now_metcalfe, grouping=True) now_metcalfe_percentage = locale.format('%.0f', now_metcalfe_percentage, grouping=True) context = {'metcalfe': metcalfe, 'dates': dates, 'now_metcalfe': now_metcalfe, 'now_metcalfe_percentage': now_metcalfe_percentage, 'metcalfe_percentage': metcalfe_percentage} return render(request, 'charts/metcalfesats_deviation.html', context) def metcalfe_deviation(request): data = DailyData.objects.order_by('date') metcalfe_percentage = [] metcalfe = [] dates = [] now_metcalfe = 0 now_metcalfe_percentage = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.xmr_metcalfeusd < 0.0007 and item.xmr_priceusd <= 0: metcalfe.append('') metcalfe_percentage.append('') else: now_metcalfe = item.xmr_metcalfeusd - item.xmr_priceusd now_metcalfe_percentage = 100*((item.xmr_metcalfeusd/item.xmr_priceusd) - 1) metcalfe.append(now_metcalfe) metcalfe_percentage.append(now_metcalfe_percentage) now_metcalfe = locale.format('%.0f', now_metcalfe, grouping=True) now_metcalfe_percentage = locale.format('%.0f', now_metcalfe_percentage, grouping=True) context = {'metcalfe': metcalfe, 'dates': dates, 'now_metcalfe': now_metcalfe, 'now_metcalfe_percentage': now_metcalfe_percentage, 'metcalfe_percentage': metcalfe_percentage} return render(request, 'charts/metcalfe_deviation.html', context) def metcalfeusd(request): data = DailyData.objects.order_by('date') color = [] metcalfe = [] prices = [] dates = [] now_metcalfe = 0 now_price = 0 maximum = 0 v0 = 0.002 delta = (0.015 - 0.002)/(6*365) count = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.xmr_metcalfeusd < 0.001: metcalfe.append('') color.append('') prices.append('') else: metcalfe.append(item.xmr_metcalfeusd) now_price = item.xmr_priceusd now_metcalfe = item.xmr_metcalfeusd if now_metcalfe > maximum: maximum = now_metcalfe color.append(30*item.xmr_pricebtc/(count*delta + v0)) prices.append(now_price) count += 1 now_price = "$"+ locale.format('%.2f', now_price, grouping=True) now_metcalfe = "$"+ locale.format('%.2f', now_metcalfe, grouping=True) maximum = "$"+ locale.format('%.2f', maximum, grouping=True) context = {'metcalfe': metcalfe, 'dates': dates, 'maximum': maximum, 'now_metcalfe': now_metcalfe, 'color': color, 'prices': prices, 'now_price': now_price} return render(request, 'charts/metcalfeusd.html', context) def coins(request): data = DailyData.objects.order_by('date') supplyxmr = [] supplybtc = [] fsupplyxmr = [] fsupplybtc = [] dates = [] now_xmr = 0 now_btc = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_supply > 0.1: supplybtc.append(item.btc_supply) now_btc = item.btc_supply else: supplybtc.append('') if item.xmr_inflation > 0.1: supplyxmr.append(item.xmr_supply) now_xmr = item.xmr_supply else: supplyxmr.append('') fsupplyxmr.append('') fsupplybtc.append('') rewardbtc = 900 supplybitcoin = item.btc_supply supply = int(item.xmr_supply)*10**12 for i in range(365*(2060-2020)): supply = int(supply) reward = (2**64 -1 - supply) >> 19 if reward < 0.6*(10**12): reward = 0.6*(10**12) supply += int(720*reward) fsupplyxmr.append(supply/(10**12)) date_aux = item.date + timedelta(i) dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d')) supplybitcoin += rewardbtc if supplybitcoin > 21000000: supplybitcoin = 21000000 fsupplybtc.append(supplybitcoin) date_aux2 = datetime.datetime.strftime(date_aux, '%Y-%m-%d') if date_aux2 == '2024-04-23': rewardbtc = rewardbtc/2 if date_aux2 == '2028-05-05': rewardbtc = rewardbtc/2 if date_aux2 == '2032-05-03': rewardbtc = rewardbtc/2 if date_aux2 == '2036-04-30': rewardbtc = rewardbtc/2 if date_aux2 == '2040-04-27': rewardbtc = rewardbtc/2 if date_aux2 == '2044-04-25': rewardbtc = rewardbtc/2 if date_aux2 == '2048-04-22': rewardbtc = rewardbtc/2 if date_aux2 == '2052-04-19': rewardbtc = rewardbtc/2 if date_aux2 == '2056-04-30': rewardbtc = rewardbtc/2 if date_aux2 == '2060-04-27': rewardbtc = rewardbtc/2 if date_aux2 == '2064-04-25': rewardbtc = rewardbtc/2 if date_aux2 == '2068-04-22': rewardbtc = rewardbtc/2 if date_aux2 == '2072-04-19': rewardbtc = rewardbtc/2 if date_aux2 == '2076-04-30': rewardbtc = rewardbtc/2 if date_aux2 == '2080-04-27': rewardbtc = rewardbtc/2 if date_aux2 == '2084-04-25': rewardbtc = rewardbtc/2 if date_aux2 == '2088-04-22': rewardbtc = rewardbtc/2 if date_aux2 == '2140-01-01': rewardbtc = 0 supplybitcoin = 21000000 supplyxmr.append('') supplybtc.append('') now_btc = locale.format('%.0f', now_btc, grouping=True) now_xmr = locale.format('%.0f', now_xmr, grouping=True) context = {'supplyxmr': supplyxmr, 'supplybtc': supplybtc, 'fsupplyxmr': fsupplyxmr, 'fsupplybtc': fsupplybtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/coins.html', context) def dailyemission(request): data = DailyData.objects.order_by('date') emissionbtc = [] emissionxmr = [] dates = [] now_btc = 0 now_xmr = 0 high_btc = 0 high_xmr = 0 for item in data: if item.btc_emissionusd == 0: emissionbtc.append('') else: emissionbtc.append(item.btc_emissionusd) now_btc = item.btc_emissionusd if item.btc_emissionusd > high_btc: high_btc = item.btc_emissionusd if item.xmr_emissionusd == 0: emissionxmr.append('') else: emissionxmr.append(item.xmr_emissionusd) now_xmr = item.xmr_emissionusd if item.xmr_emissionusd > high_xmr: high_xmr = item.xmr_emissionusd dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) for i in range(500): date_aux = item.date + timedelta(i) dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d')) emissionxmr.append('') emissionbtc.append('') now_btc = "$" + locale.format('%.0f', now_btc, grouping=True) now_xmr = "$" + locale.format('%.0f', now_xmr, grouping=True) high_btc = "$" + locale.format('%.0f', high_btc, grouping=True) high_xmr = "$" + locale.format('%.0f', high_xmr, grouping=True) context = {'emissionxmr': emissionxmr, 'emissionbtc': emissionbtc, 'high_xmr': high_xmr, 'high_btc': high_btc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/dailyemission.html', context) def extracoins(request): data = DailyData.objects.order_by('date') nsupply = [] fsupply = [] dates = [] now_diff = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_supply - item.xmr_supply > 0: nsupply.append(item.btc_supply - item.xmr_supply) else: nsupply.append('') fsupply.append('') rewardbtc = 900 supplybitcoin = item.btc_supply supply = int(item.xmr_supply)*10**12 for i in range(365*(2060-2020)): supply = int(supply) reward = (2**64 -1 - supply) >> 19 if reward < 0.6*(10**12): reward = 0.6*(10**12) supply += int(720*reward) date_aux = item.date + timedelta(i) dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d')) supplybitcoin += rewardbtc if supplybitcoin > 21000000: supplybitcoin = 21000000 fsupply.append(-supply/(10**12) + supplybitcoin) date_aux2 = datetime.datetime.strftime(date_aux, '%Y-%m-%d') if date_aux2 == '2024-04-23': rewardbtc = rewardbtc/2 if date_aux2 == '2028-05-05': rewardbtc = rewardbtc/2 if date_aux2 == '2032-05-03': rewardbtc = rewardbtc/2 if date_aux2 == '2036-04-30': rewardbtc = rewardbtc/2 if date_aux2 == '2040-04-27': rewardbtc = rewardbtc/2 if date_aux2 == '2044-04-25': rewardbtc = rewardbtc/2 if date_aux2 == '2048-04-22': rewardbtc = rewardbtc/2 if date_aux2 == '2052-04-19': rewardbtc = rewardbtc/2 if date_aux2 == '2056-04-30': rewardbtc = rewardbtc/2 if date_aux2 == '2060-04-27': rewardbtc = rewardbtc/2 if date_aux2 == '2064-04-25': rewardbtc = rewardbtc/2 if date_aux2 == '2068-04-22': rewardbtc = rewardbtc/2 if date_aux2 == '2072-04-19': rewardbtc = rewardbtc/2 if date_aux2 == '2076-04-30': rewardbtc = rewardbtc/2 if date_aux2 == '2080-04-27': rewardbtc = rewardbtc/2 if date_aux2 == '2084-04-25': rewardbtc = rewardbtc/2 if date_aux2 == '2088-04-22': rewardbtc = rewardbtc/2 if date_aux2 == '2140-01-01': rewardbtc = 0 supplybitcoin = 21000000 nsupply.append('') now_diff = locale.format('%.0f', now_diff, grouping=True) context = {'nsupply': nsupply, 'fsupply': fsupply, 'dates': dates, 'now_diff': now_diff} return render(request, 'charts/extracoins.html', context) def inflation(request): data = DailyData.objects.order_by('date') inflationxmr = [] inflationbtc = [] finflationxmr = [] finflationbtc = [] dates = [] now_xmr = 999999 now_btc = 999999 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_inflation > 0.1: inflationbtc.append(item.btc_inflation) now_btc = item.btc_inflation else: inflationbtc.append('') if item.xmr_inflation > 0.1: inflationxmr.append(item.xmr_inflation) now_xmr = item.xmr_inflation else: inflationxmr.append('') finflationxmr.append('') finflationbtc.append('') inflationbitcoin = 1.75 supply = int(item.xmr_supply)*10**12 for i in range(2000): supply = int(supply) reward = (2**64 -1 - supply) >> 19 if reward < 0.6*(10**12): reward = 0.6*(10**12) supply += int(720*reward) finflationxmr.append(100*reward*720*365/supply) date_aux = item.date + timedelta(i) dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d')) finflationbtc.append(inflationbitcoin) date_aux2 = datetime.datetime.strftime(date_aux, '%Y-%m-%d') if date_aux2 == '2024-04-23': inflationbitcoin = 0.65 inflationxmr.append('') inflationbtc.append('') now_btc = locale.format('%.2f', now_btc, grouping=True) + '%' now_xmr = locale.format('%.2f', now_xmr, grouping=True) + '%' context = {'inflationxmr': inflationxmr, 'inflationbtc': inflationbtc, 'finflationxmr': finflationxmr, 'finflationbtc': finflationbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/inflation.html', context) def blocksize(request): data = DailyData.objects.order_by('date') xmr_blocksize = [] btc_blocksize = [] dates = [] now_xmr = 0 now_btc = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_blocksize > 0.001: btc_blocksize.append(item.btc_blocksize/1024) now_btc = item.btc_blocksize else: btc_blocksize.append('') if item.xmr_blocksize > 0.001: xmr_blocksize.append(item.xmr_blocksize/1024) now_xmr = item.xmr_blocksize else: xmr_blocksize.append('') now_btc = locale.format('%.2f', now_btc, grouping=True) + ' bytes' now_xmr = locale.format('%.2f', now_xmr, grouping=True) + ' bytes' context = {'xmr_blocksize': xmr_blocksize, 'btc_blocksize': btc_blocksize, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/blocksize.html', context) def transactionsize(request): data = DailyData.objects.order_by('date') xmr_blocksize = [] btc_blocksize = [] dates = [] now_xmr = 0 now_btc = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_blocksize > 0.001 and item.btc_transactions > 0: now_btc = 144*item.btc_blocksize/(1024*item.btc_transactions) btc_blocksize.append(144*item.btc_blocksize/(1024*item.btc_transactions)) else: btc_blocksize.append('') if item.xmr_blocksize > 0.001 and item.xmr_transactions > 0: now_xmr = 720*item.xmr_blocksize/(1024*item.xmr_transactions) xmr_blocksize.append(720*item.xmr_blocksize/(1024*item.xmr_transactions)) else: xmr_blocksize.append('') now_btc = locale.format('%.2f', now_btc, grouping=True) + ' bytes' now_xmr = locale.format('%.2f', now_xmr, grouping=True) + ' bytes' context = {'xmr_blocksize': xmr_blocksize, 'btc_blocksize': btc_blocksize, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/transactionsize.html', context) def transactiondominance(request): data = DailyData.objects.order_by('date') xmr_dominance = [] dates = [] now_xmr = 0 maximum = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.xmr_transactions > 0: now_xmr = 100*item.xmr_transactions/(item.xmr_transactions+item.dash_transactions+item.zcash_transactions+item.grin_transactions) else: now_xmr = 0 if now_xmr > maximum: maximum = now_xmr xmr_dominance.append(now_xmr) now_xmr = locale.format('%.1f', now_xmr, grouping=True) + '%' maximum = locale.format('%.1f', maximum, grouping=True) + '%' context = {'xmr_dominance': xmr_dominance, 'now_xmr': now_xmr, 'maximum': maximum, 'dates': dates} return render(request, 'charts/transactiondominance.html', context) def difficulty(request): data = DailyData.objects.order_by('date') xmr_difficulty = [] btc_difficulty = [] dates = [] now_xmr = 0 now_btc = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_difficulty > 0.001: now_btc = item.btc_difficulty btc_difficulty.append(now_btc) else: btc_difficulty.append('') if item.xmr_difficulty > 0.001: now_xmr = item.xmr_difficulty xmr_difficulty.append(now_xmr) else: xmr_difficulty.append('') now_btc = locale.format('%.0f', now_btc, grouping=True) now_xmr = locale.format('%.0f', now_xmr, grouping=True) context = {'xmr_difficulty': xmr_difficulty, 'btc_difficulty': btc_difficulty, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/difficulty.html', context) def blockchainsize(request): data = DailyData.objects.order_by('date') xmr_blocksize = [] btc_blocksize = [] dates = [] now_xmr = 0 now_btc = 0 hardfork = datetime.datetime.strptime('2016-03-23', '%Y-%m-%d') #block time changed here for item in data: date = datetime.datetime.strftime(item.date, '%Y-%m-%d') dates.append(date) date = datetime.datetime.strptime(date, '%Y-%m-%d') if item.btc_blocksize > 0.001 and item.btc_transactions > 0: now_btc += 144*item.btc_blocksize/1024 if now_btc < 200: btc_blocksize.append('') else: btc_blocksize.append(now_btc) else: btc_blocksize.append('') if item.xmr_blocksize > 0.001 and item.xmr_transactions > 0: if date < hardfork: now_xmr += 1440*item.xmr_blocksize/1024 else: now_xmr += 720*item.xmr_blocksize/1024 if now_xmr < 200: xmr_blocksize.append('') else: xmr_blocksize.append(now_xmr) else: xmr_blocksize.append('') now_btc = locale.format('%.2f', now_btc/(1024*1024), grouping=True) + ' Gb' now_xmr = locale.format('%.2f', now_xmr/(1024*1024), grouping=True) + ' Gb' context = {'xmr_blocksize': xmr_blocksize, 'btc_blocksize': btc_blocksize, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/blockchainsize.html', context) def securitybudget(request): data = DailyData.objects.order_by('date') xmr_security = [] btc_security = [] dates = [] now_xmr = 0 now_btc = 0 for item in data: date = datetime.datetime.strftime(item.date, '%Y-%m-%d') dates.append(date) if item.btc_minerrevusd > 0.001: now_btc = item.btc_minerrevusd/86400 btc_security.append(now_btc) else: btc_security.append('') if item.xmr_minerrevusd > 0.001: now_xmr = item.xmr_minerrevusd/86400 xmr_security.append(now_xmr) else: xmr_security.append('') now_btc = '$' + locale.format('%.2f', now_btc, grouping=True) now_xmr = '$' + locale.format('%.2f', now_xmr, grouping=True) context = {'xmr_security': xmr_security, 'btc_security': btc_security, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/securitybudget.html', context) def efficiency(request): data = DailyData.objects.order_by('date') xmr_efficiency = [] btc_efficiency = [] dates = [] now_xmr = 0 now_btc = 0 for item in data: date = datetime.datetime.strftime(item.date, '%Y-%m-%d') dates.append(date) if item.btc_minerrevusd != 0 and item.btc_inflation > 0: if (2**32)*item.btc_difficulty*0.10/(item.btc_minerrevusd*24000) > 10: now_btc = (2**32)*item.btc_difficulty*0.10/(item.btc_minerrevusd*24000) if now_btc > 0.01: btc_efficiency.append(now_btc) else: btc_efficiency.append('') else: btc_efficiency.append('') if item.xmr_minerrevusd != 0 and item.xmr_inflation > 0: if item.xmr_difficulty*0.10/(item.xmr_minerrevusd*5000) > 0.01: now_xmr = item.xmr_difficulty*0.10/(item.xmr_minerrevusd*5000) if now_xmr > 0.01: xmr_efficiency.append(now_xmr) else: xmr_efficiency.append('') else: xmr_efficiency.append('') now_btc = locale.format('%.0f', now_btc, grouping=True) now_xmr = locale.format('%.0f', now_xmr, grouping=True) context = {'xmr_efficiency': xmr_efficiency, 'btc_efficiency': btc_efficiency, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/efficiency.html', context) def compinflation(request): data = DailyData.objects.order_by('date') dates = [] inflationxmr = [] inflationdash = [] inflationgrin = [] inflationzcash = [] inflationbtc = [] now_xmr = 999999 now_dash = 999999 now_grin = 999999 now_zcash = 999999 now_btc = 999999 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_inflation > 0.1: inflationbtc.append(item.btc_inflation) now_btc = item.btc_inflation else: inflationbtc.append('') if item.zcash_inflation > 0.1: inflationzcash.append(item.zcash_inflation) now_zcash = item.zcash_inflation else: inflationzcash.append('') if item.dash_inflation > 0.1: inflationdash.append(item.dash_inflation) now_dash = item.dash_inflation else: inflationdash.append('') if item.xmr_inflation > 0.1: inflationxmr.append(item.xmr_inflation) now_xmr = item.xmr_inflation else: inflationxmr.append('') if item.grin_inflation > 0.1: inflationgrin.append(item.grin_inflation) now_grin = item.grin_inflation else: inflationgrin.append('') now_dash = locale.format('%.2f', now_dash, grouping=True) + '%' now_grin = locale.format('%.2f', now_grin, grouping=True) + '%' now_zcash = locale.format('%.2f', now_zcash, grouping=True) + '%' now_xmr = locale.format('%.2f', now_xmr, grouping=True) + '%' now_btc = locale.format('%.2f', now_btc, grouping=True) + '%' context = {'inflationxmr': inflationxmr, 'inflationdash': inflationdash, 'inflationgrin': inflationgrin, 'inflationzcash': inflationzcash, 'inflationbtc': inflationbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'now_dash': now_dash, 'now_grin': now_grin, 'now_zcash': now_zcash, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/compinflation.html', context) def comptransactions(request): data = DailyData.objects.order_by('date') dates = [] xmr = [] dash = [] grin = [] zcash = [] btc = [] now_xmr = 999999 now_dash = 999999 now_grin = 999999 now_zcash = 999999 now_btc = 999999 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_transactions > 10: btc.append(item.btc_transactions) now_btc = item.btc_transactions else: btc.append('') if item.zcash_transactions > 10: zcash.append(item.zcash_transactions) now_zcash = item.zcash_transactions else: zcash.append('') if item.dash_transactions > 10: dash.append(item.dash_transactions) now_dash = item.dash_transactions else: dash.append('') if item.xmr_transactions > 10: xmr.append(item.xmr_transactions) now_xmr = item.xmr_transactions else: xmr.append('') if item.grin_transactions > 10: grin.append(item.grin_transactions) now_grin = item.grin_transactions else: grin.append('') now_dash = locale.format('%.0f', now_dash, grouping=True) now_grin = locale.format('%.0f', now_grin, grouping=True) now_zcash = locale.format('%.0f', now_zcash, grouping=True) now_xmr = locale.format('%.0f', now_xmr, grouping=True) now_btc = locale.format('%.0f', now_btc, grouping=True) context = {'xmr': xmr, 'dash': dash, 'grin': grin, 'zcash': zcash, 'btc': btc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'now_dash': now_dash, 'now_grin': now_grin, 'now_zcash': now_zcash, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/comptransactions.html', context) def sfmodel(request): dates = [] stock_to_flow = [] projection = [] color = [] values = [] now_price = 0 now_sf = 0 now_inflation = 0 data = Sfmodel.objects.order_by('date') count_aux = 0 for item in data: if item.color != 0: color.append(item.color) else: color.append('') if item.greyline != 0: projection.append(item.greyline) if count_aux > 25: count_aux = 0 else: projection.append(item.greyline) else: projection.append('') if item.stocktoflow > 0.2: stock_to_flow.append(item.stocktoflow) else: stock_to_flow.append('') if item.priceusd > 0.1: values.append(item.priceusd) now_price = item.priceusd now_sf = item.stocktoflow if item.date > date.today() - timedelta(4): coins = Coin.objects.filter(name='xmr').filter(date=item.date) if coins: for coin in coins: now_inflation = coin.inflation else: values.append('') count_aux += 1 dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) now_price = "$"+ locale.format('%.2f', now_price, grouping=True) now_sf = "$"+ locale.format('%.2f', now_sf, grouping=True) now_inflation = locale.format('%.2f', now_inflation, grouping=True)+'%' context = {'values': values, 'dates': dates, 'stock_to_flow': stock_to_flow, 'projection': projection, 'now_price': now_price, 'now_inflation': now_inflation, 'now_sf': now_sf, 'color': color} return render(request, 'charts/sfmodel.html', context) def sfmodellin(request): dates = [] stock_to_flow = [] projection = [] color = [] values = [] now_price = 0 now_sf = 0 now_inflation = 0 data = Sfmodel.objects.order_by('date') count_aux = 0 for item in data: if item.color != 0: color.append(item.color) else: color.append('') if item.greyline != 0: projection.append(item.greyline) if count_aux > 25: count_aux = 0 else: projection.append(item.greyline) else: projection.append('') if item.stocktoflow > 0.2: stock_to_flow.append(item.stocktoflow) else: stock_to_flow.append('') if item.priceusd > 0.1: values.append(item.priceusd) now_price = item.priceusd now_sf = item.stocktoflow if item.date > date.today() - timedelta(4): coins = Coin.objects.filter(name='xmr').filter(date=item.date) if coins: for coin in coins: now_inflation = coin.inflation else: values.append('') count_aux += 1 dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) now_price = "$"+ locale.format('%.2f', now_price, grouping=True) now_sf = "$"+ locale.format('%.2f', now_sf, grouping=True) now_inflation = locale.format('%.2f', now_inflation, grouping=True)+'%' context = {'values': values, 'dates': dates, 'stock_to_flow': stock_to_flow,'now_price': now_price, 'now_inflation': now_inflation, 'now_sf': now_sf, 'color': color} return render(request, 'charts/sfmodellin.html', context) def sfmultiple(request): symbol = 'xmr' now_sf = 0 maximum = 0 dates = [] stock_to_flow = [] buy = [] sell = [] color = [] v0 = 0.002 delta = (0.015 - 0.002)/(6*365) count = 0 sf_aux = 0 coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d')) buy.append(1) sell.append(100) if coin.stocktoflow > sf_aux*2+250: coin.stocktoflow = sf_aux sf_aux = coin.stocktoflow if coin.priceusd < 1: coin.priceusd = 1 if coin.stocktoflow != 0: now_sf = coin.supply*coin.priceusd/(coin.stocktoflow*1500000) stock_to_flow.append(now_sf) buy.append(1) sell.append(100) if now_sf > maximum: maximum = now_sf new_color = 30*coin.pricebtc/(count*delta + v0) color.append(new_color) count += 1 now_sf = locale.format('%.2f', now_sf, grouping=True) maximum = locale.format('%.2f', maximum, grouping=True) context = {'dates': dates, 'maximum': maximum, 'stock_to_flow': stock_to_flow, 'now_sf': now_sf, 'buy': buy, 'sell': sell, 'color': color} return render(request, 'charts/sfmultiple.html', context) def marketcycle(request): dates = [] color = [] sell = [] buy = [] data = Sfmodel.objects.order_by('date') for item in data: if item.color > 0: color.append(item.color - 5) else: color.append('') sell.append(100) buy.append(0) dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) now_cycle = locale.format('%.2f', item.color, grouping=True) context = {'dates': dates, 'color': color, 'sell': sell, 'buy': buy, 'now_cycle': now_cycle} return render(request, 'charts/marketcycle.html', context) def shielded(request): dates = [] values = [] values2 = [] values3 = [] gc = pygsheets.authorize(service_file='service_account_credentials.json') sh = gc.open('zcash_bitcoin') wks = sh.worksheet_by_title('Sheet1') dominance = 0 monthly = 0 values_mat = wks.get_values(start=(3,1), end=(999,5), returnas='matrix') for k in range(0,len(values_mat)): if values_mat[k][0] and values_mat[k][3]: date = values_mat[k][0] value = values_mat[k][3] value3 = values_mat[k][4] if not(value) or not(value): break else: dates.append(date) values.append(int(value)) values3.append(int(value3)) else: break previous_date = 0 coins = Coin.objects.order_by('date').filter(name='xmr') for date in dates: value2 = 0 for coin in coins: aux = str(coin.date) month = aux.split("-")[0] + '-' + aux.split("-")[1] if month == date: if previous_date != coin.date: value2 += coin.transactions previous_date = coin.date values2.append(int(value2)) dominance = 100*int(value2)/(int(value2)+int(value)+int(value3)) monthly = int(value2) monthly = format(int(monthly),',') dominance = locale.format('%.2f', dominance, grouping=True) context = {'dates': dates, 'values': values, 'values2': values2, 'values3': values3, "monthly": monthly, "dominance": dominance} return render(request, 'charts/shielded.html', context) def thermocap(request): symbol = 'xmr' dates = [] values = [] thermocap = [] color = [] v0 = 0.002 delta = (0.015 - 0.002)/(6*365) count = 0 sf_aux = 0 supply = 0 calorie = 1 calories = [] calories2 = [] calories3 = [] coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d')) if coin.stocktoflow > sf_aux*2+250: coin.stocktoflow = sf_aux sf_aux = coin.stocktoflow values.append(coin.priceusd) new_color = 30*coin.pricebtc/(count*delta + v0) color.append(new_color) calorie += (coin.supply - supply)*coin.priceusd if coin.inflation != 0: if calorie/(4200000*math.sqrt(coin.inflation)) < 0.1: calories.append('') else: calories.append(calorie/(4200000*math.sqrt(coin.inflation))) if calorie/(1000000*math.sqrt(coin.inflation)) < 0.1: calories2.append('') else: calories2.append(calorie/(1000000*math.sqrt(coin.inflation))) if 28*calorie/(2500000*math.sqrt(coin.inflation)) < 0.1: calories3.append('') else: calories3.append(28*calorie/(2500000*math.sqrt(coin.inflation))) else: calories.append('') temperature = coin.priceusd/calorie if temperature > 0.000004: temperature = 0.000004 thermocap.append(temperature) supply = coin.supply count += 1 temperature = locale.format('%.2f', temperature, grouping=True) context = {'dates': dates, 'temperature': temperature, 'values': values, 'thermocap': thermocap, 'color': color, 'calories': calories, 'calories2': calories2, 'calories3': calories3} return render(request, 'charts/thermocap.html', context) def sharpe(request): symbol = 'xmr' dates = [] values = [] color = [] rocs = [] sharpe = [] v0 = 0.002 delta = (0.015 - 0.002)/(6*365) count = 0 price = 0 coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: new_color = 30*coin.pricebtc/(count*delta + v0) count += 1 if count % 7 == 0: if price == 0: if coin.priceusd > 0: price = coin.priceusd roc = 0 else: roc = 0 else: roc = (coin.priceusd - price)/price price = coin.priceusd rocs.append(roc) dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d')) values.append(coin.priceusd) color.append(new_color) n = 52 median = pd.Series(rocs).rolling(window=n).mean().iloc[n-1:].values std = pd.Series(rocs).rolling(window=n).std().iloc[n-1:].values aux = list(map(truediv, median, std)) for count in range(51): sharpe.append('') for item in aux: sharpe.append(item*math.sqrt(52)) context = {'dates': dates, 'values': values, 'color': color, 'sharpe': sharpe} return render(request, 'charts/sharpe.html', context) def about(request): context = {} return render(request, 'charts/about.html', context) def transcost(request): data = DailyData.objects.order_by('date') costbtc = [] costxmr = [] dates = [] now_btc = 0 now_xmr = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.xmr_transcostusd == 0: costxmr.append('') else: costxmr.append(item.xmr_transcostusd) now_xmr = item.xmr_transcostusd if item.btc_transcostusd == 0: costbtc.append('') else: costbtc.append(item.btc_transcostusd) now_btc = item.btc_transcostusd now_btc = "$" + locale.format('%.2f', now_btc, grouping=True) now_xmr = "$" + locale.format('%.2f', now_xmr, grouping=True) context = {'costxmr': costxmr, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/transcost.html', context) def transcostntv(request): data = DailyData.objects.order_by('date') costbtc = [] costxmr = [] dates = [] now_btc = 0 now_xmr = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.xmr_transcostntv == 0: costxmr.append('') else: costxmr.append(item.xmr_transcostntv) now_xmr = item.xmr_transcostntv if item.btc_transcostntv == 0: costbtc.append('') else: costbtc.append(item.btc_transcostntv) now_btc = item.btc_transcostntv now_btc = locale.format('%.6f', now_btc, grouping=True) now_xmr = locale.format('%.6f', now_xmr, grouping=True) context = {'costxmr': costxmr, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/transcostntv.html', context) def minerrevcap(request): data = DailyData.objects.order_by('date') costbtc = [] costxmr = [] dates = [] now_btc = 0 now_xmr = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.xmr_minerrevcap == 0: costxmr.append('') else: costxmr.append(item.xmr_minerrevcap) now_xmr = item.xmr_minerrevcap if item.btc_minerrevcap == 0: costbtc.append('') else: costbtc.append(item.btc_minerrevcap) now_btc = item.btc_minerrevcap now_btc = locale.format('%.2f', now_btc, grouping=True) + "%" now_xmr = locale.format('%.2f', now_xmr, grouping=True) + "%" context = {'costxmr': costxmr, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/minerrevcap.html', context) def minerrev(request): data = DailyData.objects.order_by('date') costbtc = [] costxmr = [] dates = [] now_btc = 0 now_xmr = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_minerrevusd < 0.0001: costbtc.append('') else: costbtc.append(item.btc_minerrevusd) now_btc = item.btc_minerrevusd if item.xmr_minerrevusd < 0.0001: costxmr.append('') else: costxmr.append(item.xmr_minerrevusd) now_xmr = item.xmr_minerrevusd now_btc = "$" + locale.format('%.2f', now_btc, grouping=True) now_xmr = "$" + locale.format('%.2f', now_xmr, grouping=True) context = {'costxmr': costxmr, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/minerrev.html', context) def minerrevntv(request): data = DailyData.objects.order_by('date') costbtc = [] costxmr = [] dates = [] now_btc = 0 now_xmr = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_minerrevntv < 0.0001: costbtc.append('') else: costbtc.append(item.btc_minerrevntv) now_btc = item.btc_minerrevntv if item.xmr_minerrevntv < 0.0001: costxmr.append('') else: costxmr.append(item.xmr_minerrevntv) now_xmr = item.xmr_minerrevntv now_btc = locale.format('%.2f', now_btc, grouping=True) now_xmr = locale.format('%.2f', now_xmr, grouping=True) context = {'costxmr': costxmr, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/minerrevntv.html', context) def minerfeesntv(request): data = DailyData.objects.order_by('date') costbtc = [] costxmr = [] dates = [] now_btc = 0 now_xmr = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_minerfeesntv < 0.1: costbtc.append('') else: costbtc.append(item.btc_minerfeesntv) now_btc = item.btc_minerfeesntv if item.xmr_minerfeesntv < 0.1: costxmr.append('') else: costxmr.append(item.xmr_minerfeesntv) now_xmr = item.xmr_minerfeesntv now_btc = locale.format('%.2f', now_btc, grouping=True) now_xmr = locale.format('%.2f', now_xmr, grouping=True) context = {'costxmr': costxmr, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/minerfeesntv.html', context) def minerfees(request): data = DailyData.objects.order_by('date') costbtc = [] costxmr = [] dates = [] now_btc = 0 now_xmr = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_minerfeesusd < 1: costbtc.append('') else: costbtc.append(item.btc_minerfeesusd) now_btc = item.btc_minerfeesusd if item.xmr_minerfeesusd < 1: costxmr.append('') else: costxmr.append(item.xmr_minerfeesusd) now_xmr = item.xmr_minerfeesusd now_btc = locale.format('%.2f', now_btc, grouping=True) now_xmr = locale.format('%.2f', now_xmr, grouping=True) context = {'costxmr': costxmr, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/minerfees.html', context) def dailyemissionntv(request): data = DailyData.objects.order_by('date') emissionbtc = [] emissionxmr = [] dates = [] now_btc = 0 now_xmr = 0 for item in data: if item.btc_emissionntv == 0: emissionbtc.append('') else: emissionbtc.append(item.btc_emissionntv) now_btc = item.btc_emissionntv if item.xmr_emissionntv == 0: emissionxmr.append('') else: emissionxmr.append(item.xmr_emissionntv) now_xmr = item.xmr_emissionntv dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) for i in range(500): date_aux = item.date + timedelta(i) dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d')) emissionxmr.append('') emissionbtc.append('') now_btc = locale.format('%.0f', now_btc, grouping=True) now_xmr = locale.format('%.0f', now_xmr, grouping=True) context = {'emissionxmr': emissionxmr, 'emissionbtc': emissionbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/dailyemissionntv.html', context) def commit(request): data = DailyData.objects.order_by('date') costbtc = [] costxmr = [] dates = [] now_btc = 0 now_xmr = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_commitusd < 0.000001: costbtc.append('') else: costbtc.append(item.btc_commitusd) now_btc = item.btc_commitusd if item.xmr_commitusd < 0.000001: costxmr.append('') else: costxmr.append(item.xmr_commitusd) now_xmr = item.xmr_commitusd now_btc = locale.format('%.2f', now_btc, grouping=True) + " hashs / dollar" now_xmr = locale.format('%.2f', now_xmr, grouping=True) + " hashs / dollar" context = {'costxmr': costxmr, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/commit.html', context) def commitntv(request): data = DailyData.objects.order_by('date') costbtc = [] costxmr = [] dates = [] now_btc = 0 now_xmr = 0 for item in data: dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.btc_commitntv < 0.00001: costbtc.append('') else: costbtc.append(item.btc_commitntv) now_btc = item.btc_commitntv if item.xmr_commitntv < 0.00001: costxmr.append('') else: costxmr.append(item.xmr_commitntv) now_xmr = item.xmr_commitntv now_btc = locale.format('%.0f', now_btc, grouping=True) + " hashs / btc" now_xmr = locale.format('%.0f', now_xmr, grouping=True) + " hashs / xmr" context = {'costxmr': costxmr, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates} return render(request, 'charts/commitntv.html', context) def competitorssats(request): dates = [] xmr = [] dash = [] grin = [] zcash = [] count = 0 now_xmr = 0 now_dash = 0 now_grin = 0 now_zcash = 0 count = 0 coins_xmr = Coin.objects.order_by('date').filter(name='xmr') for coin_xmr in coins_xmr: if coin_xmr.pricebtc: if count > 32: xmr.append(coin_xmr.pricebtc/0.0058) now_xmr = coin_xmr.pricebtc/0.0058 dates.append(count) count += 1 elif count <= 63: continue else: xmr.append('') count = 0 coins_dash = Coin.objects.order_by('date').filter(name='dash') for coin_dash in coins_dash: count += 1 if coin_dash.pricebtc and count > 130: dash.append(coin_dash.pricebtc/0.02) now_dash = coin_dash.pricebtc/0.02 elif count <= 130: continue else: dash.append('') dates.append(count) count = 0 coins_grin = Coin.objects.order_by('date').filter(name='grin') for coin_grin in coins_grin: count += 1 if coin_grin.pricebtc and count > 155: grin.append(coin_grin.pricebtc/0.000513) now_grin = coin_grin.pricebtc/0.000513 elif count <= 155: continue else: grin.append('') dates.append(count) count = 0 coins_zcash = Coin.objects.order_by('date').filter(name='zec') for coin_zcash in coins_zcash: count += 1 if coin_zcash.pricebtc and count > 434: zcash.append(coin_zcash.pricebtc/0.05) now_zcash = coin_zcash.pricebtc/0.05 elif count <= 434: continue else: zcash.append('') dates.append(count) now_dash = locale.format('%.3f', now_dash, grouping=True) now_grin = locale.format('%.3f', now_grin, grouping=True) now_zcash = locale.format('%.3f', now_zcash, grouping=True) now_xmr = locale.format('%.3f', now_xmr, grouping=True) context = {'xmr': xmr, 'dash': dash, 'grin': grin, 'zcash': zcash, 'now_xmr': now_xmr, 'now_dash': now_dash, 'now_grin': now_grin, 'now_zcash': now_zcash, 'dates': dates} return render(request, 'charts/competitorssats.html', context) def competitorssatslin(request): dates = [] xmr = [] dash = [] grin = [] zcash = [] count = 0 now_xmr = 0 now_dash = 0 now_grin = 0 now_zcash = 0 count = 0 coins_xmr = Coin.objects.order_by('date').filter(name='xmr') for coin_xmr in coins_xmr: if coin_xmr.pricebtc: if count > 32: xmr.append(coin_xmr.pricebtc/0.0058) now_xmr = coin_xmr.pricebtc/0.0058 dates.append(count) count += 1 elif count <= 63: continue else: xmr.append('') count = 0 coins_dash = Coin.objects.order_by('date').filter(name='dash') for coin_dash in coins_dash: count += 1 if coin_dash.pricebtc and count > 130: dash.append(coin_dash.pricebtc/0.02) now_dash = coin_dash.pricebtc/0.02 elif count <= 130: continue else: dash.append('') dates.append(count) count = 0 coins_grin = Coin.objects.order_by('date').filter(name='grin') for coin_grin in coins_grin: count += 1 if coin_grin.pricebtc and count > 155: grin.append(coin_grin.pricebtc/0.000513) now_grin = coin_grin.pricebtc/0.000513 elif count <= 155: continue else: grin.append('') dates.append(count) count = 0 coins_zcash = Coin.objects.order_by('date').filter(name='zec') for coin_zcash in coins_zcash: count += 1 if coin_zcash.pricebtc and count > 434: zcash.append(coin_zcash.pricebtc/0.05) now_zcash = coin_zcash.pricebtc/0.05 elif count <= 434: continue else: zcash.append('') dates.append(count) now_dash = locale.format('%.3f', now_dash, grouping=True) now_grin = locale.format('%.3f', now_grin, grouping=True) now_zcash = locale.format('%.3f', now_zcash, grouping=True) now_xmr = locale.format('%.3f', now_xmr, grouping=True) context = {'xmr': xmr, 'dash': dash, 'grin': grin, 'zcash': zcash, 'now_xmr': now_xmr, 'now_dash': now_dash, 'now_grin': now_grin, 'now_zcash': now_zcash, 'dates': dates} return render(request, 'charts/competitorssatslin.html', context) def dread_subscribers(request): dates = [] data1 = [] data2 = [] now_xmr = 0 now_btc = 0 gc = pygsheets.authorize(service_file='service_account_credentials.json') sh = gc.open('zcash_bitcoin') wks = sh.worksheet_by_title('Sheet6') values_mat = wks.get_values(start=(3,1), end=(99,3), returnas='matrix') for k in range(0,len(values_mat)): if values_mat[k][0] and values_mat[k][2]: date = values_mat[k][0] value1 = values_mat[k][1] value2 = values_mat[k][2] if not(value1) or not(value2): break else: dates.append(date) data1.append(int(value1)) data2.append(int(value2)) now_xmr = int(value2) now_btc = int(value1) else: break dominance = 100*int(value2)/(int(value2)+int(value1)) now_btc = locale.format('%.0f', now_btc, grouping=True) now_xmr = locale.format('%.0f', now_xmr, grouping=True) dominance = locale.format('%.2f', dominance, grouping=True) context = {'dates': dates, 'now_btc': now_btc, 'now_xmr': now_xmr, 'data1': data1, "data2": data2, "dominance": dominance} return render(request, 'charts/dread_subscribers.html', context) def coincards(request): dates = [] data1 = [] data2 = [] data3 = [] data4 = [] now_xmr = 0 now_btc = 0 gc = pygsheets.authorize(service_file='service_account_credentials.json') sh = gc.open('zcash_bitcoin') wks = sh.worksheet_by_title('Sheet2') values_mat = wks.get_values(start=(3,1), end=(99,5), returnas='matrix') for k in range(0,len(values_mat)): if values_mat[k][0] and values_mat[k][2]: date = values_mat[k][0] value1 = values_mat[k][1] value2 = values_mat[k][2] value3 = values_mat[k][3] value4 = values_mat[k][4] if not(value1) or not(value2) or not(value3) or not(value4): break else: dates.append(date) data1.append(float(value1.replace(',','.'))) data2.append(float(value2.replace(',','.'))) data3.append(float(value3.replace(',','.'))) data4.append(float(value4.replace(',','.'))) now_btc = float(value1.replace(',','.')) now_xmr = float(value2.replace(',','.')) now_eth = float(value3.replace(',','.')) now_others = float(value4.replace(',','.')) else: break now_btc = locale.format('%.1f', now_btc, grouping=True) now_xmr = locale.format('%.1f', now_xmr, grouping=True) now_eth = locale.format('%.1f', now_eth, grouping=True) now_others = locale.format('%.1f', now_others, grouping=True) context = {'dates': dates, 'now_btc': now_btc, 'now_xmr': now_xmr, 'now_eth': now_eth, 'now_others': now_others, 'data1': data1, "data2": data2, "data3": data3, "data4": data4} return render(request, 'charts/coincards.html', context) def merchants(request): dates = [] data1 = [] data2 = [] data3 = [] data4 = [] data5 = [] data6 = [] data7 = [] now_xmr = 0 now_btc = 0 now_eth = 0 gc = pygsheets.authorize(service_file='service_account_credentials.json') sh = gc.open('zcash_bitcoin') wks = sh.worksheet_by_title('Sheet3') values_mat = wks.get_values(start=(3,1), end=(99,8), returnas='matrix') for k in range(0,len(values_mat)): if values_mat[k][0] and values_mat[k][2]: date = values_mat[k][0] value1 = values_mat[k][1] value2 = values_mat[k][2] value3 = values_mat[k][3] value4 = values_mat[k][4] value5 = values_mat[k][5] value6 = values_mat[k][6] value7 = values_mat[k][7] if not(value1) or not(value2) or not(value3) or not(value4) or not(value5) or not(value6) or not(value7): break else: dates.append(date) data1.append(int(value1)) data2.append(int(value2)) data3.append(int(value3)) data4.append(int(value4)) data5.append(int(value5)) data6.append(int(value6)) data7.append(int(value7)) now_btc = int(value1) now_xmr = int(value2) now_eth = int(value3) else: break now_btc = locale.format('%.0f', now_btc, grouping=True) now_xmr = locale.format('%.0f', now_xmr, grouping=True) now_eth = locale.format('%.0f', now_eth, grouping=True) context = {'dates': dates, 'now_btc': now_btc, 'now_xmr': now_xmr, 'now_eth': now_eth, 'data1': data1, "data2": data2, "data3": data3, "data4": data4, "data5": data5, "data6": data6, "data7": data7} return render(request, 'charts/merchants.html', context) def merchants_increase(request): dates = [] data1 = [] data2 = [] data3 = [] data4 = [] data5 = [] data6 = [] data7 = [] now_xmr = 0 now_btc = 0 now_eth = 0 gc = pygsheets.authorize(service_file='service_account_credentials.json') sh = gc.open('zcash_bitcoin') wks = sh.worksheet_by_title('Sheet4') values_mat = wks.get_values(start=(3,1), end=(99,8), returnas='matrix') for k in range(0,len(values_mat)): if values_mat[k][0] and values_mat[k][2]: date = values_mat[k][0] value1 = values_mat[k][1] value2 = values_mat[k][2] value3 = values_mat[k][3] value4 = values_mat[k][4] value5 = values_mat[k][5] value6 = values_mat[k][6] value7 = values_mat[k][7] if not(value1) or not(value2) or not(value3) or not(value4) or not(value5) or not(value6) or not(value7): break else: dates.append(date) data1.append(int(value1)) data2.append(int(value2)) data3.append(int(value3)) data4.append(int(value4)) data5.append(int(value5)) data6.append(int(value6)) data7.append(int(value7)) now_btc = int(value1) now_xmr = int(value2) now_eth = int(value3) else: break now_btc = locale.format('%.0f', now_btc, grouping=True) now_xmr = locale.format('%.0f', now_xmr, grouping=True) now_eth = locale.format('%.0f', now_eth, grouping=True) context = {'dates': dates, 'now_btc': now_btc, 'now_xmr': now_xmr, 'now_eth': now_eth, 'data1': data1, "data2": data2, "data3": data3, "data4": data4, "data5": data5, "data6": data6, "data7": data7} return render(request, 'charts/merchants_increase.html', context) def merchants_percentage(request): dates = [] data1 = [] data2 = [] data3 = [] data4 = [] data5 = [] data6 = [] data7 = [] now_xmr = 0 now_btc = 0 now_eth = 0 gc = pygsheets.authorize(service_file='service_account_credentials.json') sh = gc.open('zcash_bitcoin') wks = sh.worksheet_by_title('Sheet5') values_mat = wks.get_values(start=(3,1), end=(99,8), returnas='matrix') for k in range(0,len(values_mat)): if values_mat[k][0] and values_mat[k][2]: date = values_mat[k][0] value1 = values_mat[k][1] value2 = values_mat[k][2] value3 = values_mat[k][3] value4 = values_mat[k][4] value5 = values_mat[k][5] value6 = values_mat[k][6] value7 = values_mat[k][7] if not(value1) or not(value2) or not(value3) or not(value4) or not(value5) or not(value6) or not(value7): break else: dates.append(date) data1.append(float(value1.replace(',', '.'))) data2.append(float(value2.replace(',', '.'))) data3.append(float(value3.replace(',', '.'))) data4.append(float(value4.replace(',', '.'))) data5.append(float(value5.replace(',', '.'))) data6.append(float(value6.replace(',', '.'))) data7.append(float(value7.replace(',', '.'))) now_btc = float(value1.replace(',', '.')) now_xmr = float(value2.replace(',', '.')) now_eth = float(value3.replace(',', '.')) else: break now_btc = locale.format('%.1f', now_btc, grouping=True) now_xmr = locale.format('%.1f', now_xmr, grouping=True) now_eth = locale.format('%.1f', now_eth, grouping=True) context = {'dates': dates, 'now_btc': now_btc, 'now_xmr': now_xmr, 'now_eth': now_eth, 'data1': data1, "data2": data2, "data3": data3, "data4": data4, "data5": data5, "data6": data6, "data7": data7} return render(request, 'charts/merchants_percentage.html', context) def dominance(request): symbol = 'xmr' values = [] pricexmr = [] dates = [] now_value = 0 maximum = 0 coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: try: dominance = Dominance.objects.get(date=coin.date) if dominance.dominance > 0: values.append(dominance.dominance) now_value = dominance.dominance if now_value > maximum: maximum = now_value else: values.append('') except: values.append('') if coin.priceusd > 0.001: pricexmr.append(coin.priceusd) else: pricexmr.append('') coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d') dates.append(coin.date) yesterday = date.today() - timedelta(1) yesterday = datetime.datetime.strftime(yesterday, '%Y-%m-%d') if coin.date == yesterday: today = date.today() today = datetime.datetime.strftime(today, '%Y-%m-%d') try: dominance = list(Dominance.objects.order_by('-date'))[0] if str(dominance.date) == str(today): now_value = dominance.dominance dates.append(today) values.append(now_value) if now_value > maximum: maximum = now_value except: pass now_value = locale.format('%.2f', now_value, grouping=True) maximum = locale.format('%.2f', maximum, grouping=True) context = {'values': values, 'dates': dates, 'maximum': maximum, 'now_value': now_value, 'pricexmr': pricexmr} return render(request, 'charts/dominance.html', context) def rank(request): symbol = 'xmr' values = [] pricexmr = [] dates = [] now_value = 25 maximum = 100 coins = Coin.objects.order_by('date').filter(name=symbol) for coin in coins: try: rank = Rank.objects.get(date=coin.date) if rank.rank > 0: values.append(rank.rank) now_value = rank.rank if now_value < maximum: maximum = now_value else: values.append(now_value) except: values.append(now_value) if coin.priceusd > 0.001: pricexmr.append(coin.priceusd) else: pricexmr.append('') coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d') dates.append(coin.date) yesterday = date.today() - timedelta(1) yesterday = datetime.datetime.strftime(yesterday, '%Y-%m-%d') if coin.date == yesterday: today = date.today() today = datetime.datetime.strftime(today, '%Y-%m-%d') try: rank = list(Rank.objects.order_by('-date'))[0] if str(rank.date) == str(today): now_value = rank.rank dates.append(today) values.append(now_value) if now_value < maximum: maximum = now_value except: pass if now_value == 1: now_value = locale.format('%.0f', now_value, grouping=True) + 'st' if now_value == 2: now_value = locale.format('%.0f', now_value, grouping=True) + 'nd' if now_value == 3: now_value = locale.format('%.0f', now_value, grouping=True) + 'rd' if now_value > 3: now_value = locale.format('%.0f', now_value, grouping=True) + 'th' if maximum == 1: maximum = locale.format('%.0f', maximum, grouping=True) + 'st' if maximum == 2: maximum = locale.format('%.0f', maximum, grouping=True) + 'nd' if maximum == 3: maximum = locale.format('%.0f', maximum, grouping=True) + 'rd' if maximum > 3: maximum = locale.format('%.0f', maximum, grouping=True) + 'th' context = {'values': values, 'dates': dates, 'maximum': maximum, 'now_value': now_value, 'pricexmr': pricexmr} return render(request, 'charts/rank.html', context) def p2pool_hashrate(request): hashrate = [] hashrate_mini = [] combined = [] dates = [] now_hashrate = 0 now_hashrate_mini = 0 now_combined = 0 p2pool_stats = P2Pool.objects.order_by('date').filter(mini=False) for p2pool_stat in p2pool_stats: now_combined = 0 if p2pool_stat.hashrate and p2pool_stat.percentage > 0: now_hashrate = p2pool_stat.hashrate/1000000 now_combined = p2pool_stat.hashrate/1000000 hashrate.append(now_hashrate) try: p2pool_stat_mini = P2Pool.objects.filter(mini=True).get(date=p2pool_stat.date) if p2pool_stat_mini.hashrate and p2pool_stat_mini.percentage > 0: now_hashrate_mini = p2pool_stat_mini.hashrate/1000000 now_combined += p2pool_stat_mini.hashrate/1000000 except: pass hashrate_mini.append(now_hashrate_mini) combined.append(now_combined) dates.append(datetime.datetime.strftime(p2pool_stat.date, '%Y-%m-%d')) context = {'hashrate': hashrate, 'dates': dates, 'hashrate_mini': hashrate_mini, 'combined': combined} return render(request, 'charts/p2pool_hashrate.html', context) def p2pool_dominance(request): dominance = [] dominance_mini = [] dates = [] combined = [] now_dominance = 0 now_dominance_mini = 0 p2pool_stats = P2Pool.objects.order_by('date').filter(mini=False) for p2pool_stat in p2pool_stats: now_combined = 0 if p2pool_stat.hashrate and p2pool_stat.percentage > 0: now_dominance = p2pool_stat.percentage now_combined += p2pool_stat.percentage dominance.append(now_dominance) try: p2pool_stat_mini = P2Pool.objects.filter(mini=True).get(date=p2pool_stat.date) if p2pool_stat_mini.hashrate and p2pool_stat_mini.percentage > 0: now_dominance_mini = p2pool_stat_mini.percentage now_combined += p2pool_stat_mini.percentage except: pass dominance_mini.append(now_dominance_mini) combined.append(now_combined) dates.append(datetime.datetime.strftime(p2pool_stat.date, '%Y-%m-%d')) context = {'dominance': dominance, 'dates': dates, 'dominance_mini': dominance_mini,'combined': combined} return render(request, 'charts/p2pool_dominance.html', context) def p2pool_totalblocks(request): dates = [] totalblocks = [] totalblocks_mini = [] combined = [] now_totalblocks = 0 now_totalblocks_mini = 0 now_combined = 0 p2pool_stats = P2Pool.objects.order_by('date').filter(mini=False) for p2pool_stat in p2pool_stats: now_combined = 0 if p2pool_stat.totalblocksfound > now_totalblocks: now_totalblocks = p2pool_stat.totalblocksfound now_combined += p2pool_stat.totalblocksfound totalblocks.append(now_totalblocks) p2pool_stats_mini = P2Pool.objects.filter(mini=True).filter(date=p2pool_stat.date) for p2pool_stat_mini in p2pool_stats_mini: if p2pool_stat_mini.totalblocksfound >= now_totalblocks_mini: now_totalblocks_mini = p2pool_stat_mini.totalblocksfound now_combined += p2pool_stat_mini.totalblocksfound break totalblocks_mini.append(now_totalblocks_mini) combined.append(now_combined) dates.append(datetime.datetime.strftime(p2pool_stat.date, '%Y-%m-%d')) context = {'totalblocks': totalblocks, 'totalblocks_mini': totalblocks_mini, 'dates': dates, 'combined': combined} return render(request, 'charts/p2pool_totalblocks.html', context) def p2pool_totalhashes(request): dates = [] totalblocks = [] totalblocks_mini = [] combined = [] now_totalblocks = 0 now_totalblocks_mini = 0 now_combined = 0 p2pool_stats = P2Pool.objects.order_by('date').filter(mini=False) for p2pool_stat in p2pool_stats: now_combined = 0 if p2pool_stat.totalhashes > now_totalblocks: now_totalblocks = p2pool_stat.totalhashes/1000000000000 now_combined += p2pool_stat.totalhashes/1000000000000 totalblocks.append(now_totalblocks) try: p2pool_stat_mini = P2Pool.objects.filter(mini=True).get(date=p2pool_stat.date) if p2pool_stat_mini.totalhashes >= now_totalblocks_mini: now_totalblocks_mini = p2pool_stat_mini.totalhashes/1000000000000 now_combined += p2pool_stat_mini.totalhashes/1000000000000 except: pass totalblocks_mini.append(now_totalblocks_mini) combined.append(now_combined) dates.append(datetime.datetime.strftime(p2pool_stat.date, '%Y-%m-%d')) context = {'totalblocks': totalblocks, 'totalblocks_mini': totalblocks_mini, 'dates': dates, 'combined': combined} return render(request, 'charts/p2pool_totalhashes.html', context) def p2pool_miners(request): miners = [] miners_mini = [] dates = [] combined = [] now_miners = 0 now_miners_mini = 0 p2pool_stats = P2Pool.objects.order_by('date').filter(mini=False) for p2pool_stat in p2pool_stats: now_combined = 0 if p2pool_stat.miners > 0: now_miners = p2pool_stat.miners now_combined += p2pool_stat.miners miners.append(now_miners) try: p2pool_stat_mini = P2Pool.objects.filter(mini=True).get(date=p2pool_stat.date) if p2pool_stat_mini.miners > 0: now_miners_mini = p2pool_stat_mini.miners now_combined += p2pool_stat_mini.miners except: pass miners_mini.append(now_miners_mini) combined.append(now_combined) dates.append(datetime.datetime.strftime(p2pool_stat.date, '%Y-%m-%d')) context = {'miners': miners, 'dates': dates, 'miners_mini': miners_mini, 'combined': combined} return render(request, 'charts/p2pool_miners.html', context) def miningprofitability(request): dates = [] value = [] now_value = 0 coins = Coin.objects.order_by('date').filter(name='xmr') for coin in coins: if coin.hashrate > 0 and coin.priceusd > 0 and coin.revenue > 0: if 1000*coin.priceusd*coin.revenue/coin.hashrate < 5000: now_value = 1000*coin.priceusd*coin.revenue/coin.hashrate dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d')) value.append(now_value) context = {'value': value, 'dates': dates} return render(request, 'charts/miningprofitability.html', context) def tail_emission(request): inflationxmr = [] finflationxmr = [] dates = [] now_xmr = 999999 coins = Coin.objects.order_by('date').filter(name='xmr') for coin in coins: now_xmr = float(coin.inflation) supply = int(coin.supply)*10**12 for i in range(210000): supply = int(supply) reward = (2**64 -1 - supply) >> 19 if reward < 0.6*(10**12): reward = 0.6*(10**12) supply += int(720*reward) finflationxmr.append(100*reward*720*365/supply) date_aux = coin.date + timedelta(i) dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d')) now_xmr = locale.format('%.2f', now_xmr, grouping=True) + '%' context = {'inflationxmr': inflationxmr, 'finflationxmr': finflationxmr, 'now_xmr': now_xmr, 'dates': dates} return render(request, 'charts/tail_emission.html', context) def privacymarketcap(request): data = DailyData.objects.order_by('date') dates = [] marketcaps = [] xmr_marketcaps = [] now_marketcap = 0 now_dominance = 0 top_marketcap = 0 top_dominance = 0 for item in data: marketcap = 0 dominance = 0 dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.zcash_marketcap > 1000000: marketcap += item.zcash_marketcap if item.dash_marketcap > 1000000: marketcap += item.dash_marketcap if item.grin_marketcap > 1000000: marketcap += item.grin_marketcap if item.xmr_marketcap > 1000000: marketcap += item.xmr_marketcap try: xmr_dominance = Dominance.objects.get(date=item.date) dominance = marketcap*xmr_dominance.dominance/item.xmr_marketcap except: dominance = now_dominance xmr_marketcaps.append(item.xmr_marketcap) else: xmr_marketcaps.append('') now_marketcap = marketcap now_dominance = dominance if now_marketcap > top_marketcap: top_marketcap = now_marketcap if now_dominance > top_dominance: top_dominance = now_dominance if marketcap > 3000000: marketcaps.append(marketcap) else: marketcaps.append('') now_marketcap = '$'+locale.format('%.0f', now_marketcap, grouping=True) now_dominance = locale.format('%.2f', now_dominance, grouping=True) + '%' top_marketcap = '$'+locale.format('%.0f', top_marketcap, grouping=True) top_dominance = locale.format('%.2f', top_dominance, grouping=True) + '%' context = {'marketcaps': marketcaps, 'now_marketcap': now_marketcap, 'now_dominance': now_dominance, 'top_marketcap': top_marketcap, 'top_dominance': top_dominance, 'dates': dates, 'xmr_marketcaps': xmr_marketcaps} return render(request, 'charts/privacymarketcap.html', context) def privacydominance(request): data = DailyData.objects.order_by('date') dates = [] marketcaps = [] dominances = [] now_marketcap = 0 now_dominance = 0 top_marketcap = 0 top_dominance = 0 for item in data: marketcap = 0 dominance = 0 dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.zcash_marketcap > 100000: marketcap += item.zcash_marketcap if item.dash_marketcap > 100000: marketcap += item.dash_marketcap if item.grin_marketcap > 100000: marketcap += item.grin_marketcap if item.xmr_marketcap > 100000: marketcap += item.xmr_marketcap try: xmr_dominance = Dominance.objects.get(date=item.date) dominance = marketcap*xmr_dominance.dominance/item.xmr_marketcap except: dominance = now_dominance now_marketcap = marketcap now_dominance = dominance if now_marketcap > top_marketcap: top_marketcap = now_marketcap if now_dominance > top_dominance: top_dominance = now_dominance if marketcap > 300000: marketcaps.append(marketcap) else: marketcaps.append('') if dominance > 0: dominances.append(dominance) else: dominances.append('') now_marketcap = '$'+locale.format('%.0f', now_marketcap, grouping=True) now_dominance = locale.format('%.2f', now_dominance, grouping=True) + '%' top_marketcap = '$'+locale.format('%.0f', top_marketcap, grouping=True) top_dominance = locale.format('%.2f', top_dominance, grouping=True) + '%' context = {'marketcaps': marketcaps, 'dominances':dominances, 'now_marketcap': now_marketcap, 'now_dominance': now_dominance, 'top_marketcap': top_marketcap, 'top_dominance': top_dominance, 'dates': dates} return render(request, 'charts/privacydominance.html', context) def monerodominance(request): data = DailyData.objects.order_by('date') dates = [] marketcaps = [] xmr_dominance = [] now_marketcap = 0 now_dominance = 0 top_marketcap = 0 top_dominance = 0 zec_cap = 0 dash_cap = 0 grin_cap = 0 for item in data: marketcap = 0 dominance = 0 dates.append(datetime.datetime.strftime(item.date, '%Y-%m-%d')) if item.zcash_marketcap > 1000000: zec_cap = item.zcash_marketcap marketcap += zec_cap else: marketcap += zec_cap if item.dash_marketcap > 1000000: dash_cap = item.dash_marketcap marketcap += dash_cap else: marketcap += dash_cap if item.grin_marketcap > 1000000: grin_cap = item.grin_marketcap marketcap += grin_cap else: marketcap += grin_cap if item.xmr_marketcap > 1000000: marketcap += item.xmr_marketcap dominance = 100*item.xmr_marketcap/marketcap now_marketcap = marketcap now_dominance = dominance if now_marketcap > top_marketcap: top_marketcap = now_marketcap if now_dominance > top_dominance: top_dominance = now_dominance if marketcap > 3000000: marketcaps.append(marketcap) else: marketcaps.append('') if dominance > 0: xmr_dominance.append(dominance) else: xmr_dominance.append('') now_marketcap = '$'+locale.format('%.0f', now_marketcap, grouping=True) now_dominance = locale.format('%.2f', now_dominance, grouping=True) + '%' top_marketcap = '$'+locale.format('%.0f', top_marketcap, grouping=True) top_dominance = locale.format('%.2f', top_dominance, grouping=True) + '%' context = {'marketcaps': marketcaps, 'xmr_dominance': xmr_dominance, 'now_marketcap': now_marketcap, 'now_dominance': now_dominance, 'top_marketcap': top_marketcap, 'top_dominance': top_dominance, 'dates': dates} return render(request, 'charts/monerodominance.html', context) def withdrawals(request): states = [] dates = [] withdrawals = Withdrawal.objects.order_by('date') for withdrawal in withdrawals: dates.append(datetime.datetime.strftime(withdrawal.date, '%Y-%m-%d %H')) if withdrawal.state: states.append(1) else: states.append(0) context = {'states': states, 'dates': dates} return render(request, 'charts/withdrawals.html', context)