581 lines
21 KiB
Python
581 lines
21 KiB
Python
import sqlite3
|
|
import datetime
|
|
import time
|
|
import calendar
|
|
import logging
|
|
import threading
|
|
import os
|
|
from collections import deque
|
|
from typing import Iterable, List, Tuple
|
|
from contextlib import contextmanager
|
|
from flask import Flask, jsonify, request, Response
|
|
from waitress import serve
|
|
|
|
|
|
profits_database = "../profits/profits_database.db"
|
|
_local_storage = threading.local()
|
|
|
|
def get_db_connection():
|
|
current_time = time.time()
|
|
|
|
if not hasattr(_local_storage, 'connection') or not hasattr(_local_storage, 'created_at') or (current_time - _local_storage.created_at) > 3600: # Reconnect every hour
|
|
if hasattr(_local_storage, 'connection'):
|
|
try:
|
|
_local_storage.connection.close()
|
|
except:
|
|
pass
|
|
_local_storage.connection = sqlite3.connect(profits_database, check_same_thread=False)
|
|
_local_storage.connection.row_factory = sqlite3.Row
|
|
_local_storage.created_at = current_time
|
|
|
|
return _local_storage.connection
|
|
|
|
@contextmanager
|
|
def db_cursor():
|
|
conn = get_db_connection()
|
|
cur = conn.cursor()
|
|
try:
|
|
yield cur
|
|
except Exception:
|
|
conn.rollback()
|
|
raise
|
|
|
|
def load_keys_from_db(file_name):
|
|
connection = sqlite3.connect(file_name)
|
|
cursor = connection.cursor()
|
|
cursor.execute("SELECT * FROM credentials_table")
|
|
data = cursor.fetchall()
|
|
connection.close()
|
|
|
|
valid_keys = [line[1] for line in data]
|
|
|
|
return valid_keys
|
|
|
|
|
|
def get_valid_keys():
|
|
if not hasattr(get_valid_keys, '_keys'):
|
|
get_valid_keys._keys = load_keys_from_db("api_credentials.db")
|
|
return get_valid_keys._keys
|
|
|
|
|
|
def profit_report():
|
|
##Queries
|
|
#Last 60 days query
|
|
with db_cursor() as cursor:
|
|
cursor.execute("""SELECT strftime('%Y-%m-%d', timestamp, 'unixepoch', '-3 hours') AS day_utc3,
|
|
SUM(amount) AS total_amount
|
|
FROM profits_table
|
|
WHERE strftime('%s', 'now') - timestamp <= 60 * 24 * 60 * 60 -- 60 days in seconds
|
|
GROUP BY day_utc3
|
|
ORDER BY day_utc3;""")
|
|
last_60_days_rows = cursor.fetchall()
|
|
#Last 30 days query
|
|
with db_cursor() as cursor:
|
|
cursor.execute("""SELECT strftime('%Y-%m-%d', timestamp, 'unixepoch', '-3 hours') AS day_utc3,
|
|
SUM(amount) AS total_amount
|
|
FROM profits_table
|
|
WHERE strftime('%s', 'now') - timestamp <= 30 * 24 * 60 * 60 -- 30 days in seconds;""")
|
|
last_30_days = cursor.fetchall()
|
|
#Last 7 days query
|
|
with db_cursor() as cursor:
|
|
cursor.execute("""SELECT strftime('%Y-%m-%d', timestamp, 'unixepoch', '-3 hours') AS day_utc3,
|
|
SUM(amount) AS total_amount
|
|
FROM profits_table
|
|
WHERE strftime('%s', 'now') - timestamp <= 7 * 24 * 60 * 60 -- 7 days in seconds;""")
|
|
last_7_days = cursor.fetchall()
|
|
#Last n months query
|
|
with db_cursor() as cursor:
|
|
cursor.execute("""SELECT strftime('%Y-%m', timestamp, 'unixepoch', '-3 hours') AS year_month_utc3,
|
|
SUM(amount) AS total_amount
|
|
FROM profits_table
|
|
WHERE strftime('%s', 'now') - timestamp <= 18 * 30 * 24 * 60 * 60 -- 18 months in seconds
|
|
GROUP BY year_month_utc3
|
|
ORDER BY year_month_utc3;""")
|
|
last_n_months_rows = cursor.fetchall()
|
|
#Yearly totals
|
|
# cursor.execute("""SELECT strftime('%Y', timestamp, 'unixepoch', '-3 hours') AS year_utc3,
|
|
# SUM(amount) AS total_amount
|
|
# FROM profits_table
|
|
# WHERE strftime('%s', 'now') - timestamp <= 24 * 365 * 60 * 60 -- 365 days in seconds
|
|
# GROUP BY year_utc3
|
|
# ORDER BY year_utc3;""")
|
|
# yearly_totals = cursor.fetchall()
|
|
#Per exchange
|
|
with db_cursor() as cursor:
|
|
cursor.execute("""SELECT
|
|
exchange_name,
|
|
CASE
|
|
WHEN strftime('%Y-%m', timestamp, 'unixepoch', '-3 hours') = strftime('%Y-%m', 'now', 'localtime') THEN 'This Month'
|
|
WHEN strftime('%Y-%m', timestamp, 'unixepoch', '-3 hours') = strftime('%Y-%m', 'now', 'localtime', '-1 month') THEN 'Last Month'
|
|
ELSE 'Other Months'
|
|
END AS month_group,
|
|
SUM(amount) AS total_amount
|
|
FROM
|
|
profits_table
|
|
WHERE
|
|
strftime('%s', 'now') - timestamp <= 60 * 24 * 60 * 60 -- 60 days in seconds
|
|
GROUP BY
|
|
exchange_name, month_group
|
|
ORDER BY
|
|
exchange_name, month_group;""")
|
|
per_exchange = cursor.fetchall()
|
|
|
|
|
|
#Projection calculation
|
|
days_in_month = calendar.monthrange(datetime.date.today().year, datetime.date.today().month)[1]
|
|
daily_combined_media = (last_30_days[0][1]/30+last_7_days[0][1]/7)/2
|
|
current_amount = last_n_months_rows[-1][1]
|
|
days_past_this_month = int(last_60_days_rows[-1][0][8:10])
|
|
|
|
#Per exchange
|
|
binance_amount = 0
|
|
gateio_amount = 0
|
|
kucoin_amount = 0
|
|
okex_amount = 0
|
|
|
|
for row in per_exchange:
|
|
exchange_name = row[0].strip().lower()
|
|
if exchange_name=="binance":
|
|
if row[1]=="This Month":
|
|
binance_amount = row[2]
|
|
elif exchange_name=="gateio":
|
|
if row[1]=="This Month":
|
|
gateio_amount = row[2]
|
|
elif exchange_name=="kucoin":
|
|
if row[1]=="This Month":
|
|
kucoin_amount = row[2]
|
|
elif exchange_name=="okex":
|
|
if row[1]=="This Month":
|
|
okex_amount = row[2]
|
|
|
|
total_amount = binance_amount+gateio_amount+kucoin_amount+okex_amount
|
|
|
|
last_60_days_result = {row[0]: round(row[1],2) for row in last_60_days_rows}
|
|
last_18_months_result = {row[0]: round(row[1],2) for row in last_n_months_rows}
|
|
last_30_days_average = last_30_days[0][1]/30
|
|
last_7_days_average = last_7_days[0][1]/7
|
|
this_month_projection = current_amount + daily_combined_media*(days_in_month-days_past_this_month)
|
|
binance_percentage = binance_amount/total_amount*100
|
|
gateio_percentage = gateio_amount/total_amount*100
|
|
kucoin_percentage = kucoin_amount/total_amount*100
|
|
okex_percentage = okex_amount/total_amount*100
|
|
|
|
return {"Last 60 days": last_60_days_result,
|
|
"Last 18 months": last_18_months_result,
|
|
"Last 30 days average": last_30_days_average,
|
|
"Last 7 days average": last_7_days_average,
|
|
"This month projection": this_month_projection,
|
|
"Binance": binance_amount,
|
|
"Binance percentage": binance_percentage,
|
|
"Gateio": gateio_amount,
|
|
"Gateio percentage": gateio_percentage,
|
|
"Kucoin": kucoin_amount,
|
|
"Kucoin percentage": kucoin_percentage,
|
|
"OKX": okex_amount,
|
|
"OKX percentage": okex_percentage,
|
|
"Total profit": total_amount}
|
|
|
|
|
|
def query_total_profit(pair=None):
|
|
'''
|
|
Returns total profit of the trading pair.
|
|
If no pair specified, returns the grand total of all pairs.
|
|
'''
|
|
|
|
if pair is None:
|
|
query = "SELECT SUM(amount) AS total_profit FROM profits_table"
|
|
with db_cursor() as cursor:
|
|
cursor.execute(query)
|
|
query_result = cursor.fetchall()
|
|
return query_result[0][0]
|
|
else:
|
|
query = """SELECT pair, SUM(amount) AS total_profit
|
|
FROM profits_table
|
|
GROUP BY pair;"""
|
|
with db_cursor() as cursor:
|
|
cursor.execute(query)
|
|
query_result = cursor.fetchall()
|
|
for item in query_result:
|
|
if item[0].replace("/","")==pair:
|
|
return item[1]
|
|
return 0
|
|
|
|
|
|
def daily_and_monthly_totals() -> tuple[float, float]:
|
|
'''
|
|
Returns a tuple with the current day and the current month's total profit.
|
|
'''
|
|
|
|
now = datetime.datetime.now()
|
|
|
|
# Create a datetime object for the start of the day
|
|
start_of_day = datetime.datetime(now.year, now.month, now.day)
|
|
start_of_month = datetime.datetime(now.year, now.month, 1)
|
|
|
|
# Convert the start of the day to Unix time
|
|
start_of_day_unix = int(time.mktime(start_of_day.timetuple()))
|
|
start_of_month_unix = int(time.mktime(start_of_month.timetuple()))
|
|
|
|
query = """SELECT
|
|
COALESCE(SUM(CASE WHEN timestamp >= :day THEN amount END),0) AS daily_total,
|
|
COALESCE(SUM(CASE WHEN timestamp >= :month THEN amount END),0) AS monthly_total
|
|
FROM profits_table;
|
|
"""
|
|
with db_cursor() as cur:
|
|
cur.execute(query, {"day": start_of_day_unix, "month": start_of_month_unix})
|
|
row = cur.fetchone()
|
|
daily_total = float(row["daily_total"])
|
|
monthly_total = float(row["monthly_total"])
|
|
|
|
return (daily_total, monthly_total)
|
|
|
|
|
|
def query_daily_totals(pair=None):
|
|
'''
|
|
Returns a dictionary of daily totals of the trading pair.
|
|
If no pair specified, returns the totals of all pairs.
|
|
'''
|
|
|
|
result = {}
|
|
|
|
if pair is None:
|
|
query = """SELECT strftime('%Y-%m-%d', timestamp, 'unixepoch', '-3 hours') AS day_utc3,
|
|
SUM(amount) AS total_profit
|
|
FROM profits_table
|
|
GROUP BY day_utc3;"""
|
|
with db_cursor() as cursor:
|
|
cursor.execute(query)
|
|
query_result = cursor.fetchall()
|
|
for item in query_result:
|
|
result[item[0]] = item[1]
|
|
else:
|
|
query = """SELECT pair, strftime('%Y-%m-%d', timestamp, 'unixepoch', '-3 hours') AS day_utc3,
|
|
SUM(amount) AS total_profit
|
|
FROM profits_table
|
|
GROUP BY pair, day_utc3;"""
|
|
with db_cursor() as cursor:
|
|
cursor.execute(query)
|
|
query_result = cursor.fetchall()
|
|
for item in query_result:
|
|
if item[0].replace("/","")==pair:
|
|
result[item[1]] = item[2]
|
|
return result
|
|
|
|
|
|
def query_monthly_totals(pair=None):
|
|
'''
|
|
Returns a dictionary of monthly totals of the trading pair.
|
|
If no pair specified, returns the totals of all pairs.
|
|
'''
|
|
|
|
result = {}
|
|
|
|
if pair is None:
|
|
query = """SELECT strftime('%Y-%m', datetime(timestamp, 'unixepoch', '-3 hours')) AS month,
|
|
SUM(amount) AS total_profit
|
|
FROM profits_table
|
|
GROUP BY month;"""
|
|
with db_cursor() as cursor:
|
|
cursor.execute(query)
|
|
query_result = cursor.fetchall()
|
|
for item in query_result:
|
|
result[item[0]] = item[1]
|
|
else:
|
|
query = """SELECT pair, strftime('%Y-%m', datetime(timestamp, 'unixepoch', '-3 hours')) AS month,
|
|
SUM(amount) AS total_profit
|
|
FROM profits_table
|
|
GROUP BY pair, month;"""
|
|
with db_cursor() as cursor:
|
|
cursor.execute(query)
|
|
query_result = cursor.fetchall()
|
|
for item in query_result:
|
|
if item[0].replace("/","")==pair:
|
|
result[item[1]] = item[2]
|
|
return result
|
|
|
|
|
|
def last_n_deals(n):
|
|
'''
|
|
Returns a list of the latest n deals
|
|
'''
|
|
with db_cursor() as cursor:
|
|
cursor.execute("SELECT * FROM profits_table ORDER BY timestamp DESC LIMIT ?",(n,))
|
|
result = cursor.fetchall()
|
|
|
|
return result
|
|
|
|
|
|
def last_n_deals_without_history(n):
|
|
'''
|
|
Like last_n_deals, but without returning the order history. Useful in bandwidth-restricted scenarios.
|
|
'''
|
|
|
|
return [(row[0],row[1],row[2],row[3],row[4],"") for row in last_n_deals(n)]
|
|
|
|
|
|
def last_n_lines(file_name,width,amount=4,full_log=False):
|
|
|
|
file_contents = []
|
|
result = []
|
|
|
|
with open(file_name) as f:
|
|
file_contents = f.readlines()
|
|
|
|
if full_log:
|
|
for line in file_contents:
|
|
result.append(line.strip())
|
|
return result,len(file_contents)
|
|
|
|
for line in file_contents[::-1][:amount]:
|
|
trimmed = line.strip()
|
|
result.append(trimmed[:width])
|
|
if len(trimmed)>width:
|
|
result.append(trimmed[width:width*2])
|
|
return result[:amount],len(file_contents)
|
|
|
|
|
|
def tail_log(filename, lines=200):
|
|
if not os.path.exists(filename):
|
|
return []
|
|
|
|
block_size = 1024
|
|
blocks = []
|
|
with open(filename, 'rb') as f:
|
|
f.seek(0, 2)
|
|
#total_bytes = remaining_bytes = f.tell()
|
|
remaining_bytes = f.tell()
|
|
|
|
while len(blocks) < lines and remaining_bytes > 0:
|
|
read_bytes = min(block_size, remaining_bytes)
|
|
f.seek(-read_bytes, 1)
|
|
block = f.read(read_bytes).splitlines()
|
|
f.seek(-read_bytes, 1)
|
|
|
|
# Prepend to blocks (since we're reading backwards)
|
|
blocks = block[-(len(blocks)+1):] + blocks
|
|
remaining_bytes -= read_bytes
|
|
|
|
# Decode and filter empty lines
|
|
result = [line.decode('utf-8', errors='ignore').strip() for line in blocks if line.strip()]
|
|
return result[-lines:],len(result[-lines:])
|
|
|
|
|
|
stats_api = Flask(__name__)
|
|
|
|
@stats_api.route("/fetch_profit_report")
|
|
def fetch_profit_report():
|
|
'''
|
|
GET request
|
|
Parameters: None
|
|
Returns: JSON object with profit report data
|
|
'''
|
|
|
|
if not "X-API-KEY" in request.headers or not request.headers.get("X-API-KEY") in get_valid_keys():
|
|
return jsonify({'Error': 'API key invalid'}), 401
|
|
try:
|
|
return jsonify(profit_report())
|
|
except Exception as e:
|
|
print(e)
|
|
return jsonify({"Error": f"{e}"})
|
|
|
|
|
|
|
|
@stats_api.route("/fetch_last_n_deals")
|
|
def fetch_last_n_deals():
|
|
'''
|
|
GET request
|
|
Parameter: 'amount_of_deals' -> int
|
|
'''
|
|
if not "X-API-KEY" in request.headers or not request.headers.get("X-API-KEY") in get_valid_keys():
|
|
return jsonify({'Error': 'API key invalid'}), 401
|
|
try:
|
|
parameter = request.args.get("amount_of_deals")
|
|
response_value = last_n_deals(parameter)
|
|
return jsonify({"last_deals": response_value})
|
|
except Exception as e:
|
|
print(e)
|
|
return jsonify({"last_deals":""})
|
|
|
|
|
|
@stats_api.route("/fetch_last_n_deals_without_history")
|
|
def fetch_last_n_deals_without_history():
|
|
'''
|
|
GET request
|
|
Parameter: 'amount_of_deals' -> int
|
|
'''
|
|
if not "X-API-KEY" in request.headers or not request.headers.get("X-API-KEY") in get_valid_keys():
|
|
return jsonify({'Error': 'API key invalid'}), 401
|
|
try:
|
|
parameter = request.args.get("amount_of_deals")
|
|
#return jsonify({"last_deals": last_n_deals_without_history(parameter)})
|
|
response_value = last_n_deals_without_history(parameter)
|
|
return jsonify({"last_deals": response_value})
|
|
except Exception as e:
|
|
print(e)
|
|
return jsonify({"last_deals":""})
|
|
|
|
|
|
@stats_api.route("/fetch_full_log")
|
|
def fetch_full_log():
|
|
'''
|
|
GET request
|
|
Parameters: 'exchange_name" -> string
|
|
|
|
It trims the full log to 200 lines, to avoid sending too much data to the client.
|
|
'''
|
|
if not "X-API-KEY" in request.headers or not request.headers.get("X-API-KEY") in get_valid_keys():
|
|
return jsonify({'Error': 'API key invalid'}), 401
|
|
try:
|
|
exchange_name = request.args.get("exchange_name")
|
|
width = 0
|
|
last_lines, amount_of_lines = tail_log(f"../logs/{exchange_name}.log", 200)
|
|
return jsonify({"line": last_lines[-200:], "amount_of_lines": amount_of_lines})
|
|
except Exception as e:
|
|
print(e)
|
|
return {"line": [""]*width,"amount_of_lines": 0}
|
|
|
|
|
|
@stats_api.route("/fetch_log")
|
|
def fetch_log():
|
|
'''
|
|
GET request
|
|
Parameters: 'exchange_name" -> string
|
|
'width' -> int
|
|
'amount' -> int
|
|
'''
|
|
if not "X-API-KEY" in request.headers or not request.headers.get("X-API-KEY") in get_valid_keys():
|
|
return jsonify({'Error': 'API key invalid'}), 401
|
|
try:
|
|
exchange_name = request.args.get("exchange_name")
|
|
width = int(request.args.get("width")) # type: ignore
|
|
amount = int(request.args.get("amount")) # type: ignore
|
|
last_lines,total_amount_of_lines = last_n_lines(f"../logs/{exchange_name}.log",width,amount)
|
|
return jsonify({"line": last_lines, "amount_of_lines": total_amount_of_lines})
|
|
except Exception as e:
|
|
print(e)
|
|
return {"line": [""]*10,"amount_of_lines": 0}
|
|
|
|
|
|
@stats_api.route("/combined_totals")
|
|
def combined_totals():
|
|
if not "X-API-KEY" in request.headers or not request.headers.get("X-API-KEY") in get_valid_keys():
|
|
return jsonify({'Error': 'API key invalid'}), 401
|
|
daily_totals = daily_and_monthly_totals()
|
|
return jsonify({"combined": daily_totals})
|
|
|
|
|
|
@stats_api.route("/daily_totals")
|
|
def get_daily_totals():
|
|
if not "X-API-KEY" in request.headers or not request.headers.get("X-API-KEY") in get_valid_keys():
|
|
return jsonify({'Error': 'API key invalid'}), 401
|
|
daily_totals = query_daily_totals()
|
|
return jsonify(daily_totals)
|
|
|
|
|
|
@stats_api.route("/daily_totals_by_pair")
|
|
def get_daily_totals_by_pair():
|
|
'''
|
|
GET request
|
|
Parameters: 'base' -> string
|
|
'quote' -> string
|
|
'''
|
|
if not "X-API-KEY" in request.headers or not request.headers.get("X-API-KEY") in get_valid_keys():
|
|
return jsonify({'Error': 'API key invalid'}), 401
|
|
try:
|
|
base = request.args.get("base")
|
|
quote = request.args.get("quote")
|
|
daily_totals = query_daily_totals(f"{base}{quote}")
|
|
return jsonify(daily_totals)
|
|
except Exception as e:
|
|
print(e)
|
|
return jsonify({'Error': 'Halp'})
|
|
|
|
|
|
@stats_api.route("/monthly_totals")
|
|
def get_monthly_totals():
|
|
if not "X-API-KEY" in request.headers or not request.headers.get("X-API-KEY") in get_valid_keys():
|
|
return jsonify({'Error': 'API key invalid'}), 401
|
|
monthly_totals = query_monthly_totals()
|
|
return jsonify(monthly_totals)
|
|
|
|
|
|
@stats_api.route("/monthly_totals_by_pair")
|
|
def get_monthly_totals_by_pair():
|
|
'''
|
|
GET request
|
|
Parameters: 'base' -> string
|
|
'quote' -> string
|
|
'''
|
|
if not "X-API-KEY" in request.headers or not request.headers.get("X-API-KEY") in get_valid_keys():
|
|
return jsonify({'Error': 'API key invalid'}), 401
|
|
try:
|
|
base = request.args.get("base")
|
|
quote = request.args.get("quote")
|
|
monthly_totals = query_monthly_totals(f"{base}{quote}")
|
|
return jsonify(monthly_totals)
|
|
except Exception as e:
|
|
print(e)
|
|
return jsonify({'Error': 'Halp'})
|
|
|
|
|
|
@stats_api.route("/get_averages")
|
|
def get_averages():
|
|
if not "X-API-KEY" in request.headers or not request.headers.get("X-API-KEY") in get_valid_keys():
|
|
return jsonify({'Error': 'API key invalid'}), 401
|
|
try:
|
|
daily_totals = query_daily_totals()
|
|
val_30 = 0
|
|
val_7 = 0
|
|
recent_days = sorted(daily_totals.keys(), reverse=True)[:30]
|
|
acc_30 = [daily_totals[date] for date in recent_days[:30]]
|
|
acc_7 = [daily_totals[date] for date in recent_days[:7]]
|
|
length_30 = min(30,len(acc_30)) #Last 30 days
|
|
length_7 = min(7,len(acc_7)) #Last 7 days
|
|
for _ in range(length_30):
|
|
val_30 += acc_30.pop()
|
|
for _ in range(length_7):
|
|
val_7 += acc_7.pop()
|
|
return jsonify({"30_day": val_30/length_30, "7_day": val_7/length_7})
|
|
except Exception as e:
|
|
print(e)
|
|
return jsonify({'Error': 'Halp'})
|
|
|
|
|
|
@stats_api.route("/total_profit")
|
|
def total_profit():
|
|
if not "X-API-KEY" in request.headers or not request.headers.get("X-API-KEY") in get_valid_keys():
|
|
return jsonify({'Error': 'API key invalid'}), 401
|
|
total = query_total_profit()
|
|
return jsonify({"Total profit": total})
|
|
|
|
|
|
@stats_api.route("/total_profit_by_pair")
|
|
def total_profit_by_pair():
|
|
'''
|
|
GET request
|
|
Parameters: 'base' -> string
|
|
'quote' -> string
|
|
'''
|
|
if not "X-API-KEY" in request.headers or not request.headers.get("X-API-KEY") in get_valid_keys():
|
|
return jsonify({'Error': 'API key invalid'}), 401
|
|
try:
|
|
base = request.args.get("base")
|
|
quote = request.args.get("quote")
|
|
total = query_total_profit(f"{base}{quote}")
|
|
return jsonify({"Total profit": total})
|
|
except Exception as e:
|
|
print(e)
|
|
return jsonify({'Error': 'Halp'})
|
|
|
|
|
|
|
|
if __name__=="__main__":
|
|
|
|
#Waitress
|
|
logger = logging.getLogger('waitress')
|
|
logger.setLevel(logging.INFO)
|
|
serve(stats_api,host="0.0.0.0",port=5010)
|
|
|
|
#Flask
|
|
# app.run(host="0.0.0.0", port=5010, debug=True)
|
|
|