class Markov: def __init__(self, brain_id): self.brain_id = brain_id brain_path = f'data/cobe/{brain_id}' os.makedirs('data/cobe/', exist_ok=True) self.brain = Brain(brain_path) def filter(self, message): message = re.sub('\<@[A-Z0-9a-z]{9}\>', '', message) # remove mentions message = re.sub('\s{2,}', ' ', message) #remove double spaces message = re.sub('\<[^\<]+\>', '', message) #remove shit like links message = message.strip() # remove unneeded spaces valid = False if len(message) > 5: valid = True return [valid, message] def learn(self, message): valid, message = self.filter(message) if not valid: return self.brain.learn(message) def speak(self, message): response = self.brain.reply(message) valid, response = self.filter(response) if not valid: return None return response
def bot_say(seed='', think_time=THINK_TIME): """ Generate response from cobe, seeding with the message. The we do some processing on the out, like removing nicks (both active and known), or replacing nick mentions with OP or preset list. 1. remove nicks (both active and known), replace with either OP or something from a preset list TODO 2. remove odd number quotes (the first) 3. TODO """ response = Brain('brain.ai').reply( seed.replace(NICK, ''), loop_ms=think_time, ) balance_chars = ['"', '\''] remove_chars = ['[', ']', '{', '}', '(', ')'] for char in remove_chars: response = response.replace(char, '') for char in balance_chars: if response.count(char) % 2: response = response.replace(char, '', 1) return response
def create_tweet(catalyst=''): b = Brain(os.path.join(os.path.dirname(__file__), 'cobe.brain')) # get a reply from brain, encode as UTF-8 i = 0 while True: tweet = b.reply(catalyst).encode('utf-8', 'replace') if(config.filter_url): tweet = remove_url(tweet) if(config.filter_hashtag): tweet = remove_hashtag(tweet) if(config.filter_handle): tweet = remove_handle(tweet) tweet = smart_truncate(tweet) #make sure we're not tweeting something close to something else in the txt files #or we can just give up after 100 tries if check_tweet(tweet) or i >= 100: break i += 1 #put the tweet in the db db_manager.insert_tweet(tweet) return tweet
def create_tweet(catalyst='', save_to_history=True): b = Brain(os.path.join(os.path.dirname(__file__), 'cobe.brain')) # get a reply from brain, encode as UTF-8 i = 0 while True: tweet = b.reply(catalyst).replace(">", ">").replace("<", "<").replace("&", "&").replace("\"", "").replace("“", "").replace("”", "") if config.filter_url: tweet = remove_url(tweet) if config.filter_hashtag: tweet = remove_hashtag(tweet) if(config.filter_handle): tweet = remove_handle(tweet) tweet = smart_truncate(tweet) #make sure we're not tweeting something close to something else in the txt files #or we can just give up after 300 tries if check_tweet(tweet): # tweet matches criteria if save_to_history==True: db_manager.insert_tweet(tweet) print "[debug] Saved tweet to twert history database" return tweet elif i >= 300: print "[debug] Failure to create unique tweet. >300 tries" return unicode('') i += 1
def _reply(self, irc, msg, channel, text): """Send a response to text""" cobeBrain = Brain(self._getBrainDirectoryForChannel(channel)) response = cobeBrain.reply(text).encode('utf-8') response = self._strip_nick(irc, msg, response) for i in range(response.lower().count(self.magicnick.lower())): # If first word is nick, switch with the callers nick. if self.magicnick in response: response = response.replace(self.magicnick, random.choice(list(irc.state.channels[msg.args[0]].users))) if self.magicnick.lower() in response: response = response.replace(self.magicnick.lower(), random.choice(list(irc.state.channels[msg.args[0]].users))) cobeBrain.learn(response) # Let's have the bot learn the wacky things it says self.log.info("Attempting to respond in {0} with message: {1}".format(channel, response)) # delay the response here so we look real? if self.registryValue('responseDelay', channel): self.log.info("Delayed the response in %s." % channel) delayseconds = time.time() + random.randint(2, 5) schedule.addEvent(irc.queueMsg(ircmsgs.privmsg(channel, response)), delayseconds) else: irc.queueMsg(ircmsgs.privmsg(channel, response))
def __init__(self, config=CONFIG): self.ready = False self.psapi = pushshift_api self.rapi = reddit_api self.config = CONFIG self.brain = Brain(self.config.get("cobe_main_db")) self.size = 0
def learn_text(text, brain_name): brain = Brain(brain_name) if not os.path.isfile(brain_name): print("- Training...") for sent in text: brain.learn(sent) return brain
def _reply(self, irc, msg, channel, text): """Send a response to text""" cobeBrain = Brain(self._getBrainDirectoryForChannel(channel)) response = cobeBrain.reply(text).encode('utf-8') response = self._strip_nick(irc, msg, response) for i in range(response.lower().count(self.magicnick.lower())): # If first word is nick, switch with the callers nick. if self.magicnick in response: response = response.replace( self.magicnick, random.choice(list(irc.state.channels[msg.args[0]].users))) if self.magicnick.lower() in response: response = response.replace( self.magicnick.lower(), random.choice(list(irc.state.channels[msg.args[0]].users))) cobeBrain.learn( response) # Let's have the bot learn the wacky things it says self.log.info("Attempting to respond in {0} with message: {1}".format( channel, response)) # delay the response here so we look real? if self.registryValue('responseDelay', channel): self.log.info("Delayed the response in %s." % channel) delayseconds = time.time() + random.randint(2, 5) schedule.addEvent(irc.queueMsg(ircmsgs.privmsg(channel, response)), delayseconds) else: irc.queueMsg(ircmsgs.privmsg(channel, response))
def handle(msg): print msg content_type, chat_type, chat_id = telepot.glance(msg) if content_type == 'text': brain = Brain(config.get('Brain', 'path') + str(chat_id) + ".brain") brain.learn(msg['text']) if 'braulio' in msg['text'].lower(): bot.sendMessage(chat_id, brain.reply(msg['text']))
def handle(msg): print msg content_type, chat_type, chat_id = telepot.glance(msg) if content_type == 'text': brain = Brain(config.get('Brain', 'path') + str(chat_id) + ".brain") brain.learn(msg['text']) if 'braulio' in msg['text'].lower(): bot.sendMessage(chat_id,brain.reply(msg['text']))
def corpusreply(self, irc, msg, args, text): """<text> Manually have the brain reply to <text> """ b = Brain(self._brainfile) response = b.reply(text).encode('utf-8') irc.reply(response)
def main(): b = Brain("brains/bible.brain") #with open("learning/bible.txt", "r") as bibleFile: # bible = bibleFile.readlines() #for line in bible: # b.learn(line) print b.reply("Hello cobe")
def invalidCommand(self, irc, msg, tokens): channel = msg.args[0] text = msg.args[1] text = self._cleanText(text) #cobeBrain = Brain(self.brainDirectories[channel]) cobeBrain = Brain(self._getBrainDirectoryForChannel(channel)) response = cobeBrain.reply(text).encode('utf-8') response = self._strip_nick(irc, msg, response) irc.reply(response, prefixNick=False)
def testInit(self): Brain.init(TEST_BRAIN_FILE) self.failUnless(os.path.exists(TEST_BRAIN_FILE), "missing brain file after init") brain = Brain(TEST_BRAIN_FILE) self.failUnless(brain.order, "missing brain order after init") self.failUnless(brain._end_token_id, "missing brain _end_token_id after init")
def handle(msg): content_type, chat_type, chat_id = telepot.glance(msg) if content_type == 'text': brain = Brain(config.get('Brain', 'path') + str(chat_id) + ".brain") brain.learn(msg['text']) if 'reply_to_message' in msg and msg['reply_to_message']['from']['username'] == "Braulio_bot": bot.sendMessage(chat_id,brain.reply(msg['text']),reply_to_message_id=msg['message_id']) elif 'braulio' in msg['text'].lower(): bot.sendMessage(chat_id,brain.reply(msg['text']).replace("Braulio",msg['from']['first_name']))
def testInit(self): Brain.init(TEST_BRAIN_FILE) self.assertTrue(os.path.exists(TEST_BRAIN_FILE), "missing brain file after init") brain = Brain(TEST_BRAIN_FILE) self.assertTrue(brain.order, "missing brain order after init") self.assertTrue(brain._end_token_id, "missing brain _end_token_id after init")
def create_tweet(catalyst=''): b = Brain(os.path.join(os.path.dirname(__file__), 'cobe.brain')) # get a reply from brain, encode as UTF-8 i = 0 while True: tweet = b.reply(catalyst).encode('utf-8', 'replace') if(config['filter_urls']): tweet = remove_url(tweet) tweet = smart_truncate(tweet) # check if last words of tweet are less than 4 and remove them last_words_twert = tweet.split(' ') while len(last_words_twert[-1]) < 4: print "[debug] Removing last word:"+last_words_twert[-1] del(last_words_twert[-1]) tweet = ' '.join(last_words_twert) #make sure we're not tweeting something close to something else in the txt files #or we can just give up after 100 tries if check_tweet(tweet) or i >= 100: break i += 1 tweet = HTMLParser().unescape(tweet) tweet = tweet.upper() # clean up miscellaneous characters INCLUDING NUMBERS? for ch in ['(',')','1','2','3','4','5','6','7','8','9','0','.',', ,','-,','-;','-.',',,',' ;' ]: if ch in tweet: tweet=tweet.replace(ch,"") if ' TH ' in tweet: tweet = tweet.replace(' TH ',' ') if ' ND ' in tweet: tweet = tweet.replace(' ND ',' ') if ' RD ' in tweet: tweet = tweet.replace(' RD ',' ') if 'THE OF' in tweet: tweet = tweet.replace('THE OF ',' ') if " " in tweet: tweet = tweet.replace(" "," ") if " - " in tweet: tweet = tweet.replace(" - "," ") if " , " in tweet: tweet = tweet.replace(" , ",", ") tweet = tweet.rstrip(" ,;=-") tweet = tweet.lstrip(" ,;=-?{}[]/_=+") #put the tweet in the db db_manager.insert_tweet(tweet) return tweet
class BrainTest(unittest.TestCase): def setUp(self): self.brain = Brain(":memory:") def test_train(self): # It's hard to test training from here; make sure the model # gets expected probabilities. model = self.brain.model self.brain.train(u"this is a test") self.assertAlmostEqual(1.0, model.prob(u"a", u"this is".split())) self.brain.train(u"this is another test") self.assertAlmostEqual(0.5, model.prob(u"a", u"this is".split())) def test_train_many(self): self.brain.train_many([u"this is a test"]) model = self.brain.model self.assertAlmostEqual(1.0, model.prob(u"a", u"this is".split())) def test_reply(self): training = [u"this is a test", u"this is another test"] for train in training: self.brain.train(train) self.assert_(self.brain.reply(u"testing") in set(training))
def _learn_corpus(self, corpus_file, brain_name, questions=False): if not os.path.isfile(brain_name): brain = Brain(brain_name) print("- Training...") corpus = read_file(corpus_file) corpus = clean_text(corpus, get_questions=questions) for sent in corpus: brain.learn(sent) return Brain(brain_name)
def _reply(self, irc, channel, text): self.log.info("Trying to respond in %s" % channel) b = Brain(self._brainfile) response = b.reply(text).encode('utf-8') # delay the response here so we look real? if self.registryValue('responseDelay', channel): self.log.info("Delayed response in %s" % channel) delayseconds = time.time() + random.randint(2, 5) schedule.addEvent((irc.queueMsg(ircmsgs.privmsg(channel, response))), delayseconds) else: irc.queueMsg(ircmsgs.privmsg(channel, response))
def _learn(self, irc, channel, text, probability): text = self._cleantext(text) if text: if len(text) > 0 and not text.isspace(): b = Brain(self._brainfile) b.learn(text) # determine probability to respond. if random.randint(0, 100) < probability: # if we've randomly determined to talk, check the update time. sentinel = self._updatesentinel(channel) if sentinel: self._reply(irc, channel, text)
def testWrongVersion(self): Brain.init(TEST_BRAIN_FILE) # manually change the brain version to 1 brain = Brain(TEST_BRAIN_FILE) brain.graph.set_info_text("version", "1") brain.graph.commit() brain.graph.close() try: Brain(TEST_BRAIN_FILE) except CobeError, e: self.assertTrue("cannot read a version" in str(e))
def corpuslearn(self, irc, msg, args, text): """<text> Manually teach the corpus <text> """ text = self._cleantext(text) if text and len(text) > 1 and not text.isspace(): irc.reply("I am learning: {0}".format(text)) b = Brain(self._brainfile) b.learn(text) else: irc.reply("After sanitizing, I did not have any text to learn.")
def fun(message): print message.text brain = Brain("/db/" + str(message.chat.id)[1:] + ".br") # Telegram understands UTF-8, so encode text for unicode compatibility brain.learn(message.text) if "tagueul" in message.text.lower() or "tg" in message.text.lower() or "ta gueule" in message.text.lower(): bot.reply_to(message, "Non, toi ta gueule.") elif (randint(1, 100) < percent): if violence : bot.reply_to(message, brain.reply(message.text.upper(), 3000)) else : bot.reply_to(message, brain.reply(message.text, 3000)) return 'ok'
def connectionMade(self): self.nickname = self.factory.nick self.password = self.factory.password self.replyrate = self.factory.replyrate self.ignored = self.factory.ignored self.trusted = self.factory.trusted self.talking = self.factory.talking irc.IRCClient.connectionMade(self) print("Connected") print("Using brain %s" % self.factory.brain) self.brain = Brain(self.factory.brain)
def testWrongVersion(self): Brain.init(TEST_BRAIN_FILE) # manually change the brain version to 1 brain = Brain(TEST_BRAIN_FILE) brain.graph.set_info_text("version", "1") brain.graph.commit() brain.graph.close() try: Brain(TEST_BRAIN_FILE) except CobeError, e: self.assert_("cannot read a version" in str(e))
def workerThread(self): self.brain = Brain(self.fileLocation) #wait a few minutes to load enough information time.sleep(self.initialWaitTime) while True: time.sleep(self.chattiness) if len(self.brainCache) == 0: ''' try: self.sendChatMessageLock.release() except Exception, e: z = e print 'release exception: ' + str(z) ''' print 'there was nothing to reply to' pass else: print 'adding new info from cache: ' + str(self.brainCache) for msg in self.brainCache: #add all current messages to the brain self.brain.learn(msg) usedMessage = max(self.brainCache, key=lambda msg: len(msg)) print 'replying to message: ' + usedMessage message = (usedMessage + '.')[:-1] #get a copy of the longest message del self.brainCache[:] #clear cache after storing the messages in the brain self.brainCache = list() gc.collect() #release lock after making copy ''' try: self.sendChatMessageLock.release() except Exception, e: z = e print 'release exception: ' + str(z) ''' sentence = '' try: sentence = self.generate_sentence( message) #make new message print 'generated sentence: ' + sentence except IndexError, e: a = 1 if len(sentence.split(' ')) > 2 and sentence.find( '@' ) < 0: #send new message if it meets certain criteria self.cleanString(sentence) #print 'chatter says: ' + sentence command = 'PRIVMSG #otherbrand ' + " :" + sentence + '\r\n' self.commandQueueRef.sendCommandToQueue( command, self.initialWaitTime)
def _learn(self, irc, msg, channel, text, probability): """Internal method for learning phrases.""" if os.path.exists(self._getBrainDirectoryForChannel(channel)): # Does this channel have a directory for the brain file stored and does this file exist? text = self._cleanText(text) if text and len(text) > 1 and not text.isspace(): self.log.debug("Learning: {0}".format(text)) cobeBrain = Brain(self._getBrainDirectoryForChannel(channel)) cobeBrain.learn(text) if random.randint(0, 10000) <= probability: self._reply(irc, msg, channel, text) else: # Nope, let's make it! commands.getoutput('{0} {1}'.format(self._doCommand(channel), 'init')) text = self._cleanText(text) if text and len(text) > 1 and not text.isspace(): self.log.debug("Learning: {0}".format(text)) cobeBrain = Brain(self._getBrainDirectoryForChannel(channel)) cobeBrain.learn(text) if random.randint(0, 10000) <= probability: self._reply(irc, msg, channel, text)
def testExpandGraph(self): Brain.init(TEST_BRAIN_FILE, order=2) brain = Brain(TEST_BRAIN_FILE) tokens = ["this", Brain.SPACE_TOKEN_ID, "is", Brain.SPACE_TOKEN_ID, "a", Brain.SPACE_TOKEN_ID, "test"] self.assertEquals(list(brain._to_graph(brain._to_edges(tokens))), [((1, 1), False, (1, "this")), ((1, "this"), True, ("this", "is")), (("this", "is"), True, ("is", "a")), (("is", "a"), True, ("a", "test")), (("a", "test"), False, ("test", 1)), (("test", 1), False, (1, 1))])
def testInfoPickle(self): order = 2 Brain.init(TEST_BRAIN_FILE, order=order) brain = Brain(TEST_BRAIN_FILE) db = brain.graph key = "pickle_test" obj = {"dummy": "object", "to": "pickle"} db.set_info_text(key, pickle.dumps(obj)) get_info_text = lambda: pickle.loads( db.get_info_text(key, text_factory=str))
class Chatter(object): def __init__(self): self.brain = Brain('cobe.brain') with open('seed.txt', 'r') as f: text = [l.strip() for l in f.read().replace('\n', ' ').replace('.', '\n').replace('?', '\n').replace('\xa0', ' - ').split('\n') if l.strip()] for line in text: self.brain.learn(line) def reply(self, message): return self.brain.reply(message) def learn(self, line): self.brain.learn(line)
def _reply(self, irc, channel, text): """Send a response to text""" cobeBrain = Brain(self._getBrainDirectoryForChannel(channel)) response = cobeBrain.reply(text).encode('utf-8') cobeBrain.learn(response) # Let's have the bot learn the wacky things it says self.log.info("Attempting to respond in {0} with message: {1}".format(channel, response)) # delay the response here so we look real? if self.registryValue('responseDelay', channel): self.log.info("Delayed the response in %s." % channel) delayseconds = time.time() + random.randint(2, 5) schedule.addEvent(irc.queueMsg(ircmsgs.privmsg(channel, response)), delayseconds) else: irc.queueMsg(ircmsgs.privmsg(channel, response))
def __init__(self): self.brain = Brain('cobe.brain') with open('seed.txt', 'r') as f: text = [l.strip() for l in f.read().replace('\n', ' ').replace('.', '\n').replace('?', '\n').replace('\xa0', ' - ').split('\n') if l.strip()] for line in text: self.brain.learn(line)
def load_brain(ctx): ctx.storage.brains[ctx.config.brain_file] = Brain(ctx.config.brain_file, check_same_thread=False) scorer = ctx.storage.brains[ctx.config.brain_file].scorer scorer.score = scorergroup_score.__get__(scorer, ScorerGroup) scorer.add_scorer(1.0, LengthScorer()) scorer.add_scorer(1.0, BalancedScorer())
def testInfoPickle(self): order = 2 Brain.init(TEST_BRAIN_FILE, order=order) brain = Brain(TEST_BRAIN_FILE) db = brain.graph key = "pickle_test" obj = self db.set_info_text(key, pickle.dumps(obj)) # pickle cannot load from a unicode object get_info_text = lambda: pickle.loads(db.get_info_text(key)) self.assertRaises(TypeError, get_info_text) get_info_text = lambda: pickle.loads( db.get_info_text(key, text_factory=str))
def testInfoPickle(self): order = 2 Brain.init(TEST_BRAIN_FILE, order=order) brain = Brain(TEST_BRAIN_FILE) db = brain.graph key = "pickle_test" obj = {"dummy": "object", "to": "pickle"} db.set_info_text(key, pickle.dumps(obj)) # pickle cannot load from a unicode object get_info_text = lambda: pickle.loads(db.get_info_text(key)) self.assertRaises(TypeError, get_info_text) get_info_text = lambda: pickle.loads( db.get_info_text(key, text_factory=str))
def testInfoText(self): order = 2 Brain.init(TEST_BRAIN_FILE, order=order) brain = Brain(TEST_BRAIN_FILE) db = brain.graph key = "test_text" self.assertEqual(None, db.get_info_text(key)) db.set_info_text(key, "test_value") self.assertEqual("test_value", db.get_info_text(key)) db.set_info_text(key, "test_value2") self.assertEqual("test_value2", db.get_info_text(key)) db.set_info_text(key, None) self.assertEqual(None, db.get_info_text(key))
def learn(archivepath, brain, **kwargs): # start brain. Batch saves us from lots of I/O brain = Brain(brain) brain.set_stemmer(kwargs.get('language', 'english')) brain.start_batch_learning() tweets = tweet_generator(archivepath, **kwargs) count = 0 for text in tweets: count = count + 1 brain.learn(text) brain.stop_batch_learning() return count
def _reply(self, irc, msg, channel, text): """Send a response to text""" cobeBrain = Brain(self._getBrainDirectoryForChannel(channel)) response = cobeBrain.reply(text).encode('utf-8') response = self._strip_nick(irc, msg, response) cobeBrain.learn( response) # Let's have the bot learn the wacky things it says self.log.info("Attempting to respond in {0} with message: {1}".format( channel, response)) # delay the response here so we look real? if self.registryValue('responseDelay', channel): self.log.info("Delayed the response in %s." % channel) delayseconds = time.time() + random.randint(2, 5) schedule.addEvent(irc.queueMsg(ircmsgs.privmsg(channel, response)), delayseconds) else: irc.queueMsg(ircmsgs.privmsg(channel, response))
def create_tweet(catalyst=''): b = Brain(os.path.join(os.path.dirname(__file__), 'cobe.brain')) # get a reply from brain, encode as UTF-8 i = 0 while True: tweet = b.reply(catalyst).encode('utf-8', 'replace') if (config.filter_url): tweet = remove_url(tweet) tweet = smart_truncate(tweet) #make sure we're not tweeting something close to something else in the txt files #or we can just give up after 100 tries if check_tweet(tweet) or i >= 100: break i += 1 #put the tweet in the db db_manager.insert_tweet(tweet) return tweet
def _learn(self, irc, channel, text, probability): """Internal method for learning phrases.""" if os.path.exists(self._getBrainDirectoryForChannel(channel)): # Does this channel have a directory for the brain file stored and does this file exist? text = self._cleanText(text) if text and len(text) > 1 and not text.isspace(): self.log.debug("Learning: {0}".format(text)) cobeBrain = Brain(self._getBrainDirectoryForChannel(channel)) cobeBrain.learn(text) if random.randint(0, 10000) <= probability: self._reply(irc, channel, text) else: # Nope, let's make it! commands.getoutput('{0} {1}'.format(self._doCommand(channel), 'init')) text = self._cleanText(text) if text and len(text) > 1 and not text.isspace(): self.log.debug("Learning: {0}".format(text)) cobeBrain = Brain(self._getBrainDirectoryForChannel(channel)) cobeBrain.learn(text) if random.randint(0, 10000) <= probability: self._reply(irc, channel, text)
class Markov(ModuleInterface): help = "Markov - Yeah I'm sentient, what of it?" def onEnable(self): self.brain = Brain(os.path.join("hubbot", "data", "{}.brain".format(self.bot.server))) def addToBrain(self, msg): if "://" not in msg and len(msg) > 1: self.brain.learn(msg) def shouldTrigger(self, message): """ @type message: hubbot.message.IRCMessage """ if message.Type in self.acceptedTypes: return True return False def onTrigger(self, message): """ @type message: hubbot.message.IRCMessage """ if message.User.Name == self.bot.nickname: return elif message.TargetType is TargetTypes.USER and not message.MessageString.startswith(self.bot.commandChar): reply = self.brain.reply(message.MessageString, max_len=100) return IRCResponse(ResponseType.Say, reply.capitalize(), message.ReplyTo) elif self.bot.nickname.lower() in message.MessageString.lower() and len(message.MessageList) > 1: messageList = [item.lower() for item in message.MessageList if item.lower() != self.bot.nickname.lower()] reply = self.brain.reply(" ".join(messageList), max_len=100) nickList = [nick.lower() for nick in self.bot.channels[message.ReplyTo].Users.keys()] for word in reply.split(): if word.lower() in nickList: reply.replace(word, message.User.Name) return IRCResponse(ResponseType.Say, reply.capitalize(), message.ReplyTo) else: messageList = [item.lower() for item in message.MessageList if item.lower() != self.bot.nickname.lower()] self.addToBrain(" ".join(messageList))
def __init__(self, bot): self._brain_file = os.path.join(bot.op.files.data_dir, "cobe.brain") self._trace_file = os.path.join(bot.op.files.data_dir, "cobe.trace") # rotate logs if os.path.exists(self._trace_file): now = datetime.datetime.now() stamp = now.strftime("%Y-%m-%d.%H%M%S") os.rename(self._trace_file, "%s.%s" % (self._trace_file, stamp)) self._brain = Brain(self._brain_file, instatrace=self._trace_file) kibot.BaseModule.BaseModule.__init__(self, bot)
def testLearnStems(self): Brain.init(TEST_BRAIN_FILE, order=2) brain = Brain(TEST_BRAIN_FILE) brain.set_stemmer("english") stem = brain.stemmer.stem brain.learn("this is testing") c = brain.graph.cursor() stem_count = c.execute("SELECT count(*) FROM token_stems").fetchone() self.assertEqual(3, stem_count[0]) self.assertEqual(brain.graph.get_token_stem_id(stem("test")), brain.graph.get_token_stem_id(stem("testing")))
def create_tweet(catalyst=""): b = Brain(os.path.join(os.path.dirname(__file__), "cobe.brain")) # get a reply from brain, encode as UTF-8 i = 0 while True: tweet = b.reply(catalyst).encode("utf-8", "replace") if config["filter_urls"]: tweet = remove_url(tweet) tweet = smart_truncate(tweet) tweet = quote_fixer(tweet) # make sure we're not tweeting something close to something else in the txt files # or we can just give up after 100 tries if check_tweet(tweet) or i >= 2000: break i += 1 tweet = HTMLParser().unescape(tweet) # put the tweet in the db db_manager.insert_tweet(tweet) return tweet
def reply(self, lang, msg): # reply message if self.multibrain: lang = guess_language_name(msg).lower() else: lang = 'italian' if not lang in self.brains: self.brains[lang] = Brain( os.path.join( os.path.split(__file__)[0], "brains", "lampone_%s.brain" % lang)) if lang in self.languages: self.brains[lang].set_stemmer(lang) return self.brains[lang].reply(msg, loop_ms=self.reply_time)
def train_brain(self, channel): """ create a cobe brain file based on the db. This file is used by cobe to generate responses. """ logger.debug('starting training') logger.debug('ignored: {}'.format(IGNORED)) # replace the current brain try: os.remove('brain.ai') except: pass BRAIN = Brain('brain.ai') logger.debug('created brain.ai') start = time.time() BRAIN.start_batch_learning() logger_lines = db.logger.find({ 'channel': channel, 'nick': { '$nin': IGNORED }, 'message': { '$regex': '^(?!\.|\,|\!)' }, }) logger.debug('log total: {}'.format(logger_lines.count())) for line in logger_lines: BRAIN.learn(line['message']) BRAIN.stop_batch_learning() logger.debug('learned stuff. Took {:.2f}s'.format(time.time() - start))
def testExpandGraph(self): Brain.init(TEST_BRAIN_FILE, order=2) brain = Brain(TEST_BRAIN_FILE) tokens = ["this", Brain.SPACE_TOKEN_ID, "is", Brain.SPACE_TOKEN_ID, "a", Brain.SPACE_TOKEN_ID, "test"] self.assertEqual(list(brain._to_graph(brain._to_edges(tokens))), [((1, 1), False, (1, "this")), ((1, "this"), True, ("this", "is")), (("this", "is"), True, ("is", "a")), (("is", "a"), True, ("a", "test")), (("a", "test"), False, ("test", 1)), (("test", 1), False, (1, 1))])
def __init__(self, irc): # Call Supybot's scripts self.__parent = super(Cobe, self) self.__parent.__init__(irc) # Save state saved = (sys.stdout, os.getcwd()) # Create proxy for Cobe os.chdir(conf.supybot.directories.data()) sys.stdout = StringIO() # Initialize Cobe self.brain = Brain("cobe.store") # Restore state sys.stdout, cwd = saved os.chdir(cwd) random.seed()
def learn(self, msg): # learn message if self.multibrain: lang = guess_language_name(msg).lower() else: lang = 'italian' try: if not lang in self.brains: self.brains[lang] = Brain( os.path.join( os.path.split(__file__)[0], "brains", "lampone_%s.brain" % lang)) if self.brains[lang] in self.languages: brain.set_stemmer(lang) self.brains[lang].learn(msg) except Exception as e: logger.error("ERR - learn - %s" % e) return lang
def handle(msg): content_type, chat_type, chat_id = telepot.glance(msg) if content_type == 'text': brain = Brain(config.get('Brain', 'path') + str(chat_id) + ".brain") brain.learn(msg['text']) if 'reply_to_message' in msg and msg['reply_to_message']['from'][ 'username'] == "Braulio_bot": bot.sendMessage(chat_id, brain.reply(msg['text']), reply_to_message_id=msg['message_id']) elif 'braulio' in msg['text'].lower(): bot.sendMessage( chat_id, brain.reply(msg['text']).replace("Braulio", msg['from']['first_name']))
def __init__(self): self.path, self.file = os.path.split(_abspath) self.brain = Brain(u'{}/brain.sqlite'.format(self.path)) config_json = u'{}/config.json'.format(self.path) rps_json = u'{}/rps.json'.format(self.path) keys_json = u'{}/keys.json'.format(self.path) self.config = dbaccess.Config(config_json, rps_json, keys_json) # Load plugins for plug_name in self.config.get(u'plugins', list())[:]: public, private = self.handle_load([u'!load', plug_name]) for m in private: log.info(m) self.mb = util.CollectionOfNamedLists(u'{}/mb.json'.format(self.path)) self.tf = util.TitleFetcher() args = sys.argv[1:] for arg in args: if arg.startswith(u'--set-'): key, value = arg[6:].split(u'=', 1) print u'Setting \'{}\' to \'{}\'.'.format(key, value) self.config.set(key, value) # Set up ignore if the ignore list is non-empty. ignore = self.config.get(u'msg:ignore', u'') self.reignore = None if ignore: self.reignore = re.compile(ignore, re.IGNORECASE) server = self.config.get(u'irc:server') nick = self.config.get(u'irc:nick') name = self.config.get(u'irc:name') SingleServerIRCBot.__init__(self, [(server, 6667)], nick, name) self.connection.buffer_class.errors = u'replace'
def chatbot(botname, remotebot, out=sys.stdout): mem = Brain(botname + ".brain") mem.learn("This is the only thing I know!") msg = "Hello!" out.write("BEGIN LOG: %s\n" % time.ctime()) try: while True: out.write("Local: %s\n" % msg) msg = remotebot.think(msg) out.write("Remote: %s\n" % msg) if LEARN == True: mem.learn(msg) msg = mem.reply(msg) out.flush() except (KeyboardInterrupt, SystemExit, EOFError): print "Saving..." out.write("END LOG: %s\n" % time.ctime()) out.close()
def learn(self, *args, **kwargs): return Brain(self.corpus).learn(*args, **kwargs)
def reply(self, *args, **kwargs): return Brain(self.corpus).reply(*args, **kwargs)
def __init__(self, brain_id): self.brain_id = brain_id brain_path = f'data/cobe/{brain_id}' os.makedirs('data/cobe/', exist_ok=True) self.brain = Brain(brain_path)
from os import path from cobe.brain import Brain b = Brain("%s/shakespeare.sqlite" % path.split(path.abspath(__file__))[0]) b.start_batch_learning() with open("shakespeare.txt") as f: for l in f: b.learn(l) b.stop_batch_learning()