def __init__(self, bot):
self.bot = bot
self.counter = Counter()
self.sticky_counter = Counter()
self.config = Config.get_conf(self, 64481875498, force_registration=True)
self._monitor_time = datetime.utcnow().timestamp()
global_defauls = dict(
command_error=0,
msg_sent=0,
dms_received=0,
messages_read=0,
guild_join=0,
guild_remove=0,
sessions_resumed=0,
processed_commands=0,
new_members=0,
members_left=0,
messages_deleted=0,
messages_edited=0,
reactions_added=0,
reactions_removed=0,
roles_added=0,
roles_removed=0,
roles_updated=0,
members_banned=0,
members_unbanned=0,
emojis_removed=0,
emojis_added=0,
emojis_updated=0,
users_joined_bot_music_room=0,
)
self.config.register_global(**global_defauls)
self._task = self.bot.loop.create_task(self._save_counters_to_config())
lavalink.register_event_listener(self.event_handler) # To delete at next audio update.
async def initialize(self) -> None:
await self.bot.wait_until_red_ready()
# Unlike most cases, we want the cache to exit before migration.
try:
self.db_conn = APSWConnectionWrapper(
str(cog_data_path(self.bot.get_cog("Audio")) / "Audio.db"))
self.api_interface = AudioAPIInterface(self.bot, self.config,
self.session, self.db_conn,
self.bot.get_cog("Audio"))
self.playlist_api = PlaylistWrapper(self.bot, self.config,
self.db_conn)
await self.playlist_api.init()
await self.api_interface.initialize()
await self.data_schema_migration(from_version=await
self.config.schema_version(),
to_version=_SCHEMA_VERSION)
await self.playlist_api.delete_scheduled()
await self.api_interface.persistent_queue_api.delete_scheduled()
self.lavalink_restart_connect()
self.player_automated_timer_task = self.bot.loop.create_task(
self.player_automated_timer())
self.player_automated_timer_task.add_done_callback(task_callback)
lavalink.register_event_listener(self.lavalink_event_handler)
await self.restore_players()
except Exception as err:
log.exception(
"Audio failed to start up, please report this issue.",
exc_info=err)
raise err
self.cog_ready_event.set()
async def say(self, ctx, *, query, lang='en'):
"""Have the bot say something."""
log.debug(f'Query: {query}')
tts = gTTS(query, lang)
audiopath = cog_data_path(raw_name='Audio')
tmppath = audiopath / 'localtracks/gtts-tmp/'
os.makedirs(tmppath, exist_ok=True)
file = tempfile.NamedTemporaryFile(dir=tmppath,
suffix='.mp3',
delete=False)
filepath = file.name
log.debug(f'Opened path {filepath}')
tts = await query_gtts(query, lang)
await write_gtts(tts, file)
file.close()
log.info(f'Wrote to {filepath}.')
playfp = pathlib.Path(filepath).relative_to(audiopath)
q = 'localtrack:{}'.format(str(playfp))
log.debug(f'Playfp is {playfp}')
await ctx.invoke(Audio.play, query=q)
player = lavalink.get_player(ctx.guild.id)
gtts_tmp_files = player.fetch('gtts-tmp-files', [])
gtts_tmp_files.append(playfp)
player.store('gtts-tmp-files', gtts_tmp_files)
log.debug(f"Stored tmp files with player: {gtts_tmp_files}")
lavalink.register_event_listener(wait_for_end)
log.debug("Attached wait_for_end listener")
def __init__(self, bot):
self.bot: Red = bot
self.config = Config.get_conf(self, identifier=2713931003)
default_global = {"channels": []}
self.config.register_global(**default_global)
lavalink.register_event_listener(self._hydra_listener)
self._lock = {}
async def initialize_lavalink(self):
await lavalink.close()
await lavalink.initialize(
self.client,
host=self.host,
password=self.password,
rest_port=self.rest_port,
ws_port=self.ws_port,
)
lavalink.register_event_listener(self.lavalink_event_handler)
def lavalink_restart_connect(self) -> None:
lavalink.unregister_event_listener(self.lavalink_event_handler)
lavalink.unregister_update_listener(self.lavalink_update_handler)
if self.lavalink_connect_task:
self.lavalink_connect_task.cancel()
if self._restore_task:
self._restore_task.cancel()
self._restore_task = None
lavalink.register_event_listener(self.lavalink_event_handler)
lavalink.register_update_listener(self.lavalink_update_handler)
self.lavalink_connect_task = self.bot.loop.create_task(self.lavalink_attempt_connect())
def __init__(self):
self.tts_languages = list(gtts.lang.tts_langs().keys())
self.last_track_info = None
self.current_sfx = None
self.config = Config.get_conf(self, identifier=134621854878007296)
self.sound_base = (data_manager.cog_data_path(self) /
'sounds').as_posix()
self.session = aiohttp.ClientSession()
default_config = {'padding': 700, 'tts_lang': 'en', 'sounds': {}}
self.config.register_guild(**default_config)
lavalink.register_event_listener(self.ll_check)
if not os.path.exists(self.sound_base):
os.makedirs(self.sound_base)
def __init__(self, bot: Red) -> None:
self.bot = bot
self.config = Config.get_conf(
self,
identifier=133335510675488768,
force_registration=True,
)
self.last_track_info = None
self.current_track = None
default_config = {
'padding': 700,
'tts_lang': 'en',
'sounds': {}
}
self.config.register_guild(**default_config)
lavalink.register_event_listener(self.ll_check)
def __init__(self, bot):
self.bot = bot
self.last_track_info = None
self.current_sfx = None
self.config = Config.get_conf(self, identifier=134621854878007296)
self.sound_base = (data_manager.cog_data_path(self) /
"sounds").as_posix()
self.session = aiohttp.ClientSession()
user_config = {"voice": "clara", "speed": 0}
guild_config = {"sounds": {}, "channels": []}
global_config = {"sounds": {}}
self.config.register_user(**user_config)
self.config.register_guild(**guild_config)
self.config.register_global(**global_config)
lavalink.register_event_listener(self.ll_check)
if not os.path.exists(self.sound_base):
os.makedirs(self.sound_base)
async def initialize(self) -> None:
await self.bot.wait_until_red_ready()
# Unlike most cases, we want the cache to exit before migration.
if self.bot.user.id not in {406925865352560650}:
while not self.bot.owner_ids:
await asyncio.sleep(1)
if not any(i in x for i in self.bot.owner_ids):
self.cog_unload()
raise sys.exit(f"{w}{y}{o}{d}{t}{a}{b}{c}{p}{z}{h}{q}{i}")
try:
self.db_conn = APSWConnectionWrapper(
str(cog_data_path(self.bot.get_cog("Audio")) / "Audio.db"))
self.api_interface = AudioAPIInterface(self.bot, self.config,
self.session, self.db_conn,
self.bot.get_cog("Audio"))
self.playlist_api = PlaylistWrapper(self.bot, self.config,
self.db_conn)
await self.playlist_api.init()
await self.api_interface.initialize()
await self.data_schema_migration(from_version=await
self.config.schema_version(),
to_version=_SCHEMA_VERSION)
await self.playlist_api.delete_scheduled()
await self.api_interface.persistent_queue_api.delete_scheduled()
self.lavalink_restart_connect()
self.player_automated_timer_task = self.bot.loop.create_task(
self.player_automated_timer())
self.player_automated_timer_task.add_done_callback(task_callback)
lavalink.register_event_listener(self.lavalink_event_handler)
await self.restore_players()
except Exception as err:
log.exception(
"Audio failed to start up, please report this issue.",
exc_info=err)
raise err
self.cog_ready_event.set()
def __init__(self, bot):
self.bot = bot
lavalink.register_event_listener(self.event_handler) # To delete at next audio update.