def testWrap(self):
if sys.version_info[0] < 3:
pred = len
else:
pred = lambda s: len(s.encode())
s = ('foo bar baz qux ' * 100)[0:-1]
r = ircutils.wrap(s, 10)
self.assertTrue(max(map(pred, r)) <= 10)
self.assertEqual(''.join(r), s)
r = ircutils.wrap(s, 100)
self.assertTrue(max(map(pred, r)) <= 100)
self.assertEqual(''.join(r), s)
if sys.version_info[0] < 3:
uchr = unichr
u = lambda s: s.decode('utf8')
else:
uchr = chr
u = lambda x: x
s = (u('').join([uchr(0x1f527), uchr(0x1f527), uchr(0x1f527), u(' ')]) * 100)\
[0:-1]
r = ircutils.wrap(s, 20)
self.assertTrue(max(map(pred, r)) <= 20, (max(map(pred, r)), repr(r)))
self.assertEqual(''.join(r), s)
r = ircutils.wrap(s, 100)
self.assertTrue(max(map(pred, r)) <= 100)
self.assertEqual(''.join(r), s)
s = ('foobarbazqux ' * 100)[0:-1]
r = ircutils.wrap(s, 10)
self.assertTrue(max(map(pred, r)) <= 10)
self.assertEqual(''.join(r), s)
r = ircutils.wrap(s, 100)
self.assertTrue(max(map(pred, r)) <= 100)
self.assertEqual(''.join(r), s)
s = ('foobarbazqux' * 100)[0:-1]
r = ircutils.wrap(s, 10)
self.assertTrue(max(map(pred, r)) <= 10)
self.assertEqual(''.join(r), s)
r = ircutils.wrap(s, 100)
self.assertTrue(max(map(pred, r)) <= 100)
self.assertEqual(''.join(r), s)
s = uchr(233) * 500
r = ircutils.wrap(s, 500)
self.assertTrue(max(map(pred, r)) <= 500)
r = ircutils.wrap(s, 139)
self.assertTrue(max(map(pred, r)) <= 139)
def testWrap(self):
if sys.version_info[0] < 3:
pred = len
else:
pred = lambda s:len(s.encode())
s = ('foo bar baz qux ' * 100)[0:-1]
r = ircutils.wrap(s, 10)
self.assertTrue(max(map(pred, r)) <= 10)
self.assertEqual(''.join(r), s)
r = ircutils.wrap(s, 100)
self.assertTrue(max(map(pred, r)) <= 100)
self.assertEqual(''.join(r), s)
if sys.version_info[0] < 3:
uchr = unichr
u = lambda s: s.decode('utf8')
else:
uchr = chr
u = lambda x: x
s = (u('').join([uchr(0x1f527), uchr(0x1f527), uchr(0x1f527), u(' ')]) * 100)\
[0:-1]
r = ircutils.wrap(s, 20)
self.assertTrue(max(map(pred, r)) <= 20, (max(map(pred, r)), repr(r)))
self.assertEqual(''.join(r), s)
r = ircutils.wrap(s, 100)
self.assertTrue(max(map(pred, r)) <= 100)
self.assertEqual(''.join(r), s)
s = ('foobarbazqux ' * 100)[0:-1]
r = ircutils.wrap(s, 10)
self.assertTrue(max(map(pred, r)) <= 10)
self.assertEqual(''.join(r), s)
r = ircutils.wrap(s, 100)
self.assertTrue(max(map(pred, r)) <= 100)
self.assertEqual(''.join(r), s)
s = ('foobarbazqux' * 100)[0:-1]
r = ircutils.wrap(s, 10)
self.assertTrue(max(map(pred, r)) <= 10)
self.assertEqual(''.join(r), s)
r = ircutils.wrap(s, 100)
self.assertTrue(max(map(pred, r)) <= 100)
self.assertEqual(''.join(r), s)
s = uchr(233)*500
r = ircutils.wrap(s, 500)
self.assertTrue(max(map(pred, r)) <= 500)
r = ircutils.wrap(s, 139)
self.assertTrue(max(map(pred, r)) <= 139)
def _mention(self, irc):
statuses = self.api.GetMentions(since_id=self.mentionSince)
if len(statuses) > 0:
self.mentionSince = statuses[0].id
for channel in self.registryValue('channelList').split():
comment = self.registryValue('replyAnnounceMsg')
status_strs = []
for status in statuses:
msg = (status.user.screen_name + ' -- ' + status.text).encode("UTF-8")
self.log.info(msg)
status_strs.append(msg)
status_msgs = comment + " " + " || ".join(status_strs)
for msg in ircutils.wrap(status_msgs, 470):
irc.queueMsg(ircmsgs.privmsg(channel, msg))
def _tweets(self, irc):
statuses = self.api.GetUserTimeline(include_rts=True, since_id=self.tweetsSince)
if len(statuses) > 0:
self.tweetsSince = statuses[0].id
for channel in self.registryValue('channelList').split():
comment = self.registryValue('tweetAnnounceMsg')
status_strs = []
for status in statuses:
if status.retweeted_status is not None:
msg = (status.user.screen_name + ' -- RT @' + status.retweeted_status.user.screen_name + " " + status.retweeted_status.text).encode("UTF-8")
else:
msg = (status.user.screen_name + ' -- ' + status.text).encode("UTF-8")
msg = utils.web.htmlToText(msg)
self.log.info(msg)
status_strs.append(msg)
status_msgs = comment + " " + " || ".join(status_strs)
for msg in ircutils.wrap(status_msgs, 470):
irc.queueMsg(ircmsgs.privmsg(channel, msg))
def wrapped_message(self, sender, message, **kwargs):
line_length = 300
wrapped = ircutils.wrap(message, line_length)
for msg in wrapped:
sender(msg, **kwargs)
def _newHeadlines(self, irc, channels, name, url):
try:
# We acquire the lock here so there's only one announcement thread
# in this code at any given time. Otherwise, several announcement
# threads will getFeed (all blocking, in turn); then they'll all
# want to send their news messages to the appropriate channels.
# Note that we're allowed to acquire this lock twice within the
# same thread because it's an RLock and not just a normal Lock.
self.acquireLock(url)
try:
oldresults = self.cachedFeeds[url]
oldheadlines = self.getHeadlines(oldresults)
except KeyError:
oldheadlines = []
newresults = self.getFeed(url)
newheadlines = self.getHeadlines(newresults)
if len(newheadlines) == 1:
s = newheadlines[0][0]
if s in ('Timeout downloading feed.',
'Unable to download feed.'):
self.log.debug('%s %u', s, url)
return
def normalize(headline):
return (tuple(headline[0].lower().split()), headline[1])
oldheadlines = set(map(normalize, oldheadlines))
for (i, headline) in enumerate(newheadlines):
if normalize(headline) in oldheadlines:
newheadlines[i] = None
newheadlines = filter(None, newheadlines) # Removes Nones.
if newheadlines:
def filter_whitelist(headline):
v = False
for kw in whitelist:
if kw in headline[0] or kw in headline[1]:
v = True
break
return v
def filter_blacklist(headline):
v = True
for kw in blacklist:
if kw in headline[0] or kw in headline[1]:
v = False
break
return v
for channel in channels:
if len(oldheadlines) == 0:
channelnewheadlines = newheadlines[:self.registryValue('initialAnnounceHeadlines', channel)]
else:
channelnewheadlines = newheadlines[:]
whitelist = self.registryValue('keywordWhitelist', channel)
blacklist = self.registryValue('keywordBlacklist', channel)
if len(whitelist) != 0:
channelnewheadlines = filter(filter_whitelist, channelnewheadlines)
if len(blacklist) != 0:
channelnewheadlines = filter(filter_blacklist, channelnewheadlines)
if len(channelnewheadlines) == 0:
return
bold = self.registryValue('bold', channel)
sep = self.registryValue('headlineSeparator', channel)
prefix = self.registryValue('announcementPrefix', channel)
pre = format('%s%s: ', prefix, name)
if bold:
pre = ircutils.bold(pre)
sep = ircutils.bold(sep)
headlines = self.buildHeadlines(channelnewheadlines, channel)
headlines_str = pre + sep.join(headlines)
for msg in ircutils.wrap(headlines_str, 470):
irc.replies(msg, prefixer=None, joiner="",
to=channel, prefixNick=False, private=True)
finally:
self.releaseLock(url)
def testWrap(self):
pred = lambda s: len(s.encode())
s = ('foo bar baz qux ' * 100)[0:-1]
r = ircutils.wrap(s, 10)
self.assertTrue(max(map(pred, r)) <= 10)
self.assertEqual(''.join(r), s)
r = ircutils.wrap(s, 100)
self.assertTrue(max(map(pred, r)) <= 100)
self.assertEqual(''.join(r), s)
s = (''.join([chr(0x1f527), chr(0x1f527), chr(0x1f527), ' ']) * 100)\
[0:-1]
r = ircutils.wrap(s, 20)
self.assertTrue(max(map(pred, r)) <= 20, (max(map(pred, r)), repr(r)))
self.assertEqual(''.join(r), s)
r = ircutils.wrap(s, 100)
self.assertTrue(max(map(pred, r)) <= 100)
self.assertEqual(''.join(r), s)
s = ('foobarbazqux ' * 100)[0:-1]
r = ircutils.wrap(s, 10)
self.assertTrue(max(map(pred, r)) <= 10)
self.assertEqual(''.join(r), s)
r = ircutils.wrap(s, 100)
self.assertTrue(max(map(pred, r)) <= 100)
self.assertEqual(''.join(r), s)
s = ('foobarbazqux' * 100)[0:-1]
r = ircutils.wrap(s, 10)
self.assertTrue(max(map(pred, r)) <= 10)
self.assertEqual(''.join(r), s)
r = ircutils.wrap(s, 100)
self.assertTrue(max(map(pred, r)) <= 100)
self.assertEqual(''.join(r), s)
s = chr(233) * 500
r = ircutils.wrap(s, 500)
self.assertTrue(max(map(pred, r)) <= 500)
r = ircutils.wrap(s, 139)
self.assertTrue(max(map(pred, r)) <= 139)
s = '\x02\x16 barbazqux' + ('foobarbazqux ' * 20)[0:-1]
r = ircutils.wrap(s, 91)
self.assertTrue(max(map(pred, r)) <= 91)
