async def on_command_error(self, context, error):
cmd_name = context.command.name
cmd_settings = Settings.command_settings(cmd_name, context.guild.id)
if isinstance(error, discord.ext.commands.MissingPermissions
) and cmd_settings.get("visible"):
notice = "You need the following permissions for this command: {}".format(
", ".join([f"`{p}`" for p in error.missing_perms]))
await utils.say(context.channel, content=notice)
elif isinstance(error, discord.ext.commands.NotOwner):
return
else:
Logger.error(logger, error)
async def check_content(message, check, custom_message):
if check:
content = message.clean_content
try:
await message.delete()
except (discord.Forbidden, discord.HTTPException) as e:
Logger.warn(
logger,
f"Unable to delete message at {message.jump_url}. {e}")
else:
await utils.say(
message.author,
context=message,
parse=True,
content=
f"{custom_message}\nYour message: ```{content}```")
return True
return False
def set_commands(self, *cmds):
self.add_cog(commands.Admin(self))
self.add_cog(commands.General(self))
self.add_cog(commands.Statistics(self))
for c in cmds:
self.add_cog(c)
for command in self.commands:
Logger.debug(logger, f"Setting up command '{command.name}'")
cmd_settings = Settings.command_settings(command.name)
if not cmd_settings:
continue
command.aliases = cmd_settings.get("aliases", [])
command.hidden = not cmd_settings.get("visible", True)
command.description = cmd_settings.get("description", "")
command.help = cmd_settings.get("help", "")
command.usage = cmd_settings.get("usage", "")
Logger.debug(logger, f"Command '{command.name}' all set")
def include_reactions_inactivity(cls, server_id=None):
if server_id:
server_config = cls.server_features(server_id, "inactivity")
if server_config:
try:
return server_config["include_reactions"]
except KeyError as err:
Logger.debug(
logger,
f"'inactivity' config for server ID {server_id} is missing a setting for 'include_reactions'. Using default setting instead."
)
try:
return cls.default_features("inactivity")["include_reactions"]
except KeyError as err:
Logger.warn(
logger,
f"Missing a default setting for 'inactivity: include_reactions'. {err}"
)
return True
def inactive_message(cls, server_id):
default_config = cls.default_features("inactivity")
server_config = cls.server_features(server_id, "inactivity")
message_enabled = default_config["message_enabled"]
if server_config:
message_enabled = server_config.get("message_enabled",
message_enabled)
if message_enabled:
if server_config:
try:
return server_config["message"]
except KeyError:
Logger.debug(
logger,
f"'inactivity' config for server ID {server_id} is missing a setting for 'message'. Using default setting instead."
)
return default_config["message"]
return None
def inactive_threshold(cls, server_id=None):
"""Returns the minimum amount of days for a server member to be considered inactive."""
if server_id:
server_config = cls.server_features(server_id, "inactivity")
if server_config:
try:
return server_config["days_threshold"]
except KeyError as err:
Logger.debug(
logger,
f"'inactivity' config for server ID {server_id} is missing a setting for 'days_threshold'. Using default setting instead."
)
try:
return cls.default_features("inactivity")["days_threshold"]
except KeyError as err:
Logger.warn(
logger,
f"Missing a default setting for 'inactivity' feature: 'days_threshold'. {err}"
)
return 14
def log_message(message, content):
if message.guild:
Logger.info(
logger,
f"({message.guild.name} - {message.channel.name}){content}"
)
else:
try:
Logger.info(logger, f"({message.channel.name}){content}")
except AttributeError:
Logger.info(logger, f"({message.author.name}){content}")
def use_heuristic(HEURISTIC_TYPE='Perfekt-Pred-Heuristic',
epochs=1,
threshold_dem=50,
deactivate_SMS=True,
deactivate_LION=True):
# Naming the agent and setting up the directory path:
now = datetime.now()
NAME = str(
round(threshold_dem)) + '_NO_BATTERY_' + HEURISTIC_TYPE + now.strftime(
"_%d-%m-%Y_%H-%M-%S")
D_PATH = '_small_d/'
# Load the dataset:
main_dataset = mainDataset(D_PATH=D_PATH,
period_string_min='15min',
full_dataset=True)
# Normalized dataframe:
df = main_dataset.make_input_df(drop_main_terminal=False,
use_time_diff=True,
day_diff='holiday-weekend')
# Sum of the power demand dataframe (nor normalized):
power_dem_df = main_dataset.load_total_power()[24:-12]
# Load the LSTM input dataset:
lstm_dataset = lstmInputDataset(main_dataset, df, num_past_periods=12)
# Making predictions:
normal_predictions = wahrsager(lstm_dataset, power_dem_df,
TYPE='NORMAL').pred()[:-12]
seq_predictions = wahrsager(lstm_dataset,
power_dem_df,
TYPE='SEQ',
num_outputs=12).pred()
# Adding the predictions to the dataset:
df = df[24:-12]
df['normal'] = normal_predictions
df['seq_max'] = max_seq(seq_predictions)
logger = Logger(NAME, D_PATH)
# Setup reward_maker
r_maker = reward_maker(LOGGER=logger,
COST_TYPE='exact_costs',
R_TYPE='savings_focus',
R_HORIZON='single_step',
cost_per_kwh=0.2255,
LION_Anschaffungs_Preis=34100,
LION_max_Ladezyklen=1000,
SMS_Anschaffungs_Preis=115000 / 3,
SMS_max_Nutzungsjahre=20,
Leistungspreis=102,
logging_list=[
'cost_saving', 'exact_costs', 'sum_exact_costs',
'sum_cost_saving'
],
deactivate_SMS=deactivate_SMS,
deactivate_LION=deactivate_LION)
# Lade Environment:
env = common_env(reward_maker=r_maker,
df=df,
power_dem_df=power_dem_df,
input_list=['norm_total_power', 'normal', 'seq_max'],
max_SMS_SoC=12 / 3,
max_LION_SoC=54,
PERIODEN_DAUER=15,
ACTION_TYPE='contin',
OBS_TYPE='contin',
AGENT_TYPE='heuristic')
agent = heurisitc(env=env,
HEURISTIC_TYPE=HEURISTIC_TYPE,
threshold_dem=threshold_dem)
return agent.calculate(epochs=epochs)
async def on_message(self, message):
async def check_content(message, check, custom_message):
if check:
content = message.clean_content
try:
await message.delete()
except (discord.Forbidden, discord.HTTPException) as e:
Logger.warn(
logger,
f"Unable to delete message at {message.jump_url}. {e}")
else:
await utils.say(
message.author,
context=message,
parse=True,
content=
f"{custom_message}\nYour message: ```{content}```")
return True
return False
user = message.author
if message.guild:
Logger.info(
logger,
f"({message.guild.name} - {message.channel.name}) {user.name}: {message.content}"
)
else:
try:
Logger.info(
logger,
f"({message.channel.name}) {user.name}: {message.content}")
except AttributeError:
Logger.info(logger, f"({user.name}) {message.content}")
finally:
return
mee6_level_up = Settings.on_message_features(message.guild.id,
"mee6_level_up")
if mee6_level_up and mee6_level_up.get(
"enabled") and user.id == mee6_level_up["bot_id"]:
result = re.compile(r"{}".format(
mee6_level_up["message_pattern"])).search(message.content)
if result:
mentioned = message.mentions[0]
level = int(result.group(1))
Logger.info(logger, f"{mentioned.name} reached level {level}")
roles = mee6_level_up["roles"]
for r in roles:
if level >= r:
role = discord.utils.get(message.guild.roles,
id=roles[r]["id"])
await mentioned.add_roles(
role, reason=f"User reached level {r}")
pics_only = Settings.on_message_features(message.guild.id, "pics_only")
if pics_only and pics_only.get("enabled"):
channel = message.channel
if channel.id in pics_only["channels"]:
if await check_content(
message, not message.attachments,
pics_only["channels"][channel.id]["message"]):
return
await self.process_commands(message)
async def on_ready(self):
prefix = Settings.app_defaults("cmd_prefix")
Logger.info(logger,
f"{self.user.name} (ID: {self.user.id}) is now online.")
status = Settings.app_defaults("status").format(prefix=prefix)
await self.change_presence(activity=discord.Game(name=status))
async def on_error(self, context, error):
Logger.error(logger, error)