def _printWikiPage(self, values):
     action = values.get('action')
     if action is not None:
         if action == 'created':
             action = 'created by %s' % underline(values['author'])
         elif action == 'changed':
             action = 'changed by %s' % underline(values['author'])
         action = ' (%s)' % action
     yield format('%s%s %u',
         bold(values['name']),
         action or '',
         values['url']
     )

    def _finalgame(self, gamedate, gameid):
        """Grabs the boxscore json and prints a final statline."""

        url = b64decode('aHR0cDovL2RhdGEubmJhLmNvbS9qc29uL2Ntcy9ub3NlYXNvbi9nYW1lLw==') + '%s/%s/boxscore.json' % (str(gamedate), str(gameid))
        html = self._httpget(url)
        if not html:
            self.log.error("ERROR: Could not _finalgame.")
            return None
        # process json. throw this thing in a try/except block.
        try:
            jsonf = json.loads(html.decode('utf-8'))
            game = jsonf['sports_content']['game']
            if len(game) == 0:
                self.log.error("_finalgame :: I found no games in the json data.")
                return None

            # output dict. we preset DD/TD for later.
            gamestats = {'Double-double':[], 'Triple-double':[]}
            # iterate over the home/visitor.
            for var in ['visitor', 'home']:
                team = game[var]['abbreviation']
                fgp = game[var]['stats']['field_goals_percentage']
                tpp = game[var]['stats']['three_pointers_percentage']
                ftp = game[var]['stats']['free_throws_percentage']
                to = game[var]['stats']['turnovers']
                rb = (int(game[var]['stats']['rebounds_offensive'])+int(game[var]['stats']['rebounds_defensive']))  # total rb.
                ptsl = sorted(game[var]['players']['player'], key=lambda t: int(t['points']), reverse=True)[0]  # sort by points
                astl = sorted(game[var]['players']['player'], key=lambda t: int(t['assists']), reverse=True)[0]  # sort by assists. below we sort by adding rebounds.
                rbll = sorted(game[var]['players']['player'], key=lambda x: (int(x['rebounds_offensive']) + int(x['rebounds_defensive'])), reverse=True)[0]
                # inject into our gamestats dict with the text.
                gamestats[team] = "{0}: {1} {2}: {3} {4}: {5} {6}: {7} {8}: {9}  {10} :: {11} {12} {13} {14} {15} {16} {17} {18} {19}".format(\
                      ircutils.bold("FG%"), fgp,
                      ircutils.bold("FT%"), ftp,
                      ircutils.bold("3PT%"), tpp,
                      ircutils.bold("TO"), to,
                      ircutils.bold("RB"), rb,
                      ircutils.bold(ircutils.underline("LEADERS")),
                      ircutils.bold("PTS"), ptsl['last_name'].encode('utf-8'), ptsl['points'],
                      ircutils.bold("AST"), astl['last_name'].encode('utf-8'), astl['assists'],
                      ircutils.bold("RB"), rbll['last_name'].encode('utf-8'), (int(rbll['rebounds_offensive'])+int(rbll['rebounds_defensive'])))
                # look for DD/TD
                for x in game[var]['players']['player']:  # iterate over.
                    tmp = {}  # we make a dict with the key as the stat for later.
                    tmp['rb'] = int(x['rebounds_offensive']) + int(x['rebounds_defensive'])
                    tmp['blocks'] = int(x['blocks'])
                    tmp['a'] = int(x['assists'])
                    tmp['p'] = int(x['points'])
                    tmp['s'] = int(x['steals'])
                    # we only inject into matching the category and stat if 10 or over.
                    matching = [str(z.upper()) + ": " + str(p) for (z, p) in tmp.items() if p >= 10]
                    if len(matching) == 2:  # dd. inject into gamestats in the right category.
                        gamestats['Double-double'].append("{0}({1}) :: {2}".format(x['last_name'].encode('utf-8'), team, " | ".join(matching)))
                    if len(matching) > 2:  # likewise with td.
                        gamestats['Triple-double'].append("{0}({1}) :: {2}".format(x['last_name'].encode('utf-8'), team, " | ".join(matching)))

            # return the dict.
            return gamestats
        except Exception, e:
            self.log.error("_finalgame: ERROR on {0} :: {1}".format(url, e))
            return None

def present_listing_first(res, original_link=False, color_score=False):
	try:
		d = res.get("data", {}).get("children", [{}])[0].get("data",{})
		if d:
			if not original_link:
				d["url"] = "http://www.reddit.com/r/%(subreddit)s/comments/%(id)s/" % d
            
			if color_score:
				score_part = "(%s|%s)[%s]" % (ircutils.bold(ircutils.mircColor("%(ups)s", "orange")),
                                              ircutils.bold(ircutils.mircColor("%(downs)s", "12")),
                                              ircutils.bold(ircutils.mircColor("%(num_comments)s", "dark grey")))
			else:
				score_part = "(%(score)s)"
			title_part = "%(title)s"
			url_part = ircutils.underline("%(url)s")
			nsfw_part = "NSFW"*d['over_18'] or ''
			nsfw_part =ircutils.bold(ircutils.mircColor(nsfw_part, 'red'))
			template = "%s %s %s %s" % (nsfw_part, score_part, title_part, url_part)
			template = (template % d)
			template = template.replace('\n', ' ')
			template = template.replace('&','&')
		
			if d["created_utc"] < time.time() - 2678400:
				return False
			return template
			
    
	except IndexError:
		return None

 def testStripFormatting(self):
     self.assertEqual(ircutils.stripFormatting(ircutils.bold("foo")), "foo")
     self.assertEqual(ircutils.stripFormatting(ircutils.italic("foo")), "foo")
     self.assertEqual(ircutils.stripFormatting(ircutils.reverse("foo")), "foo")
     self.assertEqual(ircutils.stripFormatting(ircutils.underline("foo")), "foo")
     self.assertEqual(ircutils.stripFormatting("\x02bold\x0302,04foo\x03" "bar\x0f"), "boldfoobar")
     s = ircutils.mircColor("[", "blue") + ircutils.bold("09:21")
     self.assertEqual(ircutils.stripFormatting(s), "[09:21")

    def cfbschedule(self, irc, msg, args, optteam):
        """[team]
        Display the schedule/results for team.
        """
        
        lookupteam = self._lookupTeam(optteam)
        
        if lookupteam == "0":
            irc.reply("I could not find a schedule for: %s" % optteam)
            return
        
        url = 'http://www.cbssports.com/collegefootball/teams/schedule/%s/' % lookupteam

        try:
            req = urllib2.Request(url)
            html = (urllib2.urlopen(req)).read()
        except:
            irc.reply("Failed to open: %s" % url)
            return
            
        html = html.replace('&','&').replace(';','')
    
        soup = BeautifulSoup(html)
        
        if soup.find('table', attrs={'class':'data stacked'}).find('tr', attrs={'class':'title'}).find('td'):
            title = soup.find('table', attrs={'class':'data stacked'}).find('tr', attrs={'class':'title'}).find('td')
        else:
            irc.reply("Something broke with schedules. Did formatting change?")
            return

        div = soup.find('div', attrs={'id':'layoutTeamsPage'}) # must use this div first since there is an identical table.
        table = div.find('table', attrs={'class':'data', 'width':'100%'})
        rows = table.findAll('tr', attrs={'class':re.compile('^row[1|2]')})

        append_list = []
        
        for row in rows:
            date = row.find('td')
            team = date.findNext('td').find('a')
            time = team.findNext('td')
            
            if team.text.startswith('@'): # underline home
                team = team.text
            else:
                team = ircutils.underline(team.text)
        
            if time.find('span'): # span has score time. empty otherwise.
                time = time.find('span').string
                append_list.append(date.text + " - " + ircutils.bold(team) + " (" + time + ")")
            else:
                time = time.string
                append_list.append(date.text + " - " + ircutils.bold(team))

        descstring = string.join([item for item in append_list], " | ")
        output = "{0} for {1} :: {2}".format(title.text, ircutils.bold(optteam.title()), descstring)
        
        irc.reply(output)

 def _printTicket(self, values):
     action = values.get('action')
     if action is not None:
         if action == 'created':
             action = 'created by %s' % underline(values['reporter'])
         elif action == 'changed':
             action = 'changed by %s' % underline(values['author'])
         comment = values['comment']
         if comment:
             comment = ', ' + comment
         action = ' (%s%s)' % (action, comment)
     yield format('%s #%s: %s%s',
         bold('Ticket'),
         values['id'],
         values['summary'],
         action or ''
     )
     yield '<%s>' % values['url']

 def _printChangeset(self, values):
     yield format('%s [%s] by %s in %s (%n): %s',
         bold('Changeset'),
         values['rev'],
         underline(values['author']),
         values['path'],
         (values['file_count'], 'file'),
         ellipsisify(values['message'].strip(), 130)
     )
     yield '<%s>' % values['url']

 def _outputTweet(self, irc, msg, nick, name, text, time, tweetid):
     ret = ircutils.underline(ircutils.bold("@" + nick))
     hideName = self.registryValue('hideRealName', msg.args[0])
     if not hideName:
         ret += " ({0})".format(name)
     ret += ": {0} ({1})".format(text, ircutils.bold(time))
     if self.registryValue('addShortUrl', msg.args[0]):
         url = self._createShortUrl(nick, tweetid)
         if (url):
             ret += " {0}".format(url)
     irc.reply(ret)

    def port(self, irc, msg, args, port):
        """<port number>

        Looks up <port number> in Wikipedia's list of ports at
        https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers.
        """
        if port > 65535:
            irc.error('Port numbers cannot be greater than 65535.', Raise=True)
        if BeautifulSoup is None:
            irc.error("Beautiful Soup 4 is required for this plugin: get it"
                      " at http://www.crummy.com/software/BeautifulSoup/bs4/"
                      "doc/#installing-beautiful-soup", Raise=True)
        url = "https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers"
        fd = utils.web.getUrlFd(url)
        soup = BeautifulSoup(fd)
        if port >= 49152:
            results = ['The range 49152–65535 (2^15+2^14 to 2^16−1)—above the '
                       'registered ports—contains dynamic or private ports that '
                       'cannot be registered with IANA. This range is used for '
                       'custom or temporary purposes and for automatic '
                       'allocation of ephemeral ports.']
        else:
            results = []
            for tr in soup.find_all('tr'):
                tds = tr.find_all('td')
                if not tds:
                    continue
                portnum = tds[0].text
                if '–' in portnum:
                    startport, endport = map(int, portnum.split('–'))
                    p = range(startport, endport+1)
                else:
                    try:
                        p = [int(portnum)]
                    except ValueError:
                        continue
                if port in p:
                    text = tds[3].text
                    # Remove inline citations (text[1][2][3]), citation needed tags, etc.
                    text = re.sub('\[.*?]', '', text)

                    # List the port notes (tags such as "Official", "TCP", "UDP", etc.)
                    # This is every <td> tag except the 4th one, which is the description parsed
                    # above.
                    notes = [t.text.strip() for t in tds[:3]+tds[4:]]
                    notes = '; '.join(filter(None, notes))

                    # Remove \n, etc. in fields to prevent output corruption.
                    s = utils.str.normalizeWhitespace('%s [%s]' % (ircutils.bold(text), notes))
                    results.append(s)
        if results:
            irc.reply(format('%s: %L', ircutils.bold(ircutils.underline(port)), results))
        else:
            irc.error(_('No results found.'))

 def testStripFormatting(self):
     self.assertEqual(ircutils.stripFormatting(ircutils.bold('foo')), 'foo')
     self.assertEqual(ircutils.stripFormatting(ircutils.reverse('foo')),
                      'foo')
     self.assertEqual(ircutils.stripFormatting(ircutils.underline('foo')),
                      'foo')
     self.assertEqual(ircutils.stripFormatting('\x02bold\x0302,04foo\x03'
                                               'bar\x0f'),
                      'boldfoobar')
     s = ircutils.mircColor('[', 'blue') + ircutils.bold('09:21')
     self.assertEqual(ircutils.stripFormatting(s), '[09:21')

 def wootshirt(self, irc, msg, args):	
     """ Display daily woot.com deal."""
 
     url = "http://shirt.woot.com/salerss.aspx"
 
     dom = xml.dom.minidom.parse(urllib2.urlopen(url))
 
     product = dom.getElementsByTagName("woot:product")[0].childNodes[0].data
     price = dom.getElementsByTagName("woot:price")[0].childNodes[0].data
     purchaseurl = dom.getElementsByTagName("woot:purchaseurl")[0].childNodes[0].data
     soldout = dom.getElementsByTagName("woot:soldout")[0].childNodes[0].data # false
     shipping = dom.getElementsByTagName("woot:shipping")[0].childNodes[0].data
 
     if soldout == 'false':
         output = ircutils.mircColor("IN STOCK ", "green")
     else:
         output = ircutils.mircColor("SOLDOUT ", "red")
 
     output += ircutils.underline(ircutils.bold("ITEM:")) + " " + product + " "
     output += ircutils.underline(ircutils.bold("PRICE:")) + " " + price + " (Shipping:" + shipping + ") "
     output += ircutils.underline(ircutils.bold("URL:")) + " " + self._shortenUrl(purchaseurl) + " "
 
     irc.reply(output, prefixNick=True)

    def tennis(self, irc, msg, args, optmatch):
        """<mens|womens|mensdoubles|womensdoubles>
        Display current Tennis scores. Defaults to Men's Singles.
        """
        
        if optmatch:
            if optmatch == "womens":
                matchType = "2"
            elif optmatch == "mensdoubles":
                matchType = "3"
            elif optmatch == "womensdoubles":
                matchType = "4"
            else:
                matchType = "1"
        else:
            matchType = "1"
        
        url = 'general/tennis/dailyresults?matchType=%s' % matchType
        
        html = self._fetch(url)
        
        if html == 'None':
            irc.reply("Cannot fetch Tennis scores.")
            return
        
        soup = BeautifulSoup(html)
        tournament = soup.find('div', attrs={'class': 'sec row', 'style': 'white-space: nowrap;'})
        tournRound = soup.findAll('div', attrs={'class': 'ind sub bold'})[1] # there are two here, only display the 2nd, which is status.
        divs = soup.findAll('div', attrs={'class':re.compile('^ind$|^ind alt$')}) 

        append_list = []

        for div in divs:
            if "a href" not in div.renderContents(): # only way to get around this as the divs are not in a container.
                status = div.find('b') # find bold, which is status.
                if status:
                    status.extract() # extract so we may bold.
                
                div = div.renderContents().strip().replace('<br />',' ').replace('  ',' ')
                div = div.replace('v.',ircutils.mircColor('v.','green')).replace('d.',ircutils.mircColor('d.','red')) # colors.
                append_list.append(str(ircutils.underline(status.getText()) + " " + div.strip()))
            
        if len(append_list) > 0: # Sanity check.
            if tournament and tournRound:
                irc.reply(ircutils.mircColor(tournament.getText(), 'red') + " - " + ircutils.bold(tournRound.getText()))
                
            irc.reply(" | ".join(item for item in append_list))
        else:
            irc.reply("I did not find any active tennis matches.") 

def present_listing_first(res, original_link=False, color_score=False):
    d = res.get("data", {}).get("children", [{}])[0].get("data",{})
    if d:
        if not original_link:
            d["url"] = "http://www.reddit.com/r/%(subreddit)s/comments/%(id)s/" % d
            
        if color_score:
            score_part = "(%s/%s)[%s]" % (ircutils.mircColor("%(ups)s", "orange"),
                                          ircutils.mircColor("%(downs)s", "light blue"),
                                          ircutils.mircColor("%(num_comments)s", "dark grey"))
        else:
            score_part = "(%(score)s)"
        title_part = ircutils.bold("%(title)s")
        url_part = ircutils.underline("%(url)s")
        template = "%s \"%s\" %s" % (score_part, title_part, url_part)
        return (template % d)

 def _formatLine(self, line, channel, type):
     """Implements the 'format' configuration options."""
     format = self.registryValue('format.%s' % type, channel)
     already_colored = False
     for item in format:
         if item == 'bold':
             line = ircutils.bold(line)
         elif item == 'reverse':
             line = ircutils.reverse(line)
         elif item == 'underlined':
             line = ircutils.underline(line)
         elif already_colored:
             line = ircutils.mircColor(line, bg=item)
         elif item != '':
             line = ircutils.mircColor(line, fg=item)
     return line

    def cfbweeklyleaders(self, irc, msg, args):
        """
        Display CFB weekly leaders.
        """
        
        url = 'http://espn.go.com/college-football/weekly'

        try:
            req = urllib2.Request(url)
            html = (urllib2.urlopen(req)).read()
        except:
            irc.reply("Failed to open: %s" % url)
            return
    
        html = html.replace('tr class="evenrow', 'tr class="oddrow')

        soup = BeautifulSoup(html)
        title = soup.find('h1', attrs={'class':'h2'}) 
        tables = soup.findAll('table', attrs={'class':'tablehead'}) 

        new_data = collections.defaultdict(list)

        for table in tables:
            rows = table.findAll('tr', attrs={'class':re.compile('^oddrow.*')})[0:3] # top 3 only. List can be long. 
            for j,row in enumerate(rows): 
                stat = row.findPrevious('tr', attrs={'class':'stathead'})
                colhead = row.findPrevious('tr', attrs={'class':'colhead'}).findAll('td')
                statnames = row.findAll('td')

                del statnames[3], colhead[3] # game is always 4th. delete this. 
        
                for i,statname in enumerate(statnames):            
                    appendString = str(ircutils.bold(colhead[i].text)) + ": " + str(statname.text) # prep string to add into the list.
            
                    if i == len(statnames)-1 and not j == len(rows)-1: # last in each.
                        new_data[str(stat.getText())].append(appendString + " |")  
                    else:
                        new_data[str(stat.getText())].append(appendString)
                
        if title:
            irc.reply(ircutils.mircColor(title.getText(), 'blue'))
        
        for i,j in new_data.iteritems():
            output = "{0} :: {1}".format(ircutils.underline(i), string.join([item for item in j], " "))
            irc.reply(output)

 def slhelp(self, irc, msg, args):
     """usage: slhelp
     display the help for this module
     """
     user = irc.msg.nick
     help_content= {
         'slhelp' : 'Help for this module:',
         'sladdrent <postal code> <min surface> <max price> <min_num_room>': 'Adding a new rent search:',
         'sladdbuy <postal code> <min surface> <max price> <min_num_room>': 'Adding a new buy search:',
         'sllist': 'List your active searches:',
         'sldisable <search ID>': 'Remove the given search (use sllist to get <search ID>):',
         'slstatrent <postal code|\'all\'>': 'Print some stats about \'rent\' searches:',
         'slstatbuy <postal code|\'all\'>': 'print some stats about \'buy\'  searches:',
     }
     for cmd in help_content:
         msg = ircutils.underline(help_content[cmd])
         irc.reply(msg,to=user,private=True)
         msg = ircutils.mircColor(str(cmd), 8)
         irc.reply(msg,to=user,private=True)

    def cfbteaminfo(self, irc, msg, args, optteam):
        """[team]
        Display basic info/stats on a team
        """
        
        lookupteam = self._lookupTeam(optteam)
        
        if lookupteam == "0":
            irc.reply("I could not find a schedule for: %s" % optteam)
            return
        
        url = 'http://www.cbssports.com/collegefootball/teams/page/%s/' % lookupteam

        try:        
            req = urllib2.Request(url)
            html = (urllib2.urlopen(req)).read()
        except:
            irc.reply("Failed to open %s" % url)
            return
            
        html = html.replace('&','&').replace(';','')

        soup = BeautifulSoup(html)
        div = soup.find('div', attrs={'class':'pageTitle team'})

        name = div.find('div', attrs={'class':'name'}).find('h1')
        record = div.find('div', attrs={'class':re.compile('^record')})
        table = div.find('div', attrs={'class':'stats'}).find('table', attrs={'class':'data'})
        rows = table.findAll('tr')

        rushingOff = rows[1].findAll('td')[1]
        rushingDef = rows[1].findAll('td')[2]
        passingOff = rows[2].findAll('td')[1]
        passingDef = rows[2].findAll('td')[2]
        overallOff = rows[3].findAll('td')[1]
        overallDef = rows[3].findAll('td')[2]

        output = "{0} :: {1} - Rushing: o: {2} d: {3}  Passing: o: {4} d: {5}  Overall: o: {6} d: {7}".format(\
            ircutils.underline(name.text), record.text, rushingOff.text, rushingDef.text,\
            passingOff.text, passingDef.text, overallOff.text, overallDef.text)
            
        irc.reply(output)

    def fitocracy(self, irc, msg, args, user):
        """<ip.address>
        Use a GeoIP API to lookup the location of an IP.
        """
        irc.reply(user)
        jsonurl = "http://fitocracy-unofficial-api.herokuapp.com/user/%" % (user)

        self.log.info(jsonurl)

        try:
            request = urllib2.Request(jsonurl)
            response = urllib2.urlopen(request)
            response_data = response.read()
        except urllib2.HTTPError as err:
            if err.code == 404:
                irc.reply("Error 404")
                self.log.warning("Error 404 on: %s" % (jsonurl))
            elif err.code == 403:
                irc.reply("Error 403. Try waiting 60 minutes.")
                self.log.warning("Error 403 on: %s" % s(jsonurl))
            else:
                irc.reply("Error. Check the logs.")
            return

        try:
            jsondata = json.loads(response_data)
        except:
            irc.reply("Failed in loading JSON data for Fitocracy.")
            return

        if len(jsondata) < 1:
            irc.reply("I found no Fitocracy Data.")
            return
        name = jsondata.get("name") or "N/A"
        progress = jsondata.get("progress_text") or "N/A"
        level = jsondata.get("level", None)

        #        if user != None and city != None and region_code != None:
        output = ircutils.bold(ircutils.underline(user))
        output += " " + name + ", " + progress + " " + level

        irc.reply(output)

    def schedule(self, irc, msg, args):
        """

        """
        shows = fetch(False)
        l = []

        if shows:
            for show in shows:
                if show['show']['type'] == 'Scripted':
                    this_show = format('%s [%s] (%s)',
                            ircutils.bold(show['show']['name']),
                            str(show['season']) + 'x' + str(show['number']),
                            show['airtime'])
                    l.append(this_show)
        
        tonight_shows = ', '.join(l)

        irc.reply(format('%s: %s',
            ircutils.underline("Tonight's Shows"),
            tonight_shows))

 def _ul(self, string):
     """Returns an underline string."""
     return ircutils.underline(string)