Kumi
b80cba1d1f
Some checks failed
Docker / build (push) Has been cancelled
Updated the log messages within the `update_p2pool` function to use consistent, English-language messages. This improves readability and consistency across logging outputs. No functional behavior was altered.
970 lines
34 KiB
Python
970 lines
34 KiB
Python
import pandas as pd
|
|
import json
|
|
import requests
|
|
import datetime
|
|
from datetime import date, timedelta
|
|
from .models import (
|
|
Coin,
|
|
Social,
|
|
P2Pool,
|
|
Dominance,
|
|
Rank,
|
|
Sfmodel,
|
|
DailyData,
|
|
Withdrawal,
|
|
)
|
|
from requests import Session
|
|
from requests.exceptions import ConnectionError, Timeout, TooManyRedirects
|
|
import pytz
|
|
from django.conf import settings
|
|
|
|
DATA_FILE = settings.DATA_FILE
|
|
BASE_DIR = settings.BASE_DIR
|
|
|
|
####################################################################################
|
|
# Reddit api
|
|
####################################################################################
|
|
# TODO: Fix this...
|
|
# api = PushshiftAPI() # When it's working
|
|
api = False # When it's not
|
|
|
|
|
|
# Get daily post on Reddit
|
|
def data_prep_posts(subreddit, start_time, end_time, filters, limit):
|
|
if len(filters) == 0:
|
|
filters = [
|
|
"id",
|
|
"author",
|
|
"created_utc",
|
|
"domain",
|
|
"url",
|
|
"title",
|
|
"num_comments",
|
|
]
|
|
|
|
if api:
|
|
posts = list(
|
|
api.search_submissions(
|
|
subreddit=subreddit,
|
|
after=start_time,
|
|
before=end_time,
|
|
filter=filters,
|
|
limit=limit,
|
|
)
|
|
)
|
|
return pd.DataFrame(posts)
|
|
return 0
|
|
|
|
|
|
# Get daily comments on Reddit
|
|
def data_prep_comments(term, start_time, end_time, filters, limit):
|
|
if len(filters) == 0:
|
|
filters = ["id", "author", "created_utc", "body", "permalink", "subreddit"]
|
|
|
|
if api:
|
|
comments = list(
|
|
api.search_comments(
|
|
q=term, after=start_time, before=end_time, filter=filters, limit=limit
|
|
)
|
|
)
|
|
return pd.DataFrame(comments)
|
|
return 0
|
|
|
|
|
|
####################################################################################
|
|
# Other useful functions
|
|
####################################################################################
|
|
# Get data from a coin
|
|
def get_history_function(symbol, start_time=None, end_time=None):
|
|
update = True
|
|
count = 0
|
|
priceusd = 0
|
|
inflation = 0
|
|
pricebtc = 0
|
|
stocktoflow = 0
|
|
supply = 0
|
|
fee = 0
|
|
revenue = 0
|
|
hashrate = 0
|
|
transactions = 0
|
|
blocksize = 0
|
|
difficulty = 0
|
|
|
|
with open(BASE_DIR / "settings.json") as file:
|
|
data = json.load(file)
|
|
file.close()
|
|
|
|
if not (start_time and end_time):
|
|
start_time = "2000-01-01"
|
|
end_time = "2100-01-01"
|
|
|
|
url = (
|
|
data["metrics_provider"][0]["metrics_url_new"]
|
|
+ symbol
|
|
+ "/"
|
|
+ start_time
|
|
+ "/"
|
|
+ end_time
|
|
)
|
|
print(url)
|
|
|
|
coins = Coin.objects.filter(name=symbol).order_by("-date")
|
|
for coin in coins:
|
|
if coin.supply > 0:
|
|
supply = coin.supply
|
|
break
|
|
for coin in coins:
|
|
if coin.inflation > 0:
|
|
inflation = coin.inflation
|
|
break
|
|
for coin in coins:
|
|
if coin.hashrate > 0:
|
|
hashrate = coin.hashrate
|
|
break
|
|
for coin in coins:
|
|
if coin.transactions > 0:
|
|
transactions = coin.transactions
|
|
break
|
|
for coin in coins:
|
|
if coin.priceusd > 0:
|
|
priceusd = coin.priceusd
|
|
break
|
|
|
|
while update:
|
|
response = requests.get(url)
|
|
data_aux = json.loads(response.text)
|
|
data_aux2 = data_aux["data"]
|
|
for item in data_aux2:
|
|
day, hour = str(item["time"]).split("T")
|
|
day = datetime.datetime.strptime(day, "%Y-%m-%d")
|
|
day = datetime.datetime.strftime(day, "%Y-%m-%d")
|
|
coin = Coin.objects.filter(name=symbol).filter(date=day)
|
|
if coin:
|
|
coin.delete()
|
|
try:
|
|
coin = Coin()
|
|
coin.name = symbol
|
|
coin.date = day
|
|
try:
|
|
coin.priceusd = float(item["PriceUSD"])
|
|
priceusd = coin.priceusd
|
|
except (ValueError, KeyError, TypeError):
|
|
coin.priceusd = priceusd
|
|
try:
|
|
coin.pricebtc = float(item["PriceBTC"])
|
|
pricebtc = coin.pricebtc
|
|
except (ValueError, KeyError, TypeError):
|
|
coin.pricebtc = pricebtc
|
|
try:
|
|
coin.inflation = float(item["IssContPctAnn"])
|
|
coin.stocktoflow = (100 / coin.inflation) ** 1.65
|
|
inflation = coin.inflation
|
|
stocktoflow = coin.stocktoflow
|
|
except (ValueError, KeyError, TypeError):
|
|
coin.inflation = inflation
|
|
coin.stocktoflow = stocktoflow
|
|
try:
|
|
if symbol == "xmr":
|
|
if float(item["SplyCur"]) < 18000000:
|
|
coin.supply = float(item["SplyCur"]) + 497108
|
|
else:
|
|
coin.supply = float(item["SplyCur"])
|
|
supply = coin.supply
|
|
else:
|
|
coin.supply = float(item["SplyCur"])
|
|
supply = coin.supply
|
|
except (ValueError, KeyError, TypeError):
|
|
coin.supply = supply
|
|
try:
|
|
coin.fee = float(item["FeeTotNtv"])
|
|
fee = coin.fee
|
|
except (ValueError, KeyError, TypeError):
|
|
coin.fee = fee
|
|
try:
|
|
coin.revenue = float(item["RevNtv"])
|
|
revenue = coin.revenue
|
|
except (ValueError, KeyError, TypeError):
|
|
coin.revenue = revenue
|
|
try:
|
|
coin.hashrate = float(item["HashRate"])
|
|
hashrate = coin.hashrate
|
|
except (ValueError, KeyError, TypeError):
|
|
coin.hashrate = hashrate
|
|
try:
|
|
coin.transactions = float(item["TxCnt"])
|
|
transactions = coin.transactions
|
|
except (ValueError, KeyError, TypeError):
|
|
coin.transactions = transactions
|
|
try:
|
|
coin.blocksize = float(item["BlkSizeMeanByte"])
|
|
blocksize = coin.blocksize
|
|
except (ValueError, KeyError, TypeError):
|
|
coin.blocksize = blocksize
|
|
try:
|
|
coin.difficulty = float(item["DiffLast"])
|
|
difficulty = coin.difficulty
|
|
except (ValueError, KeyError, TypeError):
|
|
coin.difficulty = difficulty
|
|
coin.save()
|
|
count += 1
|
|
print(coin.name + " " + str(coin.date) + " " + str(item["SplyCur"]))
|
|
|
|
except (ValueError, KeyError, TypeError):
|
|
pass
|
|
try:
|
|
url = (
|
|
data["metrics_provider"][0]["metrics_url_new"]
|
|
+ symbol
|
|
+ "/"
|
|
+ start_time
|
|
+ "/"
|
|
+ end_time
|
|
+ "/"
|
|
+ data_aux["next_page_token"]
|
|
)
|
|
except (ValueError, KeyError):
|
|
update = False
|
|
break
|
|
return count
|
|
|
|
|
|
# Get most recent metrics from a data provider of your choice for 'symbol'
|
|
def get_latest_metrics(symbol, url):
|
|
update = True
|
|
count = 0
|
|
|
|
while update:
|
|
response = requests.get(url)
|
|
data = json.loads(response.text)
|
|
data_aux = data["data"]
|
|
for item in data_aux:
|
|
day, hour = str(item["time"]).split("T")
|
|
day = datetime.datetime.strptime(day, "%Y-%m-%d")
|
|
day = datetime.datetime.strftime(day, "%Y-%m-%d")
|
|
try:
|
|
coin = Coin.objects.filter(name=symbol).get(date=day)
|
|
except Coin.DoesNotExist:
|
|
coin = Coin()
|
|
|
|
try:
|
|
coin.name = symbol
|
|
coin.date = day
|
|
try:
|
|
coin.priceusd = float(item["PriceUSD"])
|
|
except (ValueError, KeyError):
|
|
coin.priceusd = 0
|
|
try:
|
|
coin.pricebtc = float(item["PriceBTC"])
|
|
except (ValueError, KeyError):
|
|
coin.pricebtc = 0
|
|
try:
|
|
coin.inflation = float(item["IssContPctAnn"])
|
|
coin.stocktoflow = (100 / coin.inflation) ** 1.65
|
|
except (ValueError, KeyError):
|
|
coin.inflation = 0
|
|
coin.stocktoflow = 0
|
|
try:
|
|
coin.supply = float(item["SplyCur"])
|
|
except (ValueError, KeyError):
|
|
coin.supply = 0
|
|
try:
|
|
coin.fee = float(item["FeeTotNtv"])
|
|
except (ValueError, KeyError):
|
|
coin.fee = 0
|
|
try:
|
|
coin.revenue = float(item["RevNtv"])
|
|
except (ValueError, KeyError):
|
|
coin.revenue = 0
|
|
try:
|
|
coin.hashrate = float(item["HashRate"])
|
|
except (ValueError, KeyError):
|
|
coin.hashrate = 0
|
|
try:
|
|
coin.transactions = float(item["TxCnt"])
|
|
except (ValueError, KeyError):
|
|
coin.transactions = 0
|
|
|
|
coin.save()
|
|
count += 1
|
|
print(str(symbol) + " " + str(coin.date))
|
|
|
|
except Exception:
|
|
pass
|
|
try:
|
|
url = data["next_page_url"]
|
|
update = True
|
|
except KeyError:
|
|
update = False
|
|
break
|
|
return count
|
|
|
|
|
|
# Get binance withdrawal state
|
|
def get_binance_withdrawal(symbol):
|
|
url = "https://www.binance.com/en/network"
|
|
|
|
withdrawals = Withdrawal.objects.order_by("-date")
|
|
if len(withdrawals) > 0:
|
|
for withdrawal in withdrawals:
|
|
break
|
|
else:
|
|
withdrawal = Withdrawal()
|
|
withdrawal.state = True
|
|
withdrawal.save()
|
|
return True
|
|
|
|
current_date = datetime.datetime.utcnow().replace(tzinfo=pytz.UTC)
|
|
response = requests.get(url)
|
|
result = response.text
|
|
position = result.find(symbol)
|
|
result = result[position : position + 400]
|
|
position = result.find("withdrawEnable")
|
|
result = result[position : position + 25]
|
|
try:
|
|
result.index("true")
|
|
if (current_date - withdrawal.date).seconds > 3600:
|
|
new_withdrawal = Withdrawal()
|
|
new_withdrawal.state = True
|
|
new_withdrawal.save()
|
|
return True
|
|
except Exception:
|
|
try:
|
|
result.index("false")
|
|
if ((current_date - withdrawal.date).seconds > 3600) or withdrawal.state:
|
|
new_withdrawal = Withdrawal()
|
|
new_withdrawal.state = False
|
|
new_withdrawal.save()
|
|
return False
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
# Get latest price data for Monero
|
|
def get_latest_price(symbol):
|
|
with open(BASE_DIR / "settings.json") as file:
|
|
data = json.load(file)
|
|
|
|
url = data["metrics_provider"][0]["price_url_old"] + symbol
|
|
print(url)
|
|
parameters = {
|
|
"convert": "USD",
|
|
}
|
|
headers = {
|
|
"Accepts": "application/json",
|
|
data["metrics_provider"][0]["api_key_name"]: data["metrics_provider"][0][
|
|
"api_key_value"
|
|
],
|
|
}
|
|
|
|
session = Session()
|
|
session.headers.update(headers)
|
|
|
|
try:
|
|
response = session.get(url, params=parameters)
|
|
data = json.loads(response.text)
|
|
print("getting latest data")
|
|
try:
|
|
if data["data"][symbol.upper()]["cmc_rank"]:
|
|
print("new data received")
|
|
pass
|
|
else:
|
|
print("problem with the data provider")
|
|
data = False
|
|
except KeyError:
|
|
data = False
|
|
except (ConnectionError, Timeout, TooManyRedirects):
|
|
data = False
|
|
|
|
file.close()
|
|
return data
|
|
|
|
|
|
# Get latest dominance value and update
|
|
def update_dominance(data):
|
|
if not (data):
|
|
print("error updating dominance")
|
|
return False
|
|
else:
|
|
dominance = Dominance()
|
|
dominance.name = "xmr"
|
|
dominance.date = datetime.datetime.strftime(date.today(), "%Y-%m-%d")
|
|
dominance.dominance = float(
|
|
data["data"]["XMR"]["quote"]["USD"]["market_cap_dominance"]
|
|
)
|
|
dominance.save()
|
|
|
|
df = pd.read_excel(DATA_FILE, engine="odf", sheet_name="Sheet7")
|
|
start_row, end_row = 2, 9999
|
|
start_col, end_col = 0, 2
|
|
values_mat = df.iloc[start_row:end_row, start_col:end_col].to_numpy()
|
|
|
|
k = len(values_mat)
|
|
date_aux = datetime.datetime.strptime(values_mat[k - 1][0], "%Y-%m-%d")
|
|
date_aux2 = datetime.datetime.strftime(date.today(), "%Y-%m-%d")
|
|
date_aux2 = datetime.datetime.strptime(date_aux2, "%Y-%m-%d")
|
|
if date_aux < date_aux2:
|
|
values_mat[k][1] = dominance.dominance
|
|
values_mat[k][0] = dominance.date
|
|
|
|
df.iloc[start_row:end_row, start_col:end_col] = values_mat
|
|
df.to_excel(DATA_FILE, sheet_name="Sheet7", index=False)
|
|
|
|
print("spreadsheet updated")
|
|
else:
|
|
print("spreadsheet already with the latest data")
|
|
return False
|
|
return data
|
|
|
|
|
|
# Get latest rank value and update
|
|
def update_rank(data=None):
|
|
if not (data):
|
|
data = get_latest_price("xmr")
|
|
if not (data):
|
|
print("error updating rank")
|
|
return False
|
|
else:
|
|
rank = Rank()
|
|
rank.name = "xmr"
|
|
rank.date = datetime.datetime.strftime(date.today(), "%Y-%m-%d")
|
|
rank.rank = int(data["data"]["XMR"]["cmc_rank"])
|
|
rank.save()
|
|
|
|
df = pd.read_excel(DATA_FILE, engine="odf", sheet_name="Sheet8")
|
|
start_row, end_row = 2, 9999
|
|
start_col, end_col = 0, 2
|
|
values_mat = df.iloc[start_row:end_row, start_col:end_col].to_numpy()
|
|
|
|
k = len(values_mat)
|
|
date_aux = datetime.datetime.strptime(values_mat[k - 1][0], "%Y-%m-%d")
|
|
date_aux2 = datetime.datetime.strftime(date.today(), "%Y-%m-%d")
|
|
date_aux2 = datetime.datetime.strptime(date_aux2, "%Y-%m-%d")
|
|
if date_aux < date_aux2:
|
|
values_mat[k][1] = rank.rank
|
|
values_mat[k][0] = rank.date
|
|
|
|
df.iloc[start_row:end_row, start_col:end_col] = values_mat
|
|
df.to_excel(DATA_FILE, sheet_name="Sheet8", index=False)
|
|
|
|
print("spreadsheet updated")
|
|
else:
|
|
print("spreadsheet already with the latest data")
|
|
return data
|
|
|
|
return data
|
|
|
|
|
|
# Load Reddit api to check if there are new followers
|
|
def check_new_social(symbol):
|
|
yesterday = datetime.datetime.strftime(date.today() - timedelta(1), "%Y-%m-%d")
|
|
socials = Social.objects.filter(name=symbol).filter(date=yesterday)
|
|
if symbol == "Bitcoin":
|
|
timeframe = 14400
|
|
hours = 86400 / timeframe
|
|
timeframe2 = 3600
|
|
hours2 = 86400 / timeframe2
|
|
elif symbol == "Monero":
|
|
timeframe = 43200
|
|
hours = 86400 / timeframe
|
|
timeframe2 = 43200
|
|
hours2 = 86400 / timeframe2
|
|
elif symbol == "Cryptocurrency":
|
|
timeframe = 14400
|
|
hours = 86400 / timeframe
|
|
timeframe2 = 1800
|
|
hours2 = 86400 / timeframe2
|
|
|
|
if not (socials):
|
|
print("new social")
|
|
request = "https://www.reddit.com/r/" + symbol + "/about.json"
|
|
response = requests.get(
|
|
request, headers={"User-agent": "Checking new social data"}
|
|
)
|
|
data = json.loads(response.content)
|
|
data = data["data"]
|
|
subscribers = data["subscribers"]
|
|
social = Social()
|
|
social.name = symbol
|
|
social.date = yesterday
|
|
social.subscriberCount = subscribers
|
|
|
|
date_aux = date.today()
|
|
date_aux = datetime.datetime.strftime(date_aux, "%Y-%m-%d")
|
|
date_aux = datetime.datetime.strptime(date_aux, "%Y-%m-%d")
|
|
timestamp1 = int(datetime.datetime.timestamp(date_aux))
|
|
|
|
timestamp2 = int(timestamp1 - timeframe)
|
|
limit = 1000
|
|
filters = []
|
|
data = data_prep_posts(symbol, timestamp2, timestamp1, filters, limit)
|
|
if data != 0:
|
|
social.postsPerHour = len(data) / hours
|
|
else:
|
|
social.postsPerHour = 0
|
|
|
|
timestamp2 = int(timestamp1 - timeframe2)
|
|
limit = 1000
|
|
data = data_prep_comments(symbol, timestamp2, timestamp1, filters, limit)
|
|
if data != 0:
|
|
social.commentsPerHour = len(data) / hours2
|
|
else:
|
|
social.commentsPerHour = 0
|
|
social.save()
|
|
print("getting new data - " + str(social.name) + " - " + str(social.date))
|
|
return True
|
|
|
|
|
|
# Update database DailyData with most recent coin data
|
|
def update_database(date_from=None, date_to=None):
|
|
date_zero = "2014-05-20"
|
|
|
|
if not (date_from) or not (date_to):
|
|
date_to = date.today()
|
|
date_from = date_to - timedelta(5)
|
|
amount = date_from - datetime.datetime.strptime(date_zero, "%Y-%m-%d").date()
|
|
else:
|
|
print(str(date_from) + " to " + str(date_to))
|
|
date_from = datetime.datetime.strptime(date_from, "%Y-%m-%d")
|
|
date_to = datetime.datetime.strptime(date_to, "%Y-%m-%d")
|
|
amount = date_from - datetime.datetime.strptime(date_zero, "%Y-%m-%d").date()
|
|
|
|
count = 0
|
|
date_aux = date_from
|
|
while date_aux <= date_to:
|
|
date_aux = date_from + timedelta(count)
|
|
date_aux2 = date_aux - timedelta(1)
|
|
try:
|
|
coin_xmr = Coin.objects.filter(name="xmr").get(date=date_aux)
|
|
coin_xmr2 = Coin.objects.filter(name="xmr").get(date=date_aux2)
|
|
coin_btc = Coin.objects.filter(name="btc").get(date=date_aux)
|
|
coin_btc2 = Coin.objects.filter(name="btc").get(date=date_aux2)
|
|
try:
|
|
coin_dash = Coin.objects.filter(name="dash").get(date=date_aux)
|
|
except Coin.DoesNotExist:
|
|
coin_dash = Coin()
|
|
try:
|
|
coin_zcash = Coin.objects.filter(name="zec").get(date=date_aux)
|
|
except Coin.DoesNotExist:
|
|
coin_zcash = Coin()
|
|
try:
|
|
coin_grin = Coin.objects.filter(name="grin").get(date=date_aux)
|
|
except Coin.DoesNotExist:
|
|
coin_grin = Coin()
|
|
|
|
if coin_btc.inflation == 0 or coin_xmr.inflation == 0:
|
|
return count
|
|
|
|
count_aux = 0
|
|
found = False
|
|
while count_aux < 100 and not (found):
|
|
try:
|
|
date_aux3 = date_aux - timedelta(count_aux)
|
|
social_btc = Social.objects.filter(name="Bitcoin").get(
|
|
date=date_aux3
|
|
)
|
|
social_xmr = Social.objects.filter(name="Monero").get(
|
|
date=date_aux3
|
|
)
|
|
social_crypto = Social.objects.filter(name="Cryptocurrency").get(
|
|
date=date_aux3
|
|
)
|
|
found = True
|
|
except Social.DoesNotExist:
|
|
found = False
|
|
count_aux += 1
|
|
except Coin.DoesNotExist:
|
|
return count
|
|
|
|
try:
|
|
data = Sfmodel.objects.get(date=coin_xmr.date)
|
|
|
|
except Sfmodel.DoesNotExist:
|
|
data = Sfmodel()
|
|
data.priceusd = 0
|
|
data.pricebtc = 0
|
|
data.stocktoflow = 0
|
|
data.greyline = 0
|
|
data.color = 0
|
|
data.date = coin_xmr.date
|
|
data.pricebtc = coin_xmr.pricebtc
|
|
data.priceusd = coin_xmr.priceusd
|
|
if data.stocktoflow == 0 and coin_xmr.supply > 0:
|
|
supply = int(coin_xmr.supply) * 10**12
|
|
reward = (2**64 - 1 - supply) >> 19
|
|
if reward < 0.6 * (10**12):
|
|
reward = 0.6 * (10**12)
|
|
inflation = 100 * reward * 720 * 365 / supply
|
|
data.stocktoflow = (100 / (inflation)) ** 1.65
|
|
v0 = 0.002
|
|
delta = (0.015 - 0.002) / (6 * 365)
|
|
data.color = 30 * coin_xmr.pricebtc / ((amount.days) * delta + v0)
|
|
amount += timedelta(1)
|
|
data.save()
|
|
|
|
try:
|
|
data = DailyData.objects.get(date=coin_xmr.date)
|
|
except DailyData.DoesNotExist:
|
|
data = DailyData()
|
|
# Date field
|
|
data.date = coin_xmr.date
|
|
# Basic information
|
|
data.btc_priceusd = 0
|
|
data.xmr_priceusd = 0
|
|
data.xmr_pricebtc = 0
|
|
# Marketcap charts
|
|
data.btc_marketcap = 0
|
|
data.xmr_marketcap = 0
|
|
data.dash_marketcap = 0
|
|
data.grin_marketcap = 0
|
|
data.zcash_marketcap = 0
|
|
# Transactions charts
|
|
data.xmr_transacpercentage = 0
|
|
data.btc_transactions = 0
|
|
data.zcash_transactions = 0
|
|
data.dash_transactions = 0
|
|
data.grin_transactions = 0
|
|
data.xmr_transactions = 0
|
|
data.btc_supply = 0
|
|
data.xmr_supply = 0
|
|
# Issuance charts
|
|
data.btc_inflation = 0
|
|
data.xmr_inflation = 0
|
|
data.dash_inflation = 0
|
|
data.grin_inflation = 0
|
|
data.zcash_inflation = 0
|
|
data.xmr_metcalfebtc = 0
|
|
data.xmr_metcalfeusd = 0
|
|
data.btc_return = 0
|
|
data.xmr_return = 0
|
|
data.btc_emissionusd = 0
|
|
data.btc_emissionntv = 0
|
|
data.xmr_emissionusd = 0
|
|
data.xmr_emissionntv = 0
|
|
# Mining charts
|
|
data.btc_minerrevntv = 0
|
|
data.xmr_minerrevntv = 0
|
|
data.btc_minerrevusd = 0
|
|
data.xmr_minerrevusd = 0
|
|
data.btc_minerfeesntv = 0
|
|
data.xmr_minerfeesntv = 0
|
|
data.btc_minerfeesusd = 0
|
|
data.xmr_minerfeesusd = 0
|
|
data.btc_transcostntv = 0
|
|
data.xmr_transcostntv = 0
|
|
data.btc_transcostusd = 0
|
|
data.xmr_transcostusd = 0
|
|
data.xmr_minerrevcap = 0
|
|
data.btc_minerrevcap = 0
|
|
data.btc_commitntv = 0
|
|
data.xmr_commitntv = 0
|
|
data.btc_commitusd = 0
|
|
data.xmr_commitusd = 0
|
|
data.btc_blocksize = 0
|
|
data.xmr_blocksize = 0
|
|
data.btc_difficulty = 0
|
|
data.xmr_difficulty = 0
|
|
# Reddit charts
|
|
data.btc_subscriberCount = 0
|
|
data.btc_commentsPerHour = 0
|
|
data.btc_postsPerHour = 0
|
|
data.xmr_subscriberCount = 0
|
|
data.xmr_commentsPerHour = 0
|
|
data.xmr_postsPerHour = 0
|
|
data.crypto_subscriberCount = 0
|
|
data.crypto_commentsPerHour = 0
|
|
data.crypto_postsPerHour = 0
|
|
|
|
# Date field
|
|
data.date = coin_xmr.date
|
|
# Basic information
|
|
data.btc_priceusd = coin_btc.priceusd
|
|
data.xmr_priceusd = coin_xmr.priceusd
|
|
data.xmr_pricebtc = coin_xmr.pricebtc
|
|
# Marketcap charts
|
|
data.btc_marketcap = float(coin_btc.priceusd) * float(coin_btc.supply)
|
|
data.xmr_marketcap = float(coin_xmr.priceusd) * float(coin_xmr.supply)
|
|
data.dash_marketcap = float(coin_dash.priceusd) * float(coin_dash.supply)
|
|
data.grin_marketcap = float(coin_grin.priceusd) * float(coin_grin.supply)
|
|
data.zcash_marketcap = float(coin_zcash.priceusd) * float(coin_zcash.supply)
|
|
|
|
# Transactions charts
|
|
try:
|
|
data.xmr_transacpercentage = coin_xmr.transactions / coin_btc.transactions
|
|
except ZeroDivisionError:
|
|
pass
|
|
data.xmr_transactions = coin_xmr.transactions
|
|
data.btc_transactions = coin_btc.transactions
|
|
data.zcash_transactions = coin_zcash.transactions
|
|
data.dash_transactions = coin_dash.transactions
|
|
data.grin_transactions = coin_grin.transactions
|
|
data.btc_supply = coin_btc.supply
|
|
data.xmr_supply = coin_xmr.supply
|
|
# Issuance charts
|
|
data.btc_inflation = coin_btc.inflation
|
|
data.xmr_inflation = coin_xmr.inflation
|
|
data.dash_inflation = coin_dash.inflation
|
|
data.grin_inflation = coin_grin.inflation
|
|
data.zcash_inflation = coin_zcash.inflation
|
|
try:
|
|
data.xmr_metcalfebtc = (
|
|
coin_xmr.transactions
|
|
* coin_xmr.supply
|
|
/ (coin_btc.supply * coin_btc.transactions)
|
|
)
|
|
data.xmr_metcalfeusd = (
|
|
coin_btc.priceusd
|
|
* coin_xmr.transactions
|
|
* coin_xmr.supply
|
|
/ (coin_btc.supply * coin_btc.transactions)
|
|
)
|
|
except ZeroDivisionError:
|
|
pass
|
|
data.btc_return = coin_btc.priceusd / 30
|
|
data.xmr_return = coin_xmr.priceusd / 5.01
|
|
data.btc_emissionusd = (coin_btc.supply - coin_btc2.supply) * coin_btc.priceusd
|
|
data.btc_emissionntv = coin_btc.supply - coin_btc2.supply
|
|
data.xmr_emissionusd = (coin_xmr.supply - coin_xmr2.supply) * coin_xmr.priceusd
|
|
data.xmr_emissionntv = coin_xmr.supply - coin_xmr2.supply
|
|
# Mining charts
|
|
data.btc_minerrevntv = coin_btc.revenue
|
|
data.xmr_minerrevntv = coin_xmr.revenue
|
|
data.btc_minerrevusd = coin_btc.revenue * coin_btc.priceusd
|
|
data.xmr_minerrevusd = coin_xmr.revenue * coin_xmr.priceusd
|
|
data.btc_minerfeesntv = coin_btc.revenue - coin_btc.supply + coin_btc2.supply
|
|
data.xmr_minerfeesntv = coin_xmr.revenue - coin_xmr.supply + coin_xmr2.supply
|
|
data.btc_minerfeesusd = (
|
|
coin_btc.revenue - coin_btc.supply + coin_btc2.supply
|
|
) * coin_btc.priceusd
|
|
data.xmr_minerfeesusd = (
|
|
coin_xmr.revenue - coin_xmr.supply + coin_xmr2.supply
|
|
) * coin_xmr.priceusd
|
|
try:
|
|
data.btc_transcostntv = coin_btc.fee / coin_btc.transactions
|
|
data.xmr_transcostntv = coin_xmr.fee / coin_xmr.transactions
|
|
data.btc_transcostusd = (
|
|
coin_btc.priceusd * coin_btc.fee / coin_btc.transactions
|
|
)
|
|
data.xmr_transcostusd = (
|
|
coin_xmr.priceusd * coin_xmr.fee / coin_xmr.transactions
|
|
)
|
|
except ZeroDivisionError:
|
|
pass
|
|
try:
|
|
data.xmr_minerrevcap = 365 * 100 * coin_xmr.revenue / coin_xmr.supply
|
|
data.btc_minerrevcap = 365 * 100 * coin_btc.revenue / coin_btc.supply
|
|
except ZeroDivisionError:
|
|
pass
|
|
try:
|
|
data.btc_commitntv = coin_btc.hashrate / (coin_btc.revenue)
|
|
data.xmr_commitntv = coin_xmr.hashrate / (coin_xmr.revenue)
|
|
data.btc_commitusd = coin_btc.hashrate / (
|
|
coin_btc.revenue * coin_btc.priceusd
|
|
)
|
|
data.xmr_commitusd = coin_xmr.hashrate / (
|
|
coin_xmr.revenue * coin_xmr.priceusd
|
|
)
|
|
except ZeroDivisionError:
|
|
pass
|
|
try:
|
|
data.btc_blocksize = coin_btc.blocksize
|
|
data.xmr_blocksize = coin_xmr.blocksize
|
|
data.btc_difficulty = coin_btc.difficulty
|
|
data.xmr_difficulty = coin_xmr.difficulty
|
|
except ZeroDivisionError:
|
|
pass
|
|
# Reddit charts
|
|
try:
|
|
data.btc_subscriberCount = social_btc.subscriberCount
|
|
data.btc_commentsPerHour = social_btc.commentsPerHour
|
|
data.btc_postsPerHour = social_btc.postsPerHour
|
|
data.xmr_subscriberCount = social_xmr.subscriberCount
|
|
data.xmr_commentsPerHour = social_xmr.commentsPerHour
|
|
data.xmr_postsPerHour = social_xmr.postsPerHour
|
|
data.crypto_subscriberCount = social_crypto.subscriberCount
|
|
data.crypto_commentsPerHour = social_crypto.commentsPerHour
|
|
data.crypto_postsPerHour = social_crypto.postsPerHour
|
|
except (Social.DoesNotExist, UnboundLocalError):
|
|
data.btc_subscriberCount = 0
|
|
data.btc_commentsPerHour = 0
|
|
data.btc_postsPerHour = 0
|
|
data.xmr_subscriberCount = 0
|
|
data.xmr_commentsPerHour = 0
|
|
data.xmr_postsPerHour = 0
|
|
data.crypto_subscriberCount = 0
|
|
data.crypto_commentsPerHour = 0
|
|
data.crypto_postsPerHour = 0
|
|
|
|
data.save()
|
|
|
|
try:
|
|
print(
|
|
str(coin_xmr.supply)
|
|
+ " xmr "
|
|
+ str(data.xmr_subscriberCount)
|
|
+ " - "
|
|
+ str(social_xmr.subscriberCount)
|
|
+ " = "
|
|
+ str(int(data.xmr_marketcap))
|
|
+ " => "
|
|
+ str(coin_xmr.inflation)
|
|
)
|
|
except (Social.DoesNotExist, UnboundLocalError):
|
|
pass
|
|
|
|
count += 1
|
|
|
|
return count
|
|
|
|
|
|
# Get latest P2Pool data
|
|
def update_p2pool():
|
|
today = date.today()
|
|
yesterday = date.today() - timedelta(1)
|
|
try:
|
|
p2pool_stat = P2Pool.objects.filter(mini=False).get(date=today)
|
|
print("Found P2Pool of today")
|
|
if p2pool_stat.percentage > 0:
|
|
print("Percentage > 0")
|
|
update = False
|
|
else:
|
|
print("Percentage < 0")
|
|
p2pool_stat.delete()
|
|
try:
|
|
coin = Coin.objects.filter(name="xmr").get(date=yesterday)
|
|
print("Found coin of yesterday")
|
|
if coin.hashrate > 0:
|
|
update = True
|
|
else:
|
|
update = False
|
|
except Coin.DoesNotExist:
|
|
print("Didn't find coin of yesterday")
|
|
update = False
|
|
except P2Pool.DoesNotExist:
|
|
print("Didn't find P2Pool of today")
|
|
try:
|
|
coin = Coin.objects.filter(name="xmr").get(date=yesterday)
|
|
if coin.hashrate > 0:
|
|
update = True
|
|
else:
|
|
update = False
|
|
except Coin.DoesNotExist:
|
|
update = False
|
|
|
|
if update:
|
|
p2pool_stat = P2Pool()
|
|
p2pool_stat.date = today
|
|
response = requests.get("https://p2pool.io/api/pool/stats")
|
|
|
|
data = json.loads(response.text)
|
|
p2pool_stat.hashrate = data["pool_statistics"]["hashRate"]
|
|
p2pool_stat.percentage = (
|
|
100 * data["pool_statistics"]["hashRate"] / coin.hashrate
|
|
)
|
|
p2pool_stat.miners = data["pool_statistics"]["miners"]
|
|
p2pool_stat.totalhashes = data["pool_statistics"]["totalHashes"]
|
|
p2pool_stat.totalblocksfound = data["pool_statistics"]["totalBlocksFound"]
|
|
p2pool_stat.mini = False
|
|
p2pool_stat.save()
|
|
print("p2pool saved!")
|
|
|
|
df = pd.read_excel(DATA_FILE, engine="odf", sheet_name="p2pool")
|
|
start_row, end_row = 2, 9999
|
|
start_col, end_col = 0, 2
|
|
values_mat = df.iloc[start_row:end_row, start_col:end_col].to_numpy()
|
|
|
|
k = len(values_mat)
|
|
date_aux = datetime.datetime.strptime(values_mat[k - 1][0], "%Y-%m-%d")
|
|
date_aux2 = datetime.datetime.strftime(date.today(), "%Y-%m-%d")
|
|
date_aux2 = datetime.datetime.strptime(date_aux2, "%Y-%m-%d")
|
|
if date_aux < date_aux2:
|
|
values_mat[k][5] = p2pool_stat.totalblocksfound
|
|
values_mat[k][4] = p2pool_stat.totalhashes
|
|
values_mat[k][3] = p2pool_stat.percentage
|
|
values_mat[k][2] = p2pool_stat.hashrate
|
|
values_mat[k][1] = p2pool_stat.miners
|
|
values_mat[k][0] = datetime.datetime.strftime(p2pool_stat.date, "%Y-%m-%d")
|
|
|
|
df.iloc[start_row:end_row, start_col:end_col] = values_mat
|
|
df.to_excel(DATA_FILE, sheet_name="p2pool", index=False)
|
|
|
|
print("spreadsheet updated")
|
|
else:
|
|
print("spreadsheet already with the latest data")
|
|
return data
|
|
|
|
today = date.today()
|
|
yesterday = date.today() - timedelta(1)
|
|
try:
|
|
p2pool_stat = P2Pool.objects.filter(mini=True).get(date=today)
|
|
print("Found P2PoolMini of today")
|
|
if p2pool_stat.percentage > 0:
|
|
print("Percentage > 0")
|
|
update = False
|
|
else:
|
|
print("Percentage < 0")
|
|
p2pool_stat.delete()
|
|
try:
|
|
coin = Coin.objects.filter(name="xmr").get(date=yesterday)
|
|
|
|
print("Found coin of yesterday")
|
|
if coin.hashrate > 0:
|
|
update = True
|
|
else:
|
|
update = False
|
|
except Coin.DoesNotExist:
|
|
print("Didn't find coin of yesterday")
|
|
update = False
|
|
except P2Pool.DoesNotExist:
|
|
print("Didn't find P2PoolMini of today")
|
|
try:
|
|
coin = Coin.objects.filter(name="xmr").get(date=yesterday)
|
|
if coin.hashrate > 0:
|
|
update = True
|
|
else:
|
|
update = False
|
|
except Coin.DoesNotExist:
|
|
update = False
|
|
|
|
if update:
|
|
p2pool_stat = P2Pool()
|
|
p2pool_stat.date = today
|
|
response = requests.get("https://p2pool.io/mini/api/pool/stats")
|
|
|
|
data = json.loads(response.text)
|
|
p2pool_stat.hashrate = data["pool_statistics"]["hashRate"]
|
|
p2pool_stat.percentage = (
|
|
100 * data["pool_statistics"]["hashRate"] / coin.hashrate
|
|
)
|
|
p2pool_stat.miners = data["pool_statistics"]["miners"]
|
|
p2pool_stat.totalhashes = data["pool_statistics"]["totalHashes"]
|
|
p2pool_stat.totalblocksfound = data["pool_statistics"]["totalBlocksFound"]
|
|
p2pool_stat.mini = True
|
|
p2pool_stat.save()
|
|
print("p2pool_mini saved!")
|
|
|
|
df = pd.read_excel(DATA_FILE, engine="odf", sheet_name="p2poolmini")
|
|
start_row, end_row = 2, 9999
|
|
start_col, end_col = 0, 2
|
|
values_mat = df.iloc[start_row:end_row, start_col:end_col].to_numpy()
|
|
|
|
k = len(values_mat)
|
|
date_aux = datetime.datetime.strptime(values_mat[k - 1][0], "%Y-%m-%d")
|
|
date_aux2 = datetime.datetime.strftime(date.today(), "%Y-%m-%d")
|
|
date_aux2 = datetime.datetime.strptime(date_aux2, "%Y-%m-%d")
|
|
if date_aux < date_aux2:
|
|
values_mat[k][5] = p2pool_stat.totalblocksfound
|
|
values_mat[k][4] = p2pool_stat.totalhashes
|
|
values_mat[k][3] = p2pool_stat.percentage
|
|
values_mat[k][2] = p2pool_stat.hashrate
|
|
values_mat[k][1] = p2pool_stat.miners
|
|
values_mat[k][0] = datetime.datetime.strftime(p2pool_stat.date, "%Y-%m-%d")
|
|
|
|
df.iloc[start_row:end_row, start_col:end_col] = values_mat
|
|
df.to_excel(DATA_FILE, sheet_name="p2poolmini", index=False)
|
|
|
|
print("spreadsheet updated")
|
|
else:
|
|
print("spreadsheet already with the latest data")
|
|
return data
|
|
|
|
return True
|