async def embd(ctx, *args):
colors = {
"red": Color.red(),
"green": Color.green(),
"gold": Color.gold(),
"orange": Color.orange(),
"blue": Color.blue(),
"purple": Color.purple(),
"teal": Color.teal(),
"magenta": Color.magenta(),
"grey": Color.lighter_grey()
}
if args:
argstr = " ".join(args)
if "-c " in argstr:
text = argstr.split("-c ")[0]
color_str = argstr.split("-c ")[1]
color = colors[
color_str] if color_str in colors else Color.default()
else:
text = argstr
color = Color.default()
await client.say(embed=Embed(color=color, description=text))
await client.delete_message(ctx.message)
def turn_summary(self):
'''
Generates an embed summarizing the turn
'''
turn_embed = Embed(
title="Turn Summary",
color=Color.teal(),
timestamp=datetime.utcnow(),
)
# Summarize the actions, challenges, and responses of the game
if self._action is not None:
turn_embed.add_field(name="Action",
value=self._action.complete_message(),
inline=False)
if self._challenge1 is not None:
turn_embed.add_field(name="Challenge 1",
value=self._challenge1.complete_message(),
inline=False)
if self._response is not None:
turn_embed.add_field(name="Response",
value=self._response.complete_message(),
inline=False)
if self._challenge2 is not None:
turn_embed.add_field(name="Challenge 2",
value=self._challenge2.complete_message(),
inline=False)
if len(self._deaths) > 0:
turn_embed.add_field(name="Deaths",
value="\n".join(d.complete_message()
for d in self._deaths))
turn_embed.set_footer(text="Turn completed at")
return turn_embed
async def modifier(self, ctx):
modifiers = self.modifiers
if ctx.invoked_subcommand is not None:
return
# Display Modifiers Menu
list_ = ""
for mod in modifiers:
try:
list_ += mod['name'] + "\n"
except TypeError:
list_ += mod + "\n"
applied = ""
for mod in self.tournament.modifiers:
try:
applied += f"`{mod['name']}` = {mod['value']} \n"
except TypeError:
applied += f"`{mod}` \n"
embed = Embed(title="Modifiers Menu", color=Color.teal())
embed.add_field(name="Available Modifiers", value=list_, inline=True)
if applied != "":
embed.add_field(name="Active Modifiers",
value=applied,
inline=True)
await ctx.send(embed=embed)
def profile_id(ctx, args):
syntax_err = discord.Embed(title="Failed",
colour=Color.red(),
description="ERROR: !profileid <user id>")
if len(args) < 2:
return syntax_err
user_id = args[1]
user_presence = RobloxAPI.get_user_presence(user_id).json()
user = RobloxAPI.get_user_by_id(user_id).json()
pfp = RobloxAPI.get_pfp_by_id(user_id)
status = RobloxAPI.get_user_status(user_id)
display_name = user['displayName']
presence_type = RobloxAPI.get_presence_type(
user_presence['userPresences'][0]['userPresenceType'])
presence_type_num = user_presence['userPresences'][0]['userPresenceType']
game_name = "Not in game" if presence_type_num is 0 or presence_type_num is 1 else \
user_presence['userPresences'][0][
'lastLocation']
game_id = user_presence['userPresences'][0]['placeId']
game_url = None if presence_type_num is 1 or presence_type_num is 0 else RobloxAPI.get_game_link(
game_id)
e = discord.Embed(title=display_name,
colour=Color.teal(),
description="Information on Roblox Profile",
url=game_url)
e.set_thumbnail(url=pfp)
e.add_field(name="Status", value=status, inline=False)
e.add_field(name="In-Game", value=presence_type, inline=True)
e.add_field(name="Game", value=game_name, inline=False)
return e
def random():
# type: () -> Color
chilipepper = Color(0x9B1B30)
tan = Color(0xBEAA3E)
icedcoffee = Color(0xB18F6A)
return choice([
Color.teal(),
Color.dark_teal(),
Color.green(),
Color.dark_green(),
Color.blue(),
Color.dark_blue(),
Color.purple(),
Color.dark_purple(),
Color.magenta(),
Color.dark_magenta(),
Color.gold(),
Color.dark_gold(),
Color.orange(),
Color.dark_orange(),
Color.red(),
Color.dark_red(),
Color.lighter_grey(),
Color.darker_grey(),
Color.blurple(),
tan,
icedcoffee,
chilipepper,
])
def __init__(self, client):
self.client = client
self.client_color = Color.red()
self.color_dict = {
1: [Color.teal(), 'teal'],
2: [Color.dark_teal(), 'dark_teal'],
3: [Color.green(), 'green'],
4: [Color.dark_green(), 'dark_green'],
5: [Color.blue(), 'blue'],
6: [Color.dark_blue(), 'dark_blue'],
7: [Color.purple(), 'purple'],
8: [Color.dark_purple(), 'dark_purple'],
9: [Color.magenta(), 'magenta'],
10: [Color.dark_magenta(), 'dark_magenta'],
11: [Color.gold(), 'gold'],
12: [Color.dark_gold(), 'dark_gold'],
13: [Color.orange(), 'orange'],
14: [Color.dark_orange(), 'dark_orange'],
15: [Color.red(), 'red'],
16: [Color.dark_red(), 'dark_red'],
17: [Color.lighter_grey(), 'lighter_grey'],
18: [Color.dark_grey(), 'grey'],
19: [Color.light_grey(), 'light_grey'],
20: [Color.darker_grey(), 'darker_grey']
}
def random():
# type: () -> Color
tan = Color(0xBEAA3E)
return choice([
Color.teal(),
Color.dark_teal(),
Color.green(),
Color.dark_green(),
Color.blue(),
Color.dark_blue(),
Color.purple(),
Color.dark_purple(),
Color.magenta(),
Color.dark_magenta(),
Color.gold(),
Color.dark_gold(),
Color.orange(),
Color.dark_orange(),
Color.red(),
Color.dark_red(),
Color.lighter_grey(),
Color.darker_grey(),
Color.blurple(),
tan,
])
def random():
c = [
Color.teal(),
Color.dark_teal(),
Color.green(),
Color.dark_green(),
Color.blue(),
Color.dark_blue(),
Color.purple(),
Color.dark_purple(),
Color.magenta(),
Color.dark_magenta(),
Color.gold(),
Color.dark_gold(),
Color.orange(),
Color.dark_orange(),
Color.red(),
Color.dark_red(),
Color.lighter_grey(),
Color.darker_grey(),
Color.blurple(),
tan,
icedcoffee,
chilipepper
]
return c[randint(0, len(c) - 1)]
def timedOut(reason, ctx, bot, footer):
embed = Embed(title=reason,
colour = ctx.author.colour if ctx else Color.teal(),
timestamp=datetime.datetime.now())
embed.set_footer(text=footer)
embed.set_author(name=bot.user.name, icon_url=bot.user.avatar_url)
return embed
def help_command(ctx, args):
from src import main
from src.settings import Config
commands_list = ""
for key in main.commands:
commands_list += f"{key}\n"
e = discord.Embed(title="Commands", colour=Color.teal(), description="List of available commands.") \
.set_thumbnail(url=Config.THUMBNAIL_URL) \
.add_field(name="Commands", value=commands_list, inline=True)
return e
def get_gradient_color(percentage):
percentage = 50 + int(percentage) / 2
return gradient(
Color.red(),
Color.magenta(),
Color.lighter_grey(),
Color.teal(),
Color.green(),
percentage=percentage,
)
async def t(self, ctx):
tournament = self.tournament
embed = Embed(title=tournament.name, color=Color.teal())
for field in self.attr:
value = getattr(tournament, field)
embed.add_field(name=field.title(), value=value)
if tournament.id is not None:
embed.set_footer(text="Tournament ID: " + str(tournament.id))
await ctx.send("Here's how the tournament currently looks like:",
embed=embed)
def gen_embed(title: str, description: str = None, data: dict = {}):
"""Generate a Discord embed
Args:
title (str): The title of the embed
description (str, optional): The description of the embed. Defaults to None.
data (dict, optional): The fields of the embed. Defaults to {}.
Returns:
discord.Embed: A Discord embed ready to send
"""
e = Embed(title=title, description=description, color=Color.teal())
for key, value in data.items():
e.add_field(name=key, value=value)
return e
async def pypisearch(self, ctx: Context, arg: str):
"""Get info about a Python package directly from PyPi"""
res_raw = await self.get_package(f"https://pypi.org/pypi/{arg}/json")
try:
res_json = await res_raw.json()
except ContentTypeError:
return await ctx.send(
embed=Embed(
description="No such package found in the search query.",
color=Color.blurple(),
)
)
res = res_json["info"]
def getval(key):
return res[key] or "Unknown"
name = getval("name")
author = getval("author")
author_email = getval("author_email")
description = getval("summary")
home_page = getval("home_page")
project_url = getval("project_url")
version = getval("version")
_license = getval("license")
embed = Embed(
title=f"{name} PyPi Stats", description=description, color=Color.teal()
)
embed.add_field(name="Author", value=author, inline=True)
embed.add_field(name="Author Email", value=author_email, inline=True)
embed.add_field(name="Version", value=version, inline=False)
embed.add_field(name="License", value=_license, inline=True)
embed.add_field(name="Project Url", value=project_url, inline=False)
embed.add_field(name="Home Page", value=home_page)
embed.set_thumbnail(url="https://i.imgur.com/syDydkb.png")
await ctx.send(embed=embed)
async def start_reminder(self, destination):
try:
ten_mins_before = self.time - timedelta(minutes=10)
await utils.sleep_until(ten_mins_before)
mentions = ""
for player in self.subscribed:
mentions += player.mention + " "
embed = Embed(
title="Reminder",
description=f"**{self.name}** will start in 10 minutes!",
color=Color.teal())
await destination.send(mentions, embed=embed)
except CancelledError:
pass
async def display_exp(self, ctx, member: Optional[Member]):
member = member or ctx.author
xp, lvl = db.record(
"SELECT xp, level FROM member_exp WHERE member_id = ? AND guild_id = ?;",
member.id, member.guild.id) or (None, None)
if lvl is not None:
embed = create_embed(
"Level",
f"{member.display_name} is level {lvl:,} with {xp:,} XP.",
color=Color.teal(),
thumbnail_url=member.avatar_url)
await ctx.send(embed=embed)
else:
await ctx.send("That member does not have any exp data.")
async def tset(self, ctx, attribute, *, value):
if attribute not in self.attr:
raise commands.BadArgument(
f"`{attribute}` is not a valid tournament attribute.")
if attribute == 'host':
value = await commands.MemberConverter().convert(ctx, value)
elif attribute == 'time':
try:
value = parser.parse(value, dayfirst=True)
except ValueError:
raise commands.BadArgument(
f"`{value}` is not a valid time format. Refer to the pinned messages for a list of time formats."
)
old_value = getattr(self.tournament, attribute)
setattr(self.tournament, attribute, value)
if self.tournament.status in (3, 4):
embed = UpdatedEmbed(self.tournament)
await self.tournament.msg.edit(embed=embed)
await ctx.send(
f"{Emote.check} The `{attribute}` has been set to **{value}**.")
fields = [{
"name": "Old Value",
"value": old_value
}, {
"name": "New Value",
"value": value
}]
if old_value is None:
del fields[0]
Log("Value Updated",
description=
f"{ctx.author.mention} updated the `{attribute}` for **{self.tournament.name}**.",
color=Color.teal(),
fields=fields)
def roblox_profile(ctx, args):
syntax_err = discord.Embed(
title="Failed",
colour=Color.red(),
description="ERROR: !roblox/!profile <username>")
if len(args) < 2:
return syntax_err
username = args[1]
# Both Profile Commands can be optimized for sure, by reducing the amount of requests
user = RobloxAPI.get_user_by_username(username).json()
user_presence = RobloxAPI.get_user_presence(user['data'][0]['id']).json()
user_id = user['data'][0]['id']
pfp = RobloxAPI.get_pfp_by_id(user_id)
status = RobloxAPI.get_user_status(user_id)
display_name = user['data'][0]['displayName']
presence_type = RobloxAPI.get_presence_type(
user_presence['userPresences'][0]['userPresenceType'])
presence_type_num = user_presence['userPresences'][0]['userPresenceType']
game_name = "Not in game" if presence_type_num is 0 or presence_type_num is 1 else \
user_presence['userPresences'][0][
'lastLocation']
game_id = user_presence['userPresences'][0]['placeId']
game_url = None if presence_type_num is 1 or presence_type_num is 0 else RobloxAPI.get_game_link(
game_id)
e = discord.Embed(title=display_name,
colour=Color.teal(),
description="Information on Roblox Profile",
url=game_url)
e.set_thumbnail(url=pfp)
e.add_field(name="Status", value=status, inline=False)
e.add_field(name="In-Game", value=presence_type, inline=True)
e.add_field(name="Game", value=game_name, inline=False)
return e
async def stats(self, ctx):
current_process = psutil.Process()
cpu_usage = current_process.cpu_percent()
memory = (resource.getrusage(resource.RUSAGE_SELF).ru_maxrss) / 1000
current_time = time.time()
difference = int(round(current_time - main_up))
text = str(datetime.timedelta(seconds=difference))
embed = discord.Embed(title="Stats", color=Color.teal())
embed.add_field(
name="Server Count",
value=f"""```css
[{len(self.bot.guilds)} servers]```""",
)
embed.add_field(
name="CPU usage",
value=f"""```css
[{cpu_usage}%]```""",
inline=True,
)
embed.add_field(
name="Uptime",
value=f"""```css
[{text}]```""",
)
embed.add_field(
name="Memory",
value=f"""```ini
[{memory} kb]```""",
)
embed.add_field(
name="User Countries",
value=f"""```ini
[{await count()}]```""",
)
embed.add_field(
name="Creator",
value=f"""```ini
[Coder N#0001]```""",
inline=True,
)
embed.add_field(
name="Websocket Ping",
value=f"""```ini
[{self.bot.latency * 1000} ms]```""",
)
embed.add_field(
name="Commands",
value=f"""```css
[{len(self.bot.commands)}]```""",
)
embed.set_footer(
text=
"If some percentages show 0.0%, it means that the number is really close to zero."
)
await ctx.channel.send(embed=embed)
async def commands(message, client):
if message.content.startswith('>help'):
txt = ""
txt += "**FONCTIONS D\'ANIMATION DU DISCORD**\n"
txt += "-----------------------------------\n"
txt += ':dog2: | **>ordre** : Donne un ordre à Ohana.\n'
txt += '> Paramètres :\n'
txt += '> *assis*, *couché* ou *patte* | Liste non exhaustive.A toi de trouver les autres :upside_down:.\n'
txt += '> Exemple : **>ordre patte chien**\n'
txt += ':frame_photo: | **>race** : affiche une race d\`une espèce aléatoire.\n'
txt += '> Paramètres :\n'
txt += '> *chien* :dog:, *chat* :cat: ou *cheval* :horse: | Permet de préciser l\'espèce dont la race tirée au sort est associée.\n'
txt += '> Exemple : **>race chien**\n'
txt += ':teacher: | **>anecdote** : affiche une anecdote sur les animaux.\n'
txt += "\n"
txt += "**FONCTIONS POUR LES QUIZ**\n"
txt += "-----------------------------------\n"
txt += ':question: | **>quiz** : commande globale pour toutes les commandes liées aux quiz.\n'
txt += '> Paramètres :\n'
txt += '> *planning* :calendar: | Affiche la liste des quiz avec leur date.\n'
txt += '> *classement* :crown: | Affiche le classement en cours (mois courant).\n'
txt += '> *rappel* :notepad_spiral: | Gestion de la liste des joueurs de quiz qui veulent un rappel 10 minutes avant les quiz.\n'
txt += "\n"
txt += "**FONCTIONS DE GESTION DU DISCORD**\n"
txt += "-----------------------------------\n"
# txt += ':bar_chart: **>utilisateurs** : affiche des statistiques sur les utilisateurs du Discord.\n'
# txt += ':bar_chart: **>messages** : affiche des statistiques sur les messages postés sur le Discord.\n'
# txt += ':calendar: **>algo** : affiche le lien vers le flowchart du bot.\n'
txt += ':calendar: **>code** : affiche le lien vers la roadmap du bot.\n'
txt += ':computer: **>data** : regénère les fichiers de données pour mettre à jour les statistiques.\n'
await message.channel.send(txt)
if message.content.startswith('>test'):
commands = [
'>help', '>race', '>race chat', '>race chien', '>race cheval',
'>anecdote', '>ordre assis', '>ordre couché', '>ordre patte',
'>ordre high five', '>ordre belle', '>utilisateur', '>messages',
'>code', '>data'
]
for command in commands:
await message.channel.send(command)
await asyncio.sleep(1)
# INTERACTIONS COMMANDS
if message.content.startswith('>ordre'):
await functions.apply_order(message)
if message.content.startswith('>anecdote'):
await functions.anecdote(message)
if message.content.startswith('>race'):
await functions.race(message)
# QUIZ COMMANDS
if message.content.startswith('>quiz planning'):
import pandas as pd
df = pd.read_excel("inputs/xlsx/planning.xlsx")
def category(cat):
if "Chien" in cat:
return ":dog2:"
if "Chat" in cat:
return ":cat2:"
if "Cheval" in cat:
return ":racehorse:"
if "Oiseau" in cat:
return ":bird:"
if "NAC" in cat:
return ":rabbit2:"
if "?" in cat:
return ":interrobang:"
return ":feet:"
txt = "**QUIZ PASSÉS**\n"
separator_added = False
for id, row in df.iterrows():
# Date Titre Catégorie
ts = pd.to_datetime(str(row['Date']))
date = ts.strftime('%d/%m/%Y')
d, m, y = date.split("/")
d = functions.rank_to_emote(d, type="date")
m = functions.rank_to_emote(m, type="date")
y = functions.rank_to_emote(y, type="date")
import datetime
if (ts > datetime.datetime.now() and not separator_added):
txt += "**QUIZ FUTURS**\n"
separator_added = True
# txt += "{}/{}/{} : {} {}\n".format(d,m,y, row['Titre'], category(row['Catégorie']))
txt += ":arrow_forward: {} {} : {}\n".format(
category(row['Catégorie']), date, row['Titre'])
if len(txt) > 1000:
am = discord.AllowedMentions(everyone=False,
users=False,
roles=False,
replied_user=False)
await message.channel.send(txt, allowed_mentions=am)
txt = ""
am = discord.AllowedMentions(everyone=False,
users=False,
roles=False,
replied_user=False)
await message.channel.send(txt, allowed_mentions=am)
if message.content.startswith('>question'):
import pandas as pd
df = pd.read_csv("inputs/csv/fci.csv", delimiter="\t")
l = list()
for key, row in df.sample().iterrows():
r = row
while r['id'] in l:
for key, row in df.sample().iterrows():
r = row
l.append(r['id'])
id_b = r['id']
name_b = r['name_fr']
country_b = r['country']
propositions = list()
propositions.append(country_b)
await message.channel.send("De quel pays provient la race : " +
name_b.title())
rows_same_country = df[df['country'] == country_b]
rows_diff_country = df.merge(
rows_same_country, how='outer',
indicator=True).loc[lambda x: x['_merge'] == 'left_only']
other_responses = rows_diff_country.sample(3)
for key, row in other_responses.iterrows():
propositions.append(row['country'].title())
for p in propositions:
await message.channel.send("- {}".format(p.title()))
await message.channel.send(":star: Réponse : ||" + country_b.title() +
"||")
if message.content.startswith('>quiz classement'):
quiz.prepare_csv()
functions.create_podium()
df_members = pd.read_csv("outputs/members.csv")
def get_discriminator(author):
return author.split("#")[-1]
df_quizz = pd.read_csv("outputs/charts/classement.csv")
df_quizz['discriminator'] = df_quizz.apply(
lambda x: get_discriminator(x['Username']), axis=1)
df_members['discriminator'] = df_members['discriminator'].astype(int)
df_quizz['discriminator'] = df_quizz['discriminator'].astype(int)
df = df_quizz.merge(df_members,
how="left",
suffixes=('_quizz', '_data'))
await message.channel.send(file=discord.File('outputs/podium.png'))
txt = "Classement du mois :\n"
for key, row in df.head(10).iterrows():
print(row['id' ''])
txt += "{}\n{} [<@{}>]\n:homes: {} |:1234: {}pts\n".format(
functions.rank_to_emote(key + 1),
row['display_name'].split("-")[0].strip(), row['id'],
row['refuge'], row['Points'])
if len(txt) > 1000:
am = discord.AllowedMentions(everyone=False,
users=False,
roles=False,
replied_user=False)
await message.channel.send(txt, allowed_mentions=am)
txt = ""
am = discord.AllowedMentions(everyone=False,
users=False,
roles=False,
replied_user=False)
await message.channel.send(txt, allowed_mentions=am)
# await functions.order_not_available(message);
if message.content.startswith('>bug'):
from discord.utils import get
user = get(message.guild.members, name="Cédric")
if user:
await user.send(content=message.author.name)
await user.send(content=message.content)
else:
print("NON")
if message.content.startswith('>quiz rappel'):
await functions.order_not_available(message)
# ADMIN COMMANDS
if message.content.startswith('>algo'):
await functions.order_not_available(message)
if message.content.startswith('>utilisateurs'):
# await functions.order_not_available(message);
# return
df = pd.read_csv("outputs/members.csv")
cjs = df['refuge'].unique()
cjs = sorted(cjs)
roles = [
'Administrateurs', 'Modérateurs', 'Responsables de refuge',
'Agents animaliers', 'Référents', 'Encadrants', 'Jeunes'
]
colors = dict()
colors['Administrateurs'] = Color.red()
colors['Modérateurs'] = Color.orange()
colors['Responsables de refuge'] = Color.green()
colors['Agents animaliers'] = Color.teal()
colors['Référents'] = Color.purple()
colors['Encadrants'] = Color.blue()
colors['Jeunes'] = Color.gold()
colors['Non présentés'] = Color.dark_red()
for cj in cjs:
await message.channel.send(":map: **{}** :map:".format(cj))
df_temp = df[df['refuge'] == cj]
for role in roles:
l = list()
for key, row in df_temp[df_temp['top_role'] ==
role].iterrows():
l.append(row['display_name'])
if len(l) > 0:
l = sorted(l)
emeb = discord.Embed(title=role,
description="\n".join(l),
color=colors[role])
await message.channel.send(embed=emeb)
if message.content.startswith('>messages'):
import time
start_time = time.time()
await message.channel.send('Bien reçu ! Je vais compter les messages.')
await message.channel.send('Je reviens dans quelques secondes ...')
df = pd.read_csv("outputs/csv/messages.csv")
import seaborn as sns
top_five = df['channel'].value_counts().keys()[:5]
df_temp = df[df['channel'].isin(top_five)]
sns_plot = sns.catplot(y="channel",
kind="count",
palette="pastel",
edgecolor=".6",
data=df_temp)
sns_plot.savefig("outputs/images/output.png")
await message.channel.send('En tout, il y a {} messages.'.format(
len(list(df['content']))))
await message.channel.send(
'Répartition dans les salons :',
file=discord.File('outputs/images/output.png'))
await message.channel.send("J'ai trouvé ce résultat en %d secondes." %
int(time.time() - start_time))
return
if message.content.startswith('>code'):
await message.channel.send(
'Tu veux connaître les prochaines améliorations du bot ? Ca se passe ici !'
)
await message.channel.send(
'https://github.com/cedricmaigrot/Discord_laSPA/projects/1')
await message.channel.send(
'Tu veux faire ton propre bot comme <@818564026237452350> ? Le code est en open source !'
)
await message.channel.send(file=discord.File('inputs/images/work.gif'))
if message.content.startswith('>data'):
import time
start_time = time.time()
await message.channel.send('Bien reçu ! Je vais mémoriser les données.'
)
await message.channel.send('Je reviens dans quelques secondes ...')
for guild in client.guilds:
if guild.name in "Clubs Jeunes SPA":
# lst = list()
# for channel in guild.channels:
# print("Channel : " + channel.name)
# try:
# hist = await channel.history(limit=20000).flatten()
# for h in hist:
# lst.append([h.activity, h.application, h.attachments, h.author, h.call, h.channel,
# h.channel_mentions, h.clean_content, h.content, h.created_at, h.edited_at,
# h.embeds, h.flags, h.guild, h.id, h.jump_url, h.mention_everyone, h.mentions,
# h.nonce, h.pinned, h.raw_channel_mentions, h.raw_mentions, h.raw_role_mentions,
# h.reactions, h.reference, h.role_mentions, h.stickers, h.system_content, h.tts,
# h.type, h.webhook_id])
# except:
# pass
# df_messages = pd.DataFrame(lst, columns=["activity", "application", "attachments", "author", "call",
# "channel", "channel_mentions", "clean_content", "content",
# "created_at", "edited_at", "embeds", "flags", "guild", "id",
# "jump_url", "mention_everyone", "mentions", "nonce", "pinned",
# "raw_channel_mentions", "raw_mentions", "raw_role_mentions",
# "reactions", "reference", "role_mentions", "stickers",
# "system_content", "tts", "type", "webhook_id"])
# df_messages.to_csv("outputs/messages.csv")
# df_messages.to_excel("outputs/messages.xlsx")
# df_messages.to_html("outputs/messages.html")
df_messages = pd.read_excel("outputs/messages.xlsx")
lst = list()
for member in guild.members:
print("Member : " + member.name)
lst.append([
member.activities, member.activity, member.avatar,
member.avatar_url, member.bot, member.color,
member.colour, member.created_at,
member.default_avatar, member.default_avatar_url,
member.desktop_status, member.discriminator,
member.display_name, member.guild,
member.guild_permissions, member.id, member.joined_at,
member.mention, member.mobile_status, member.name,
member.nick, member.pending, member.premium_since,
member.public_flags, member.raw_status, member.roles,
member.status, member.system, member.top_role,
member.voice, member.web_status
])
df_members = pd.DataFrame(
lst,
columns=[
"activities", "activity", "avatar", "avatar_url",
"bot", "color", "colour", "created_at",
"default_avatar", "default_avatar_url",
"desktop_status", "discriminator", "display_name",
"guild", "guild_permissions", "id", "joined_at",
"mention", "mobile_status", "name", "nick", "pending",
"premium_since", "public_flags", "raw_status", "roles",
"status", "system", "top_role", "voice", "web_status"
])
def get_shelter(roles):
shelter = "Inconnu"
for role in roles:
r = discord.utils.get(guild.roles, id=role.id)
if "Club Jeunes" in r.name:
shelter = r.name
print(r.name)
return shelter
df_members['refuge'] = df_members.apply(
lambda x: get_shelter(x['roles']), axis=1)
df_members.to_csv("outputs/members.csv")
df_members.to_excel("outputs/members.xlsx")
df_members.to_html("outputs/members.html")
lst = list()
for role in guild.roles:
print("Role : " + role.name)
lst.append([
role.color, role.colour, role.created_at, role.guild,
role.hoist, role.id, role.managed, role.members,
role.mention, role.mentionable, role.name,
role.permissions, role.position, role.tags
])
df_roles = pd.DataFrame(lst,
columns=[
"color", "colour", "created_at",
"guild", "hoist", "id", "managed",
"members", "mention",
"mentionable", "name",
"permissions", "position", "tags"
])
df_roles.to_csv("outputs/roles.csv")
df_roles.to_excel("outputs/roles.xlsx")
df_roles.to_html("outputs/roles.html")
df_members['discriminator'] = df_members[
'discriminator'].astype(str)
def get_discriminator(author):
name = "{}".format(author)
return name.split("#")[-1]
df_messages['author_discriminator'] = df_messages.apply(
lambda x: get_discriminator(x['author']), axis=1)
df_messages['author_discriminator'] = df_messages[
'author_discriminator'].astype(str)
df_merge = df_messages.merge(df_members,
left_on='author_discriminator',
right_on='discriminator',
suffixes=('_messages',
'_members'))
df_merge = df_merge.merge(df_roles,
left_on='top_role',
right_on='name',
suffixes=('', '_role'))
# df_messages[(~df_messages['id'].isin(df_merge['id_messages']))]['author']
df_merge.to_html("outputs/merge.html")
df_merge.to_csv("outputs/merge.csv")
df_merge.to_excel("outputs/merge.xlsx")
await message.channel.send('C\'est fait !')
await message.channel.send("J'ai fait cela en %d secondes." %
int(time.time() - start_time))
return
import discord
from discord.ext import commands
import random
from discord import Color as c
teal = c.teal()
magenta = c.magenta(
) #choose any colour, but be mindful of the discord.Color colours, they are wierd, unless you go with a custom RGB "system"
class Load(commands.Cog):
def __init__(self, client):
self.client = client
@commands.command()
async def commands(self, ctx):
em = discord.Embed(color=teal)
em.add_field(name="`Prefix`",
value='**My Prefix Is** - <',
inline=False)
em.add_field(
name="Commands",
value=
'Do <Commands to get a list of the finest commands i have to offer.',
inline=False)
em.add_field(name='Developer',
value="Do <dev to see who made me!",
inline=False)
em.set_author(
name="Command Information",
icon_url=
async def on_member_unban(self, guild, user):
await self.logembed(user, "Unbanned", Color.teal())
def __init__(self, bot):
self.colors = (Color.red(), Color.gold(), Color.green(),
Color.magenta(), Color.teal(), Color.dark_blue())
self.bot = bot
self.session = aiohttp.ClientSession(
headers={'User-agent': 'RedditCrawler'})
