Python callbacks.addressed函数代码示例

 def testAddressedWithMultipleNicks(self):
     msg = ircmsgs.privmsg("#foo", "bar: baz")
     self.assertEqual(callbacks.addressed("bar", msg), "baz")
     # need to recreate the msg objects since the old ones have already
     # been tagged
     msg = ircmsgs.privmsg("#foo", "bar: baz")
     self.assertEqual(callbacks.addressed("biff", msg, nicks=["bar"]), "baz")

 def testAddressedWithMultipleNicks(self):
     msg = ircmsgs.privmsg('#foo', 'bar: baz')
     self.assertEqual(callbacks.addressed('bar', msg), 'baz')
     # need to recreate the msg objects since the old ones have already
     # been tagged
     msg = ircmsgs.privmsg('#foo', 'bar: baz')
     self.assertEqual(callbacks.addressed('biff', msg, nicks=['bar']),
                      'baz')

 def doPrivmsg(self, irc, msg):
     channel = msg.args[0].lower()
     text = msg.args[1].strip()
     # ignore ctcp, action and only messages in a channel.
     # if txt.startswith(conf.supybot.reply.whenAddressedBy.chars()):
     if ircmsgs.isCtcp(msg) or ircmsgs.isAction(msg) or not irc.isChannel(channel):
         return
     # on to the text. check if we're ignoring the text matching regex here.
     if re.match(self.registryValue('ignoreRegex'), text):
         return
     # should we strip urls from text?
     if self.registryValue('stripUrls'):
         text = re.sub(r'(http[^\s]*)', '', text)
     # determine probability if addressed or not.
     if callbacks.addressed(irc.nick, msg):
         text = re.sub('(' + irc.nick + '*?\W+)', '', text, re.IGNORECASE)
         probability = self.registryValue('probabilityWhenAddressed', channel)
     else:
         probability = self.registryValue('probability', channel)
     # should we strip nicks from the text?
     if self.registryValue('stripNicks'):
         removenicks = '|'.join(item + '\W.*?\s' for item in irc.stats.channels[channel].users)
         text = re.sub(r'' + removenicks + '', '', text)
     # finally, pass to our learn function.
     self._learn(irc, channel, text, probability)

 def doPrivmsg(self, irc, msg):
     if irc.isChannel(msg.args[0]):
         channel = plugins.getChannel(msg.args[0])
         canSpeak = False
         now = time.time()
         throttle = self.registryValue('randomSpeaking.throttleTime',
                                       channel)
         prob = self.registryValue('randomSpeaking.probability', channel)
         delay = self.registryValue('randomSpeaking.maxDelay', channel)
         irc = callbacks.SimpleProxy(irc, msg)
         if now > self.lastSpoke + throttle:
             canSpeak = True
         if canSpeak and random.random() < prob:
             f = self._markov(channel, irc, prefixNick=False, to=channel,
                              Random=True)
             schedule.addEvent(lambda: self.q.enqueue(f), now + delay)
             self.lastSpoke = now + delay
         words = self.tokenize(msg)
         words.insert(0, '\n')
         words.insert(0, '\n')
         words.append('\n')
         # This shouldn't happen often (CTCP messages being the possible exception)
         if not words or len(words) == 3:
             return
         if self.registryValue('ignoreBotCommands', channel) and \
                 callbacks.addressed(irc.nick, msg):
             return
         def doPrivmsg(db):
             for (first, second, follower) in utils.seq.window(words, 3):
                 db.addPair(channel, first, second, follower)
         self.q.enqueue(doPrivmsg)

    def sendToOthers(self, irc, triggerMsg, s):
        channel = triggerMsg.args[0]
        nick = triggerMsg.nick
        for relay in self.relays:
            if relay.channelRegex.match(channel) and relay.networkRegex.match(irc.network) and (len(triggerMsg.args[1] < 1 or relay.messageRegex.search(triggerMsg.args[1]))):
                if not relay.hasIRC:
                    self.log.info('LinkRelay:  IRC %s not yet scraped.' % relay.targetNetwork)
                elif relay.targetIRC.zombie:
                    self.log.info('LinkRelay:  IRC %s appears to be a zombie' % relay.targetNetwork)
                elif relay.targetChannel not in relay.targetIRC.state.channels:
                    self.log.info('LinkRelay:  I\'m not in in %s on %s' % (relay.targetChannel, relay.targetNetwork))
                else:
#                    if re.match('\x0314\w+ has quit on \w+ \(.*\)', s):
#                        pm = False
#                    else:
#                        pm = True
#                    for chan in irc.state.channels:
#                        if re.match('^%s$' % relay.sourceChannel, chan):
#                            pm = False
                    if triggerMsg.args[0] not in irc.state.channels and not re.match('\x0314\w+ has quit on \w+ \(.*\)', s):
                        # cuts off the end of commands, so that passwords won't be revealed in relayed PM's
                        if callbacks.addressed(irc.nick, triggerMsg):
                            s = re.sub('(>\x03 \w+) .*', '\\1 \x0314[truncated]', s)
                        s = '(via PM) %s' % s
                    msg = ircmsgs.privmsg(relay.targetChannel, s)
                    msg.tag('relayedMsg')
                    relay.targetIRC.sendMsg(msg)

 def getName(self, nick, msg, match):
     addressed = callbacks.addressed(nick, msg)
     name = callbacks.addressed(nick, ircmsgs.IrcMsg(prefix="", args=(msg.args[0], match.group(1)), msg=msg))
     if not name:
         name = match.group(1)
     if not addressed:
         if not self.registryValue("allowUnaddressedKarma"):
             return ""
         if not msg.args[1].startswith(match.group(1)):
             return ""
         name = match.group(1)
     elif addressed:
         if not addressed.startswith(name):
             return ""
     name = name.strip("()")
     return name

 def doPrivmsg(self, irc, msg):
     channel = msg.args[0]
     if not irc.isChannel(channel):
         return
     if self.registryValue('enable', channel):
         if callbacks.addressed(irc.nick, msg): #message is direct command
             return
         actions = []
         db = self.getDb(channel)
         cursor = db.cursor()
         cursor.execute("SELECT regexp, action FROM triggers")
         results = cursor.fetchall()
         if len(results) == 0:
             return
         for (regexp, action) in results:
             for match in re.finditer(regexp, msg.args[1]):
                 if match is not None:
                     thisaction = action
                     self._updateRank(channel, regexp)
                     for (i, j) in enumerate(match.groups()):
                         thisaction = re.sub(r'\$' + str(i+1), match.group(i+1), thisaction)
                     actions.append(thisaction)
         
         for action in actions:
             self._runCommandFunction(irc, msg, action)

 def doPrivmsg(self, irc, msg):
     if (irc.isChannel(msg.args[0])):
         channel = plugins.getChannel(msg.args[0])
         canSpeak = False
         now = time.time()
         throttle = self.registryValue('randomSpeaking.throttleTime', channel)
         prob = self.registryValue('randomSpeaking.probability', channel)
         delay = self.registryValue('randomSpeaking.maxDelay', channel)
         irc = callbacks.SimpleProxy(irc, msg)
         if now > self.lastSpoke + throttle:
             canSpeak = True
         if canSpeak and random.random() < prob:
             #f = self._markov(channel, irc, prefixNick=False, to=channel, Random=True)
             reply = self.db.buildReply(channel, None)
             if (reply is None):
                 return
             irc.reply(reply, prefixNick=False, to=channel)
             #self._markov(channel, irc, prefixNick=False, to=channel, Random=True)
             #schedule.addEvent(lambda: self.q.enqueue(f), now+delay)
             self.lastSpoke = now+delay
         words = self.tokenize(msg)
         if not words or len(words) == 3:
             return
         if (self.registryValue('ignoreBotCommands', channel) and callbacks.addressed(irc.nick, msg)):
             return
         self.db.addPair(channel, None, words[0])
         self.db.addPair(channel, words[-1], None)
         for (first, second) in utils.seq.window(words, 2):
             self.db.addPair(channel, first, second)

 def titleSnarfer(self, irc, msg, match):
     channel = msg.args[0]
     if not irc.isChannel(channel):
         return
     if callbacks.addressed(irc.nick, msg):
         return
     if self.registryValue('titleSnarfer', channel):
         url = match.group(0)
         if not self._checkURLWhitelist(url):
             return
         r = self.registryValue('nonSnarfingRegexp', channel)
         if r and r.search(url):
             self.log.debug('Not titleSnarfing %q.', url)
             return
         r = self.getTitle(irc, url, False)
         if not r:
             return
         (target, title) = r
         if title:
             domain = utils.web.getDomain(target
                     if self.registryValue('snarferShowTargetDomain', channel)
                     else url)
             prefix = self.registryValue('snarferPrefix', channel)
             s = "%s %s" % (prefix, title)
             if self.registryValue('snarferShowDomain', channel):
                 s += format(_(' (at %s)'), domain)
             irc.reply(s, prefixNick=False)
     if self.registryValue('snarfMultipleUrls', channel):
         # FIXME: hack
         msg.tag('repliedTo', False)

 def doPrivmsg(self, irc, msg):
     if callbacks.addressed(irc.nick, msg): #message is not direct command
         return
     channel = msg.args[0]
     if not self.registryValue('correct.enable', channel):
         return
     if not hasattr(self, '_re'):
         threading.Thread(target=self.fetch_dict).start()
         return
     occurences = self._re.findall(msg.args[1])
     if not occurences:
         return
     unique_occurences = []
     occurences_set = set()
     for occurence in occurences:
         if not occurence in self._dict and \
                 occurence.endswith('s') and occurence[0:-1] in self._dict:
             occurence = occurence[0:-1]
         if occurence not in occurences_set:
             unique_occurences.append(occurence)
             occurences_set.add(occurence)
     irc.reply(format('Utilise %L plutôt que %L.',
         ['« %s »' % self._dict[x] for x in unique_occurences],
         ['« %s »' % x for x in unique_occurences])
         .replace(' and ', ' et ')) # fix i18n

    def doPrivmsg(self, irc, msg):
        if not world.testing and \
                msg.args[0] not in ('#limnoria', '#limnoria-bots'):
            return
        if callbacks.addressed(irc.nick, msg):
            return

        # Internal
        match = self._addressed.match(msg.args[1])
        if match is None:
            prefix = ''
        else:
            prefix = match.group(1) + ': '
        def reply(string):
            irc.reply(prefix + string, prefixNick=False)

        # Factoids
        matches = self._factoid.findall(msg.args[1])
        for name in matches:
            arg = None
            match = self._dynamicFactoid.match(name)
            if match is not None:
                name = match.group('name')
                arg = match.group('arg')
            name = name.lower()
            if arg is None:
                if name in staticFactoids:
                    reply(staticFactoids[name])
            else:
                if name in dynamicFactoids:
                    reply(dynamicFactoids[name] % arg)

 def doPrivmsg(self, irc, msg):
     self.addIRC(irc)
     channel = msg.args[0]
     s = msg.args[1]
     s, args = self.getPrivmsgData(channel, msg.nick, s,
                            self.registryValue('color', channel))
     ignoreNicks = [ircutils.toLower(item) for item in \
         self.registryValue('nickstoIgnore.nicks', msg.args[0])]
     if self.registryValue('nickstoIgnore.affectPrivmsgs', msg.args[0]) \
         == 1 and ircutils.toLower(msg.nick) in ignoreNicks:
             #self.log.debug('LinkRelay: %s in nickstoIgnore...' % ircutils.toLower(msg.nick))
             #self.log.debug('LinkRelay: List of ignored nicks: %s' % ignoreNicks)
             return
     elif channel not in irc.state.channels: # in private
         # cuts off the end of commands, so that passwords
         # won't be revealed in relayed PM's
         if callbacks.addressed(irc.nick, msg):
             if self.registryValue('color', channel):
                 color = '\x03' + self.registryValue('colors.truncated',
                         channel)
                 match = '(>\017 \w+) .*'
             else:
                 color = ''
                 match = '(> \w+) .*'
             s = re.sub(match, '\\1 %s[%s]' % (color, _('truncated')), s)
         s = '(via PM) %s' % s
     self.sendToOthers(irc, channel, s, args, isPrivmsg=True)

    def doPrivmsg(self, irc, msg):
        if not world.testing and msg.args[0] not in ("#BMN"):
            return
        if callbacks.addressed(irc.nick, msg):
            return

        # Internal
        match = self._addressed.match(msg.args[1])
        if match is None:
            prefix = ""
        else:
            prefix = match.group(1) + ": "

        def reply(string):
            irc.reply(prefix + string, prefixNick=False)

        # Factoids
        matches = self._factoid.findall(msg.args[1])
        for name in matches:
            arg = None
            match = self._dynamicFactoid.match(name)
            if match is not None:
                name = match.group("name")
                arg = match.group("arg")
            name = name.lower()
            if arg is None:
                if name in staticFactoids:
                    reply(staticFactoids[name])
            else:
                if name in dynamicFactoids:
                    reply(dynamicFactoids[name] % arg)

    def doPrivmsg(self, irc, msg):
        if not conf.supybot.defaultIgnore(): # Only do this when defaultIgnore is set
            return
        if chr(1) in msg.args[1]:
            return
        try:
            user = ircdb.users.getUser(msg.prefix)
            if user.checkHostmask(msg.prefix):
                return
        except:
            pass

        text = callbacks.addressed(irc.nick, msg)
        cmd = ''
        if not text or text != "login":
            if msg.args[1]:
                if ircutils.isChannel(msg.args[0]):
                    if msg.args[1][0] == '@':
                        cmd = msg.args[1][1:]
                else:
                    if msg.args[1][0] == '@':
                        cmd = msg.args[1][1:]
                    else:
                        cmd = msg.args[1]
                if cmd != "login":
                    return
            else:
                return
        self.log.info("IRCLogin: Calling login for %s" % msg.prefix)
        self._callCommand(["login"], irc, msg, [])

    def doPrivmsg(self, irc, msg):
        if callbacks.addressed(irc.nick, msg): #message is direct command
            return
        (channel, text) = msg.args

        if ircmsgs.isAction(msg):
            text = ircmsgs.unAction(msg)

        learn = self.registryValue('learn', channel)
        reply = self.registryValue('reply', channel)
        replyOnMention = self.registryValue('replyOnMention', channel)
        replyWhenSpokenTo = self.registryValue('replyWhenSpokenTo', channel)

        mention = irc.nick.lower() in text.lower()
        spokenTo = msg.args[1].lower().startswith('%s: ' % irc.nick.lower())

        if replyWhenSpokenTo and spokenTo:
            reply = 100
            text = text.replace('%s: ' % irc.nick, '')
            text = text.replace('%s: ' % irc.nick.lower(), '')

        if replyOnMention and mention:
            if not replyWhenSpokenTo and spokenTo:
                reply = 0
            else:
                reply = 100

        if randint(0, 99) < reply:
            self.reply(irc, msg, text)

        if learn:
            self.learn(irc, msg, text)