def make_rss_item(self): """ Generate PyRSS2Gen Item from the commit info """ item_title = "Revision " + self.revision item_link = url + "?rev=" + self.revision rss_item = PyRSS2Gen.RSSItem(title = item_title, link = item_link, description = self.make_rss_item_desc(), guid = PyRSS2Gen.Guid(item_link), pubDate = datetime.datetime.now()) return rss_item
def get_feed(self, num=50): api = Twitter(auth=OAuth( self.config.access_token_key, self.config.access_token_secret, self.config.consumer_key, self.config.consumer_secret)) rss = PyRSS2Gen.RSS2(self.title, self.link, self.description, lastBuildDate=datetime.datetime.now(), items=[]) if self.statuses_file: twitter_statuses = open(self.statuses_file, 'w') twitter_statuses.write('') twitter_statuses.close() twitter_statuses = open(self.statuses_file, 'a') statuses_sum = api.statuses.home_timeline(count=num) statuses_sum.sort(key=lambda tweet: tweet['created_at'], reverse=False) for tweet in statuses_sum: tweet_text = tweet['text'].replace('і', 'i').replace( 'є', 'je').replace('ї', 'ji').replace('Є', 'je').replace( 'Ї', 'ji').replace('І', 'I') item = PyRSS2Gen.RSSItem(title='@' + tweet['user']['screen_name'] + ': ' + tweet_text) tweet_url = r'https://twitter.com/' + tweet['user'][ 'screen_name'] + r'/status/' + tweet['id_str'] if tweet['in_reply_to_status_id']: tweet_replied = api.statuses.show( id=tweet['in_reply_to_status_id']) text_replied = tweet_replied['text'] item.description = str( r'In reply to: <a href=https://twitter.com/' + tweet['in_reply_to_screen_name'] + r'/status/' + tweet['in_reply_to_status_id_str'] + '>' + tweet['in_reply_to_screen_name'] + '</a>: ' + text_replied) + ' <br>The original text: ' + tweet_text else: item.description = r'<a href=' + tweet_url + '>tweet link</a><br> ' + tweet_text if tweet['entities']['urls']: item.link = tweet['entities']['urls'][0]['expanded_url'] item.guid = PyRSS2Gen.Guid(tweet_url) item.pubDate = tweet['created_at'] item.author = tweet['user']['name'] rss.items.append(item) '''if self.statuses_file: twitter_statuses.write(tweet['user']['name']) + '\n' twitter_statuses.write(tweet['text']) + '\n' ''' rss.write_xml(open(self.xml_out_file, "w"), encoding='utf-8') if self.statuses_file: twitter_statuses.close()
def generate_rss(f, e): """Generate rss""" for file in f[:10]: RSS.items.append( PyRSS2Gen.RSSItem(title=file['title'], link=BASEURL + file['url'], description=file['content'], author="Ronan", guid=PyRSS2Gen.Guid(BASEURL + file['url']), pubDate=datetime.datetime( file['year'], file['month'], file['day']))) RSS.write_xml(open(DESTINATION + "feed.xml", "w"))
def make_rss_item(system_config, page_list, item, project_url): global rss_item_list location = "{0}/post/{1}".format(project_url, item["name"]) raw_document = yield from file.async_read_file("./document/{0}.md".format( item["name"])) desc = yield from async_markdown(system_config, raw_document) rss_item_list[page_list.index(item)] = rss_item( title=item["title"], link=location, description=desc, guid=PyRSS2Gen.Guid(location), pubDate=datetime.datetime.fromtimestamp(item["time"]))
def rss_items(context, request): api = TemplateAPI(context, request) items = result_items(context, request) return [ RSS2.RSSItem( title=item.title, link=api.url(item), description=item.description, guid=RSS2.Guid(api.url(item)), pubDate=item.modification_date, ) for item in items ]
def feed(items, data=FEED_DATA): return RSS2.RSS2( **data, items = [RSS2.RSSItem( title = i['title'], link = i['link'], description = i['description'], guid = RSS2.Guid(i['guid']), enclosure = RSS2.Enclosure(url=i['file'], type='audio/mpeg', length=i['bytes']), pubDate = i['date'], ) for i in items ] )
def getProductsList(): forecast = define_source("http://www.met.ie/forecasts/") #forecast = forecast[0:1] response.headers['Content-Type'] = 'application/rss+xml' rss = PyRSS2Gen.RSS2( title = "Andrew's PyRSS2Gen feed", link = "http://www.dalkescientific.com/Python/PyRSS2Gen.html", description = "The latest news about PyRSS2Gen, a " "Python library for generating RSS2 feeds", lastBuildDate = datetime.datetime.now(), items = [ PyRSS2Gen.RSSItem( title = "PyRSS2Gen-0.0 released", link = "http://www.dalkescientific.com/news/030906-PyRSS2Gen.html", description = "Dalke Scientific today announced PyRSS2Gen-0.0, " "a library for generating RSS feeds for Python. ", guid = PyRSS2Gen.Guid("http://www.dalkescientific.com/news/" "030906-PyRSS2Gen.html"), pubDate = datetime.datetime(2003, 9, 6, 21, 31)), PyRSS2Gen.RSSItem( title = "Thoughts on RSS feeds for bioinformatics", link = "http://www.dalkescientific.com/writings/diary/" "archive/2003/09/06/RSS.html", description = "One of the reasons I wrote PyRSS2Gen was to " "experiment with RSS for data collection in " "bioinformatics. Last year I came across...", guid = PyRSS2Gen.Guid("http://www.dalkescientific.com/writings/" "diary/archive/2003/09/06/RSS.html"), pubDate = datetime.datetime(2003, 9, 6, 21, 49)), ]) #rss.write_xml(open("pyrss2gen.xml", "w")) return rss.to_xml()
def getAsRssItem(self): statinfo = os.stat(self.abs_filepath) file_length = statinfo.st_size return PyRSS2Gen.RSSItem( title=self.title, link=self.target_url, description="No Description for " + self.title, guid=PyRSS2Gen.Guid(self.target_url), pubDate=datetime.datetime.now(), enclosure=PyRSS2Gen.Enclosure(self.target_url, file_length, 'audio/mpeg'), )
def get(date): time = date.strftime('%Y-%m-%d') data = [] jsons = pool.map(lambda c: json.load(urllib.urlopen(URL.format(c, time))), ['C', 'Q', 'Hp']) t = jsons[0]['contentEntity'] data.append( gen.RSSItem(title=t['strContTitle'], author=t['strContAuthor'], description=t['strContent'], link=t['sWebLk'], pubDate=parse(t['strLastUpdateDate']), guid=gen.Guid('content' + t['strContentId']))) t = jsons[1]['questionAdEntity'] data.append( gen.RSSItem(title=t['strQuestionTitle'], author='', description=(t['strQuestionContent'] + '<br/><br/>' + t['strAnswerTitle'] + '<br/>' + t['strAnswerContent']), link=t['sWebLk'], pubDate=parse(t['strLastUpdateDate']), guid=gen.Guid('question' + t['strQuestionId']))) t = jsons[2]['hpEntity'] data.append( gen.RSSItem(title=t['strHpTitle'], author=t['strAuthor'], description=('<a href="{}"><img src="{}"></a><br/>'.format( t['strOriginalImgUrl'], t['strThumbnailUrl']) + t['strContent']), link=t['sWebLk'], pubDate=parse(t['strLastUpdateDate']), guid=gen.Guid('hp' + t['strHpId']))) return datetime.strptime(t['strMarketTime'], '%Y-%m-%d'), data
def append_rss_items(rss_feed, items): """Append items to rss feed object""" if not rssgen: return None for raw_entry in items: entry = rss_defaults.copy() entry.update(raw_entry) item = rssgen.RSSItem(title=entry["title"], link=entry["link"], description=entry["description"], guid=rssgen.Guid(entry["guid"]), pubDate=entry["publish_date"]) rss_feed.items.append(item) return rss_feed
def makerss(): lst_title = [] lst_category = [] lst_text = [] lst_url = [] lst_pubdate = [] lst_author = [] lst_reply = [] lst_recom = [] db = MySQLdb.connect(config.mysql_server, config.mysql_id, config.mysql_password, config.mysql_db, charset='utf8') curs = db.cursor(MySQLdb.cursors.DictCursor) rss = PyRSS2Gen.RSS2(title="clien_hot10", link="http://www.clien.net", description="RSS_clien_hot10", lastBuildDate=datetime.datetime.now(), items=[]) rowcount = curs.execute("""SELECT * FROM rss order by sn DESC limit 80 """) for r in curs.fetchall(): lst_title.append(r['title']) lst_category.append(r['category']) lst_text.append(r['text']) lst_url.append(r['url']) lst_pubdate.append(r['pubdate']) lst_author.append(r['author']) lst_reply.append(r['reply']) lst_recom.append(r['recom']) for i, title in enumerate(lst_title): tt = "[%s][%s]" % (str(lst_reply[i]), str(lst_recom[i])) item = PyRSS2Gen.RSSItem( title=lst_title[i] + tt, link='https://www.clien.net' + lst_url[i], guid=PyRSS2Gen.Guid('https://www.clien.net' + lst_url[i]), description=lst_text[i], # pubDate = datetime.datetime.fromtimestamp(lst_pubdate[i]), pubDate=lst_pubdate[i], author=lst_author[i]) rss.items.append(item) rss.write_xml(open(BASEPATH + 'rss_clien_hot10.htm', 'w'))
def _add_tweet(self, tweet): """Adds a Tweet. into the feed.""" text = tweet.get('text', 'Twitter without text') item = PyRSS2Gen.RSSItem(title=text, link=tweet.get('url', 'Twitter without link'), description=text, guid=PyRSS2Gen.Guid( tweet.get('guid', 'Some guid')), pubDate=tweet.get('pubDate', None), author=tweet.get('author', None)) self._rss_items.append(item)
def list_orders_feed(email): # browser hit this url, need to handle # TODO: Is this still used? # user auth for both use cases if 'Authorization' in request.headers: # FIXME: pretty sure this is gone # coming in from bulk downloader logger.info("Apparent bulk download attempt, headers: %s" % request.headers) auth_header_dec = base64.b64decode(request.headers['Authorization']) uauth = tuple(auth_header_dec.split(":")) else: if 'logged_in' not in session or session['logged_in'] is not True: return redirect(url_for('index', next=request.url)) else: uauth = (session['user'].username, session['user'].wurd) orders = api_up("/list-orders/{}".format(email), uauth=uauth, json={'status': 'complete'}) order_items = dict() for orderid in orders: item_status = api_up('/item-status/{}'.format(orderid), uauth=uauth) item_status = item_status.get(orderid, {}) item_status = map(lambda x: Scene(**x), item_status) order_info = api_up('/order/{}'.format(orderid), uauth=uauth) order_items[orderid] = dict(scenes=item_status, orderdate=order_info['order_date']) rss = PyRSS2Gen.RSS2( title='ESPA Status Feed', link='http://espa.cr.usgs.gov/ordering/status/{0}/rss/'.format(email), description='ESPA scene status for:{0}'.format(email), language='en-us', lastBuildDate=datetime.datetime.now(), items=[]) for orderid, order in order_items.items(): for scene in order['scenes']: if scene.status != 'complete': continue description = ('scene_status:{0},orderid:{1},orderdate:{2}'.format( scene.status, orderid, order['orderdate'])) new_rss_item = PyRSS2Gen.RSSItem(title=scene.name, link=scene.product_dload_url, description=description, guid=PyRSS2Gen.Guid( scene.product_dload_url)) rss.items.append(new_rss_item) return rss.to_xml(encoding='utf-8')
def build_rss(links, rssfile): rss = PyRSS2Gen.RSS2( title="brmzkw links feed", link="http://www.brmzkw.info", description="My tech readings", lastBuildDate=datetime.datetime.utcnow(), items=[ PyRSS2Gen.RSSItem(title=item['url'], link=item['url'], description=' '.join(item['keywords']), guid=PyRSS2Gen.Guid(item['url']), pubDate=datetime.datetime.strptime( item['date'], '%Y/%m/%d')) for item in links ]) rss.write_xml(rssfile)
def item_creator(new_paper): # Create RSS-items out of all new papers items = [] for paper in new_paper: heading = paper.snp + ": " + paper.title item = PyRSS2Gen.RSSItem(title=heading) description = "Written by " + paper.author + "\n" description = description + "Published in " + paper.journal + "\n" description = description + "Abstract: " + paper.abstract + "\n" description = description + "PMID: " + paper.pmid link = "http://www.ncbi.nlm.nih.gov/pubmed?term=" + paper.pmid item.description = description item.link = link item.guid = PyRSS2Gen.Guid(link) items.append(item) return items
def gen_rss(items): items_rss = [] for item in items: rss_item = PyRSS2Gen.RSSItem(title=item['full_name'], link=item['url'], description=item['des'], guid=PyRSS2Gen.Guid(item['url']), pubDate=item['update_time']) items_rss.append(rss_item) rss = PyRSS2Gen.RSS2(title="private code feed", link=code_url, description="private code feed", lastBuildDate=datetime.datetime.now(), items=items_rss) rss.write_xml(open(file_path, 'w', encoding='utf-8'), encoding='utf-8')
def __init__(self, base_url, rel_file, full_name): """ Override PyRSS2Gen.RSSItem constructor to simplify constructor args for user """ tag = TinyTag.get(rel_file) if tag.title is None: tag.title, ext = os.path.splitext(os.path.basename(rel_file)) super().__init__( title=tag.title, link=urllib.parse.quote(rel_file), author=tag.artist, enclosure=PyRSS2Gen.Enclosure(base_url + "/" + urllib.parse.quote(rel_file), tag.filesize, "audio/mpeg"), guid=PyRSS2Gen.Guid(hashlib.sha256(full_name.encode('utf-8')).hexdigest(), isPermaLink=False), pubDate=tag.year )
def pageToRSS(page,args): try: url = "https://%s/%s" % (getDomain(args),page['publishPath']) item = PyRSS2Gen.RSSItem( title = page['title'], link = url, description = page['description'], guid = PyRSS2Gen.Guid(url), pubDate = dt.datetime.combine(page['date']['original'], dt.datetime.min.time()) ) except KeyError as e: print("Error generating RSS entry for page") pp.pprint(page) raise(e) return(item)
def generate_rss(self): rss = PyRSS2Gen.RSS2(title=conf.SITE_NAME, link=conf.SITE_URL, description=conf.SITE_DESCRIPTION, lastBuildDate=datetime.datetime.utcnow(), items=[]) for i, e in enumerate(self.feed): item = PyRSS2Gen.RSSItem(title=e['title'], link=e['link'], description=e['description'], guid=PyRSS2Gen.Guid(e['link']), pubDate=datetime.datetime.fromtimestamp( e['pubDate'])) rss.items.append(item) if i == 15: break rss.write_xml(open(os.path.join(conf.OUTPUT_PATH, "feed.xml"), "w"))
def _generate_xml_rss(self): posts = [] for link, content in iter( self.content_aggregator.get_latest_posts().items()): link = "{0}/{1}".format(self.config['site']['url'], link) posts.append( PyRSS2Gen.RSSItem(title=content['page_title'], link=link, description=content['page_briefing'], guid=PyRSS2Gen.Guid(link), pubDate=content['page_date_time'])) return PyRSS2Gen.RSS2(title=self.config['site']['title'], link=self.config['site']['url'], description=self.config['site']['briefing'], lastBuildDate=datetime.now(), items=posts)
def gallery_rss(self, img_list, dest_img_list, img_titles, lang, permalink, output_path, title): """Create a RSS showing the latest images in the gallery. This doesn't use generic_rss_renderer because it doesn't involve Post objects. """ def make_url(url): return urljoin(self.site.config['BASE_URL'], url.lstrip('/')) items = [] for img, srcimg, title in list(zip( dest_img_list, img_list, img_titles))[:self.kw["feed_length"]]: img_size = os.stat( os.path.join(self.site.config['OUTPUT_FOLDER'], img)).st_size args = { 'title': title, 'link': make_url(img), 'guid': rss.Guid(img, False), 'pubDate': self.image_date(srcimg), 'enclosure': rss.Enclosure(make_url(img), img_size, mimetypes.guess_type(img)[0]), } items.append(rss.RSSItem(**args)) rss_obj = rss.RSS2(title=title, link=make_url(permalink), description='', lastBuildDate=datetime.datetime.utcnow(), items=items, generator='http://getnikola.com/', language=lang) rss_obj.rss_attrs["xmlns:dc"] = "http://purl.org/dc/elements/1.1/" rss_obj.self_url = make_url(permalink) rss_obj.rss_attrs["xmlns:atom"] = "http://www.w3.org/2005/Atom" dst_dir = os.path.dirname(output_path) utils.makedirs(dst_dir) with io.open(output_path, "w+", encoding="utf-8") as rss_file: data = rss_obj.to_xml(encoding='utf-8') if isinstance(data, utils.bytes_str): data = data.decode('utf-8') rss_file.write(data)
def getDetails(url, baseURL): page = urllib2.urlopen(url).read() soup = BeautifulSoup(page) date = soup.findAll('date')[0].text pubDate = datetime.datetime.strptime(date, "%A %B %d,%Y") img = soup.findAll('div', {'class': 'img-comic-container' })[0].find('img')['src'] results = {} results['item'] = PyRSS2Gen.RSSItem( title = 'Dilbert comic for ' + pubDate.strftime("%B %d, %Y"), description = "<a href='" + url + "'><img src='" + str(img) + "' /></a>", pubDate = pubDate, link = url, guid = PyRSS2Gen.Guid(url) ) results['prev_href'] = soup.findAll('div', {'class': re.compile('nav-left')})[0].find('a')['href'] return results
def list_orders_feed(email): # bulk downloader and the browser hit this url, need to handle # user auth for both use cases url = "/list-orders-feed/{}".format(email) if 'Authorization' in request.headers: # coming in from bulk downloader logger.info("Apparent bulk download attempt, headers: %s" % request.headers) auth_header_dec = base64.b64decode(request.headers['Authorization']) response = api_get(url, uauth=tuple(auth_header_dec.split(":"))) else: if 'logged_in' not in session or session['logged_in'] is not True: return redirect(url_for('login', next=request.url)) else: response = api_get(url) if "msg" in response: logger.info("Problem retrieving rss for email: %s \n message: %s\n" % (email, response['msg'])) status_code = 404 if "Invalid username/password" in response['msg']: status_code = 403 return jsonify(response), status_code else: rss = PyRSS2Gen.RSS2( title='ESPA Status Feed', link='http://espa.cr.usgs.gov/ordering/status/{0}/rss/'.format( email), description='ESPA scene status for:{0}'.format(email), language='en-us', lastBuildDate=datetime.datetime.now(), items=[]) for item in response: for scene in response[item]['scenes']: description = 'scene_status:{0},orderid:{1},orderdate:{2}'.format( scene['status'], item, response[item]['orderdate']) new_rss_item = PyRSS2Gen.RSSItem(title=scene['name'], link=scene['url'], description=description, guid=PyRSS2Gen.Guid( scene['url'])) rss.items.append(new_rss_item) return rss.to_xml(encoding='utf-8')
def create_rss_feed(poemlink): rss = PyRSS2Gen.RSS2( title="Jason's PF feed", link=poemlink, description="Poem of the day", lastBuildDate=datetime.now(), items=[ PyRSS2Gen.RSSItem( title=f"Poem for {date.today()}", link=poemlink, guid=PyRSS2Gen.Guid(f"Poem for {date.today()}"), pubDate=datetime.now(), ), ], ) rss.write_xml(open("poem.xml", "w"))
def create_rss(info: Program, stuff): rss = PyRSS2Gen.RSS2( title=info.name, link="http://fake-link.com", description="podcast description", lastBuildDate=datetime.now(), items=[ PyRSS2Gen.RSSItem( title=s["title"], description=s["description"], guid=PyRSS2Gen.Guid(s["audio_url"]), enclosure=PyRSS2Gen.Enclosure(s["audio_url"], 0, "audio/mpeg"), pubDate=s["date"], ) for s in stuff ], ) return rss
def feed(): prefix = '://'.join(request.urlparts[:2]) title = 'Malaysian Bill Watcher' link = prefix + '/' description = 'This is an app for Malaysian to see bill being passed by the Parliament' lastBuildDate = datetime.datetime.utcnow() session = models.DBSession() bills = (session.query(models.Bill).join( (models.Bill.bill_revs, models.BillRevision)).order_by(models.BillRevision.update_date).all()) items = [] for bill in bills[-1:-101:-1]: _rev = bill.bill_revs[0] _title = bill.long_name _description = "year: %s\n" \ "status: %s\n" \ "url: %s\n" \ "name: %s\n" \ "read_by: %s\n" \ "supported_by: %s\n" \ "date_presented: %s" % \ (_rev.year, _rev.status, _rev.url, bill.name, _rev.read_by, _rev.supported_by, _rev.date_presented) _link = prefix + '/detail/%s/' % (_rev.id) _pubDate = _rev.update_date _guid = PyRSS2Gen.Guid(_link) item = PyRSS2Gen.RSSItem(title=_title, description=_description, link=_link, guid=_guid, pubDate=_pubDate) items.append(item) rss = PyRSS2Gen.RSS2(title=title, link=link, description=description, items=items) output = cStringIO.StringIO() rss.write_xml(output) response.content_type = 'application/rss+xml' return output.getvalue()
def create_feed(feed_info, output_stream, encoding=DEFAULT_ENCODING, max_threads=DEFAULT_MAX_THREADS): logger.info("Creating feed \"" + feed_info['title'] + "\".") result_feed = [] with concurrent.futures.ThreadPoolExecutor( max_workers=max_threads) as executor: future = executor.map(fetch_feed, feed_info['feeds']) for feed in future: result_feed.extend(feed) # Sorting (just to be sure) result_feed = sorted(result_feed, key=lambda k: k['published_parsed'], reverse=True) # Truncating del result_feed[feed_info['size']:] # Creating the feed rss_items = [] for item in result_feed: rss_items.append( PyRSS2Gen.RSSItem( title=item['title'], link=item['link'], description=item['summary'], guid=PyRSS2Gen.Guid(item['link']), pubDate=format_date(item['published_parsed']), )) rss = PyRSS2Gen.RSS2(title=feed_info['title'], link=feed_info['link'], description=feed_info['summary'], lastBuildDate=now, items=rss_items) logger.info("Writing to stream (encoding: %s)..." % encoding) if encoding is DEFAULT_ENCODING: rss.write_xml(output_stream, encoding) else: xml = rss.to_xml(encoding=DEFAULT_ENCODING) output_stream.write(xml.encode(DEFAULT_ENCODING).decode(encoding))
def generate_feed_items(self): self.cursor.execute( "select * from posts order by timestamp desc limit 10") from_db = self.cursor.fetchall() posts = list() files = list() for (id_, text, enclosure_url, enclosure_media_type, timestamp) in from_db: post = RSS2.RSSItem( title=text, description=text, link=self.base_url + "%s.html" % id_, guid=RSS2.Guid(self.base_url + "%s.html" % id_), pubDate=formatdate( totimestamp(dateutil.parser.parse(timestamp)))) if enclosure_url is not None: post.enclosure = RSS2.Enclosure(url=enclosure_url, type=enclosure_media_type, length=0) posts.append(post) html_output = Template(self.template).render( rss_title=self.title, rss_link=self.link, rss_description=self.description, rss_feed_link=self.base_url + self.rss_filename, post_title=text, post_description=text, post_timestamp=timestamp, post_id=id_, enclosure_url=enclosure_url, enclosure_media_type=enclosure_media_type) html_fname = os.path.join(self.output_dir, "%s.html" % id_) with open(html_fname, "wb") as fh: fh.write(html_output) files.append(html_fname) rss = RSS2.RSS2(title=self.title, link=self.link, description=self.description, lastBuildDate=datetime.datetime.utcnow(), items=posts) rss_fname = os.path.join(self.output_dir, self.rss_filename) rss.write_xml(open(rss_fname, "wb")) files.append(rss_fname) return files
def users_rss_private(user_hash): import datetime import PyRSS2Gen as RSS2 parts = user_hash.split('_') if (len(parts) > 0): user_id = parts[0] rss_hash = parts[1] try: user = User.objects(id=user_id)[0] except IndexError: return 'Wrong hash!' else: # Check rss hash if (user.rss_hash() == rss_hash): notes = Note.objects(user=user).order_by('-created_at')[:20] notes_items = [] for note in notes: notes_items.append( RSS2.RSSItem( title=note.title, link=note.get_url_rss(), description=note.get_dropbox_content(), guid=RSS2.Guid("http://jabjot.com/notes/" + str(note.id)), pubDate=note.created_at)) rss = RSS2.RSS2( title=user.username + "'s private notes feed - jabjot", link="http://jabjot.com/user/rss/private/" + str(user.id) + '_' + user.rss_hash(), description=user.username + "'s latest notes.", lastBuildDate=datetime.datetime.utcnow(), items=notes_items) return rss.to_xml(encoding='utf-8') else: return 'Wrong hash!' else: return 'Wrong hash!'
def generate_rss(articles): """Generates RSS feed of Blog Articles.""" rss_items = [] for article in articles: article_link = BLOG_URL + article['html_file'] rss_items.append( PyRSS2Gen.RSSItem(title=article['friendly_name'], link=article_link, guid=PyRSS2Gen.Guid(article_link), pubDate=get_article_ts(article['html_file']))) rss = PyRSS2Gen.RSS2(title=BLOG_TITLE, description=BLOG_DESCRIPTION, link=BLOG_URL, lastBuildDate=datetime.datetime.utcnow(), items=rss_items) rss.write_xml(open('index.xml', 'w'))