def __init__(self, client): self.client = client self.client_tools = ClientTools(client) self.database_tools = DatabaseTools(client) insert_channel = "INSERT INTO channels (channel_id, channel_name) VALUES (%s, %s)" update_channel = "UPDATE `gssp_logging`.`channels` SET `channel_name`=%s WHERE `channel_id`=%s;" if not bool(config['discord'].get("skip_scrape")): for guild in client.guilds: logger.info("{}: Updating channels".format(str(guild))) for channel in guild.text_channels: try: cursor.execute( insert_channel, (channel.id, emoji.demojize(channel.name))) logger.debug("Inserted {} to DB".format( emoji.demojize(channel.name))) except mysql.connector.errors.IntegrityError: cursor.execute( update_channel, (emoji.demojize(channel.name), channel.id)) logger.debug("Updated {}".format( emoji.demojize(channel.name))) logger.info("{}: Updating users".format(str(guild))) for member in tqdm(guild.members, total=len(guild.members), desc="Adding users for {}".format( str(guild))): self.database_tools.add_user(member) logger.info("{}: Finished {} users".format( str(guild), len(guild.members))) logger.info("{}: Updating roles".format(str(guild))) for role in guild.roles: if role.name != "@everyone": try: cursor.execute(insert_role, (role.id, emoji.demojize(role.name), guild.id, int(role.mentionable))) except mysql.connector.errors.IntegrityError: cursor.execute(update_role, (emoji.demojize( role.name), int(role.mentionable), role.id)) # this is designed to assist with migration, by moving old discord role members over to the new # system seamlessly member_ids = [] for member in role.members: member_ids.append(member.id) role_db = DbRole(role.id, role.name, 0, members=member_ids) role_db.save_members() logger.info("{}: Finished {} roles".format( guild, len(guild.roles))) cnx.commit() else: logger.warn( "Skipping scraping data from existing servers - data may be out of date" )
def __init__(self, client): self.client = client self.client_extras = ClientTools(client) self.database_extras = DatabaseTools(self.client_extras)
class Tagger(commands.Cog): def __init__(self, client): self.client = client self.client_extras = ClientTools(client) self.database_extras = DatabaseTools(self.client_extras) @commands.command(aliases=["t"]) async def tagger(self, ctx, nsfw: bool = False, selected_channel: discord.TextChannel = None): """ Generates tags for you based on what you talk about """ if (not ctx.message.channel.is_nsfw()) and nsfw: return await ctx.send(strings['tagger']['errors']['nsfw'].format( str(ctx.author))) output = await ctx.send(strings['tagger']['title'] + strings['emojis']['loading']) await output.edit(content=output.content + "\n" + strings['tagger']['status']['messages']) async with ctx.channel.typing(): username = self.database_extras.opted_in(user_id=ctx.author.id) if not username: return await output.edit( content=output.content + strings['tagger']['errors']['not_opted_in']) messages, channels = await self.database_extras.get_messages( ctx.author.id, config['limit']) text = [] text = await self.client_extras.build_messages( ctx, nsfw, messages, channels, selected_channel=selected_channel) text1 = "" for m in text: text1 += str(m) + "\n" await output.edit(content=output.content + strings['emojis']['success'] + "\n" + strings['tagger']['status']['analytical_data']) algo = algo_client.algo('nlp/AutoTag/1.0.1') await output.delete() response = algo.pipe(text1) tags = list(response.result) tag_str = "" for tag in tags: tag_str = "- " + tag + "\n" + tag_str em = await self.client_extras.markov_embed( "Tags for " + str(ctx.author), tag_str) output = await ctx.send(embed=em) emoji = await self.client_extras.get_delete_emoji() emoji = emoji[1] return await self.client_extras.delete_option(self.client, output, ctx, emoji)
class Admin(commands.Cog): def __init__(self, client): self.client = client self.database_tools = DatabaseTools(client) self.client_tools = ClientTools(client) @commands.group(hidden=True) async def debug(self, ctx): """Debug utilities for AGSE and Discord""" if ctx.invoked_subcommand is None: await ctx.send( "Invalid params. Run `help debug` to get all commands.") @is_server_allowed() @debug.command(aliases=["isprocessed", "processed"]) async def is_processed(self, ctx, user=None): """ Admin command used to check if a member has opted in """ if user is None: user = ctx.author.name msg = await ctx.send(strings['process_check']['status']['checking']) if not self.database_tools.opted_in(user=user): return await msg.edit( content=strings['process_check']['status']['not_opted_in']) return await ctx.edit( content=strings['process_check']['status']['opted_in']) @is_owner_or_admin() @debug.command(aliases=["dumproles"]) async def dump_roles(self, ctx): """ Dump all roles to a text file on the host """ to_write = "" for guild in self.client.guilds: to_write += "\n\n=== {} ===\n\n".format(str(guild)) for role in guild.roles: to_write += "{} : {}\n".format(role.name, role.id) roles = open("roles.txt", "w") roles.write(to_write) roles.close() em = discord.Embed(title="Done", description="Check roles.txt") await ctx.channel.send(embed=em) @debug.command(aliases=["lag"]) async def latency(self, ctx, detailed=None): detailed = bool(detailed) # this is a tuple, with [0] being the shard_id, and [1] being the latency latencies = self.client.latencies lowest_lag = latencies[0] highest_lag = latencies[0] sum = 0 for i in latencies: if i[1] < lowest_lag[1]: lowest_lag = i if i[1] > highest_lag[1]: highest_lag = i # could probably do this in a one liner, but may as well as we have to iterate anyway sum += i[1] avg = (sum / len(latencies)) embed = discord.Embed(title="Latency") # add specific information about latency embed.add_field(name="Avg", value="{}".format(str(avg))) embed.add_field(name="Lowest Latency", value="{} on shard {}".format(lowest_lag[1], lowest_lag[0])) embed.add_field(name="Highest Latency", value="{} on shard {}".format(highest_lag[1], highest_lag[0])) if detailed: embed.add_field(name="RawData", value=str(latencies)) return await ctx.channel.send(embed=embed) @debug.command(aliases=["role_id"]) async def roleid(self, ctx, role_name): for role in ctx.guild.roles: if role_name.lower() == role.name.lower(): return await ctx.send(role.id) return await ctx.send(embed=discord.Embed( title="Could not find role {}".format(role_name))) @is_server_allowed() @commands.group(aliases=["rolem"]) async def role_manage(self, ctx): """Manages AGSE roles (ping groups)""" if ctx.invoked_subcommand is None: await ctx.send( "Invalid params. Run `help rolem` to get all commands.") @role_manage.command() async def add(self, ctx, *, role_name): """Add a role. Note: by default, it isn't joinable""" if role_name[0] == '"' and role_name[-1] == '"': role_name = role_name[1:-1] role_check = get_role(ctx.guild.id, role_name) em = discord.Embed(title="Success", description="Created role {}".format(role_name), color=green) if role_check is not None: em = discord.Embed(title="Error", description="Role is already in the DB", color=red) else: query = "INSERT INTO `gssp`.`roles` (`role_name`, `guild_id`) VALUES (%s, %s);" cursor.execute(query, (role_name, ctx.guild.id)) cnx.commit() return await ctx.channel.send(embed=em) @role_manage.command(aliases=["remove"]) async def delete(self, ctx, *, role_name): """Deletes a role - cannot be undone!""" if role_name[0] == '"' and role_name[-1] == '"': role_name = role_name[1:-1] role_check = get_role(ctx.guild.id, role_name) em = discord.Embed(title="Success", description="Deleted role {}".format(role_name), color=green) if role_check is None: em = discord.Embed( title="Error", description="{} is not in the DB".format(role_name), color=red) else: query = "DELETE FROM `gssp`.`roles` WHERE `role_name` = %s AND `guild_id` = %s" cursor.execute(query, (role_name, ctx.guild.id)) cnx.commit() return await ctx.channel.send(embed=em) @role_manage.command(aliases=["togglepingable"]) async def pingable(self, ctx, *, role_name): """Change a role from not pingable to pingable or vice versa""" if role_name[0] == '"' and role_name[-1] == '"': role_name = role_name[1:-1] role = get_role(ctx.guild.id, role_name) if role is None: return await ctx.channel.send( embed=discord.Embed(title='Error', description='Could not find that role', color=red)) if role['is_pingable'] == 1: update_query = "UPDATE `gssp`.`roles` SET `is_pingable`='0' WHERE `role_id`=%s AND `guild_id` = %s;" text = "not pingable" else: update_query = "UPDATE `gssp`.`roles` SET `is_pingable`='1' WHERE `role_id`=%s AND `guild_id` = %s;" text = "pingable" cursor.execute(update_query, ( role['role_id'], ctx.guild.id, )) cnx.commit() await ctx.channel.send( embed=discord.Embed(title="SUCCESS", description="Set {} ({}) to {}".format( role['role_name'], role['role_id'], text), color=green)) @role_manage.command( aliases=["togglejoinable", "togglejoin", "toggle_join"]) async def joinable(self, ctx, *, role_name): """ Toggles whether a role is joinable """ if role_name[0] == '"' and role_name[-1] == '"': role_name = role_name[1:-1] role = get_role(ctx.guild.id, role_name) if role is None: em = discord.Embed( title="Error", description="Could not find role {}".format(role_name), color=red) return await ctx.channel.send(embed=em) if role['is_joinable'] == 1: update_query = "UPDATE `gssp`.`roles` SET `is_joinable`='0' WHERE `role_id`=%s;" text = "not joinable" else: update_query = "UPDATE `gssp`.`roles` SET `is_joinable`='1' WHERE `role_id`=%s;" text = "joinable" cursor.execute(update_query, (role['role_id'], )) em = discord.Embed(title="Success", description="Set {} ({} to {}".format( role['role_name'], role['role_id'], text), color=green) cnx.commit() await ctx.channel.send(embed=em) @is_owner_or_admin() @commands.group(aliases=["config"]) async def settings(self, ctx): """Manages settings of AGSE""" if ctx.invoked_subcommand is None: await ctx.send( "Invalid params. Run `help settings` to get all commands.") @settings.command(aliases=[ "resyncroles", "syncroles", "rolesync", "role_sync", "sync_roles" ]) async def resync_roles(self, ctx): """ Force refresh the roles in the database with the roles discord has. """ for guild in self.client.guilds: for role in guild.roles: if role.name != "@everyone": try: cursor.execute(insert_role, (role.id, role.name)) except mysql.connector.errors.IntegrityError: pass # this is designed to assist with migration, by moving old discord role members over to the new # system seamlessly member_ids = [] for member in role.members: member_ids.append(member.id) role_db = DbRole(role.id, role.name, 0, members=member_ids) role_db.save_members() cursor.execute(update_role, (emoji.demojize(role.name), role.id)) await ctx.send(embed=discord.Embed( title="Success", description="Resynced roles.", color=green)) @is_owner_or_admin() @settings.group(aliases=["permissions"]) async def perms(self, ctx): """Manages AGSE roles (ping groups)""" if ctx.invoked_subcommand is None: await ctx.send( "Run `help settings perms` to get info on subcommands") @perms.command() async def promote_role(self, ctx, role_id): """ Add a role to the list of allowed roles """ role = ctx.guild.get_role(int(role_id)) if role is None: return await ctx.send( embed=discord.Embed(title="Error", description="That role does not exist", color=red)) settings = guild_settings.get_settings(guild=ctx.guild) if role_id in settings['staff_roles']: return await ctx.send( embed=discord.Embed(title="Error", description="Role already has admin perms", color=red)) settings['staff_roles'].append(role_id) guild_settings.write_settings(settings) return await ctx.send(embed=discord.Embed( title="Success", description="Role {} added to admin list".format(role.name), color=green)) @perms.command() async def demote_role(self, ctx, role_id): role_id = int(role_id) role_to_remove = ctx.guild.get_role(int(role_id)) if role_to_remove is None: return await ctx.send( embed=discord.Embed(title="Error", description="That role does not exist", color=red)) settings = guild_settings.get_settings(guild=ctx.guild) if role_id in ctx.author.roles: # this means the user is removing a role that gives them perms users_permitted_roles = [ ] # list of roles that give user permission to run this for role in ctx.author.roles: for role_existing in settings['staff_roles']: if role_existing == role.id: users_permitted_roles.append(role) if len(users_permitted_roles) <= 1: return await ctx.send(embed=discord.Embed( title="Error", description= "You cannot remove a role that gives permissions without another role which has permissions to do so", color=red)) try: settings['staff_roles'].remove(str(role_id)) guild_settings.write_settings(settings) return await ctx.send(embed=discord.Embed( title="Success", description="Removed {} from permitted role list".format( role_to_remove.name), color=green)) except ValueError: return await ctx.send(embed=discord.Embed( title="Error", description= "That role does not exist in the permitted role list", color=red)) @is_owner_or_admin() @commands.command() async def sync(self, ctx): clone_target = self.client.get_guild( config['discord'].get("clone_server_target")) def generate_progress_embed(m_text, colour=yellow, url=None): em = discord.Embed( title="Server Clone Progress", description="Status: {text}".format(text=m_text), colour=colour) if url is not None: em.add_field(name="Invite link", value=url) return em guild = ctx.guild # we just need to now create an instant invite to *somewhere* on the server progress = await ctx.send(embed=generate_progress_embed( "Dumping existing data from {guild.name}".format(guild=guild))) channels = [] roles = [] def get_channel_position(old_id=None, new_id=None): if new_id is None and old_id is None: raise AttributeError for x in range(0, len(channels)): channel = channels[x] # the and is not None prevent us from returning whatever channel has None as an attribute if (channel.get("old_id") == old_id and old_id is not None) or (channel.get("new_id") == new_id and new_id is not None): return x return None def get_channel(old_id=None, new_id=None): position = get_channel_position(old_id=old_id, new_id=new_id) if position is None: return None return channels[position] def add_channel(old_channel, new_channel=None): to_append = (dict(old_id=old_channel.id, old_channel=old_channel)) if new_channel is None: to_append['new_id'] = None to_append['new_channel'] = None else: to_append['new_id'] = new_channel.id to_append['new_channel'] = new_channel channels.append(to_append) def set_new_channel(old_channel_id, new_channel): # we don't use the new_channel id, as not merged yet position = get_channel_position(old_id=old_channel_id) new_channel = get_channel_object_dict(new_channel) channels[position]['new_channel'] = new_channel channels[position]['new_id'] = new_channel['id'] def get_role_position(old_id=None, new_id=None): if new_id is None and old_id is None: return None # means we don't have to do unnecesary searches if old_id is not None: old_id = int(old_id) if new_id is not None: new_id = int(new_id) for x in range(0, len(roles)): role = roles[x] # the and is not None prevent us from returning whatever channel has None as an attribute if (role.get("old_id") == old_id and old_id is not None) or ( role.get("new_id") == new_id and new_id is not None): return x return None def get_role(old_id=None, new_id=None): position = get_role_position(old_id=old_id, new_id=new_id) if position is None: return None return roles[position] def add_role(old_role, new_role=None): to_append = (dict(old_id=old_role.id, old_role=old_role)) if new_role is None: to_append['new_id'] = None to_append['new_role'] = None else: to_append['new_id'] = new_role.id to_append['new_role'] = new_role roles.append(to_append) def set_new_role(old_role_id, new_role): # we don't use the new_role id, as not merged yet position = get_role_position(old_id=old_role_id) roles[position]['new_role'] = new_role roles[position]['new_id'] = new_role.id def get_role_object_dict(role): if type(role) == dict: return role # if already role, just return it return dict(id=role.id, name=role.name, permissions=role.permissions.value, colour=role.colour.value, hoist=role.hoist, mentionable=role.mentionable) def get_role_dicts(roles=roles): backup_roles = roles role_dicts = [] for role in roles: if role.get('old_role') is not None: role['old_role'] = get_role_object_dict(role['old_role']) if role.get('new_role') is not None: role['new_role'] = get_role_object_dict(role['new_role']) role_dicts.append(role) return role_dicts def get_channel_type(channel): if type(channel) == discord.channel.TextChannel: return "Text" if type(channel) == discord.channel.VoiceChannel: return "Voice" if type(channel) == discord.channel.CategoryChannel: return "Category" return "Unknown" def get_channel_object_dict(channel): if type(channel) == dict: return channel # already converted new_overwrites = [] overwrites = channel.overwrites for overwrite in overwrites: allow, deny = overwrite[1].pair() if type(overwrite[0]) == discord.role.Role: role = get_role(old_id=overwrite[0].id) if role is None: to_append = dict( grantee=dict(old_id=overwrite[0].id, type="Role")) else: to_append = dict(grantee=dict( old_id=role.get('old_id'), new_id=role.get('new_id'), old_name=role.get('old_role', dict()).get('name'), type="Role")) else: # user overwrite to_append = dict( grantee=dict(id=overwrite[0].id, type="User")) to_append['allow_permission'] = allow.value to_append['deny_permission'] = deny.value new_overwrites.append(to_append) to_return = dict(id=channel.id, name=channel.name, type=get_channel_type(channel), overwrites=new_overwrites, position=channel.position) if to_return['type'] != "Category": if channel.category is not None: to_return['category'] = get_channel_object_dict( channel.category) else: to_return['category'] = None if to_return['type'] == "Text": # do text to_return['topic'] = channel.topic to_return['slowmode_delay'] = channel.slowmode_delay to_return['nsfw'] = channel.nsfw elif to_return['type'] == "Voice": # do voice to_return['bitrate'] = channel.bitrate to_return['user_limit'] = channel.user_limit return to_return def get_channel_dicts(channels=channels): backup_channels = channels channel_dicts = [] for channel in channels: if channel.get('old_channel') is not None: channel['old_channel'] = get_channel_object_dict( channel['old_channel']) if channel.get('new_channel') is not None: channel['new_role'] = get_channel_object_dict( channel['new_channel']) channel_dicts.append(channel) channels = backup_channels return channel_dicts def generate_overwrites(old_channel): overwrites = dict() for overwrite in old_channel['overwrites']: allow = discord.Permissions(overwrite['allow_permission']) deny = discord.Permissions(overwrite['deny_permission']) permission_pair = discord.PermissionOverwrite.from_pair( allow, deny) target = None # we do this incase down the road there's a new type of grantee we haven't handled # if a user isn't in the new server, we can't add overwrites for them if overwrite['grantee']['type'] == "User": target = clone_target.get_member( overwrite['grantee']['id']) # this is the code which will convert the old_id in the overwrite into the new_id elif overwrite['grantee']['type'] == "Role": role = get_role(old_id=overwrite['grantee']['old_id']) if role is not None: target = clone_target.get_role(role['new_id']) else: old_role = ctx.guild.get_role( overwrite['grantee']['old_id']) if old_role.name == "@everyone": target = clone_target.default_role else: print( "Could not find new role pair for old role with ID {}" .format(overwrite['grantee']['old_id'])) if target is not None: overwrites[target] = permission_pair return overwrites s_channels = guild.channels s_channels.sort(key=lambda x: x.position, reverse=False) for channel in s_channels: add_channel(channel) s_roles = guild.roles s_roles.reverse() for role in s_roles: if role.name != "@everyone": add_role(role) await progress.edit(embed=generate_progress_embed( "Wiping roles of {clone_target.name}".format( clone_target=clone_target))) for role in clone_target.roles: try: await role.delete(reason="Cleaning for copying") except discord.errors.HTTPException: pass await progress.edit(embed=generate_progress_embed( "Wiping channels of {clone_target.name}".format( clone_target=clone_target))) for channel in clone_target.channels: await channel.delete(reason="Cleaning for copying") print("Wiped channels") await progress.edit(embed=generate_progress_embed( "Creating new roles in {clone_target.name}".format( clone_target=clone_target))) for role in get_role_dicts(): old_role = role['old_role'] logger.info("Adding role{id} - {name}".format( id=role['old_id'], name=role['old_role']['name'])) new_role_to_merge = await clone_target.create_role( name=old_role['name'], permissions=discord.Permissions( permissions=old_role['permissions']), colour=discord.Colour(old_role['colour']), hoist=old_role['hoist'], mentionable=old_role['mentionable']) set_new_role(old_role['id'], new_role_to_merge) get_role_dicts( ) # this converts all the new channels into nice dictionary formats await progress.edit(embed=generate_progress_embed( "Creating new channels in {clone_target.name}".format( clone_target=clone_target))) # first, we add the categories channels_to_add = get_channel_dicts() channels.sort(key=lambda x: x['old_channel']['position'], reverse=False) for channel in channels_to_add: old_channel = channel['old_channel'] if old_channel['type'] == "Category": logger.info("Adding category {id} - {name}".format( id=old_channel['id'], name=old_channel['name'])) # build overwrites overwrites = generate_overwrites(old_channel) channel = await clone_target.create_category_channel( old_channel['name'], overwrites=overwrites, reason="Syncing of channels") set_new_channel(old_channel['id'], channel) # this makes sure everything is still in dictionary formats channels_to_add = get_channel_dicts() # now we know all our categories are added, we can add all other channels for channel in channels_to_add: old_channel = channel['old_channel'] if old_channel['type'] != "Category": logger.info("Adding {type} channel {id} - {name}".format( type=old_channel['type'], id=old_channel['id'], name=old_channel['name'])) overwrites = generate_overwrites(old_channel) category = get_channel( old_id=old_channel['category'].get('id')) if category is not None: category_id = category['new_id'] # gets the role object that we need to create the channel category = clone_target.get_channel(category_id) if old_channel['type'] == "Text": channel = await clone_target.create_text_channel( old_channel['name'], overwrites=overwrites, reason="Syncing of channels", position=old_channel['position'], topic=old_channel['topic'], slowmode_delay=old_channel['slowmode_delay'], nsfw=old_channel['nsfw'], category=category) elif old_channel['type'] == "Voice": channel = await clone_target.create_voice_channel( old_channel['name'], overwrites=overwrites, reason="Syncing of channels", position=old_channel['position'], bitrate=old_channel['bitrate'], user_limit=old_channel['user_limit'], category=category) channel = get_channel_object_dict(channel) set_new_channel(old_channel['id'], channel) with open(".last_sync.json", "w") as f: f.write( json.dumps(dict(roles=get_role_dicts(roles=roles), channels=get_channel_dicts(channels=channels)), indent=4)) invite = await clone_target.text_channels[0].create_invite( max_age=0, max_uses=0, unique=True, reason="Generating invite link to join with") await progress.edit(embed=generate_progress_embed( "Done!", colour=green, url=invite.url))
class Nyoom(commands.Cog): def __init__(self, client): self.client = client self.client_extras = ClientTools(client) self.database_extras = DatabaseTools(self.client_extras) async def get_times(self, user_id=None): """ username : user you want to get messages for Returns: times: list of all timestamps of users messages """ if user_id is None: get_time = "SELECT `time` FROM `messages_detailed` ORDER BY TIME ASC" cursor.execute(get_time) else: get_time = "SELECT `time` FROM `messages_detailed` WHERE `user_id` = %s ORDER BY TIME ASC" cursor.execute(get_time, (user_id,)) timesA = cursor.fetchall() times = [] for time in timesA: times.append(time[0]) return times async def calculate_nyoom(self, output, user_id=None): # load interval between messages we're using from the configs interval = config['discord']['nyoom_interval'] times = await self.get_times(user_id=user_id) # group them into periods of activity periods = [] curPeriod = [times[0], times[0], 0] # begining of period, end of period, number of messages in period for time in times: if time > curPeriod[1] + datetime.timedelta(0, interval): # if theres more than a 10min dif between this time and last time # make a new period periods.append(curPeriod) curPeriod = [time, time, 1] else: curPeriod[1] = time # the period now ends with the most recent timestamp curPeriod[2] += 1 # add the message to the period # sum the total length of activity periods and divide by total number of messages totalT = 0 totalM = len(times) for period in periods: totalT += ((period[1] - period[ 0]).total_seconds() / 60) + 1 # total number of minutes for the activity period, plus a fudge factor to prevent single message periods from causing a divide by zero issue later totalT /= 60 # makes the total active time and nyoom_metric count hours of activity rather than minutes nyoom_metric = totalM / totalT # number of message per minute during periods of activity return totalM, totalT, nyoom_metric @commands.command() async def nyoom(self, ctx, user: discord.Member = None): """ Calculate the specified user's nyoom metric. e.g. The number of messages per hour they post while active (posts within 10mins of each other count as active) user : user to get nyoom metric for, if not author """ if user is None: user = ctx.message.author output = await ctx.send(strings['nyoom_calc']['status']['calculating'] + strings['emojis']['loading']) username = self.database_extras.opted_in(user_id=user.id) if not username: return await output.edit(content=output.content + '\n' + strings['nyoom_calc']['status']['not_opted_in']) # grab a list of times that user has posted totalM, totalT, nyoom_metric = await self.calculate_nyoom(output, user_id=user.id) await output.delete() embed = discord.Embed(title="Nyoom metrics", color=colours.blue) embed.add_field(name="Message count", value=totalM) embed.add_field(name="Total hours", value=totalT) embed.add_field(name="Nyoom metric", value=nyoom_metric) embed.set_footer(text="These values may not be 100% accurate") return await ctx.send(embed=embed) @commands.command(aliases=["nyoomserver", "ns", "n_s"]) async def nyoom_server(self, ctx): """ Calculate nyoom metric for entire server """ output = await ctx.send(strings['nyoom_calc']['status']['calculating'] + strings['emojis']['loading']) totalM, totalT, nyoom_metric = await self.calculate_nyoom(output) # prepare the final embed to send embed = discord.Embed(title="Nyoom metrics", color=colours.blue) embed.add_field(name="Message count", value=totalM) embed.add_field(name="Total hours", value=totalT) embed.add_field(name="Nyoom metric", value=nyoom_metric) embed.set_footer(text="These values may not be 100% accurate") await output.delete() return await ctx.send(embed=embed)
def __init__(self, client): self.database_tools = DatabaseTools(client) self.client = client
class Sentiment(commands.Cog): def __init__(self, client): self.client = client self.client_extras = ClientTools(client) self.database_extras = DatabaseTools(self.client_extras) @commands.command(aliases=["s"]) async def sentiment(self, ctx, raw: bool = False, nsfw: bool = False, selected_channel: discord.TextChannel = None): """ Calculate sentiment.json from your messages! """ raw = bool(raw) if (not ctx.message.channel.is_nsfw()) and nsfw: return await ctx.send(strings['tagger']['errors']['nsfw'].format(str(ctx.author))) output = await ctx.send(strings['tagger']['title'] + strings['emojis']['loading']) await output.edit(content=output.content + "\n" + strings['tagger']['status']['messages']) async with ctx.channel.typing(): username = self.database_extras.opted_in(user_id=ctx.author.id) if not username: return await output.edit(content=output.content + strings['tagger']['errors']['not_opted_in']) messages, channels = await self.database_extras.get_messages(ctx.author.id, config['limit'] / 10) text = [] text = await self.client_extras.build_messages(ctx, nsfw, messages, channels, selected_channel=selected_channel) await output.edit( content=output.content + strings['emojis']['success'] + "\n" + strings['tagger']['status'][ 'analytical_data']) algo = algo_client.algo('nlp/SocialSentimentAnalysis/0.1.4') response = algo.pipe({"sentenceList": text}) tags = list(response.result) await output.delete() file = open("sentiment.json", "w") file.write(str(tags)) positive = 0 negative = 0 neutral = 0 compound = 0 for tag in tags: positive += tag['positive'] negative += tag['negative'] neutral += tag['neutral'] compound += tag['compound'] em = discord.Embed(title="Sentiment", color=colours.blue) positive = (math.ceil((positive / len(tags)) * 10000)) / 100 negative = (math.ceil((negative / len(tags)) * 10000)) / 100 neutral = (math.ceil((neutral / len(tags)) * 10000)) / 100 compound = (math.ceil((compound / len(tags)) * 10000)) / 100 if raw: file.close() em.add_field(name="Positivity", value=str(positive)) em.add_field(name="Negativity", value=str(negative)) em.add_field(name="Neutrality", value=str(neutral), inline=False) em.add_field(name = "Flip-floppity-ness", value = str(compound)) em.add_field(name="Info", value="*Max value for these are 100 points, min are -100 points*", inline=False) else: positive = math.floor(positive / 2) negative = math.floor(negative / 2) em.add_field(name="Niceness", value=(":heart:" * positive), inline=False) em.add_field(name="Evilness", value=(":smiling_imp:" * math.floor(negative)), inline=False) shoe = random.randint(0, 5) if shoe == 0: emoji_flip = ":sandal:" elif shoe == 1: emoji_flip = ":arrows_counterclockwise:" elif shoe == 2: emoji_flip = ":yin_yang:" elif shoe == 3: emoji_flip = ":libra:" else: emoji_flip = "<a:zthonkspin:399368569500205056>" em.add_field(name = "Flip-floppitiness", value = (emoji_flip * math.floor(compound)), inline = False) output = await ctx.send(embed=em) emoji = await self.client_extras.get_delete_emoji() emoji = emoji[1] return await self.client_extras.delete_option(self.client, output, ctx, emoji)
class ClientTools(): def __init__(self, client): self.database_tools = DatabaseTools(client) self.client = client def channel_allowed(self, channel_id, existing_channel, nsfw=False): """ Check if a channel is allowed in current context channel_id: ID of channel existing_channel: channel object of existing channel nsfw: whether to only return NSFW channels """ channel = self.client.get_channel(int(channel_id)) if channel is None: return False enabled = False for group in enabled_groups: if str(channel.category).lower() == str(group).lower(): enabled = True break if not enabled: return False if not existing_channel.is_nsfw() and bool(nsfw): return False if channel.is_nsfw(): # checks if user wants / is allowed explicit markovs return bool(nsfw) # this means that if the channel *is* NSFW, we return True, but if it isn't, we return False else: # channel is SFW if bool(nsfw): return False # this stops SFW chats from being included in NSFW markovs return True async def build_messages(self, ctx, nsfw, messages, channels, selected_channel=None): """ Returns/appends to a list messages from a user Params: messages: list of messages channel: list of channels for messages selected_channel: Not required, but channel to filter to. If none, filtering is disabled. text = list of text that already exists. If not set, we just create one """ text = [] for counter, m in enumerate(messages): if self.channel_allowed(channels[counter], ctx.message.channel, nsfw): if selected_channel is not None: if self.client.get_channel(int( channels[counter])).id == selected_channel.id: text.append(m) else: text.append(m) return text async def get_delete_emoji(self): delete_emoji = self.client.get_emoji(int(strings['emojis']['delete'])) if delete_emoji is not None: emoji_name = delete_emoji.name else: emoji_name = "❌" return emoji_name, delete_emoji async def error_embed(self, ctx, error, message=None, colour=discord.Embed.Empty): embed = discord.Embed(title='Command Error', colour=colour) embed.description = str(error) embed.add_field(name='Server', value=ctx.guild) embed.add_field(name='Channel', value=ctx.channel.mention) embed.add_field(name='User', value=ctx.author) embed.add_field(name='Message', value=ctx.message.content) embed.timestamp = datetime.datetime.utcnow() await ctx.send(content=message, embed=embed) async def markov_embed(self, title, message): em = discord.Embed(title=title, description=message) name = await self.get_delete_emoji() name = name[0] em.set_footer(text=strings['markov']['output']['footer'].format(name)) return em async def delete_option(self, client, message, ctx, delete_emoji, timeout=config['discord']['delete_timeout']): """Utility function that allows for you to add a delete option to the end of a command. This makes it easier for users to control the output of commands, esp handy for random output ones.""" await message.add_reaction(delete_emoji) def check(r, u): return str( r) == str(delete_emoji ) and u == ctx.author and r.message.id == message.id try: await client.wait_for("reaction_add", timeout=timeout, check=check) await message.remove_reaction(delete_emoji, client.user) await message.remove_reaction(delete_emoji, ctx.author) em = discord.Embed(title=str(ctx.message.author) + " deleted message", description="User deleted this message.") return await message.edit(embed=em) except concurrent.futures._base.TimeoutError: await message.remove_reaction(delete_emoji, client.user) async def build_data_profile(self, members, limit=50000): """ Used for building a data profile based on a user Members: list of members we want to import for Guild: Guild object Limit: limit of messages to be imported """ for guild in self.client.guilds: for cur_channel in guild.text_channels: adding = False for group in enabled_groups: if str(cur_channel.category).lower() == str(group).lower(): adding = True break if adding: logger.info("Logging from {}".format(cur_channel.name)) counter = 0 already_added = 0 async for message in cur_channel.history(limit=limit, reverse=True): if message.author in members: self.database_tools.add_message_to_db(message) logger.info( "{} scraped for {} users - added {} messages, found {} already added" .format(cur_channel.name, len(members), counter, already_added)) async def process_message(self, message): await self.check_flags(message) user_exp = self.database_tools.opted_in(user_id=message.author.id) if user_exp is not False: self.database_tools.add_message_to_db(message) logger.debug("Message from {}".format(user_exp)) # this records analytical data - don't adjust this without reading # Discord TOS first try: cursor.execute(add_message, (int(message.id), str(message.channel.id), message.created_at.strftime('%Y-%m-%d %H:%M:%S'))) cnx.commit() except mysql.connector.errors.IntegrityError: pass try: # if its double(or more) prefixed then it cant be a command (?word is a command, ????? is not) if message.content[len(config['discord'] ['prefix'])] == config['discord']['prefix']: return except IndexError: return async def check_flags(self, message): if type(message.channel) == discord.DMChannel: return if message.author.id == self.client.user.id: return matches = [] flag_settings = guild_settings.get_bad_words(message.guild) flags = flag_settings['words'] regexes = flag_settings.get('regex') if regexes is None: regexes = [] channel_id = flag_settings['alert_channel'] if channel_id is None: return for flag in flags: if flag.lower() != "" and flag in message.content.lower(): matches.append(flag) for regex in regexes: try: temp_regex = re.compile(regex, re.IGNORECASE) for word in message.content.lower().split(" "): if temp_regex.match(word): matches.append(word) except: pass # we do this because some regex may be bad if len(matches) > 0: embed = discord.Embed(title="Potential usage of flag detected", color=colours.dark_red) embed.add_field(name="Flag(s)", value=str(matches)) embed.add_field(name="Message", value=str(message.content)) embed.add_field(name="Author", value=str(message.author.mention)) embed.add_field(name="Author ID", value=str(message.author.id)) embed.add_field(name="Channel", value=str(message.channel.mention)) embed.add_field(name="Time", value=str(message.created_at)) embed.add_field(name="Message ID", value=str(message.id)) embed.add_field(name="Guild ID", value=str(message.channel.guild.id)) embed.add_field(name="Guild", value=str(message.channel.guild)) embed.add_field( name="Message Link", value=str("https://discordapp.com/channels/{}/{}/{}".format( message.guild.id, message.channel.id, message.id)), inline=False) channel = self.client.get_channel(channel_id) await channel.send(embed=embed) async def optout_user(self, user): """ Opt a user out of experiments, and delete their data Returns number of messages deleted """ logger.info("Deleting data for user ID {}".format(user.id)) cursor.execute("DELETE FROM users WHERE user_id = %s", (user.id, )) result = cursor.execute( "DELETE FROM messages_detailed WHERE user_id = %s", (user.id, )) cnx.commit() logger.info("Data deleted.")
class Markov(commands.Cog): def __init__(self, client): self.client = client self.database_tools = DatabaseTools(client) self.client_tools = ClientTools(client) @commands.command(aliases=["m_s"]) async def markov_server(self, ctx, nsfw: bool = False, selected_channel: discord.TextChannel = None): """ Generates markov output based on entire server's messages. """ nsfw_mismatch = False if selected_channel is not None: if selected_channel.is_nsfw() and not nsfw: nsfw_mismatch = True elif not selected_channel.is_nsfw() and nsfw: nsfw_mismatch = True if nsfw_mismatch: return await ctx.send(embed=discord.Embed( title="Error", description= "The selected channel and the NSFW flag do not match. Please ensure these are both correct.", color=colours.red)) output = await ctx.send(strings['markov']['title'] + strings['emojis']['loading']) await output.edit(content=output.content + "\n" + strings['markov']['status']['messages']) async with ctx.channel.typing(): text = [] messages, channels = await self.database_tools.get_messages( ctx.author.id, config['limit_server'], server=True) text = await self.client_tools.build_messages( ctx, nsfw, messages, channels, selected_channel=selected_channel) text1 = "" for m in text: text1 += str(m) + "\n" if len(text) < 10: return await output.edit( content=output.content + strings['markov']['errors']['low_activity']) try: await output.edit( content=output.content + strings['emojis']['success'] + "\n" + strings['markov']['status']['building_markov']) # text_model = POSifiedText(text) text_model = markovify.NewlineText( text, state_size=config['state_size']) except KeyError: return ctx.send('Not enough data yet, sorry!') await output.edit(content=output.content + strings['emojis']['success'] + "\n" + strings['markov']['status']['making']) text = text_model.make_short_sentence(140) attempt = 0 while (True): attempt += 1 if attempt >= 10: return await ctx.send( strings['markov']['errors']['failed_to_generate']) message_formatted = str(text) if message_formatted != "None": break await output.delete() em = await self.client_tools.markov_embed( strings['markov']['output']['title_server'], message_formatted) output = await ctx.send(embed=em) return await self.client_tools.delete_option( self.client, output, ctx, self.client.get_emoji(int(strings['emojis']['delete'])) or "❌") @commands.command(aliases=["m"]) async def markov(self, ctx, nsfw: bool = False, selected_channel: discord.TextChannel = None): """ Generates markov output for user who ran this command """ if (not ctx.message.channel.is_nsfw()) and nsfw: return await ctx.send(strings['markov']['errors']['nsfw'].format( str(ctx.author))) output = await ctx.send(strings['markov']['title'] + strings['emojis']['loading']) await output.edit(content=output.content + "\n" + strings['markov']['status']['messages']) async with ctx.channel.typing(): username = self.database_tools.opted_in(user_id=ctx.author.id) if not username: return await output.edit( content=output.content + strings['markov']['errors']['not_opted_in']) messages, channels = await self.database_tools.get_messages( ctx.author.id, config['limit']) text = [] text = await self.client_tools.build_messages( ctx, nsfw, messages, channels, selected_channel=selected_channel) text1 = "" for m in text: text1 += str(m) + "\n" try: await output.edit( content=output.content + strings['emojis']['success'] + "\n" + strings['markov']['status']['building_markov']) # text_model = POSifiedText(text) text_model = markovify.NewlineText( text, state_size=config['state_size']) except KeyError: return ctx.send('Not enough data yet, sorry!') attempt = 0 while (True): attempt += 1 if attempt >= 10: await output.delete() return await ctx.send( strings['markov']['errors']['failed_to_generate']) new_sentance = text_model.make_short_sentence(140) message_formatted = str(new_sentance) if message_formatted != "None": break await output.edit(content=output.content + strings['emojis']['success'] + "\n" + strings['markov']['status']['analytical_data']) await self.database_tools.save_markov(text_model, ctx.author.id) await output.edit(content=output.content + strings['emojis']['success'] + "\n" + strings['markov']['status']['making']) await output.delete() em = await self.client_tools.markov_embed(str(ctx.author), message_formatted) output = await ctx.send(embed=em) return await self.client_tools.delete_option( self.client, output, ctx, self.client.get_emoji(int(strings['emojis']['delete'])) or "❌")
import concurrent import discord import markovify import time from discord.ext import commands from discord import Embed from ags_experiments.client_tools import ClientTools from ags_experiments.database import cnx from ags_experiments.database.database_tools import DatabaseTools from ags_experiments.settings.config import config, strings client = commands.Bot(command_prefix="--------------------", owner_id=config['discord']['owner_id']) client_tools = ClientTools(client) database_tools = DatabaseTools(client) print("Awaiting login") position = 0 opted_in_users = [] channel = None server = None async def get_members(server, message=None): members = [] for user in server.members: if database_tools.is_automated(user): members.append(user) if message is not None: await message.edit(content="Initialising - found {count} users".format(count=len(members)))
def __init__(self, client): self.client = client self.prefix = config['discord']['prefix'] self.client_extras = ClientTools(client) self.database_extras = DatabaseTools(self.client_extras)
class Controls(commands.Cog): def __init__(self, client): self.client = client self.database_tools = DatabaseTools(client) self.client_tools = ClientTools(client) @commands.command(aliases=["optin", "opt_in"]) async def experiments(self, ctx): """ Opt into data analysis and experiments. """ message = ctx.message channel = message.channel author = message.author create_user = "******" try: cursor.execute(create_user, (author.id, author.name)) cnx.commit() em = discord.Embed( title=strings['data_collection']['opt_in_title'], description=opt_in_message) em.set_footer(text=strings['data_collection']['opt_in_footer']) return await channel.send(embed=em) except mysql.connector.errors.IntegrityError: get_user = "******" cursor.execute(get_user, (author.id,)) opt_in_user = "******" cursor.execute(opt_in_user, (author.id,)) await channel.send(strings['data_collection']['data_track_start'] + " for " + str(ctx.message.author)) await self.client_tools.build_data_profile([author]) await channel.send(strings['data_collection']['complete'].format(author.name)) @commands.command(aliases=["opt_in_automated", "optinautomated"]) async def automated(self, ctx): """ Opt in to automated messages. Run this again to opt out. """ if not self.database_tools.opted_in(user_id=ctx.author.id): return await ctx.channel.send(embed=discord.Embed(title="Error", description=strings['tagger']['errors']['not_opted_in'], color=colours.red)) if self.database_tools.is_automated(ctx.author): output = await ctx.channel.send("Opting you out of automation.") query = "UPDATE `users` SET `automate_opted_in`=b'0' WHERE `user_id`=%s;" cursor.execute(query, (ctx.author.id,)) cnx.commit() await output.delete() return await ctx.channel.send(embed=discord.Embed(title="Success", description='You will be removed from the pool on the next refresh (IE: when the bot goes back around in a loop again)')) else: output = await ctx.channel.send("Opting you into automation") query = "UPDATE`users` SET `automate_opted_in`=b'1' WHERE `user_id`=%s;" cursor.execute(query, (ctx.author.id,)) cnx.commit() await output.delete() return await ctx.channel.send(embed=discord.Embed(title="Success", description='Opted in!', color=colours.green)) @commands.command(aliases=["blacklist", "block_list", "black_list"]) async def blocklist(self, ctx, command=None, word=None): """ Prevents words from being shown publicly through methods such as markov and markov_server. Note: they will still be logged, and this just prevents them being shown in chat. Command: option to use Word: Word to add or remove from blocklist """ pm_channel = (discord.channel.DMChannel == type(ctx.channel)) if not pm_channel: try: await ctx.message.delete() except discord.errors.Forbidden: logger.warn( "Could not delete blacklist command, lacking permissions") if command is None: return await ctx.send(""" No subcommand selected - please enter a subcommand for your blocklist. ?blocklist add [word] : Add word to blocklist ?blocklist remove [word] : Remove word from blocklist ?blocklist get : Get PM of current blocklist """) # fetch current blocklist blockL = await self.database_tools.get_blocklist(ctx.author.id) update_blocklist = "UPDATE blocklists SET blocklist = %s WHERE user_id = %s" if command == "add": if word is None: return await ctx.send(strings['blocklist']['status']['no_word'], delete_after=config['discord']['delete_timeout']) msg = await ctx.send(strings['blocklist']['status']['adding']) # check if the word is already on the list. throw error if it is if word.lower() not in blockL: # if its not then add it blockL.append(word.lower()) # update DB with new list new_json = json.dumps(blockL) cursor.execute(update_blocklist, (new_json, ctx.author.id,)) else: await msg.delete() return await ctx.send(strings['blocklist']['status']['exist']) elif command == "remove": if word is None: return await ctx.send(strings['blocklist']['status']['no_word'], delete_after=config['discord']['delete_timeout']) msg = await ctx.send(strings['blocklist']['status']['removing']) # try and remove it from list (use a try statement, catching ValueError) try: blockL.remove(word.lower()) except ValueError: return await msg.edit(content=strings['blocklist']['status']['not_exist']) # update DB with new list new_json = json.dumps(blockL) cursor.execute(update_blocklist, (new_json, ctx.author.id,)) elif command == "get": # make it nice to look at if blockL == []: msg = strings['blocklist']['status']['empty'] else: msg = strings['blocklist']['status']['list'] for item in blockL: # done so that the merge with the long string is only done once per word part = ' ' + item + ',' msg += part msg = msg[:-1] # trim off the trailing , # send a private message with the nice to look at blocklist # this prevents the next commands from running return await ctx.author.send(msg) else: return await ctx.send(""" No subcommand selected - please enter a subcommand for your blocklist. ?blocklist add [word] : Add word to blocklist ?blocklist remove [word] : Remove word from blocklist ?blocklist get : Get PM of current blocklist """) await msg.edit(content=strings['blocklist']['status']['complete']) @commands.command(aliases=["opt_out"]) async def optout(self, ctx): """ Run this to optout of experiments, and delete your data """ em = discord.Embed( title=strings['data_collection']['opt_out_starting_title'], description=strings['data_collection']['opt_out_starting_message'], color=colours.red) current_embed = await ctx.send(embed=em) await self.client_tools.optout_user(ctx.author) em = discord.Embed(title=strings['data_collection']['opt_out_finish_title'], description=strings['data_collection']['opt_out_finish_message'], color=colours.green) await current_embed.edit(embed=em) @commands.command(aliases=["datainfo", "data", "aboutme", "mydata", "my_data", "about_me"]) async def data_info(self, ctx): """Returns the data we store on you.""" async with ctx.channel.typing(): username = self.database_tools.opted_in(user_id=ctx.author.id) if not username: em = discord.Embed(title="You are not opted in", description="As you are opted out, we have no info on you", color=colours.red) return await ctx.author.send(embed=em) message_count = await self.database_tools.get_message_count( user_id=ctx.author.id) blocklist = await self.database_tools.get_blocklist(ctx.author.id) blocklist_count = len(blocklist) # just to prevent this being used later as it contains sensitive info del(blocklist) em = discord.Embed(title="Data info", color=colours.blue) em.add_field(name="Message count", value=message_count) em.add_field(name="Blocklist count", value=blocklist_count) # we send to the author, so the data is kept private as per GDPR await ctx.author.send(embed=em) await ctx.message.delete()