def response(self, nick, args, kwargs): try: feed = rssparser.parse(self.rssurl) # get latest entry and their homepage url title = feed['items'][0]['title'].split() offer = ' '.join(title[:-2]) try: price = "$%.2f" % title[-1] except: price = '' longdescription = feed['items'][0]['description'] page = feed['items'][0]['link'] # strip out html longdescription = stripHTML(longdescription).strip() # these can get absurdly long if longdescription > self.max: longdescription = longdescription[:self.max-4] + ' ...' return '%s: %s\n[%s]\n%s' % (offer, price, page, longdescription) except Exception, e: log.warn('error in %s: %s' % (self.__module__, e)) log.exception(e) return "%s: Couldn't load the page woot returned D:" % nick
def response(self, nick, args, kwargs): try: feed = rssparser.parse(self.rssurl) # get latest entry and their homepage url title = feed['items'][0]['title'].split() offer = ' '.join(title[:-2]) try: price = "$%.2f" % title[-1] except: price = '' longdescription = feed['items'][0]['description'] page = feed['items'][0]['link'] # strip out html longdescription = stripHTML(longdescription).strip() # these can get absurdly long if longdescription > self.max: longdescription = longdescription[:self.max - 4] + ' ...' return '%s: %s\n[%s]\n%s' % (offer, price, page, longdescription) except Exception, e: log.warn('error in %s: %s' % (self.__module__, e)) log.exception(e) return "%s: Couldn't load the page woot returned D:" % nick
def response(self, nick, args, kwargs): query = args[0] try: check = self.clean.sub('', query) check = re.compile(check, re.I) results = [] doc = geturl(self.url) for i in self.incidents.findall(doc): data = [stripHTML(c) for c in self.data.findall(i)][1:] if len(data) != 4: continue if check.search(data[2]): results.append('=> %s: %s - %s - %s' % (data[0], data[1], data[2], data[3])) if len(results) > 0: return '\n'.join(results) else: return '%s: No incidents found' % nick except Exception, e: log.warn('error in %s: %s' % (self.__module__, e)) log.exception(e) return '%s: I failed to perform that lookup' % nick
def parse_email(self, payload): try: message = email.message_from_string(payload) for part in message.walk(): if part.get_content_maintype() == 'multipart': continue mime_type = part.get_content_type() body = part.get_payload(decode=True) if mime_type == 'text/plain': break elif mime_type == 'text/html': body = stripHTML(body) break for spam in self._spams: if spam in body: body = body.replace(spam, '') body = body.strip() cleaned = [] for line in body.splitlines(): line = line.strip() if not len(line) or line.startswith('>'): continue elif self._quoted.search(line) or line == self._sig: break else: cleaned.append(line) body = ' '.join(cleaned) except Exception, e: raise ParsingError, "couldn't parse payload: %s" % e
def response(self, nick, args, kwargs): try: try: user = args[0] except: user = None if user is None or user == '': doc = geturl(self.randomURL) user = re.search('"currentJournal": "(.*?)"', doc).group(1) url = urljoin(self.baseURL, '/users/%s/data/rss' % user) feed = rssparser.parse(url) # get latest entry and their homepage url entry = feed['items'][0]['description'] page = feed['channel']['link'] # strip out html entry = stripHTML(entry) # detect unusual amounts of high ascii, probably russian journal if isUTF8(entry): return '%s: Russian LJ :(' % nick # these can get absurdly long entry = entry[:self.max] return '%s: [%s] %s' % (nick, page, entry) except Exception, e: log.warn('error in %s: %s' % (self.__module__, e)) log.exception(e) return "%s: Couldn't load the page LJ returned D:" % nick
def response(self, nick, args, kwargs): word = args[0].lower() try: try: num = int(args[1]) except: num = 1 url = urljoin(self.base_url, word) doc = geturl(url) defs = self.re_defs.search(doc).group(1) defs = self.re_newline.sub('', defs) defs = self.re_def_break.split(defs) if len(defs) > 1: defs.pop(0) if num > len(defs): num = 1 definition = defs[num - 1] definition = stripHTML(definition) definition = self.header.sub('', definition) return '%s: [%s/%s] %s' % (nick, num, len(defs), definition) except Exception, e: log.warn('error in %s: %s' % (self.__module__, e)) log.exception(e) return "%s: I couldn't look that up for some reason. D:" % nick
def normalize(name): name = stripHTML(name) name = badchars.sub('', name) name = name.lower() name = name.strip() name = whitespace.sub(' ', name) return name
def rate_imdb(self, name): """Get user rating from IMDB""" page = geturl(self.imdb_search, {'s': 'tt', 'q': name}, referer=self.imdb_url) soup = BeautifulSoup(page) if soup.title.renderContents() == 'IMDb Title Search': main = soup.body.find('div', id='main') name = self.normalize(name) url = None for p in main('p', style=None): for row in p.table('tr'): link = row('td')[2].a if self.normalize(link.renderContents()) == name: url = urljoin(self.imdb_url, link['href']) break if url: break else: raise ValueError('no exact matches') soup = BeautifulSoup(geturl(url, referer=self.imdb_search)) try: rating = soup.body.find('div', 'meta').b.renderContents() except AttributeError: rating = 'Unrated' return stripHTML(soup.title.renderContents()), rating
def response(self, nick, args, kwargs): try: source = self.sources[args[0]] try: query = args[1] except: query = None try: num = int(query) query = None except: num = None if num: url = source.bynum.replace(u'num', unicode(num)) opts = None elif query: url = source.search opts = dict(source.opts) opts[source.query] = query else: url = source.random opts = None doc = geturl(url, opts=opts) entries = source.entries.findall(doc) if query: entries = filter(None, entries) entry = random.choice(entries) entry = stripHTML(entry).strip() return entry except Exception, error: log.warn(u'error in module %s' % self.__module__) log.exception(error) return u'%s: %s' % (nick, self._error)
def response(self, nick, args, kwargs): try: item = feedparser.parse(self.url).entries[0] body = stripHTML(item.description).strip() return u' | '.join([item.link, body, item.updated]) except Exception, error: log.warn(u'error in module %s' % self.__module__) log.exception(error) return u'%s: %s' % (nick, error)
def lookup(self, term, idx=1): """Lookup term in dictionary""" url = urljoin(self.define_url, quote(term.lower())) soup = getsoup(url, referer=self.base_url) for br in soup('br'): br.extract() val = stripHTML(soup.renderContents().decode('utf-8')) val = val.replace(u'\xa0', ' ').replace('\n', ' ') return self.whitespace_re.sub(' ', val).strip()
def normalize(name): """Normalize a movie title for easy comparison""" name = stripHTML(name) name = year.sub('', name) name = badchars.sub(' ', name) name = name.lower() name = name.strip() name = whitespace.sub(' ', name) return name
class Main(Base): def __init__(self, madcow): self.madcow = madcow self.enabled = madcow.config.twitter.enabled self.frequency = madcow.config.twitter.updatefreq self.output = madcow.config.twitter.channel self.api = twitter.Api() self.api.SetCache(None) # this fills up /tmp :( self.api.SetUserAgent( 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0)') self.api.SetCredentials(self.madcow.config.twitter.username, self.madcow.config.twitter.password) self.__updatelast() def __updatelast(self): """Updates timestamp of last update.""" self.lastupdate = time.gmtime() def __get_update_str(self): return time.strftime("%a, %d %b %Y %X GMT", self.lastupdate) def response(self, *args): """This is called by madcow, should return a string or None""" try: log.debug('getting tweets...') tweets = self.api.GetFriendsTimeline(since=self.__get_update_str()) except Exception, e: try: if e.code == 304: log.debug('no new tweets') return except: pass log.warn('error in %s: %s' % (self.__module__, e)) log.exception(e) return log.debug('found %s tweets, parsing') lines = [] for t in reversed(tweets): if time.localtime( t.GetCreatedAtInSeconds() ) < self.lastupdate: # twitter fails sometimes, so we do our own filter.. print "ignoring old tweet with timestamp %s (TWITTER SUCKS)" % t.created_at continue line = ">> tweet from %s: %s <<" % (t.user.screen_name, stripHTML(t.text)) lines.append(line) self.__updatelast() if lines: return "\n".join(lines) else: return None
def receiveMessage(self, user, multiparts, flags): req = Request(message=stripHTML(multiparts[0][0])) req.nick = user.name req.channel = 'AIM' req.private = True req.addressed = True req.aim = self log.info('[AIM] <%s> %s' % (req.nick, req.message)) self.bot.checkAddressing(req) self.bot.process_message(req)
def extract_quote(self, obj): li = obj.find(u'li') contents = li.contents contents = [unicode(part) for part in contents] quote = u' '.join(contents) quote = stripHTML(quote) quote = _linebreak.sub(u' ', quote) quote = _whitespace.sub(u' ', quote) quote = quote.strip() return quote
def response(self, nick, args, kwargs): query = args[0] try: if not query or query == 'headline': url = self._world_url else: url = self._search_url + urllib.quote(query) feed = rssparser.parse(url) item = feed['items'][0] url = item['link'] title = stripHTML(item['title']) sum = stripHTML(item['description']) return '\n'.join((url, title, sum)) except Exception, e: log.warn('error in %s: %s' % (self.__module__, e)) log.exception(e) return '%s: %s' % (nick, self._error)
def normalize(self, name): """Normalize a movie title for easy comparison""" name = stripHTML(name) name = self.year_re.sub('', name) # strip trailing year name = self.rev_article_re.sub(r'\2 \1', name) # Movie, The = The Movie name = self.articles_re.sub('', name) # strip leading the/an name = self.badchars_re.sub(' ', name) # only allow alnum name = name.lower() # lowercase only name = name.strip() # strip whitespace name = self.whitespace_re.sub(' ', name) # compress whitespace return name
def post(self, url, tags): try: html = self.ua.open(url, size=2048) title = stripHTML(self.title.search(html).group(1)) except AttributeError: title = url opts = {u'url': url, u'description': title, u'tags': u' '.join(tags), u'replace': u'no', u'shared': u'yes'} self.ua.open(self.posturl, opts=opts)
def response(self, nick, args, kwargs): try: soup = getsoup(self.spec_url % int(args[0]) if args[0] else self.rand_url) soup.find('div', id='submit').extract() post = soup.body.find('div', 'post') return u'%s: (%d) %s' % (nick, int(post.find('a', 'fmllink')['href'].split('/')[-1]), stripHTML(' '.join(link.renderContents() for link in post('a', 'fmllink')).decode('utf-8', 'ignore'))) except Exception, error: log.warn(u'error in module %s' % self.__module__) log.exception(error) return u'%s: Today I couldn\'t seem to access fmylife.com.. FML' % nick
def get_text(): page = geturl(url) soup = BeautifulSoup(page) texts = soup.body.findAll('div', 'post_content') text = random.choice(texts) text = text.renderContents() text = stripHTML(text) text = text.splitlines() text = [line.strip() for line in text] text = [line for line in text if line] text = u'\n'.join(text) return text
def response(self, nick, args, kwargs): try: opts = {'hl': 'en', 'aq': 'f', 'safe': 'off', 'q': args[0]} soup = getsoup(self.google_search, opts, referer=self.google_url) a = soup.body.find('a', 'spell') if a: res = stripHTML(a.renderContents().decode('utf-8', 'ignore')) else: res = u'spelled correctly' except Exception, error: log.warn('error in module %s' % self.__module__) log.exception(error) res = u'I had trouble with that'
def post(self, url, tags): try: html = self.ua.openurl(url, size=2048) title = stripHTML(self.title.search(html).group(1)) except: title = url opts = { 'url': url, 'description': title, 'tags': ' '.join(tags), 'replace': 'no', 'shared': 'yes', } self.ua.openurl(self.posturl, opts=opts)
def bodycount(self): try: doc = geturl(self._bodycount_url) data = self._bodycount_re.search(doc).group(1) data = data.decode('ascii', 'replace') data = stripHTML(data) data = self._re_whitespace.sub(u' ', data) data = data.strip() return data except Exception, error: log.warn(u'error in module %s' % self.__module__) log.exception(error) return u'UNKNOWN'
def bodycount(self): try: doc = geturl(IraqWar._bodycount_url) soup = BeautifulSoup(doc) data = soup.find('td', attrs={'class': 'main-num'}) data = data.find('a') data = str(data.contents[0]) data = stripHTML(data) data = IraqWar._re_whitespace.sub(' ', data) data = data.strip() return data except Exception, e: log.warn('error in %s: %s' % (self.__module__, e)) log.exception(e) return 'UNKNOWN'
def response(self, nick, args, kwargs): query = args[0] try: doc = geturl(self.passage, opts={'search': query, 'version': 31}) response = self.verse.search(doc).group(1) response = self.footnotes.sub('', response) response = self.junk_html.sub('', response) response = stripHTML(response) response = response.strip() return response[:self.max] except Exception, e: log.warn('error in %s: %s' % (self.__module__, e)) log.exception(e) return "%s: God didn't like that." % nick
def response(self, nick, args, kwargs): try: doc = geturl(self.random) soup = BeautifulSoup(doc) confs = soup.findAll('div', attrs={'class': 'content'})[3:] conf = random.choice(confs) conf = [str(p) for p in conf.findAll('p')] conf = ' '.join(conf) conf = stripHTML(conf) conf = conf.strip() return conf except Exception, e: log.warn('error in %s: %s' % (self.__module__, e)) log.exception(e) return '%s: I had some issues with that..' % nick
def response(self, nick, args, kwargs): try: doc = geturl(self.random, add_headers={'Accept': '*/*'}) soup = BeautifulSoup(doc) main = soup.find(u'div', attrs={u'id': u'main'}) confs = main.findAll(u'div', attrs={u'class': u'content'}) conf = random.choice(confs) conf = [unicode(p) for p in conf.findAll(u'p')] conf = u' '.join(conf) conf = stripHTML(conf) conf = conf.strip() return conf except Exception, error: log.warn(u'error in module %s' % self.__module__) log.exception(error) return u'%s: I had some issues with that..' % nick
def get_summary(self, query): soup, title = self.get_soup(query) # check if this is a disambiguation page, if so construct special page # there isn't a consistent style guide, so we just try to do the # most common format (ordered list of links). if this fails, return # a friendly failure for now if soup.find(u'div', attrs={u'id': u'disambig'}): try: summary = u'%s (Disambiguation) - ' % title for link in soup.find(u'ul').findAll(u'a'): title = unicode(link[u'title']).strip() if len(summary) + len(title) + 2 > self.summary_size: break if not summary.endswith(u' '): summary += u', ' summary += title except: summary = u'Fancy, unsupported disambiguation page!' return summary # massage into plain text by concatenating paragraphs content = [] for para in soup.findAll(u'p'): content.append(unicode(para)) content = u' '.join(content) # clean up rendered text content = stripHTML(content) # strip markup content = Wiki._citations.sub(u'', content) # remove citations content = Wiki._parens.sub(u'', content) # remove parentheticals content = Wiki._whitespace.sub(u' ', content) # compress whitespace content = Wiki._fix_punc.sub(r'\1', content) # fix punctuation content = content.strip() # strip whitespace # search error if title == self.error: return u'No results found for "%s"' % query # generate summary by adding as many sentences as possible before limit summary = u'%s -' % title for sentence in Wiki._sentence.findall(content): if len(summary) + 1 + len(sentence) > self.summary_size: break summary += u' %s' % sentence return summary
def response(self, nick, args, kwargs): query = args[0] try: doc = geturl(self.search, opts={u'verbose': u'on', u'name': query}) drink = self.drink.search(doc).group(1) url = urljoin(self.baseurl, drink) doc = geturl(url) title = self.title.search(doc).group(1) ingredients = self.ingredients.findall(doc) instructions = self.instructions.search(doc).group(1) response = u'%s: %s - %s - %s' % ( nick, title, u', '.join(ingredients), instructions) response = stripHTML(response) return response except Exception, error: log.warn(u'error in module %s' % self.__module__) log.exception(error) return u"%s: Something ungood happened looking that up, sry" % nick
def response(self, nick, args, kwargs): query = args[0] try: doc = geturl(self.search, opts={'verbose': 'on', 'name': query}) drink = self.drink.search(doc).group(1) url = urljoin(self.baseurl, drink) doc = geturl(url) title = self.title.search(doc).group(1) ingredients = self.ingredients.findall(doc) instructions = self.instructions.search(doc).group(1) response = '%s: %s - %s - %s' % ( nick, title, ', '.join(ingredients), instructions) response = stripHTML(response) return response except Exception, e: log.warn('error in %s: %s' % (self.__module__, e)) log.exception(e) return "%s: Something ungood happened looking that up, sry" % nick
def rate(self, movie): try: opts = dict(self.movie_opts) opts['ts'] = movie page = geturl(self.search, opts=opts) movie = normalize(movie) movies = self.result.findall(page) movies = [(path, normalize(title)) for path, title in movies] url = None for path, title in movies: if title == movie: url = urljoin(self.baseurl, path) break if not url: url = urljoin(self.baseurl, movies[0][0]) page = geturl(url, referer=self.search) try: critic_rating = self.critic_rating.search(page).group(1) critic_rating = 'Critics: ' + critic_rating + '/100' except: critic_rating = None try: user_rating = self.user_rating.search(page).group(1) user_rating = 'Users: ' + user_rating + '/10' except: user_rating = None title = html_title.search(page).group(1) title = title.replace(': Reviews', '') response = 'Meta' if normalize(title) != movie: response += ' [%s]' % stripHTML(title) ratings = [ i for i in (critic_rating, user_rating) if i is not None ] ratings = ', '.join(ratings) if ratings: response += ' - %s' % ratings return response except: return
def response(self, nick, args, kwargs): query = args[0] if query is None or query == '': url = self.random_url else: query = ' '.join(query.split()) query = query.replace(' ', '_') query = urllib.quote(query) + '.html' url = urljoin(self.baseurl, query) try: doc = geturl(url) results = self.artfart.findall(doc) result = random.choice(results) title, art = result art = stripHTML(art) return '>>> %s <<<\n%s' % (title, art) except Exception, e: log.warn('error in %s: %s' % (self.__module__, e)) log.exception(e) return "%s: I had a problem with that, sorry." % nick
def response(self, nick, args, kwargs): try: fail = BeautifulSoup(geturl(self.url)).h1 return self.spaces_re.sub( " ", stripHTML( u"%s: %s: %s %s: %s" % ( nick, self.col("red", text="FAIL"), self.fail_re.search(fail.renderContents()).group(1), self.col("green", text="FIX"), self.fail_re.search(fail.findNext("h1").renderContents()).group(1), ) ), ) except Exception, error: log.warn("error in module %s" % self.__module__) log.exception(error) return u"%s: Too much fail for technobabble" % (nick, error)
def rate_rt(self, name): """Rating from rotten tomatoes""" page = geturl(self.rt_search, {'search': name}, referer=self.rt_url) soup = BeautifulSoup(page) for table in soup.body('table'): if table.caption.renderContents() == 'Movies': break else: raise ValueError('no movies found in search results') name = self.normalize(name) for row in table.tbody('tr'): link = row.a if self.normalize(link.renderContents()) == name: url = urljoin(self.rt_url, link['href']) break else: raise ValueError('no exact matches') soup = BeautifulSoup(geturl(url, referer=self.rt_search)) info = soup.body.find('div', 'movie_info_area') return stripHTML(info.h1.renderContents()), info.a['title']
def response(self, nick, args, kwargs): query = args[0] if query is None or query == u'': url = self.random_url else: query = u' '.join(query.split()) query = query.replace(u' ', u'_') query = urllib.quote(query) + u'.html' url = urljoin(self.baseurl, query) try: doc = geturl(url) results = self.artfart.findall(doc) result = random.choice(results) title, art = result art = stripHTML(art) return u'>>> %s <<<\n%s' % (title, art) except Exception, error: log.warn(u'error in module %s' % self.__module__) log.exception(error) return u"%s: I had a problem with that, sorry." % nick
def response(self, nick, args, kwargs): try: source = self.sources[args[0]] try: query = args[1] except: query = None try: num = int(query) query = None except: num = None if num: url = source.bynum.replace('num', str(num)) elif query: url = source.search.replace('query', query) else: url = source.random doc = geturl(url) entries = source.entries.findall(doc) if query: entries = [entry for entry in entries if query in entry] if len(entries) > 1: entry = random.choice(entries) else: entry = entries[0] return stripHTML(entry) except Exception, e: log.warn('error in %s: %s' % (self.__module__, e)) log.exception(e) return '%s: %s' % (nick, self._error)
def rate(self, movie): """Get the freshness rating of a movie""" try: opts = {'sitesearch': 'rt', 'search': movie} page = geturl(self.search, opts=opts, referer=self.baseurl) movie = normalize(movie) title = html_title.search(page).group(1) if title == self.search_title: # normalize search results movies = self.movies.findall(page) movies = [(path, normalize(title)) for path, title in movies] # look for exact match url = None for path, title in movies: if title == movie: url = urljoin(self.baseurl, path) break # no exact match, take first one if not url: url = urljoin(self.baseurl, movies[0][0]) # load page page = geturl(url, referer=self.search) # find rating title = self.movie_title.search(page).group(1) rating = self.rating.search(page).group(1) # construct response response = 'Freshness' if normalize(title) != movie: response += ' [%s]' % stripHTML(title) response += ': %s' % rating return response except: return
def rate(self, movie): """Get the rating for a movie""" try: page = geturl(self.search, opts={'s': 'all', 'q': movie}) movie = normalize(movie) title = html_title.search(page).group(1) if title == self.search_title: # normalize search results movies = self.movies.findall(page) movies = [(y, z) for x, y, z in movies] movies = [(path, normalize(title)) for path, title in movies] movies = [(path, title) for path, title in movies if title] # see if we can find an exact match url = None for path, title in movies: if title == movie: url = urljoin(self.baseurl, path) break # no exact match, take first option returned if not url: url = urljoin(self.baseurl, movies[0][0]) # load actual page & title page = geturl(url, referer=self.search) title = html_title.search(page).group(1) # get rating and generate response rating = self.rating.search(page).group(1) response = 'IMDB' if normalize(title) != movie: response += ' [%s]' % stripHTML(title) response += ': %s/10' % rating return response except: return
def get_quote(self, symbol): url = Yahoo._quote_url.replace('SYMBOL', symbol) page = geturl(url) soup = BeautifulSoup(page) company = ' '.join([str(item) for item in soup.find('h1').contents]) company = stripHTML(company) tables = soup.findAll('table') table = tables[0] rows = table.findAll('tr') data = {} current_value = 0.0 open_value = 0.0 for row in rows: key, val = row.findAll('td') key = str(key.contents[0]) if key == 'Change:': try: img = val.find('img') alt = str(img['alt']) val = alt + stripHTML(str(val.contents[0])) except: val = '0.00%' elif key == 'Ask:': continue else: val = stripHTML(str(val.contents[0])) val = val.replace(',', '') if Yahoo._isfloat.search(val): val = float(val) data[key] = val if key == 'Last Trade:' or key == 'Index Value:': current_value = val elif key == 'Prev Close:': open_value = val # see if we can calculate percentage try: change = 100 * (current_value - open_value) / open_value data['Change:'] += ' (%.2f%%)' % change except: pass # try and colorize the change field try: if 'Up' in data['Change:']: data['Change:'] = self._green + data['Change:'] + self._reset elif 'Down' in data['Change:']: data['Change:'] = self._red + data['Change:'] + self._reset except: pass # build friendly output output = [] for key, val in data.items(): if isinstance(val, float): val = '%.2f' % val output.append('%s %s' % (key, val)) return '%s - ' % company + ' | '.join(output)
def forecast(self, location): page = geturl(url=self.search, opts={'query': location}, referer=self.baseurl) soup = BeautifulSoup(page) # disambiguation page if 'Search Results' in str(soup): table = soup.find('table', attrs={'class': 'boxB full'}) rows = table.findAll('tr') results = [] match = None for row in rows: cells = row.findAll('td', attrs={'class': 'sortC'}) for cell in cells: link = cell.find('a') if link is None or 'addfav' in str(link['href']): continue city = str(link.contents[0]) href = urljoin(self.baseurl, str(link['href'])) results.append(city) if city.lower() == location.lower(): match = urljoin(self.baseurl, href) break if match: break if match: page = geturl(url=match) soup = BeautifulSoup(page) else: return 'Multiple results found: %s' % ', '.join(results) rss_url = soup.find('link', attrs=self._rss_link)['href'] rss = rssparser.parse(rss_url) title = str(soup.find('h1').string).strip() conditions = stripHTML(rss['items'][0]['description']) fields = self._bar.split(conditions) data = {} for field in fields: try: key, val = self._keyval.search(field).groups() data[key] = val except: pass try: temp = float(self._tempF.search(data['Temperature']).group(1)) blink = False if temp < 0: color = 6 elif temp >=0 and temp < 40: color = 2 elif temp >= 40 and temp < 60: color = 10 elif temp >= 60 and temp < 80: color = 3 elif temp >= 80 and temp < 90: color = 7 elif temp >= 90 and temp < 100: color = 5 elif temp >= 100: color = 5 blink = True data['Temperature'] = '\x03%s\x16\x16%s\x0F' % (color, data['Temperature']) if blink: data['Temperature'] = '\x1b[5m' + data['Temperature'] + \ '\x1b[0m' except: pass output = [] for key, val in data.items(): line = '%s: %s' % (key, val) output.append(line) output = ' | '.join(output) return '%s: %s' % (title, output)