stats/app/libraries/database.py

1312 líneas
31 KiB
Python
Original Vista normal Històric

2023-04-08 13:15:29 +02:00
import os
import sys
import psycopg2
from psycopg2 import sql
from psycopg2.extensions import ISOLATION_LEVEL_AUTOCOMMIT
import uuid
from datetime import datetime
import pytz
tz = pytz.timezone('Europe/Madrid')
class Database():
name = 'fediverse database library'
def __init__(self, config_file=None, mau_db=None, mau_db_user=None, mau_db_user_password=None):
self.config_file = "config/db_config.txt"
self.mau_db = self.__get_parameter("mau_db", self.config_file)
self.mau_db_user = self.__get_parameter("mau_db_user", self.config_file)
self.mau_db_user_password = self.__get_parameter("mau_db_user_password", self.config_file)
db_setup = self.__check_dbsetup(self)
if not db_setup:
self.mau_db = input("\nMau database name: ")
self.mau_db_user = input("\nMau database user: ")
self.mau_db_user_password = input("\nMau database user password: ")
self.__createdb(self)
self.__create_config(self)
self.__write_config(self)
def get_nodeinfo_endpoint(self, server):
try:
conn = None
conn = psycopg2.connect(database = self.mau_db, user = self.mau_db_user, password = self.mau_db_user_password, host = "/var/run/postgresql", port = "6432")
cur = conn.cursor()
cur.execute("select server, api from servers where server=(%s)", (server,))
row = cur.fetchone()
if row != None:
server = row[0]
api = row[1]
else:
server = ''
api = ''
cur.close()
return (server, api)
except (Exception, psycopg2.DatabaseError) as error:
sys.exit(error)
finally:
if conn is not None:
conn.close()
def save_time(self, program, start, finish):
insert_sql = "INSERT INTO execution_time(program, start, finish) VALUES(%s,%s,%s) ON CONFLICT DO NOTHING"
conn = None
try:
conn = psycopg2.connect(database = self.mau_db, user = self.mau_db_user, password = self.mau_db_user_password, host = "/var/run/postgresql", port = "6432")
cur = conn.cursor()
cur.execute(insert_sql, (program, start, finish,))
cur.execute("UPDATE execution_time SET start=(%s), finish=(%s) where program=(%s)", (start, finish, program))
conn.commit()
cur.close()
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
def write_api(self, server, software, users, mau, alive, api, soft_version):
now = datetime.now()
insert_sql = "INSERT INTO fediverse(server, updated_at, software, users, mau, alive, users_api, version) VALUES(%s,%s,%s,%s,%s,%s,%s,%s) ON CONFLICT DO NOTHING"
conn = None
try:
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
print(f'Writing {server} nodeinfo data...')
cur.execute(insert_sql, (server, now, software, users, mau, alive, api, soft_version))
cur.execute(
"UPDATE fediverse SET updated_at=(%s), software=(%s), users=(%s), mau=(%s), alive=(%s), users_api=(%s), version=(%s) where server=(%s)",
(now, software, users, mau, alive, api, soft_version, server)
)
cur.execute("UPDATE world SET checked='t' where server=(%s)", (server,))
conn.commit()
cur.close()
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
def check_peer(self, server):
found = False
select_server_sql = 'select server from servers where server=(%s)'
select_dead_server_sql = 'select server from deadservers where server=(%s)'
try:
conn = None
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
# check server
cur.execute(select_server_sql, (server,))
row = cur.fetchone()
if row != None:
found = True
cur.execute(select_dead_server_sql, (server,))
row = cur.fetchone()
if row != None:
found = True
cur.close()
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
return found
def get_not_updated_servers(self):
not_updated_servers = []
try:
conn = None
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
# get saved servers list
cur.execute("select server from servers where updated_at is null")
rows = cur.fetchall()
for row in rows:
not_updated_servers.append(row[0])
cur.close()
print("Not updated servers: " + str(len(not_updated_servers)))
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
return not_updated_servers
def get_saved_servers(self):
saved_servers = []
try:
conn = None
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
# get saved servers list
cur.execute("select server from servers where api is not null")
rows = cur.fetchall()
for row in rows:
saved_servers.append(row[0])
cur.close()
print("Saved servers: " + str(len(saved_servers)))
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
return saved_servers
def get_dead_servers(self):
dead_servers = []
try:
conn = None
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
# get dead servers list
cur.execute("select server from deadservers")
rows = cur.fetchall()
for row in rows:
dead_servers.append(row[0])
cur.close()
print("Dead servers: " + str(len(dead_servers)))
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
return dead_servers
def soft_totals(self):
# get current total servers and users, get users from every software
now = datetime.now()
gettotals_sql = "select count(server), sum(users), sum(mau) from mau where alive"
get_soft_totals_sql = "select software, sum(users) as users, sum(mau) as mau, count(server) as servers from mau where users != 0 and mau is not null and alive group by software order by mau desc"
soft_total_project = []
soft_total_users = []
soft_total_mau = []
soft_total_servers = []
try:
conn = None
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
cur.execute(gettotals_sql)
row = cur.fetchone()
total_servers = row[0]
total_users = row[1]
total_mau = row[2]
cur.execute(get_soft_totals_sql)
rows = cur.fetchall()
for row in rows:
soft_total_project.append(row[0])
soft_total_users.append(row[1])
soft_total_mau.append(row[2])
soft_total_servers.append(row[3])
cur.close()
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
return (soft_total_project, soft_total_users, soft_total_mau, soft_total_servers, total_servers, total_users, total_mau)
def get_last_checked_servers(self):
# get last checked servers from fediverse DB
alive_servers = []
try:
conn = None
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
# get world servers list
cur.execute("select server from world where server in (select server from fediverse where users_api != '')")
rows = cur.fetchall()
for row in rows:
alive_servers.append(row[0])
cur.close()
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
return alive_servers
def write_alive_server(self, server, software, version, users, mau, alive):
now = datetime.now()
insert_sql = "INSERT INTO mau(server, software, version, users, mau, alive, updated_at) VALUES(%s,%s,%s,%s,%s,%s,%s) ON CONFLICT DO NOTHING"
conn = None
try:
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
cur.execute(insert_sql, (server, software, version, users, mau, alive, now))
cur.execute("UPDATE mau SET software=(%s), version=(%s), users=(%s), mau=(%s), alive=(%s), updated_at=(%s) where server=(%s)", (software, version, users, mau, alive, now, server))
conn.commit()
cur.close()
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
def write_not_alive_server(self, server):
now = datetime.now()
update_sql = "UPDATE mau set alive='f', updated_at=(%s) where server=(%s)"
conn = None
try:
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
cur.execute(update_sql, (now, server))
conn.commit()
cur.close()
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
def write_server(self, server, api):
now = datetime.now()
insert_sql = "INSERT INTO servers(server, api, created_at, peers) VALUES(%s, %s, %s, %s) ON CONFLICT DO NOTHING"
conn = None
try:
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
cur.execute(insert_sql, (server, api, now, False))
conn.commit()
cur.close()
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
def write_deadserver(self, server):
now = datetime.now()
insert_sql = "INSERT INTO deadservers(server, checked_at) VALUES(%s,%s) ON CONFLICT DO NOTHING"
conn = None
try:
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
cur.execute(insert_sql, (server, now))
conn.commit()
cur.close()
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
def update_peer(self, server):
now = datetime.now()
update_sql = "UPDATE servers set peers=(%s), updated_at=(%s) where server=(%s)"
conn = None
try:
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
cur.execute(update_sql, ('t', now, server))
conn.commit()
cur.close()
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
def update_server(self, server, api):
now = datetime.now()
update_sql = "UPDATE servers set server=(%s), api=(%s), updated_at=(%s) where server=(%s)"
conn = None
try:
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
cur.execute(update_sql, (server, api, now, server))
conn.commit()
cur.close()
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
def soft_totals(self):
# get current total servers and users, get users from every software
now = datetime.now()
gettotals_sql = "select count(server), sum(users), sum(mau) from mau where alive"
get_soft_totals_sql = "select software, sum(users) as users, sum(mau) as mau, count(server) as servers from mau where users != 0 and mau is not null and alive group by software order by mau desc"
soft_total_project = []
soft_total_users = []
soft_total_mau = []
soft_total_servers = []
try:
conn = None
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
cur.execute(gettotals_sql)
row = cur.fetchone()
total_servers = row[0]
total_users = row[1]
total_mau = row[2]
cur.execute(get_soft_totals_sql)
rows = cur.fetchall()
for row in rows:
soft_total_project.append(row[0])
soft_total_users.append(row[1])
soft_total_mau.append(row[2])
soft_total_servers.append(row[3])
cur.close()
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
return (soft_total_project, soft_total_users, soft_total_mau, soft_total_servers, total_servers, total_users, total_mau)
def last_values(self, total_servers, total_users, total_mau):
# get last check values and write current total ones
now = datetime.now()
evo_servers = 0
evo_users = 0
evo_mau = 0
select_sql = "select total_servers, total_users, total_mau from totals order by datetime desc limit 1"
insert_sql = "INSERT INTO totals(datetime, total_servers, total_users, total_mau) VALUES(%s,%s,%s,%s)"
try:
conn = None
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
cur.execute(select_sql)
row = cur.fetchone()
if row is not None:
servers_before = row[0]
users_before = row[1]
mau_before = row[2]
else:
servers_before = 0
users_before = 0
mau_before = 0
cur.execute(insert_sql, (now, total_servers, total_users, total_mau))
conn.commit()
cur.close()
evo_servers = total_servers - servers_before
evo_users = total_users - users_before
evo_mau = total_mau - mau_before
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
return (evo_servers, evo_users, evo_mau)
def write_evo(self, evo_servers, evo_users, evo_mau):
# write evo values
now = datetime.now()
insert_sql = "INSERT INTO evo(datetime, servers, users, mau) VALUES(%s,%s,%s,%s)"
conn = None
try:
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
cur.execute(insert_sql, (now, evo_servers, evo_users, evo_mau))
conn.commit()
cur.close()
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
def last_world_datetime(self):
# get world's last update datetime
conn = None
try:
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
cur.execute("select updated_at from world order by updated_at desc limit 1")
row = cur.fetchone()
last_update = row[0]
last_update = last_update.strftime('%m/%d/%Y, %H:%M:%S')
cur.close()
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
return last_update
def max(self):
# get max servers, max users and max mau
conn = None
try:
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
cur.execute("select MAX(total_servers) from totals")
row = cur.fetchone()
if row is not None:
max_servers = row[0]
else:
max_servers = 0
cur.execute("select MAX(total_users) from totals")
row = cur.fetchone()
if row is not None:
max_users = row[0]
else:
max_users = 0
cur.execute("select MAX(total_mau) from totals")
row = cur.fetchone()
if row is not None:
max_mau = row[0]
else:
max_mau = 0
cur.close()
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
return (max_servers, max_users, max_mau)
def get_plots(self):
# get plots
servers_plots = []
users_plots = []
mau_plots = []
global_day = []
global_servers = []
global_users = []
global_mau = []
global_week = []
global_week_users = []
global_week_mau = []
2023-04-08 13:15:29 +02:00
conn = None
try:
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
cur.execute("select total_servers, total_users, total_mau from totals order by datetime desc limit 14")
rows = cur.fetchall()
for row in rows:
servers_plots.append(row[0])
users_plots.append(row[1])
mau_plots.append(row[2])
cur.execute("select distinct on (date_trunc('day', datetime)) datetime::TIMESTAMP::DATE, total_servers, total_users, total_mau from totals group by date_trunc('day', datetime), datetime")
rows = cur.fetchall()
for row in rows:
global_day.append(row[0])
global_servers.append(row[1])
global_users.append(row[2])
global_mau.append(row[3])
cur.execute("select distinct on (date_trunc('week', datetime)) datetime::TIMESTAMP::DATE, total_users, total_mau from totals group by date_trunc('week', datetime), datetime")
rows = cur.fetchall()
for row in rows:
global_week.append(row[0])
global_week_users.append(row[1])
global_week_mau.append(row[2])
2023-04-08 13:15:29 +02:00
cur.close()
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
return (servers_plots, users_plots, mau_plots, global_day, global_servers, global_users, global_mau, global_week, global_week_users, global_week_mau)
2023-04-08 13:15:29 +02:00
def get_server_data(self, server):
was_alive = None
software = None
api = None
soft_version = None
first_checked_at = None
downs_qty = None
mau = 0
try:
conn = None
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password = self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
cur.execute("select alive, software, users_api, version, first_checked_at, downs, mau from fediverse where server=(%s)", (server,))
row = cur.fetchone()
if row is not None:
was_alive = row[0]
software = row[1]
api = row[2]
soft_version = row[3]
first_checked_at = row[4]
downs_qty = row[5]
mau = row[6]
cur.close()
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
return (was_alive, software, api, soft_version, first_checked_at, downs_qty, mau)
def get_soft_data(self, search_soft):
try:
conn = None
conn = psycopg2.connect(database = self.mau_db, user = self.mau_db_user, password = self.mau_db_user_password, host = "/var/run/postgresql", port = "6432")
cur = conn.cursor()
cur.execute("select count(server), sum(users), sum(mau) from fediverse where software=(%s) and alive", (search_soft,))
row = cur.fetchone()
if row != None:
servers = row[0]
users = row[1]
mau = row[2]
else:
servers = 0
users = 0
mau = 0
cur.close()
return (servers, users, mau)
except (Exception, psycopg2.DatabaseError) as error:
sys.exit(error)
finally:
if conn is not None:
conn.close()
def fediquery_server_data(self, search_server):
try:
conn = None
conn = psycopg2.connect(database = self.mau_db, user = self.mau_db_user, password = self.mau_db_user_password, host = "/var/run/postgresql", port = "6432")
cur = conn.cursor()
cur.execute("select server, software, version, users, mau, alive from fediverse where server=(%s)", (search_server,))
row = cur.fetchone()
if row != None:
server = row[0]
software = row[1]
version = row[2]
users = row[3]
if row[4] != None:
mau = row[4]
else:
mau = 0
alive = row[5]
else:
server = ''
software = ''
version = ''
users = 0
mau = 0
alive = False
cur.close()
return (server, software, version, users, mau, alive)
except (Exception, psycopg2.DatabaseError) as error:
sys.exit(error)
finally:
if conn is not None:
conn.close()
def get_uptime(self):
try:
conn = None
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password=self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
cur.execute("select count(server) from fediverse where alive")
row = cur.fetchone()
alive_servers = row[0]
cur.execute("select MAX(date_trunc('day', last_checked_at) - date_trunc('days', first_checked_at)) from fediverse;")
row = cur.fetchone()
max_uptime = row[0]
cur.execute("select count(server) from fediverse where date_trunc('days', last_checked_at)-date_trunc('days',first_checked_at)=(%s)", (max_uptime,))
row = cur.fetchone()
if row is not None:
best_servers = row[0]
cur.execute("select software, count(*) as servers from fediverse where date_trunc('days',last_checked_at)-date_trunc('days', first_checked_at)=(%s) group by software order by servers desc", (max_uptime,))
rows = cur.fetchall()
software_lst = []
servers_lst = []
for row in rows:
software_lst.append(row[0])
servers_lst.append(row[1])
cur.close()
return (alive_servers, max_uptime, best_servers, software_lst, servers_lst)
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
def get_percentage(self, uptime_servers, software):
try:
conn = None
conn = psycopg2.connect(database=self.mau_db, user=self.mau_db_user, password=self.mau_db_user_password, host="/var/run/postgresql", port="6432")
cur = conn.cursor()
cur.execute("select count(server) from fediverse where alive and software=(%s)", (software,))
row = cur.fetchone()
if row is not None:
soft_total_servers = row[0]
cur.close()
soft_uptime_percent = round((uptime_servers * 100) / soft_total_servers, 1)
return (soft_uptime_percent)
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
@staticmethod
def __check_dbsetup(self):
db_setup = False
try:
conn = None
conn = psycopg2.connect(database = self.mau_db, user = self.mau_db_user, password = self.mau_db_user_password, host = "/var/run/postgresql", port = "6432")
db_setup = True
except (Exception, psycopg2.DatabaseError) as error:
print(error)
return db_setup
@staticmethod
def __createdb(self):
conn = None
try:
conn = psycopg2.connect(dbname='postgres',
user=self.mau_db_user, host='',
password=self.mau_db_user_password)
conn.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)
cur = conn.cursor()
print(f"Creating database {self.mau_db}. Please wait...")
cur.execute(sql.SQL("CREATE DATABASE {}").format(
sql.Identifier(self.mau_db))
)
print(f"Database {self.mau_db} created!\n")
self.__dbtables_schemes(self)
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
@staticmethod
def __dbtables_schemes(self):
db = self.mau_db
table = "mau"
sql = "create table "+table+" (server varchar(200) PRIMARY KEY, software varchar(50), version varchar(50), users int, mau int, alive boolean, updated_at timestamptz)"
self.__create_table(self, table, sql)
table = "servers"
sql = "create table "+table+" (server varchar(200) PRIMARY KEY, api varchar(50), created_at timestamptz, peers boolean, update_at timestamptz)"
self.__create_table(self, table, sql)
table = "deadservers"
sql = "create table "+table+" (server varchar(200) PRIMARY KEY, checked_at timestamptz)"
self.__create_table(self, table, sql)
table = "totals"
sql = "create table "+table+" (datetime timestamptz PRIMARY KEY, total_servers INT, total_users INT, total_mau INT)"
self.__create_table(self, table, sql)
table = "evo"
sql = "create table "+table+" (datetime timestamptz PRIMARY KEY, servers INT, users INT, mau INT)"
self.__create_table(self, table, sql)
table = "execution_time"
sql = "create table "+table+" (program varchar(20) PRIMARY KEY, start timestamptz, finish timestamptz)"
self.__create_table(self, table, sql)
@staticmethod
def __create_table(self, table, sql):
conn = None
try:
conn = psycopg2.connect(database = self.mau_db, user = self.mau_db_user, password = self.mau_db_user_password, host = "/var/run/postgresql", port = "6432")
cur = conn.cursor()
print(f"Creating table {table}")
cur.execute(sql)
conn.commit()
print(f"Table {table} created!\n")
except (Exception, psycopg2.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
def __get_parameter(self, parameter, config_file):
if not os.path.isfile(config_file):
print(f"File {config_file} not found..")
return
with open( config_file ) as f:
for line in f:
if line.startswith( parameter ):
return line.replace(parameter + ":", "").strip()
print(f"{config_file} Missing parameter {parameter}")
sys.exit(0)
@staticmethod
def __create_config(self):
if not os.path.exists('config'):
os.makedirs('config')
if not os.path.exists(self.config_file):
print(self.config_file + " created!")
with open(self.config_file, 'w'): pass
@staticmethod
def __write_config(self):
with open(self.config_file, 'a') as the_file:
the_file.write(f'mau_db: {self.mau_db}\nmau_db_user: {self.mau_db_user}\nmau_db_user_password: {self.mau_db_user_password}')
print(f"adding parameters to {self.config_file}\n")