class ChatterModel(BaseModel): def __init__(self): self.bot = ChatBot('tgbot') self.text_last = {} def _get(self, message, c_last, payload, predict): # update the bot statement = Statement(payload) if message.chat.id in c_last: last = c_last[message.chat.id] self.bot.learn_response(statement, last) c_last[message.chat.id] = statement # choose the best reply if predict: response = self.bot.generate_response(statement) return [(response.confidence, response.text)] def text(self, message, predict): return self._get(message, self.text_last, message.text, predict)
def chatMessages(message): logging.debug("Message received = %s", message) message = message.strip() try: parts = message.split(":") firstPart = parts[0] firstPart = firstPart.strip() logging.debug("First part=%s", firstPart) bot = ChatBot( 'Feedback Learning Bot', storage_adapter='chatterbot.storage.SQLStorageAdapter', logic_adapters=[{ 'import_path': 'chatterbot.logic.BestMatch' }, { 'import_path': 'chatterbot.logic.LowConfidenceAdapter', 'threshold': 0.65, 'default_response': 'I am sorry, I am new to it.' }], input_adapter='chatterbot.input.VariableInputTypeAdapter', output_adapter='chatterbot.output.TerminalAdapter') logging.debug("Inside Bot processing") CONVERSATION_ID = bot.storage.create_conversation() input_statement = bot.input.process_input_statement(firstPart) statement, response = bot.generate_response(input_statement, CONVERSATION_ID) if firstPart.lower() == "tquestion": logging.debug("Saving answer") question = parts[1] logging.debug("question=%s", question) question_statement = bot.input.process_input_statement(question) try: AnsTag = parts[2] if AnsTag.lower() == "tanswer": AnsTag = AnsTag.strip() logging.debug("AnsTag=%s", AnsTag) Answer = parts[3] Answer = Answer.strip() if Answer: logging.debug("Answer=%s", Answer) answer_statement = bot.input.process_input_statement( Answer) bot.learn_response(answer_statement, question_statement) bot.storage.add_to_conversation( CONVERSATION_ID, question_statement, answer_statement) bot.output.process_response(answer_statement) emit("Bot_Reply", "Saved your answer.") else: emit("Bot_Reply", "Answer tag is incorrect") except: emit("Bot_Reply", "No Answer found for question") else: logging.debug("Response=%s", response.text) emit("Bot_Reply", response.text) except: logging.debug("something is not good") emit("Bot_Reply", "something is not good")
def main(): # Uncomment the following line to enable verbose logging logging.basicConfig(level=logging.INFO) # Create a new instance of a ChatBot bot = ChatBot( "Terminal", storage_adapter="chatterbot.storage.JsonFileStorageAdapter", logic_adapters=[{ 'import_path': 'chatterbot.logic.MathematicalEvaluation' }, { 'import_path': 'chatterbot.logic.TimeLogicAdapter' }, { 'import_path': 'chatterbot.logic.BestMatch' }, { 'import_path': 'chatterbot.logic.SpecificResponseAdapter', 'input_text': 'Help me!', 'output_text': 'Ok, here is a link: http://chatterbot.rtfd.org/en/latest/quickstart.html' }], trainer='chatterbot.trainers.ListTrainer', input_adapter="chatterbot.input.TerminalAdapter", output_adapter="chatterbot.output.TerminalAdapter", database="../database.json") DEFAULT_SESSION_ID = bot.default_session.id print('Type something to begin...') # The following loop will execute each time the user enters input while True: try: input_statement = bot.input.process_input_statement() statement, response = bot.generate_response( input_statement, DEFAULT_SESSION_ID) print('\n Is "{}" this a coherent response to "{}"? \n'.format( response, input_statement)) if get_feedback(): bot.learn_response(response, input_statement) bot.output.process_response(response) # Update the conversation history for the bot # It is important that this happens last, after the learning step bot.conversation_sessions.update(bot.default_session.id_string, ( statement, response, )) # Press ctrl-c or ctrl-d on the keyboard to exit except (KeyboardInterrupt, EOFError, SystemExit): break
def chatbot(): conn = rpyc.classic.connect( 'ev3dev.local') # host name or IP address of the EV3 ev3 = conn.modules['ev3dev.ev3'] # import ev3dev.ev3 remotely bot = ChatBot('Luigi', storage_adapter='chatterbot.storage.MongoDatabaseAdapter', logic_adapters=["chatterbot.logic.BestMatch"], input_adapter='chatterbot.input.TerminalAdapter', output_adapter='chatterbot.output.TerminalAdapter', trainer='chatterbot.trainers.ChatterBotCorpusTrainer', database='chatterbot-database') bot.train("chatterbot.corpus.english") CONVERSATION_ID = bot.storage.create_conversation() ev3.Sound.volume = 200 ev3.Sound.speak('Hello ! Say something to begin').wait m = ev3.MediumMotor('outA') m.run_to_rel_pos(position_sp=30, speed_sp=900, stop_action="hold") m.run_to_rel_pos(position_sp=-30, speed_sp=900, stop_action="hold") print('Hello ! Say something to begin') # The following loop will execute each time the user enters input while True: try: input_statement = bot.input.process_input_statement() statement, response = bot.generate_response( input_statement, CONVERSATION_ID) ev3.Sound.speak('%s' % bot.output.process_response(response)).wait() reaction_tete = 'no' if reaction_tete in bot.output.process_response(response): m.run_to_rel_pos(position_sp=45, speed_sp=900, stop_action="hold") m.run_to_rel_pos(position_sp=-45, speed_sp=900, stop_action="hold") #print('\n Is "{}" a coherent response to "{}"? \n'.format(response, input_statement)) # if get_feedback(): #print("please input the correct one") #response1 = bot.input.process_input_statement() #bot.learn_response(response1, input_statement) #bot.storage.add_to_conversation(CONVERSATION_ID, statement, response1) #print("Responses added to bot!") # Press ctrl-c or ctrl-d on the keyboard to exit except (KeyboardInterrupt, EOFError, SystemExit): break
def get_message(message): chatbot = ChatBot('Ron Obvious', read_only=True, logic_adapters=['chatterbot.logic.BestMatch', {'import_path': 'chatterbot.logic.BestMatch', 'threshold': 0.65, 'default_response': 'I am sorry, but I can only answer questions related to ACM.' } ], input_adapter='chatterbot.input.VariableInputTypeAdapter', output_adapter='chatterbot.output.OutputAdapter', filter='chatterbot.filters.RepetitiveResponseFilter') # Create a new trainer for the chatbot trainer = ChatterBotCorpusTrainer(chatbot) # Train the chatbot based on the english corpus trainer.train("chatterbot.corpus.english.greetings", "chatterbot.corpus.english.conversations", "chatterbot.corpus.english.emotion", "chatterbot.corpus.english.psychology") return chatbot.generate_response(message)
def process(self, input_statement, additional_response_selection_parameters): import time import sys import os while True: try: input_statement = Statement(text=input()) response = ChatBot.generate_response(input_statement) print('\n Is "{}" a coherent response to "{}"? \n'.format( response.text, input_statement.text)) if get_feedback() is False: print('please input the correct one') correct_response = Statement(text=input()) ChatBot.learn_response(correct_response, input_statement) print('Responses added to bot!') except (KeyboardInterrupt, EOFError, SystemExit): break
class AIChatBot: def __init__(self, bot_name, self_training, low_confidence_threshold, low_confidence_responses, random_response=True, premoderation_callback=None, db_file=None, db_uri=None): """Create new AIChatBot instance. Args: bot_name (str): Bot name. db_uri (str): Database URI. db_file (str): Database file (should not be used, left for backward compatibility) self_training (bool): Will bot train itself. low_confidence_threshold (float): Confidence threshold, if lower - low_confidence_responses will be used. low_confidence_responses (list): Responses that will be used if confidence is lower than threshold. random_response (bool): If true, choose random response instead of the most frequent. premoderation_callback (function): Premoderation function, set None to disable. """ # Backward compatibility if db_uri is None and db_file is not None: db_uri = 'sqlite:///{}'.format(db_file) warnings.warn( 'use db_uri instead of deprecated db_file, it will be removed in the future', DeprecationWarning) self.__chatbot = ChatBot( bot_name, logic_adapters=['chatterbot.logic.BestMatch'], response_selection_method=get_random_response if random_response else get_most_frequent_response, filters=['chatterbot.filters.RepetitiveResponseFilter'], database_uri=db_uri) self.__conversation_id = self.__chatbot.storage.create_conversation() self.previous_response = None self.__self_training = self_training self.__low_confidence_threshold = low_confidence_threshold self.__low_confidence_responses = low_confidence_responses self.__premoderation_callback = premoderation_callback def get_response(self, question, premoderation_payload=None): """Get response to the message. Args: question (str): Message. premoderation_payload: Data to pass to premoderation_callback. Returns: str: Response. """ # Get supposed response question = Statement(question) response = self.__chatbot.generate_response(question, self.__conversation_id)[1] """:type : Response""" # Choose random response if confidence is lower than threshold if response.confidence < self.__low_confidence_threshold and self.__low_confidence_responses: response = Statement(choice(self.__low_confidence_responses)) if self.__premoderation_callback: response = self.__premoderation_callback(question.text, response.text, premoderation_payload) if not response: return response = Statement(response) response.confidence = 1 self.__chatbot.learn_response(response, question) self.__chatbot.storage.add_to_conversation(self.__conversation_id, question, response) if self.__self_training and self.previous_response and '?' in self.previous_response.text and \ self.previous_response.confidence >= self.__low_confidence_threshold: self.__chatbot.learn_response(question, self.previous_response) self.__chatbot.storage.add_to_conversation(self.__conversation_id, self.previous_response, question) self.previous_response = response return response.text def learn(self, question, response): """Learn a response. Args: question (str): Question. response (str): Response """ question = Statement(question) response = Statement(response) self.__chatbot.learn_response(response, question) self.__chatbot.storage.add_to_conversation(self.__conversation_id, question, response) def statement_exists(self, statement_text): """Check if statement exists. Args: statement_text (str): Statement text. Returns: bool """ return True if self.__chatbot.storage.find(statement_text) else False def remove_statement(self, statement_text): """Remove statement from database. Args: statement_text (str): Statement text. """ self.__chatbot.storage.remove(statement_text)
"import_path": "chatterbot.logic.BestMatch", "statement_comparison_function": "chatterbot.comparisons.levenshtein_distance", "response_selection_method": "chatterbot.response_selection.get_most_frequent_response" }, { 'import_path': 'chatterbot.logic.LowConfidenceAdapter', 'threshold': 0.65, 'default_response': 'Disculpa, estoy aprendiendo a entenderte. ¿Puedes ser mas especifico?' }, { 'import_path': 'chatterbot.logic.SpecificResponseAdapter', 'input_text': 'Desarrollador', 'output_text': 'Ok, Facebook: https://www.facebook.com/pdts31' } ], preprocessors=[ 'chatterbot.preprocessors.clean_whitespace' ], #Autoentrenamiento read_only=False, ) #DEFAULT_SESSION_ID =chatbot.default_session.id chatbot.set_trainer(ChatterBotCorpusTrainer) chatbot.train("./train.yml") while True: input_statement = chatbot.input.process_input_statement() statement, response = chatbot.generate_response(input_statement, 1) print("\n%s\n\n"%response)
if 'yes' in text.lower(): return True elif 'no' in text.lower(): return False else: print('Please type either "Yes" or "No"') return get_feedback() print('Type something to begin...') # The following loop will execute each time the user enters input while True: try: input_statement = chatbot.input.process_input_statement() # conversation_id = chatbot.storage.create_conversation() statement, response = chatbot.generate_response(input_statement, conversation_id=None) print('Is "{}" an appropriate response to "{}"?'.format( response.text, input_statement)) if get_feedback(): chatbot.learn_response(response, input_statement) else: print('Say what??') better = chatbot.input.process_input_statement() chatbot.learn_response(better, input_statement) # Press ctrl-c or ctrl-d on the keyboard to exit except (KeyboardInterrupt, EOFError, SystemExit): break
if 'Yes' in text: return True elif 'No' in text: return False else: print('Please type either "Yes" or "No"') return get_feedback() print('Type something to begin...') # The following loop will execute each time the user enters input while True: try: input_statement = bot.input.process_input_statement() statement, response, confidence = bot.generate_response( input_statement) print('\n Is "{}" this a coherent response to "{}"? \n'.format( response, input_statement)) if get_feedback(): bot.learn_response(response) bot.output.process_response(response, confidence) # Update the conversation history for the bot # It is important that this happens last, after the learning step bot.recent_statements.append(( statement, response, ))
if 'Yes' in text: return True elif 'No' in text: return False else: print('Please type either "Yes" or "No"') return get_feedback() print('Type something to begin...') # The following loop will execute each time the user enters input while True: try: input_statement = bot.input.process_input_statement() statement, response, confidence = bot.generate_response(input_statement) print('\n Is "{}" this a coherent response to "{}"? \n'.format(response, input_statement)) if get_feedback(): bot.learn_response(response,input_statement) bot.output.process_response(response, confidence) # Update the conversation history for the bot # It is important that this happens last, after the learning step bot.conversation_sessions.update( bot.default_session.id_string, (statement, response, ) )
'Puedes reservarlo ahora en: https://www.royalcaribbean-espanol.com/' }, ], preprocessors=['chatterbot.preprocessors.clean_whitespace'], read_only=True, ) DEFAULT_SESSION_ID = chatbot.default_session from chatterbot.trainers import ChatterBotCorpusTrainer chatbot.set_trainer(ChatterBotCorpusTrainer) chatbot.train("./cruises_ES.yml") print( "---------------------------------------------------------------------------" ) print( "--------------------BIENVENIDO AL CHAT CON CARIBBEANBOT---------------------" ) print( "---------------------------------------------------------------------------" ) print("Has tu pregunta:") while True: input_statement = chatbot.input.process_input_statement() statement, response = chatbot.generate_response(input_statement, DEFAULT_SESSION_ID) print("\n%s\n\n" % response)
class Edgar: def __init__(self): if not ValidacaoHelper.rodando('mongo'): system('echo "x89FiaNB" | sudo -S systemctl start mongodb') self.__bot = ChatBot( name='Edgar', preprocessors=['chatterbot.preprocessors.clean_whitespace'], logic_adapters=[{ 'import_path': 'chatterbot.logic.BestMatch', }], storage_adapter='chatterbot.storage.MongoDatabaseAdapter', database_uri='mongodb://localhost:27017/chatterbot-database') self.__resposta = None self.idade = 0 self.treinado = False self.sentenca_usuario = '' @property def bot(self): return self.__bot @property def resposta(self): return self.__resposta @property def resposta_str(self): return f'{self.__resposta}' def responda(self): if self.__resposta: return f"{self.__resposta}." else: return "Não há afirmações a serem respondidas." def escute(self, sentenca): self.__resposta = self.__bot.generate_response(Statement(sentenca)) self.sentenca_usuario = sentenca def aprenda(self, resposta_valida, sentenca): self.__resposta = resposta_valida treinador_resposta_correta = ListTrainer(self.__bot) treinador_resposta_correta.train([sentenca, resposta_valida]) def cantar(self): iniciar_canto() mixer.music.load("./Sounds/music.mp3") mixer.music.play() mixer.music.set_volume(1) clock = time.Clock() clock.tick(10) while mixer.music.get_busy(): event.poll() clock.tick(10) @property def apresentacao(self): return f'\t\t {"*" * 15} Programa de testes com o robô Edgar {"*" * 15} ' \ '\nVocê terá uma conversa com o Edgar, para sair digite "Edgar, por hoje é só"'
return True elif 'no' in text.lower(): return False else: print('Please type either "Yes" or "No"') return get_feedback() print('Type something to begin...') # The following loop will execute each time the user enters input while True: try: input_statement = Statement(text=input()) response = bot.generate_response( input_statement ) print('\n Is "{}" a coherent response to "{}"? \n'.format( response.text, input_statement.text )) if get_feedback(): print('please input the correct one') correct_response = Statement(text=input()) bot.learn_response(correct_response, input_statement) print('Responses added to bot!') # Press ctrl-c or ctrl-d on the keyboard to exit except (KeyboardInterrupt, EOFError, SystemExit): break
class Wheatley: def __init__(self, bot): logging.basicConfig(level=logging.INFO) self.bot = bot self.ping_replace = re.compile(r"<@[0-9]{2,}>", re.IGNORECASE) with open('./config/wheatley.json') as data_file: self.wheatley_config = json.load(data_file) self.chatbot = ChatBot( 'akhrot', logic_adapters=["chatterbot.logic.BestMatch"], trainer='chatterbot.trainers.ChatterBotCorpusTrainer', storage_adapter='chatterbot.storage.MongoDatabaseAdapter', database=self.wheatley_config['database'], database_uri=self.wheatley_config['database_uri']) self.admin_roles = self.wheatley_config['admin-roles'] def write_to_yaml(self, messages): file_handle = open(self.wheatley_config['corpus-folder'] + str(time.time()) + '.yml', 'w+', encoding='utf-8') file_handle.write('categories:\n- discord-chat\nconversations:\n') alt = True for message in messages: msg = self.ping_replace.sub('', message.content).replace( '"', "'").replace('\\', '\\\\') if alt: file_handle.write('- - "' + msg + '"\n') else: file_handle.write(' - "' + msg + '"\n') alt = not alt file_handle.close() async def download_messages(self, channel, limit, is_all, current_count, last_msg, msg_handle): before = None dwnld_limit = 100 if last_msg is not None: before = last_msg if (not is_all and current_count >= limit): await self.bot.edit_message(msg_handle, 'Finished downloading messages.') return current_count batch_size = 0 msg_set = [] async for message in self.bot.logs_from(channel, limit=dwnld_limit, before=before): batch_size += 1 last_msg = message msg_set.append(message) self.write_to_yaml(msg_set) await self.bot.edit_message( msg_handle, 'Downloaded ' + str(current_count) + ' messages.') current_count += batch_size if batch_size < 100: await self.bot.edit_message(msg_handle, 'Finished downloading messages.') return current_count else: return current_count + await self.download_messages( channel, limit, is_all, current_count, last_msg, msg_handle) @commands.command(pass_context=True, no_pm=True) async def dwnld(self, ctx, limit: str, channel: discord.Channel): if (len( set([role.name.lower() for role in ctx.message.author.roles ]).intersection(set(self.admin_roles))) == 0): await self.bot.send_message(ctx.message.channel, 'Unauthorized to issue this command.') return logging.info('issued download with: ' + limit + ', in :' + channel.name + '.') resp = await self.bot.send_message(ctx.message.channel, 'Downloading messages.') is_all = False if (limit == 'all'): is_all = True limit = None else: limit = int(limit) await self.download_messages(channel, limit, is_all, 0, None, resp) @commands.command(pass_context=True, no_pm=True) async def train(self, ctx): if (len( set([role.name.lower() for role in ctx.message.author.roles ]).intersection(set(self.admin_roles))) == 0): await self.bot.send_message(ctx.message.channel, 'Unauthorized to issue this command.') return logging.info('issued train command.') msg_handle = await self.bot.say('Issued the train command.') self.chatbot.train(self.wheatley_config['corpus-folder']) await self.bot.edit_message(msg_handle, 'Finished training.') async def talk(self, message): logging.info('MSG: ' + message.content + ' in ' + message.channel.name) luck = random() if ('hey wheatley' in message.content.lower()): if (luck < 0.33): await self.bot.send_message(message.channel, 'yes bby') elif (luck >= 0.33 and luck < 0.66): await self.bot.send_message(message.channel, 'idk man') else: await self.bot.send_message(message.channel, 'f**k no my dewd') elif ('magnet' in message.content.lower()): await self.bot.send_message( message.channel, ''.join(choice(ascii_letters) for x in range(15))) else: if (luck > 0.33): logging.info('trigerred') start_time = time.time() try: await self.bot.send_typing(message.channel) except: pass #f**k it if (message.channel.name != 'general'): _, response = self.chatbot.generate_response( self.chatbot.input.process_input_statement( message.content), self.chatbot.default_session.uuid) else: response = self.chatbot.get_response(message.content) end_time = time.time() logging.info('Time taken for response:' + str(end_time - start_time)) await self.bot.send_message(message.channel, response.text)
class Wheatley: def __init__(self, bot): logging.basicConfig(level=logging.INFO) self.bot = bot self.ping_replace = re.compile(r"<@!{0,1}@&{0,1}[0-9]{2,}>", re.IGNORECASE) with open('./config/wheatley.json') as data_file: self.wheatley_config = json.load(data_file) logging.info('CSTRING:' + self.wheatley_config[self.wheatley_config['database_type'] + '_database_uri']) if (self.wheatley_config['database_type'] == "mongo"): self.chatbot = ChatBot( 'wheatley', logic_adapters=["chatterbot.logic.BestMatch"], trainer='chatterbot.trainers.ChatterBotCorpusTrainer', storage_adapter='chatterbot.storage.MongoDatabaseAdapter', database=self.wheatley_config['database'], database_uri=self.wheatley_config[ self.wheatley_config['database_type'] + '_database_uri']) elif (self.wheatley_config['database_type'] == "mysql"): self.chatbot = ChatBot( 'wheatley', logic_adapters=["chatterbot.logic.BestMatch"], trainer='chatterbot.trainers.ChatterBotCorpusTrainer', storage_adapter='chatterbot.storage.SQLStorageAdapter', database_uri=self.wheatley_config[ self.wheatley_config['database_type'] + '_database_uri']) self.admin_roles = self.wheatley_config['admin-roles'] def write_to_yaml(self, messages): file_handle = open(self.wheatley_config['corpus-folder'] + str(time.time()) + '.yml', 'w+', encoding='utf-8') corpus_dict = {'categories': ['discord-chat'], 'conversations': []} for stim, resp in zip(messages[0::2], messages[1::2]): stim = self.ping_replace.sub('', stim.content).replace('\\', '\\\\') resp = self.ping_replace.sub('', resp.content).replace('\\', '\\\\') if (self.wheatley_config['max_dialog_length'] is not -1): stim = stim[:self.wheatley_config['max_dialog_length']] resp = resp[:self.wheatley_config['max_dialog_length']] corpus_dict['conversations'].append([stim, resp]) file_handle.write(yaml.dump(corpus_dict, default_flow_style=False)) file_handle.close() async def download_messages(self, channel, limit, is_all, current_count, last_msg, msg_handle): before = None dwnld_limit = 100 if last_msg is not None: before = last_msg if (not is_all and current_count >= limit): await self.bot.edit_message(msg_handle, 'Finished downloading messages.') return current_count batch_size = 0 msg_set = [] async for message in self.bot.logs_from(channel, limit=dwnld_limit, before=before): batch_size += 1 last_msg = message msg_set.append(message) self.write_to_yaml(msg_set) if (current_count % 1000 == 0): await self.bot.edit_message( msg_handle, 'Downloaded ' + str(current_count) + ' messages.') current_count += batch_size if batch_size < 100: await self.bot.edit_message(msg_handle, 'Finished downloading messages.') return current_count else: return current_count + await self.download_messages( channel, limit, is_all, current_count, last_msg, msg_handle) @commands.command(pass_context=True, no_pm=True) async def dwnld(self, ctx, limit: str, channel: discord.Channel): if (len( set([role.name.lower() for role in ctx.message.author.roles ]).intersection(set(self.admin_roles))) == 0): await self.bot.send_message(ctx.message.channel, 'Unauthorized to issue this command.') return logging.info('issued download with: ' + limit + ', in :' + channel.name + '.') resp = await self.bot.send_message(ctx.message.channel, 'Downloading messages.') is_all = False if (limit == 'all'): is_all = True limit = None else: limit = int(limit) await self.download_messages(channel, limit, is_all, 0, None, resp) @commands.command(pass_context=True, no_pm=True) async def train(self, ctx): if (len( set([role.name.lower() for role in ctx.message.author.roles ]).intersection(set(self.admin_roles))) == 0): await self.bot.send_message(ctx.message.channel, 'Unauthorized to issue this command.') return logging.info('issued train command.') msg_handle = await self.bot.say('Issued the train command.') self.chatbot.train(self.wheatley_config['corpus-folder']) await self.bot.edit_message(msg_handle, 'Finished training.') async def talk(self, message): logging.info('MSG: ' + message.content) luck = random() if ('hey wheatley' in message.content.lower()): if (luck < 0.33): await self.bot.send_message(message.channel, 'yes bby') elif (luck >= 0.33 and luck < 0.66): await self.bot.send_message(message.channel, 'idk man') else: await self.bot.send_message(message.channel, 'f**k no my dewd') elif ('magnet' in message.content.lower()): await self.bot.send_message( message.channel, ''.join(choice(ascii_letters) for x in range(15))) else: if (luck > 0.33): logging.info('trigerred') start_time = time.time() conv_id = self.chatbot.default_conversation_id if not conv_id: conv_id = self.chatbot.storage.create_conversation() if (message.channel.is_private and message.author.id == '<your_id>'): logging.info('IN DMS') elif (not message.channel.is_private): logging.info('IN CHANNEL:' + message.channel.name) else: logging.info('UNAUTHORIZED DMS FROM:' + message.author.name + ' #' + message.author.id) return try: await self.bot.send_typing(message.channel) except: pass #f**k it if (message.channel.name != 'general'): _, response = self.chatbot.generate_response( self.chatbot.input.process_input_statement( message.content), conv_id) else: response = self.chatbot.get_response(message.content) end_time = time.time() logging.info('Time taken for response:' + str(end_time - start_time)) clean_msg = self.ping_replace.sub('', response.text) try: await self.bot.send_message(message.channel, clean_msg) except discord.errors.Forbidden as ex: logging.info(str(ex))
if 'yes' in text.lower(): return False elif 'no' in text.lower(): return True else: print('Please type either "Yes" or "No"') return get_feedback() print("Type something to begin...") # The following loop will execute each time the user enters input while True: try: input_statement = bot.input.process_input_statement() statement, response = bot.generate_response(input_statement, CONVERSATION_ID) bot.output.process_response(response) print('\n Is "{}" a coherent response to "{}"? \n'.format(response, input_statement)) if get_feedback(): print("please input the correct one") response1 = bot.input.process_input_statement() bot.learn_response(response1, input_statement) bot.storage.add_to_conversation(CONVERSATION_ID, statement, response1) print("Responses added to bot!") # Press ctrl-c or ctrl-d on the keyboard to exit except (KeyboardInterrupt, EOFError, SystemExit): break
if 'Yes' in text: return True elif 'No' in text: return False else: print('Please type either "Yes" or "No"') return get_feedback() print('Type something to begin...') # The following loop will execute each time the user enters input while True: try: input_statement = bot.input.process_input_statement() statement, response = bot.generate_response(input_statement, DEFAULT_SESSION_ID) print('\n Is "{}" this a coherent response to "{}"? \n'.format(response, input_statement)) if get_feedback(): bot.learn_response(response,input_statement) bot.output.process_response(response) # Update the conversation history for the bot # It is important that this happens last, after the learning step bot.conversation_sessions.update( bot.default_session.id_string, (statement, response, ) )
class NLG_unit(object): """ This object contains tools to answer in natural language any message non-Fib related Attributes: chatterbot_bot(:class:`chatterbot.ChatBot`): chatterbot bot to process the non-fib-Related questions train_queue(:obj:`dict`): dictionary that act as a queue of training concepts conversation_id(:obj:`int` or None): Identifier that keeps track of the diferent amounts of conversations learnt """ def __init__(self): self.chatterbot_bot = ChatBot( "Fibot", storage_adapter="chatterbot.storage.SQLStorageAdapter", ) self.train_queue = {} self.conversation_id = None """ This function load the learnt model for chatterbot """ def load(self): self.conversation_id = self.chatterbot_bot.storage.create_conversation() """ Parameters: chat_id (:obj:`str`): chat_id of the person to get feedback from correct (:obj:`bool`): tells whether the prediction was correct_statement correct_statement (:obj:`str` or None): Correction if there is This function enables the chatterbot bot to learn if he predicted good and allows him to learn new responses. """ def give_feedback(self, chat_id, correct = True, correct_statement = None): if not correct: message = self.train_queue[chat_id]['message'] correct_statement = Statement(correct_statement) self.chatterbot_bot.learn_response(correct_statement, message) self.chatterbot_bot.storage.add_to_conversation(self.conversation_id, message, correct_statement) self.send_message(chat_id, "Aprendido!. Mándame más si quieres, o desactívame usando /train_off") else: self.send_message(chat_id, "Bien. Mándame más si quieres, o desactívame usando /train_off") """ Parameters: chat_id (:obj:`str`): chat_id of the person to process the answer for message (:obj:`str`): message the user introduced to be processed This function makes the bot predict the following message, and asks for checks. """ def process_answer_training(self, chat_id, message): print("Query de %s con mensaje %s"%(chat_id, message)) self.send_chat_action(chat_id) input_statement = Statement(message) statement, response = self.chatterbot_bot.generate_response(input_statement, self.conversation_id) self.send_message(chat_id,'Es "{}" una respuesta coherente a "{}"? (Sí/No)'.format(response, message)) self.train_queue[chat_id] = { 'message': input_statement, 'response': response } """ Parameters: message (:obj:`str`): message the user introduced to be processed debug (:obj:`bool`): indicates the level of verbosity This function returns the predicted responses for message """ def get_response(self, message, debug = False): input_statement = Statement(message) _, response = self.chatterbot_bot.generate_response(input_statement, self.conversation_id) if debug: return "%s, confidence = %d"%(response['text'], response['confidence']) else: return str(response) """ Parameters: chat_id (:obj:`str`): chat_id of the person to process the answer for message (:obj:`str`): content of the messages This function allows nlg class to send messages for the training duties """ def send_message(self, chat_id, message): params = { 'chat_id': chat_id, 'text': message } bot_token = os.getenv('FibotTOKEN') base_url = 'https://api.telegram.org/bot%s/sendMessage'%bot_token response = requests.get(base_url, params = params) """ Parameters: chat_id (:obj:`str`): chat_id of the person to process the answer for action (:obj:`str`): action to send of the messages This function allows nlg class to send chat_action for the training duties """ def send_chat_action(self, chat_id, action = ChatAction.TYPING): params = { 'chat_id': chat_id, 'action': action } bot_token = os.getenv('FibotTOKEN') base_url = 'https://api.telegram.org/bot%s/sendChatAction'%bot_token response = requests.get(base_url, params = params)
], preprocessors=['chatterbot.preprocessors.clean_whitespace'], ) trainer = ChatterBotCorpusTrainer(chatbot) trainer.train('./soporte.yml') levenshtein_distance = LevenshteinDistance() #synset_distance = SynsetDistance() #sentiment_comparison = SentimentComparison() #jaccard_similarity = JaccardSimilarity() disparate = Statement( 'Te has equivocado') #convertimos una frase en un tipo statement entradaDelUsuario = "" #variable que contendrá lo que haya escrito el usuario while entradaDelUsuario != "adios": entradaDelUsuario = Statement(text=input()) #leemos la entrada del usuario respuesta = chatbot.generate_response(entradaDelUsuario) try: fecha = datetime_parsing(entradaDelUsuario.text) fecha = fecha[0] print(fecha[0]) except: pass if levenshtein_distance.compare(entradaDelUsuario, disparate) > 0.51: print('¿Qué debería haber dicho?') entradaDelUsuarioCorreccion = Statement(input()) chatbot.learn_response(entradaDelUsuarioCorreccion, entradaDelUsuario) print("He aprendiendo que cuando digas {} debo responder {}".format( entradaDelUsuario.text, entradaDelUsuarioCorreccion.text)) print(respuesta)
class Chatterbot: def __init__(self, bot): self.bot = bot self.settings = dataIO.load_json('data/chatterbot/settings.json') self.chatterbot = ChatBot('Athena', database='LanLogFour', storage_adapter='chatterbot.storage.' 'MongoDatabaseAdapter', input_adapter='chatterbot.input.' 'VariableInputTypeAdapter', output_adapter='chatterbot.output.' 'OutputAdapter', output_format='text', logic_adapters=[ {'import_path': 'chatterbot.logic.' 'BestMatch', 'statement_comparison_function': 'chatterbot.comparisons.' 'levenshtein_distance', 'response_selection_method': 'chatterbot.response_selection.' 'get_most_frequent_response'}, 'chatterbot.logic.MathematicalEvaluation' ] ) self.conversations = {} self.previous_statement = {} @commands.command(pass_context=True) async def chat(self, ctx): """Reads messages from chat""" message = ctx.message.content[6:] conversation_id = self._get_conversation(ctx.message.channel.id) response = await self._get_response(message, conversation_id) await self.bot.say(response) @commands.command() @checks.serverowner_or_permissions(manage_server=True) async def chattertraindocs(self): """Runs training on the docs""" self.chatterbot.set_trainer(ListTrainer) with open('data/chatterbot/doc1.txt') as f: doc1 = f.readlines() with open('data/chatterbot/doc2.txt') as f: doc2 = f.readlines() docData = doc1 + doc2 docData = [x.strip(',') for x in docData] docData = [x.strip('\'') for x in docData] docData = [x.strip('\n') for x in docData] self.chatterbot.train(docData) await self.bot.say("Training complete.") @commands.command() @checks.serverowner_or_permissions(manage_server=True) async def chattertrain(self): self.chatterbot.set_trainer(ChatterBotCorpusTrainer) self.chatterbot.train("chatterbot.corpus.english") await self.bot.say("Training complete") @commands.command(no_pm=True, pass_context=True) @checks.serverowner_or_permissions(manage_server=True) async def chatchannel(self, context, channel: discord.Channel = None): """ Set the channel to which the bot will sent its continues updates. Example: [p]chatchannel #talk """ if channel: self.settings['CHANNEL_ID'] = str(channel.id) dataIO.save_json('data/chatterbot/settings.json', self.settings) message = 'Channel set to {}'.format(channel.mention) elif not self.settings['CHANNEL_ID']: message = 'No Channel set' else: channel = discord.utils.get( self.bot.get_all_channels(), id=self.settings['CHANNEL_ID']) if channel: message = 'Current channel is {}'.format(channel.mention) else: self.settings['CHANNEL_ID'] = None message = 'No channel set' await self.bot.say(message) @commands.command(pass_context=True) @checks.serverowner_or_permissions(manage_server=True) async def chatterignore(self, context, channel: discord.Channel = None): if channel: self.settings['BLOCKED_CHANNELS'].append(channel.id) # TODO: Check if already in list dataIO.save_json('data/chatterbot/settings.json', self.settings) message = '{} added to blocked channels.'.format(channel.mention) elif not self.settings['BLOCKED_CHANNELS']: message = 'No channels blocked' # else: # channel = discord.utils.get( # self.bot.get_all_channels(), # id=self.settings['BLOCKED_CHANNELS']) # if channel: # message = 'Current channel is {}'.format(channel.mention) # else: # self.settings['CHANNEL_ID'] = None # message = 'No channel set' await self.bot.say(message) async def listener(self, message): if message.author.id == self.bot.user.id: pass elif message.content == '': pass elif message.content[0] == '!': # Kludge pass elif message.mention_everyone is True: pass elif message.mentions != []: pass elif message.role_mentions != []: pass elif message.channel.id == self.settings['CHANNEL_ID']: conversation_id = self._get_conversation(message.channel.id) response = await self._get_response(message.content, conversation_id) await self.bot.send_message(message.channel, response) elif message.channel.id not in self.settings['BLOCKED_CHANNELS']: conversation_id = self._get_conversation(message.channel.id) input_statement = self.chatterbot.input.process_input_statement( message.content) if conversation_id in self.previous_statement: self.chatterbot.learn_response( input_statement, self.previous_statement[conversation_id]) self.previous_statement[conversation_id] = input_statement else: self.previous_statement[conversation_id] = input_statement else: pass async def _get_response(self, input_item, conversation_id): input_statement = self.chatterbot.input.process_input_statement( input_item) # Preprocess the input statement for preprocessor in self.chatterbot.preprocessors: input_statement = preprocessor(self.chatterbot, input_statement) statement, response = self.chatterbot.generate_response( input_statement, conversation_id) # Learn that the user's input was a valid response to the chat bot's # previous output if not self.chatterbot.read_only: if conversation_id in self.previous_statement: prev = self.previous_statement[conversation_id] else: prev = None self.chatterbot.learn_response(statement, prev) self.chatterbot.storage.add_to_conversation(conversation_id, statement, response) self.previous_statement[conversation_id] = response # Process the response output with the output adapter return str(response) def _get_conversation(self, channel_id): try: conversation_id = self.conversations[channel_id] except KeyError: conversation_id = self.chatterbot.storage.create_conversation() self.conversations[channel_id] = conversation_id return conversation_id
table = str.maketrans('', '', string.punctuation) stripped = [w.translate(table) for w in words] for w in stripped: if w == "": stripped.remove(w) elif w == " ": stripped.remove(w) filtered_sen_pun = ' '.join(stripped) print('Punc :', filtered_sen_pun) # Lowering the case #filtered_sent=filtered_sen_pun.lower() input_statement = Statement(filtered_sen_pun) print('-' * 100) print('input_statement ==>', input_statement) response = bot.generate_response(input_statement) print('=' * 100) print("Chatbot :", response.text) print('\n Is "{}" a coherent response to "{}"? \n'.format( response.text, input_statement.text)) if get_feedback(): print('please input the correct one') correct_response = Statement(text=input()) bot.learn_response(correct_response, input_statement) print('Responses added to bot!') # Press ctrl-c or ctrl-d on the keyboard to exit except (KeyboardInterrupt, EOFError, SystemExit): break
class ChatClient(discord.Client): def __init__(self, *args, **kwargs): super(ChatClient, self).__init__(*args, **kwargs) self.bot = ChatBot( 'Fred', storage_adapter='chatterbot.storage.SQLStorageAdapter', database='./db.sqlite3') self.commands = {'ping': self.ping, 'train': self.train} @asyncio.coroutine def ping(self, message): yield from self.send_message(message.channel, content="pong") @asyncio.coroutine def train(self, message): if message.channel.is_private: yield from self.send_message( message.channel, content= ":stuck_out_tongue: Sorry you have to teach me on a server where I can check your role." ) return if not "Bot Trainer" in [role.name for role in message.author.roles]: yield from self.send_message( message.channel, content= ":unamused: Only user with the 'Bot Trainer' role can train me." ) return if not "(:)" in message.content: yield from self.send_message( message.channel, content= ":confused: You have no reply for me to learn. Use (:) to seperate message." ) return train_times = 1 if "(super_train)" in message.clean_content: train_times = 100 yield from self.send_message( message.channel, content=f":clock: super_train underway please be patient") learn_message, learn_reply = message.clean_content.replace( "!" + get_command(message.content), "").replace("(super_train)", "").split("(:)") self.learn(learn_message, learn_reply, train_times=train_times) yield from self.send_message( message.channel, content= f"learnt: \n message = {learn_message} \n reply = {learn_reply}") def corpus_train(): self.bot.set_trainer(ChatterBotCorpusTrainer) self.bot.train("chatterbot.corpus.english", ) def learn(self, message, reply, train_times=1): logging.info("--- Learning ---") message = remove_mentions(message) reply = remove_mentions(reply) self.bot.set_trainer(ListTrainer) self.bot.train([ message, reply, ] * train_times) logging.info("learning message: " + message) logging.info("learning reply: " + reply) @asyncio.coroutine def on_ready(self): logging.info('Connected!') logging.info('Username: '******'ID: ' + self.user.id) @asyncio.coroutine def send_reply(self, message): logging.info("--- Sending Reply ---") message_without_mentions = remove_mentions(message.clean_content) reply = str( self.bot.generate_response(Statement(message_without_mentions), None)[1]) yield from self.send_message(message.channel, content=reply) logging.info("message: " + message_without_mentions) logging.info("reply: " + reply) @asyncio.coroutine def on_message(self, message): if message.author == self.user: return if message.content.startswith("!"): command = get_command(message.clean_content) try: yield from self.commands[command](message) except KeyError: yield from self.send_message( message.channel, content=(command + ":stuck_out_tongue: is not a registered command")) return if self.user in message.mentions or message.channel.is_private: yield from self.send_reply(message) else: if message.clean_content.endswith("?") or len( message.mentions) > 0: reply = yield from self.wait_for_message() if reply.author in [self.user, message.author]: logging.info("forgetting conversation") return self.learn(message.clean_content, reply.clean_content)