def find_match(self, message, banphrase_id=None): match = None if banphrase_id is not None: match = find(lambda banphrase: banphrase.id == banphrase_id, self.banphrases) if match is None: match = find(lambda banphrase: banphrase.exact_match(message), self.banphrases) return match
def modules_edit(module_id, **options): module_manager = ModuleManager(None).load(do_reload=False) current_module = find(lambda m: m.ID == module_id, module_manager.all_modules) if current_module is None: return render_template('admin/module_404.html'), 404 sub_modules = [] for module in module_manager.all_modules: module.db_module = None with DBManager.create_session_scope() as db_session: for db_module in db_session.query(Module): module = find(lambda m: m.ID == db_module.id, module_manager.all_modules) if module: module.db_module = db_module if module.PARENT_MODULE == current_module.__class__: sub_modules.append(module) if current_module.db_module is None: return render_template('admin/module_404.html'), 404 if request.method == 'POST': form_values = {key: value for key, value in request.form.items()} res = current_module.parse_settings(**form_values) if res is False: return render_template('admin/module_404.html'), 404 current_module.db_module.settings = json.dumps(res) db_session.commit() settings = None try: settings = json.loads(current_module.db_module.settings) except (TypeError, ValueError): pass current_module.load(settings=settings) payload = { 'id': current_module.db_module.id, } SocketClientManager.send('module.update', payload) AdminLogManager.post('Module edited', options['user'], current_module.NAME) return render_template('admin/configure_module.html', module=current_module, sub_modules=sub_modules) else: settings = None try: settings = json.loads(current_module.db_module.settings) except (TypeError, ValueError): pass current_module.load(settings=settings) return render_template('admin/configure_module.html', module=current_module, sub_modules=sub_modules)
def find_match(self, message, id=None): match = None if id is not None: match = find(lambda banphrase: banphrase.id == id, self.banphrases) if match is None: match = find(lambda banphrase: banphrase.exact_match(message), self.banphrases) return match
def command_detailed(raw_command_string): command_string_parts = raw_command_string.split("-") command_string = command_string_parts[0] command_id = None try: command_id = int(command_string) except ValueError: pass bot_commands_list = get_commands_list() if command_id is not None: command = find(lambda c: c["id"] == command_id, bot_commands_list) else: command = find(lambda c: c["resolve_string"] == command_string, bot_commands_list) if command is None: # XXX: Is it proper to have it return a 404 code as well? return render_template("command_404.html") examples = command["examples"] return render_template("command_detailed.html", command=command, examples=examples)
def command_detailed(raw_command_string): command_string_parts = raw_command_string.split('-') command_string = command_string_parts[0] command_id = None try: command_id = int(command_string) except ValueError: pass bot_commands_list = get_commands_list() if command_id is not None: command = find(lambda c: c['id'] == command_id, bot_commands_list) else: command = find(lambda c: c['resolve_string'] == command_string, bot_commands_list) if command is None: # XXX: Is it proper to have it return a 404 code as well? return render_template('command_404.html') examples = command['examples'] return render_template('command_detailed.html', command=command, examples=examples)
def find_match(self, message, id=None): match = None if id is not None: match = find(lambda autoresponse: autoresponse.id == id, self.autoresponses) if match is None: match = find( lambda autoresponse: autoresponse.exact_match(message), self.autoresponses) return match
def pleblist_history_stream(stream_id): with DBManager.create_session_scope() as session: stream = session.query(Stream).filter_by(id=stream_id).one_or_none() if stream is None: return render_template('pleblist_history_404.html'), 404 previous_stream = session.query(Stream).filter_by(id=stream_id - 1).one_or_none() next_stream = session.query(Stream).filter_by(id=stream_id + 1).one_or_none() # Fetch all associated stream chunks so we can associate songs to a certain stream chunk stream_chunks = session.query(StreamChunk).filter(StreamChunk.stream_id == stream.id).all() q = session.query(PleblistSong).filter(PleblistSong.stream_id == stream.id).order_by(PleblistSong.id.asc()) songs = [] queue_index = 0 queue_time = 0 for song in q: if song.song_info is None: continue data = { 'song_duration': song.song_info.duration if song.skip_after is None else song.skip_after, } if song.date_played is None: # Song has not been played # Figure out when it will be played~ data['queue_index'] = queue_index data['queue_time'] = queue_time queue_index = queue_index + 1 queue_time = queue_time + data['song_duration'] else: # Song has already been played # Figure out a link to the vod URL stream_chunk = find(lambda stream_chunk: stream_chunk.chunk_start <= song.date_played and (stream_chunk.chunk_end is None or stream_chunk.chunk_end >= song.date_played), stream_chunks) if stream_chunk is not None: vodtime_in_seconds = (song.date_played - stream_chunk.chunk_start).total_seconds() - data['song_duration'] data['vod_url'] = '{}?t={}'.format(stream_chunk.video_url, seconds_to_vodtime(vodtime_in_seconds)) songs.append((data, song)) total_length_left = sum([song.skip_after or song.song_info.duration if song.date_played is None and song.song_info is not None else 0 for _, song in songs]) first_unplayed_song = find(lambda song: song[1].date_played is None, songs) return render_template('pleblist_history.html', stream=stream, previous_stream=previous_stream, next_stream=next_stream, songs=songs, total_length_left=total_length_left, first_unplayed_song=first_unplayed_song, stream_chunks=stream_chunks)
def reload(self): # TODO: Make disable/enable better, so we don't need to disable modules # that we're just going to enable again further down below. for module in self.modules: log.debug('Disabling {module.NAME}'.format(module=module)) module.disable(self.bot) self.modules = [] with DBManager.create_session_scope() as db_session: for enabled_module in db_session.query(Module).filter_by(enabled=True): module = find(lambda m: m.ID == enabled_module.id, self.all_modules) if module is not None: options = {} if enabled_module.settings is not None: try: options['settings'] = json.loads(enabled_module.settings) except ValueError: log.warn('Invalid JSON') self.modules.append(module.load(**options)) log.debug('Enabling {module.NAME}'.format(module=module)) module.enable(self.bot) to_be_removed = [] self.modules.sort(key=lambda m: 1 if m.PARENT_MODULE is not None else 0) for module in self.modules: if module.PARENT_MODULE is None: module.submodules = [] else: parent = find(lambda m: m.__class__ == module.PARENT_MODULE, self.modules) if parent is not None: parent.submodules.append(module) module.parent_module = parent else: log.warn('Missing parent for module {}, disabling it.'.format(module.NAME)) module.parent_module = None to_be_removed.append(module) for module in to_be_removed: log.debug('Disabling (2) {module.NAME}'.format(module=module)) module.disable(self.bot) self.modules.remove(module) # Perform a last on_loaded call on each module. # This is used for things that require submodules to be loaded properly # i.e. the quest system for module in self.modules: module.on_loaded()
def on_banphrase_update(self, data, conn): try: banphrase_id = int(data['id']) except (KeyError, ValueError): log.warn('No banphrase ID found in on_banphrase_update') return False updated_banphrase = find(lambda banphrase: banphrase.id == banphrase_id, self.banphrases) if updated_banphrase: with DBManager.create_session_scope(expire_on_commit=False) as db_session: db_session.add(updated_banphrase) db_session.refresh(updated_banphrase) db_session.expunge(updated_banphrase) else: with DBManager.create_session_scope(expire_on_commit=False) as db_session: updated_banphrase = db_session.query(Banphrase).filter_by(id=banphrase_id).one_or_none() db_session.expunge_all() if updated_banphrase is not None: self.db_session.add(updated_banphrase.data) if updated_banphrase: if updated_banphrase not in self.banphrases: self.banphrases.append(updated_banphrase) if updated_banphrase.enabled is True and updated_banphrase not in self.enabled_banphrases: self.enabled_banphrases.append(updated_banphrase) for banphrase in self.enabled_banphrases: if banphrase.enabled is False: self.enabled_banphrases.remove(banphrase)
def on_managers_loaded(self, **rest): # This function is used to resume a quest in case the bot starts when the stream is already live if not self.current_quest_key: log.error( "Current quest key not set when on_managers_loaded event fired, something is wrong" ) return if self.current_quest: # There's already a quest chosen for today return redis = RedisManager.get() current_quest_id = redis.get(self.current_quest_key) log.info(f"Try to load submodule with ID {current_quest_id}") if not current_quest_id: # No "current quest" was chosen by an above manager return current_quest_id = current_quest_id quest = find(lambda m: m.ID == current_quest_id, self.submodules) if not quest: log.info("No quest with id %s found in submodules (%s)", current_quest_id, self.submodules) return self.current_quest = quest self.current_quest.quest_module = self self.current_quest.start_quest() log.info(f"Resumed quest {quest.get_objective()}")
def pleblist_history_stream(stream_id): with DBManager.create_session_scope() as session: stream = session.query(Stream).filter_by(id=stream_id).one_or_none() if stream is None: return render_template('pleblist_history_404.html'), 404 previous_stream = session.query(Stream).filter_by(id=stream_id - 1).one_or_none() next_stream = session.query(Stream).filter_by(id=stream_id + 1).one_or_none() q = session.query(PleblistSong, User).outerjoin(User, PleblistSong.user_id == User.id).filter(PleblistSong.stream_id == stream.id).order_by(PleblistSong.id.asc(), PleblistSong.id.asc()) songs = [] for song, user in q: song.user = user songs.append(song) total_length_left = sum([song.skip_after or song.song_info.duration if song.date_played is None and song.song_info is not None else 0 for song in songs]) first_unplayed_song = find(lambda song: song.date_played is None, songs) stream_chunks = session.query(StreamChunk).filter(StreamChunk.stream_id == stream.id).all() return render_template('pleblist_history.html', stream=stream, previous_stream=previous_stream, next_stream=next_stream, songs=songs, total_length_left=total_length_left, first_unplayed_song=first_unplayed_song, stream_chunks=stream_chunks)
def parse_settings(self, **in_settings): ret = {} for key, value in in_settings.items(): setting = find( lambda setting, setting_key=key: setting.key == setting_key, self.SETTINGS) if setting is None: # We were passed a setting that's not available for this module return False log.debug(f"{key}: {value}") res, new_value = setting.validate(value) if res is False: # Something went wrong when validating one of the settings log.warning(new_value) return False ret[key] = new_value for setting in self.SETTINGS: if setting.type == "boolean": if setting.key not in ret: ret[setting.key] = False log.debug("{}: {} - special".format(setting.key, False)) return ret
def validate_module(module_id): module = find(lambda m: m.ID == module_id, pajbot.modules.available_modules) if module is None: return False return module.MODULE_TYPE not in (ModuleType.TYPE_ALWAYS_ENABLED, )
def validate_module(module_id): module = find(lambda m: m.ID == module_id, pajbot.modules.available_modules) if module is None: return False return module.MODULE_TYPE not in (ModuleType.TYPE_ALWAYS_ENABLED,)
def on_banphrase_update(self, data, conn): try: banphrase_id = int(data['id']) except (KeyError, ValueError): log.warn('No banphrase ID found in on_banphrase_update') return False updated_banphrase = find( lambda banphrase: banphrase.id == banphrase_id, self.banphrases) if updated_banphrase: with DBManager.create_session_scope( expire_on_commit=False) as db_session: db_session.add(updated_banphrase) db_session.refresh(updated_banphrase) db_session.expunge(updated_banphrase) else: with DBManager.create_session_scope( expire_on_commit=False) as db_session: updated_banphrase = db_session.query(Banphrase).filter_by( id=banphrase_id).one_or_none() db_session.expunge_all() if updated_banphrase is not None: self.db_session.add(updated_banphrase.data) if updated_banphrase: if updated_banphrase not in self.banphrases: self.banphrases.append(updated_banphrase) if updated_banphrase.enabled is True and updated_banphrase not in self.enabled_banphrases: self.enabled_banphrases.append(updated_banphrase) for banphrase in self.enabled_banphrases: if banphrase.enabled is False: self.enabled_banphrases.remove(banphrase)
def remove_handler(event, method): handler = None try: handler = find(lambda h: HandlerManager.method_matches(h, method), HandlerManager.handlers[event]) if handler is not None: HandlerManager.handlers[event].remove(handler) except KeyError: # No handlers for this event found log.error('remove_handler No handler for {} found.'.format(event))
def remove_handler(event: str, method: Callable[..., bool]) -> None: try: handler = find(lambda h: h[0] == method, HandlerManager.handlers[event]) if handler is not None: HandlerManager.handlers[event].remove(handler) except KeyError: # No handlers for this event found log.error(f"remove_handler No handler for {event} found.")
def privmsg(self, channel, message, increase_message=True): if increase_message: conn = find(lambda c: c.conn.is_connected() and c.num_msgs_sent < self.message_limit, self.connlist) else: conn = find(lambda c: c.conn.is_connected(), self.connlist) if conn is None: log.error('No available connections to send messages from. Delaying message a few seconds.') self.reactor.execute_delayed(2, self.privmsg, (channel, message, increase_message)) return False conn.conn.privmsg(channel, message) if increase_message: conn.num_msgs_sent += 1 self.reactor.execute_delayed(31, conn.reduce_msgs_sent) if conn.num_msgs_sent >= self.message_limit: self.run_maintenance()
def remove_handler(event, method): handler = None try: handler = find(lambda h: HandlerManager.method_matches(h, method), HandlerManager.handlers[event]) if handler is not None: HandlerManager.handlers[event].remove(handler) except KeyError: # No handlers for this event found log.error("remove_handler No handler for {} found.".format(event))
def tick(self): if self.bot.is_online: for timer in self.online_timers: timer.time_to_send_online -= 1 timer = find(lambda timer: timer.time_to_send_online <= 0, self.online_timers) if timer: timer.run(self.bot) timer.time_to_send_online = timer.interval_online self.online_timers.remove(timer) self.online_timers.append(timer) else: for timer in self.offline_timers: timer.time_to_send_offline -= 1 timer = find(lambda timer: timer.time_to_send_offline <= 0, self.offline_timers) if timer: timer.run(self.bot) timer.time_to_send_offline = timer.interval_offline self.offline_timers.remove(timer) self.offline_timers.append(timer)
def modules(**options) -> ResponseReturnValue: module_manager = ModuleManager(None).load(do_reload=False) with DBManager.create_session_scope() as db_session: for db_module in db_session.query(Module): module = find(lambda m: m.ID == db_module.id, module_manager.all_modules) if module: module.db_module = db_module return render_template("admin/modules.html", modules=module_manager.all_modules)
def on_module_update(self, data, conn): log.info('ModuleManager: module.update begin ({})'.format(data)) # self.reload() new_state = data.get('new_state', None) if new_state is True: self.enable_module(data['id']) elif new_state is False: self.disable_module(data['id']) else: module = find(lambda m: m.ID == data['id'], self.all_modules) self.load_module(module) log.info('ModuleManager: module.update done')
def modules(**options): module_manager = ModuleManager(None).load(do_reload=False) for module in module_manager.all_modules: module.db_module = None with DBManager.create_session_scope() as db_session: for db_module in db_session.query(Module): module = find(lambda m: m.ID == db_module.id, module_manager.all_modules) if module: module.db_module = db_module return render_template('admin/modules.html', modules=module_manager.all_modules)
def get(self, raw_command_id): command_string = raw_command_id command_id = None try: command_id = int(command_string) except (ValueError, TypeError): pass if command_id: command = find(lambda c: c['id'] == command_id, pajbot.web.utils.get_cached_commands()) else: command = find(lambda c: c['resolve_string'] == command_string, pajbot.web.utils.get_cached_commands()) if not command: return { 'message': 'A command with the given ID was not found.' }, 404 return { 'command': command }, 200
def disable_module(self, module_id, reload_commands=False): module = find(lambda m: m.ID == module_id, self.all_modules) if module is None: log.error('No module with the ID {} found.'.format(module_id)) return False module.disable(self.bot) if module not in self.modules: log.error('Module {} is not in the list of enabled modules pajaW'.format(module_id)) return False self.modules.remove(module)
def get(raw_command_id): command_string = raw_command_id command_id = None try: command_id = int(command_string) except (ValueError, TypeError): pass if command_id: command = find(lambda c: c["id"] == command_id, pajbot.web.utils.get_cached_commands()) else: command = find(lambda c: c["resolve_string"] == command_string, pajbot.web.utils.get_cached_commands()) if not command: return { "message": "A command with the given ID was not found." }, 404 return {"command": command}, 200
def privmsg(self, channel, message, increase_message=True): if increase_message: conn = find( lambda c: c.conn.is_connected() and c.num_msgs_sent < self. message_limit, self.connlist) else: conn = find(lambda c: c.conn.is_connected(), self.connlist) if conn is None: log.error( 'No available connections to send messages from. Delaying message a few seconds.' ) self.reactor.execute_delayed(2, self.privmsg, (channel, message, increase_message)) return False conn.conn.privmsg(channel, message) if increase_message: conn.num_msgs_sent += 1 self.reactor.execute_delayed(31, conn.reduce_msgs_sent) if conn.num_msgs_sent >= self.message_limit: self.run_maintenance()
def reload(self): # TODO: Make disable/enable better, so we don't need to disable modules # that we're just going to enable again further down below. for module in self.modules: module.disable(self.bot) self.modules = [] with DBManager.create_session_scope() as db_session: for enabled_module in db_session.query(Module).filter_by( enabled=True): module = self.get_module(enabled_module.id) if module is not None: options = {} if enabled_module.settings is not None: try: options["settings"] = json.loads( enabled_module.settings) except ValueError: log.warning("Invalid JSON") self.modules.append(module.load(**options)) module.enable(self.bot) to_be_removed = [] self.modules.sort( key=lambda m: 1 if m.PARENT_MODULE is not None else 0) for module in self.modules: if module.PARENT_MODULE is None: module.submodules = [] else: parent = find(lambda m: m.__class__ == module.PARENT_MODULE, self.modules) if parent is not None: parent.submodules.append(module) module.parent_module = parent else: # log.warning('Missing parent for module {}, disabling it.'.format(module.NAME)) module.parent_module = None to_be_removed.append(module) for module in to_be_removed: module.disable(self.bot) self.modules.remove(module) # Perform a last on_loaded call on each module. # This is used for things that require submodules to be loaded properly # i.e. the quest system for module in self.modules: module.on_loaded()
def on_timer_remove(self, data, conn): try: timer_id = int(data['id']) except (KeyError, ValueError): log.warn('No timer ID found in on_timer_update') return False removed_timer = find(lambda timer: timer.id == timer_id, self.timers) if removed_timer: if removed_timer in self.timers: self.timers.remove(removed_timer) if removed_timer in self.online_timers: self.online_timers.remove(removed_timer) if removed_timer in self.offline_timers: self.offline_timers.remove(removed_timer)
def enable_module(self, module_id): log.debug('Enabling module {}'.format(module_id)) module = find(lambda m: m.ID == module_id, self.all_modules) if module is None: log.error('No module with the ID {} found.'.format(module_id)) return False module.enable(self.bot) if module in self.modules: log.error('Module {} is already in the list of enabled modules pajaW'.format(module_id)) return False self.modules.append(module) self.load_module(module)
def on_command_update(self, data): try: command_id = int(data["command_id"]) except (KeyError, ValueError): log.warning("No command ID found in on_command_update") return command = find(lambda command: command.id == command_id, self.db_commands.values()) if command is not None: self.remove_command_aliases(command) self.load_by_id(command_id) log.debug("Reloaded command with id {}".format(command_id)) self.rebuild()
def on_command_update(self, data, conn): try: command_id = int(data['command_id']) except (KeyError, ValueError): log.warn('No command ID found in on_command_update') return False command = find(lambda command: command.id == command_id, self.db_commands.values()) if command is not None: self.remove_command_aliases(command) self.load_by_id(command_id) log.debug('Reloaded command with id {}'.format(command_id)) self.rebuild()
def on_banphrase_remove(self, data, conn): try: banphrase_id = int(data['id']) except (KeyError, ValueError): log.warn('No banphrase ID found in on_banphrase_remove') return False removed_banphrase = find(lambda banphrase: banphrase.id == banphrase_id, self.banphrases) if removed_banphrase: if removed_banphrase.data and removed_banphrase.data in self.db_session: self.db_session.expunge(removed_banphrase.data) if removed_banphrase in self.enabled_banphrases: self.enabled_banphrases.remove(removed_banphrase) if removed_banphrase in self.banphrases: self.banphrases.remove(removed_banphrase)
def test_find_iterate(): from pajbot.utils import find d = { "foo": True, "bar": True, "xD": False, } haystack = ["foo", "baz", "bar"] for k, v in d.items(): needle = find(lambda t: t == k, haystack) if v: assert needle == k else: assert needle is None
def on_timer_remove(self, data): try: timer_id = int(data["id"]) except (KeyError, ValueError): log.warning("No timer ID found in on_timer_update") return False removed_timer = find(lambda timer: timer.id == timer_id, self.timers) if removed_timer: if removed_timer in self.timers: self.timers.remove(removed_timer) if removed_timer in self.online_timers: self.online_timers.remove(removed_timer) if removed_timer in self.offline_timers: self.offline_timers.remove(removed_timer) return True
def on_banphrase_remove(self, data): try: banphrase_id = int(data["id"]) except (KeyError, ValueError): log.warning("No banphrase ID found in on_banphrase_remove") return False removed_banphrase = find(lambda banphrase: banphrase.id == banphrase_id, self.banphrases) if removed_banphrase: if removed_banphrase.data and removed_banphrase.data in self.db_session: self.db_session.expunge(removed_banphrase.data) if removed_banphrase in self.enabled_banphrases: self.enabled_banphrases.remove(removed_banphrase) if removed_banphrase in self.banphrases: self.banphrases.remove(removed_banphrase)
def on_timer_update(self, data): try: timer_id = int(data["id"]) except (KeyError, ValueError): log.warning("No timer ID found in on_timer_update") return False updated_timer = find(lambda timer: timer.id == timer_id, self.timers) if updated_timer: with DBManager.create_session_scope( expire_on_commit=False) as db_session: db_session.add(updated_timer) db_session.refresh(updated_timer) updated_timer.refresh_action() db_session.expunge(updated_timer) else: with DBManager.create_session_scope( expire_on_commit=False) as db_session: updated_timer = db_session.query(Timer).filter_by( id=timer_id).one_or_none() # Add the updated timer to the timer lists if required if updated_timer: if updated_timer not in self.timers: self.timers.append(updated_timer) if updated_timer not in self.online_timers: if updated_timer.interval_online > 0: self.online_timers.append(updated_timer) updated_timer.refresh_tts() if updated_timer not in self.offline_timers: if updated_timer.interval_offline > 0: self.offline_timers.append(updated_timer) updated_timer.refresh_tts() for timer in self.online_timers: if timer.enabled is False or timer.interval_online <= 0: self.online_timers.remove(timer) for timer in self.offline_timers: if timer.enabled is False or timer.interval_offline <= 0: self.offline_timers.remove(timer) return True
def on_managers_loaded(self): if self.current_quest is None: redis = RedisManager.get() current_quest_id = redis.get(self.current_quest_key) log.info('Try to load submodule with ID {}'.format(current_quest_id)) if current_quest_id is not None: current_quest_id = current_quest_id quest = find(lambda m: m.ID == current_quest_id, self.submodules) if quest is not None: log.info('Resumed quest {}'.format(quest.get_objective())) self.current_quest = quest self.current_quest.start_quest() else: log.info('No quest with id {} found in submodules ({})'.format(current_quest_id, self.submodules))
def on_command_remove(self, data): try: command_id = int(data["command_id"]) except (KeyError, ValueError): log.warning("No command ID found in on_command_update") return command = find(lambda command: command.id == command_id, self.db_commands.values()) if command is None: log.warning("Invalid ID sent to on_command_update") return self.db_session.expunge(command.data) self.remove_command_aliases(command) log.debug("Remove command with id {}".format(command_id)) self.rebuild()
def on_command_remove(self, data, conn): try: command_id = int(data['command_id']) except (KeyError, ValueError): log.warn('No command ID found in on_command_update') return False command = find(lambda command: command.id == command_id, self.db_commands.values()) if command is None: log.warn('Invalid ID sent to on_command_update') return False self.db_session.expunge(command.data) self.remove_command_aliases(command) log.debug('Remove command with id {}'.format(command_id)) self.rebuild()
def _disable_orphan_modules(self) -> None: to_be_removed: List[BaseModule] = [] self.modules.sort(key=lambda m: 1 if m.PARENT_MODULE is not None else 0) for module in self.modules: if module.PARENT_MODULE is None: module.submodules = [] else: parent = find(lambda m: m.__class__ == module.PARENT_MODULE, self.modules) if parent is not None: parent.submodules.append(module) module.parent_module = parent else: # log.warning('Missing parent for module {}, disabling it.'.format(module.NAME)) module.parent_module = None to_be_removed.append(module) for module in to_be_removed: module.disable(self.bot) self.modules.remove(module)
def on_autoresponse_remove(self, data, conn): try: autoresponse_id = int(data['id']) except (KeyError, ValueError): log.warn('No autoresponse ID found in on_autoresponse_remove') return False removed_autoresponse = find( lambda autoresponse: autoresponse.id == autoresponse_id, self.autoresponses) if removed_autoresponse: if removed_autoresponse.data and removed_autoresponse.data in self.db_session: self.db_session.expunge(removed_autoresponse.data) if removed_autoresponse in self.enabled_autoresponses: self.enabled_autoresponses.remove(removed_autoresponse) if removed_autoresponse in self.autoresponses: self.autoresponses.remove(removed_autoresponse)
def load(self, do_reload=True): """ Load module classes """ from pajbot.modules import available_modules self.all_modules = [module(self.bot) for module in available_modules] with DBManager.create_session_scope() as db_session: # Make sure there's a row in the DB for each module that's available db_modules = db_session.query(Module).all() for module in self.all_modules: mod = find(lambda db_module, registered_module=module: db_module.id == registered_module.ID, db_modules) if mod is None: log.info("Creating row in DB for module {}".format(module.ID)) mod = Module(module.ID, enabled=module.ENABLED_DEFAULT) db_session.add(mod) if do_reload is True: self.reload() return self
def load(self, do_reload=True): """ Load module classes """ from pajbot.modules import available_modules self.all_modules = [module() for module in available_modules] with DBManager.create_session_scope() as db_session: # Make sure there's a row in the DB for each module that's available db_modules = db_session.query(Module).all() for module in self.all_modules: mod = find(lambda m: m.id == module.ID, db_modules) if mod is None: log.info('Creating row in DB for module {}'.format(module.ID)) mod = Module(module.ID, enabled=module.ENABLED_DEFAULT) db_session.add(mod) if do_reload is True: self.reload() return self
def pleblist_history_stream(stream_id): with DBManager.create_session_scope() as session: stream = session.query(Stream).filter_by( id=stream_id).one_or_none() if stream is None: return render_template('pleblist_history_404.html'), 404 previous_stream = session.query(Stream).filter_by(id=stream_id - 1).one_or_none() next_stream = session.query(Stream).filter_by(id=stream_id + 1).one_or_none() q = session.query(PleblistSong, User).outerjoin( User, PleblistSong.user_id == User.id).filter( PleblistSong.stream_id == stream.id).order_by( PleblistSong.id.asc(), PleblistSong.id.asc()) songs = [] for song, user in q: song.user = user songs.append(song) total_length_left = sum([ song.skip_after or song.song_info.duration if song.date_played is None and song.song_info is not None else 0 for song in songs ]) first_unplayed_song = find(lambda song: song.date_played is None, songs) stream_chunks = session.query(StreamChunk).filter( StreamChunk.stream_id == stream.id).all() return render_template('pleblist_history.html', stream=stream, previous_stream=previous_stream, next_stream=next_stream, songs=songs, total_length_left=total_length_left, first_unplayed_song=first_unplayed_song, stream_chunks=stream_chunks)
def on_managers_loaded(self): if self.current_quest is None: redis = RedisManager.get() current_quest_id = redis.get(self.current_quest_key) log.info( 'Try to load submodule with ID {}'.format(current_quest_id)) if current_quest_id is not None: current_quest_id = current_quest_id quest = find(lambda m: m.ID == current_quest_id, self.submodules) if quest is not None: log.info('Resumed quest {}'.format(quest.get_objective())) self.current_quest = quest self.current_quest.start_quest() else: log.info( 'No quest with id {} found in submodules ({})'.format( current_quest_id, self.submodules))
def parse_settings(self, **in_settings): ret = {} for key, value in in_settings.items(): setting = find(lambda setting: setting.key == key, self.SETTINGS) if setting is None: # We were passed a setting that's not available for this module return False log.debug('{}: {}'.format(key, value)) res, new_value = setting.validate(value) if res is False: # Something went wrong when validating one of the settings log.warn(new_value) return False ret[key] = new_value for setting in self.SETTINGS: if setting.type == 'boolean': if setting.key not in ret: ret[setting.key] = False log.debug('{}: {} - special'.format(setting.key, False)) return ret
def check_message(self, message, user): match = find(lambda banphrase: banphrase.match(message, user), self.enabled_banphrases) return match or False
def get_module(self, module_id): return find(lambda m: m.ID == module_id, self.all_modules)