async def update_roles():
guild = bot.get_guild(int(CommonConfig().get_guild_id()))
roles = RolesConfig().get_roles()
mc_players = Database(host=VerifyConfig().get_host(),
user=VerifyConfig().get_user(),
database=VerifyConfig().get_db(),
passwd=VerifyConfig().get_passwd()).get_data()
for mc_player in mc_players:
if guild.get_member(int(mc_player['discord'])) is not None:
member = guild.get_member(int(mc_player['discord']))
if mc_player['mcrole'].lower() in roles:
role = guild.get_role(int(roles[mc_player['mcrole'].lower()]))
if role not in member.roles:
print(member.name + "'s Rollen wurden geupdatet")
await member.add_roles(role)
await member.send("Deine Rollen wurden aktualisiert!")
verified = guild.get_role(int(CommonConfig().get_verified_role()))
if verified not in member.roles:
print(member.name + " hat sich verifiziert")
await member.add_roles(verified)
await member.send("Du wurdest erfolgreich verifiziert!")
await guild.get_channel(
int(CommonConfig().get_general())
).send(member.mention + " hat sich erfolgreich verifiziert!")
await member.edit(nick=Player(uuid=mc_player['uuid']).username)
def __init__(self, name, sub, display=False):
self.path = path_sys[
_platform] + 'Experiments/' #"/Volumes/data/AMOLF/groups/hecke-group/Corentin/rawdata/"
self.name = name
self.sub = sub
#to comment if no mysql server
self.DB = Database.DB()
self.DB.connect(self.name)
self.tmp = Tmp()
#to comment if no mysql server
self.infos = Infos()
self.infos.file = self.path + self.name + '/Files/infos' + str(
self.sub) + '.p'
self.load(dat='infos')
self.infos.file = self.path + self.name + '/Files/infos' + str(
self.sub) + '.p'
#self.infos.ROI=ROI()
self.timeseries = Timeseries()
self.timeseries.file = self.path + self.name + '/Files/timeseries' + str(
self.sub) + '.p'
self.load(dat='timeseries')
self.timeseries.file = self.path + self.name + '/Files/timeseries' + str(
self.sub) + '.p'
self.imagedata = Imagedata()
self.imagedata.file = self.path + self.name + '/Files/imagedata' + str(
self.sub) + '.p'
self.movie = Movie()
self.movie.file = self.path + self.name + '/Movies/' + str(
self.sub) + '/'
class DailyStocks(object):
db, db_engine = Database.initSession()
def __init__(self, date):
self.date = date
self.CGO = {}
self.stock_list = list(
pd.read_sql_query("select distinct code from basic_list",
self.db_engine).code)
def get_cgo(self):
for code in self.stock_list:
try:
# 找到当前日期，获得当前日期以前的100个数据
sql = "select * from basic_list where code =" + "'" + code + "'" + "and date < " + "'" + self.date + "'"
data = pd.read_sql_query(sql, self.db_engine)
data = data[-100:]
data.reset_index(drop=True, inplace=True)
# 计算每日均价
np_data = np.array(
data[['close_price', 'ave_price', 'turnover_rate']])
length = np.shape(np_data)[0]
for i in range(length):
for j in range(i + 1, length):
# data.loc[index, 'turnover_weight'] *= (1 - data.loc[j, 'turnover_weight'])
np_data[i][2] *= (1 - np_data[j][2])
num = np.sum(np_data[:, 2])
np_data[:, 2] /= num
RP = np.sum(np_data[:, 2] * np_data[:, 1])
# data.eval("""
# RP = turnover_weight * ave_price
# """, inplace=True)
# RP = data['RP'].sum()
self.CGO[code] = (np_data[-1][0] - RP) / RP
except:
pass
def insertCGO(self):
ss = scoped_session(self.db)
dbs = ss()
data = self.CGO.items()
dbs.execute(Database.cgo_list.__table__.insert(),
[{
"date": self.date,
"code": element[0],
"cgo_factor": float(element[1])
} for element in data])
dbs.commit()
dbs.close()
ss.remove()
def selectRandom(self, table_name, cols, parameters, values, operators):
db = Database.Database()
cur = db.connection.cursor()
if (isinstance(cols, list)):
cols_str = ""
cols_size = len(cols)
for i in range(0, cols_size):
if i == cols_size - 1:
cols_str += str(cols[i])
break
cols_str += (str(cols[i]) + ", ")
else:
cols_str = "*"
if (not parameters):
cur.execute('''SELECT ''' + cols_str + ''' FROM "''' + table_name +
'''" ORDER BY RANDOM() limit 1;''')
else:
parameters_size = len(parameters)
conditions = ""
for j in range(0, parameters_size):
if j == parameters_size - 1:
conditions += (str(parameters[j]) + " = " + str(values[j]))
break
conditions += (str(parameters[j]) + " = " + str(values[j]) +
" " + str(operators[j]) + " ")
cur.execute('''SELECT ''' + cols_str + ''' FROM "''' + table_name +
'''" WHERE ''' + conditions +
''' ORDER BY RANDOM() limit 1;''')
rows = cur.fetchall()
cur.close()
return rows
async def ontime(self, ctx, name):
for x in OntimeConfig().get_tables():
await ctx.send(x + ": " + Util().formatDate(
Database(host=OntimeConfig().get_host(),
user=OntimeConfig().get_user(),
database=OntimeConfig().get_db(),
passwd=OntimeConfig().get_passwd()).get_ontime(
Player(username=name).uuid, x)))
def get_top5(date):
db, db_engine = Database.initSession()
cgo_sql = "select * from cgo_list where date =" + "'" + date + "'"
cgo = pd.read_sql_query(cgo_sql, db_engine)
data = cgo.sort_values(by='cgo_factor', ascending=False)
data = data[0 * int(data.shape[0] / 5):1 * int(data.shape[0] / 5)]
stock_list = list(data.code)
return stock_list
async def verify(ctx, name):
code = Util().id_generator(5)
if not Player(username=name):
raise PlayerNotFoundError
db = Database(host=VerifyConfig().get_host(),
user=VerifyConfig().get_user(),
database=VerifyConfig().get_db(),
passwd=VerifyConfig().get_passwd())
temp_verification = db.create_temp_verfication(
id=str(ctx.author.id), code=code, uuid=Player(username=name).uuid)
if temp_verification == 0:
await ctx.send(
"Gib zum Verifizieren folgenden Command auf einem der Server ein:\n`/verify "
+ code + "`\nHinweis: Es kann bis zu " +
str(math.floor(int(CommonConfig().get_update_interval()) /
60)) +
" Minuten dauern, bis du deinen Rang erhälst!")
elif temp_verification == 1:
await ctx.send("Account bereits verifiziert!")
elif temp_verification == 2:
new_code = Util().id_generator(5)
db.delete_code(str(ctx.author.id), Player(username=name).uuid)
db.create_temp_verfication(str(ctx.author.id),
Player(username=name).uuid, new_code)
await ctx.send(
"Command wurde bereits eingegeben, deshalb musste ein neuer Command generiert werden:\n`/verify "
+ new_code + "`")
def __init__(self, name, sub):
self.name = name
self.sub = sub
self.DB = Database.DB()
self.DB.connect(self.name)
self.tmp = Tmp()
self.infos = Infos()
self.infos.file = self.path + self.name + '/Files/infos' + str(
self.sub) + '.p'
def select(self, table_name, cols, condition, value):
conn = Database.Database()
cur = conn.connection.cursor()
if (condition == ""):
cur.execute("SELECT ( " + cols + " ) from " + table_name)
else:
cur.execute("SELECT ( " + cols + " ) from " + table_name + " WHERE " + condition + " = " + value)
rows = cur.fetchall()
conn.close()
return rows
def __init__(self, name, sub):
self.path = path_sys[_platform] + 'Experiments/'
self.name = name
self.sub = sub
self.DB = Database.DB()
self.DB.connect(self.name)
self.tmp = Tmp()
self.infos = Infos()
self.infos.file = self.path + self.name + '/Files/infos' + str(
self.sub) + '.p'
self.imagedata = Imagedata()
self.imagedata.file = self.path + self.name + '/Files/imagedata' + str(
self.sub) + '.p'
def __init__(self, name, sub):
self.pref = '/'
self.name = name
self.sub = sub
self.DB = Database.DB()
self.DB.connect(self.name)
self.tmp = Tmp()
self.infos = Infos()
self.infos.file = self.path + self.name + '/Files/infos' + str(
self.sub) + '.p'
self.imagedata = Imagedata()
self.imagedata.file = self.path + self.name + '/Files/imagedata' + str(
self.sub) + '.p'
self.timeseries = Timeseries()
self.timeseries.file = self.path + self.name + '/Files/timeseries' + str(
self.sub) + '.p'
def makeWebhookResult(req):
print "-------------DOWN IS REQUEST START------------"
print req
print "-------------UP IS REQUEST END------------"
if req.get("result").get("action") == "request-game":
print "go"
print config.test
print "TEST_KEY"
print os.environ["TEST_KEY"]
return requestGame(req)
elif req.get("result").get("action") == "get-from-db":
return requestDB(req)
elif req.get("result").get("action") == "test-event":
return requestEvent(req)
elif req.get("result").get("action") == "test-singleton":
return requestSingleton(req)
elif req.get("result").get("action") == "createDB":
requestDB(req)
conn = Database.Database()
return conn.__createTables__()
elif req.get("result").get("action") == "get-random-name":
return requestRandomName()
elif req.get("result").get("action") == "req-username":
return requestUserName(req)
elif req.get("result").get("action") == "addMenu":
return addMenu()
elif req.get("result").get("action") == "deleteMenu":
return deleteMenu()
elif req.get("result").get("action") == "notify_start" or req.get(
"result").get("action") == "notify_stop":
return notifyMeSomeTimes(req)
elif req.get("result").get("action") == "id_pages":
return getId_pages()
elif req.get("result").get("action") == "appScopedID":
return getAppScopedID(req)
elif req.get("result").get("action") == "notifyMeWithButton":
return notifyWithButton()
else:
return {}
class Factors(object):
db, db_engine = Database.initSession()
def __init__(self):
self.data = None
def getToday(self):
self.data = pd.read_excel(path, dtype=object)
self.data[['return']] = self.data[['return']].astype(float)
def insertToday(self):
engine = self.db_engine
max_iteration = math.ceil(self.data.shape[0] / 50000)
for i in range(max_iteration):
if i != max_iteration - 1:
self.data[i * 50000:(i + 1) * 50000].to_sql('basic_list',
con=engine,
if_exists='append',
index=False)
else:
self.data[i * 50000:].to_sql('basic_list',
con=engine,
if_exists='append',
index=False)
from Data import Database
import sys
if __name__ == '__main__':
print("Check connection with the database....", end="")
status, code, msg = Database.checkDatabase()
if status:
print("Success!")
print("Table already exists")
sys.exit()
if code != "f405":
print("Connect to database failed: %s" % msg)
print("Please check your config")
sys.exit()
print("Creating tables......", end="")
Database.createTables()
print("Success!")
# total_threads[st].start()
# running_threads.append(total_threads[st])
# st += 1
# continue
# for t in running_threads:
# if not t.is_alive():
# running_threads.remove(t)
# for t in total_threads:
# t.join()
# f = Factors()
# f.getToday()
#print(f.data)
#获取时间交集，保证全部时间的交集一致
db, db_engine = Database.initSession()
basic = pd.read_excel(path, dtype=object)
code_list = "select distinct code from basic_list"
code_list = list(pd.read_sql_query(code_list, db_engine).code)
error_code = []
for code in code_list:
#date_sql = "select distinct date from basic_list where code =" + "'"+code+"'"
#date_list = list(pd.read_sql_query(date_sql, db_engine).date)
date_list = list(basic[basic['code'] == code].date)
if len(date_list) > 1900:
pass
#print(allin(date_list,date_intersection))
def registerUser(self, pageScopedID):
db = Database.Database()
appScopedID = self.getAppScopedID(pageScopedID)
db.insert("User", ["Page_ScopedID", "App_ScopedID"],
[pageScopedID, appScopedID],
["Page_ScopedID", "App_ScopedID"], "")
