async def on_guild_remove(member):
# Get the channel to send the messages to
default_channel = member.guild.system_channel or member.guild.channels[0]
# Load audit log
async for entry in member.guild.audit_logs(limit=1):
if entry.target.id == member.id:
# Triggers when user is kicked
if entry.action == discord.AuditLogAction.kick:
await default_channel.send(embed=utils.embed(
title="Kicked!",
description=
f"Get f****d! {member.mention} has just been KICKED by {entry.user.mention}:wave::skin-tone-3:"
))
logger.info(
f"{member.display_name} was just kicked from {member.guild.name} by {entry.user.display_name}"
)
return
# Triggers when user is banned
elif entry.action == discord.AuditLogAction.ban:
await default_channel.send(embed=utils.embed(
title="Banned!",
description=
f"Get MEGA f****d! {member.mention} has just been BANNED by {entry.user.mention} :wave::skin-tone-3:"
))
logger.info(
f"{member.display_name} was just banned from {member.guild.name} by {entry.user.display_name}"
)
return
# Any other action is a server leave so send that flavour text
await default_channel.send(embed=utils.embed(
title="Left the server",
description=f"{member.mention} has left the server:wave::skin-tone-3:")
)
logger.info(f"{member.display_name} has left the server")
async def adminsremove(self, ctx, member: Member):
self.bot.admins.verify_admin(ctx)
if str(member.id) not in self.bot.admins.get_admins_for_guild(
ctx.guild.id):
raise commands.CommandError(f"{member.mention} isn't an admin.")
self.bot.admins.remove_user_from_admins(member.id, ctx.guild.id)
await ctx.send(embed=utils.embed(
title="Removed from admins",
description=f"Removed admin from {member.mention}."))
self.logger.info(
f"{ctx.author.display_name} removed admin from {member.display_name}."
)
async def lobby_(self, ctx, channel: discord.VoiceChannel):
"""sets your guilds lobby channel from which
the summon command move its members"""
current_id = self.config.get('lobby', ctx.guild.id)
fail = True
if current_id == channel.id:
msg = "This channel is already the lobby"
else:
self.config.store('lobby', channel.id, ctx.guild.id)
msg = f"{channel.mention} is now the lobby"
fail = False
await ctx.send(embed=utils.embed(msg, error=fail))
async def enable(self, ctx, feature):
"""enables or disables features like:
join/leave sounds or random guild icon"""
action = ctx.invoked_with.lower()
if feature not in self.features:
msg = f"`.{action} <{', '.join(self.features)}>`"
await ctx.send(embed=utils.embed(msg, error=True))
else:
current = self.config.get(feature, ctx.guild.id)
if (action == 'enable') is current:
cur_action = "active" if current else "inactive"
msg = f"The {feature} feature is already `{cur_action}`"
await ctx.send(embed=utils.embed(msg, error=True))
else:
self.config.store(feature, not current, ctx.guild.id)
new_action = "active" if not current else "inactive"
msg = f"The {feature} feature is now {new_action}"
await ctx.send(embed=utils.embed(msg))
if feature == "sound" and ctx.guild.voice_client:
await ctx.guild.voice_client.disconnect()
async def adminsadd(self, ctx, member: Member):
self.bot.admins.verify_admin(ctx)
if str(member.id) in self.bot.admins.get_admins_for_guild(
ctx.guild.id):
raise commands.CommandError(
f"{member.mention} is already an admin.")
self.bot.admins.add_user_to_admins(member.id, ctx.guild.id)
await ctx.send(
embed=utils.embed(title="Added to admins",
description=f"{member.mention} is now an admin.")
)
self.logger.info(
f"{ctx.author.display_name} made {member.display_name} an admin.")
async def hide(self, ctx, channel: discord.VoiceChannel):
"""hides given channel for the join/leave sound feature"""
hidden_channel = self.config.get('hidden', ctx.guild.id)
action = "hidden now..."
if hidden_channel is None:
self.config.store('hidden', [channel.id], ctx.guild.id)
elif channel.id in hidden_channel:
hidden_channel.remove(channel.id)
self.config.save()
action = "visible again..."
else:
hidden_channel.append(channel.id)
self.config.save()
msg = f"The channel `{channel.name}` is {action}"
await ctx.send(embed=utils.embed(msg))
async def purge(self, ctx, limit: int, from_user: Member = None):
self.bot.admins.verify_admin(ctx)
self.deleted_message_count = 0
await ctx.message.channel.purge(
limit=min(limit, 100),
check=lambda m: self.sent_by_user(m.author, from_user))
sent_by_message = f" sent by {from_user.mention}" if from_user is not None else ""
await ctx.send(embed=utils.embed(
title="Purge since",
description=
f"{ctx.message.author.mention} purged {limit} message history"
f"{sent_by_message} from {ctx.message.channel.mention}.",
footer_text=f"Total messages removed: {self.deleted_message_count}"
))
sent_by_message = f" sent by {from_user.display_name}" if from_user is not None else ""
self.logger.info(
f"{ctx.author.display_name} purged {limit} message history"
f"{sent_by_message} from {ctx.message.channel.name}.")
async def blacklist(self, ctx):
blacklist = self.bot.blacklist.get_blacklist_for_guild(ctx.guild.id)
blacklist = [utils.get_user_from_id(x, ctx.guild).mention for x in blacklist] or ['None']
await ctx.send(embed = utils.embed(title = 'Blacklist', description = '\n'.join(blacklist)))
async def echo(self, ctx, *message: str):
await ctx.send(
embed=utils.embed(title="Echo", description=' '.join(message)))
utils.log(
f"{ctx.message.author.display_name} echoed \"{' '.join(message)}\""
)
async def set(self, ctx):
msg = f"`{ctx.prefix}set <{', '.join(self.keywords)}>`"
await ctx.send(embed=utils.embed(msg))
async def starcount_(self, ctx, amount: int):
"""sets the guilds limit on which messages
will be embedded in the guilds starboard"""
self.config.store('starcount', amount, ctx.guild.id)
msg = f"The messages now need {amount} stars to be pinned"
await ctx.send(embed=utils.embed(msg))
D.load_state_dict(d_state_dict)
n_gpu = torch.cuda.device_count()
device = torch.device('cuda:0' if n_gpu > 0 else 'cpu')
G.to(device), G.eval()
D.to(device), D.eval()
noise_dim, n_emb = 100, N_EMB
for r in range(10):
fixed_noise = torch.randn(120, noise_dim,
device=device) # .repeat(120, 1)
fixed_condition = torch.zeros(120, N_EMB, device=device)
for i in range(12):
for j in range(10):
fixed_condition[i * 10 + j] = embed(i, j,
n_emb=n_emb).to(device)
with torch.no_grad():
fixed_image = G(fixed_noise, fixed_condition)
save_image(fixed_image.data[:12 * 10],
os.path.join(opt.save_dir, 'result%d.png' % r),
nrow=10,
normalize=True)
# for r in range(10):
# fixed_noise = torch.randn(10, noise_dim, device = device)# .repeat(120, 1)
# fixed_condition = torch.zeros(10, N_EMB, device = device)
# # code = [(8, 1), (1, 7), (10, 8), (0, 4), (2, 5)]
# code = [(1, i) for i in range(10)]
# for i in range(10):
async def reloadProfiles(self, ctx):
self.bot.admins.verify_admin(ctx)
self.bot.profiles.load_profiles()
await ctx.send(embed=utils.embed(
title="Reload profiles", description=f"Profiles file reloaded."))
def callback_newComment(comment):
logger.logger.debug(comment)
msg = "【" + custom_time(comment["post_time"]) + "】【" + comment[
"nick_name"] + "】【" + comment["title"] + "】：" + comment["content"]
logger.logger.info(msg)
itchat_group.send_msg(msg)
if session.loadFromFile():
if session.checklogin():
logger.logger.info("Read Session Succeed!")
else:
logger.logger.info("Read Session Fail")
session.clear()
if not session.checklogin():
if login.Login(_config,
qrCallback=qrCallback,
verifycodeCallback=callback_verifyCode):
logger.logger.debug("Login Success. Return to main function")
logger.logger.debug("Start Message Listener")
session.saveToFile()
message.init(_config, callback_newMessage)
comment.init(_config, callback_newComment)
embed()
print(len(dataset.y_dev), 'dev samples')
mlb = MultiLabelBinarizer().fit(dataset.y_train)
num_classes = mlb.classes_.shape[0]
train_y = mlb.transform(dataset.y_train)
test_y = mlb.transform(dataset.y_test)
dev_y = mlb.transform(dataset.y_dev)
embedding_file = sys.argv[2]
vocab_file = sys.argv[3]
embeddings = numpy.load(embedding_file)
vocab_en = json.load(open(vocab_file))
print('Preprocessing')
train_x = embed(dataset.x_train,
embeddings,
vocab_en,
use_tfidf=use_tfidf,
avg_method='mean')
test_x = embed(dataset.x_test,
embeddings,
vocab_en,
use_tfidf=use_tfidf,
avg_method='mean')
dev_x = embed(dataset.x_dev,
embeddings,
vocab_en,
use_tfidf=use_tfidf,
avg_method='mean')
if train_de:
model = build_model(train_x, num_classes)
async def on_command_error(ctx, error):
# Print the exception to the user
await ctx.send(embed=utils.embed(title="Command error",
description=f"{error}"),
delete_after=bot.config.ERROR_DISPLAY_TIME)
logger.error(f"Command error: {error}")
