def fetch(): allheadlines = [] newsurls = { 'googlenews': 'https://www.nasa.gov/rss/dyn/lg_image_of_the_day.rss', } for key, url in newsurls.items(): allheadlines.extend(getHeadlines(url)) rss = PyRSS2Gen.RSS2( title='తెలుగులో నాసా ఇమేజ్ ఆఫ్ ది డే', link='https://www.nasa.gov/rss/dyn/lg_image_of_the_day.rss', description='తాజా నాసా ఇమేజ్ ఆఫ్ ది డే చిత్రం తెలుగులో', language='te-ind', items=[], ) for hl in allheadlines: rss.items.append( PyRSS2Gen.RSSItem( title=hl[1], link=hl[0], description=hl[2], enclosure=PyRSS2Gen.Enclosure(url=hl[3], length=hl[4], type=hl[5]), pubDate=hl[6], )) # rss.write_xml(open("తెలుగులో నాసా ఇమేజ్ ఆఫ్ ది డే.xml", "w", encoding="utf-16")) soup = BeautifulSoup(rss.to_xml(encoding="utf-16"), 'lxml') return soup.prettify()
def buildFeed(entries,output): entries.sort(key = lambda t:t[3],reverse=True) items = [] for e in entries: items.append(PyRSS2Gen.RSSItem( title = e[0], link = e[1], pubDate=e[3], enclosure = PyRSS2Gen.Enclosure(e[1],0, "video/mp4"), description = e[2] )) rss = PyRSS2Gen.RSS2( title='Daly News Dump', link='http://newspodcast.github.io/newspodcast/podcast.xml', description = 'Get your daly news!', lastBuildDate = datetime.datetime.now(), image=PyRSS2Gen.Image("http://icons.iconarchive.com/icons/pelfusion/long-shadow-ios7/1024/News-icon.png", "Logo", "http://icons.iconarchive.com/icons/pelfusion/long-shadow-ios7/1024/News-icon.png", 1024, 1024, "awsome logo"), pubDate = datetime.datetime.now(), items = items ) rss.write_xml(open(output, "w")) f = open(output,"r") xml = xl.parse(f) result = xml.toprettyxml() f.close() with open(output,"wb") as f: f.write(result.encode("utf-8"))
def get(self, request): items = [] blogs = Blog.objects.filter(page_type=Blog.BLOG).order_by('-pub_date') imageType = ContentType.objects.filter( type_name=ContentType.IMAGE_TYPE).first() for blog in blogs: img = blog.contents.filter(content_type_id=imageType.id).first() item = PyRSS2Gen.RSSItem( title=blog.blog_title, link=blog.guid, author="[email protected] (Maria)", pubDate=blog.pub_date, guid=PyRSS2Gen.Guid(blog.guid), ) if img != None: item.enclosure = PyRSS2Gen.Enclosure( url="http://designminted.com/get-img/{0}/".format(img.id), length=len(img.content_data), type=img.file_extension, ) items.append(item) rss = MyRSS2.MyRSS2( title="Design Minted, LLC", link="http://designminted.com", description= "Maria from Design Minted, LLC's interior decorating blog", lastBuildDate=datetime.datetime.now(), items=items, ) rss.rss_attrs['xmlns:atom'] = "http://www.w3.org/2005/Atom" return HttpResponse(rss.to_xml(), content_type="application/rss+xml")
def rssitems(self, n=10): result = [] for file in self.data: try: rssitem = ItunesRSSItem( title=file.title, link=file.link if 'link' in file.__dict__ else 'http://www.podcast.de/', author=file.artist, description=file.description, pubDate=file.pubdate, guid=PyRSS2Gen.Guid(file.url), enclosure=PyRSS2Gen.Enclosure( file.url, file.filesize, "audio/mpeg" ) ) rssitem.image = self._create_image_tag(rssitem) rssitem.duration = str(dt.timedelta(seconds=file.playtime)) result.append(rssitem) except AttributeError as e: raise RuntimeError("{}: {}".format(file.basename, e.message)) waste = [(i.pubDate, i) for i in result] waste.sort() waste.reverse() waste = waste[:n] result = [pair[1] for pair in waste] self.log.debug(u' rssitems: Found %d items' % len(result)) return result
def feed_latest(request): entry = EntryDetail() entries = entry.get_queryset().filter( status=PUBLISHED).order_by('-creation_date')[:50] for entry in entries: if entry.entry_type == TYPE_ANNOUNCEMENT: url = entry.get_absolute_url().replace('/blog/', '/announcement/') entry.urls = url else: entry.urls = entry.get_absolute_url() items = [] for entry in entries: link = "%s%s" % (settings.BASE_URL, entry.urls) enclosure = None if entry.image: enclosure = PyRSS2Gen.Enclosure(entry.image.url, 1024, 'image/jpeg') item = PyRSS2Gen.RSSItem(title=entry.title, link=link, guid=PyRSS2Gen.Guid(link), enclosure=enclosure, pubDate=entry.creation_date) items.append(item) rss = PyRSS2Gen.RSS2(title='newtonproject.org', link="%s/feed/" % settings.BASE_URL, description="newtonproject", lastBuildDate=datetime.datetime.now(), docs='%s/about/' % settings.BASE_URL, items=items) rss.rss_attrs['xmlns:atom'] = 'http://www.w3.org/2005/Atom' xml = rss.to_xml(encoding='UTF-8') return HttpResponse(xml, mimetype='application/rss+xml;charset=utf-8')
def process_ep(self, ep): for ext in self.options.upload_formats: fullpathname = os.path.join(self.show_dir, ext, ep.slug + "." + ext) if os.path.exists(fullpathname): # this should be ep.some_url but oh well. url = '{base}/{year}/{show}/{ext}/{slug}.{ext}'.format( base=self.options.base_url, year=ep.start.year, show=ep.show.slug, slug=ep.slug, ext=ext) info = PyRSS2Gen.RSSItem( title=ep.name, description=ep.description, guid=PyRSS2Gen.Guid(ep.conf_url), pubDate=ep.start, link=ep.conf_url, enclosure=PyRSS2Gen.Enclosure( url=url, length=os.stat(fullpathname).st_size, type='video/' + ext, )) self.items.append(info)
def make_video_rss(fh, eps): items = [] for ep in eps: info = PyRSS2Gen.RSSItem( title=ep.name, description=ep.description, guid=PyRSS2Gen.Guid(ep.conf_url), pubDate=ep.end, link=ep.conf_url, enclosure=PyRSS2Gen.Enclosure( url= 'http://meetings-archive.debian.net/pub/debian-meetings/%s/%s/%s.webm' % (ep.end.year, ep.show.slug, ep.slug), length=os.stat( '/home/veyepar/Videos/veyepar/%s/%s/webm/%s.webm' % (ep.show.client.slug, ep.show.slug, ep.slug)).st_size, type='video/webm', )) items.append(info) rss = PyRSS2Gen.RSS2(title="Debconf 16 video RSS feed", link="https://debconf16.debconf.org", description="The published videos from Debconf 16", lastBuildDate=datetime.datetime.now(), items=items) rss.write_xml(fh, encoding='UTF-8')
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('/')) all_data = list(zip(img_list, dest_img_list, img_titles)) if self.kw['sort_by_date']: all_data.sort(key=lambda a: self.image_date(a[0])) else: # Sort by name all_data.sort(key=lambda a: a[0]) if all_data: img_list, dest_img_list, img_titles = zip(*all_data) else: img_list, dest_img_list, img_titles = [], [], [] 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='https://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 enclosure(entry): return next( PyRSS2Gen.Enclosure( url = link.href, length = link.length, type = link.type ) for link in entry.links if link.rel == 'enclosure' )
def setup_podcast(self, url): assert httpretty.is_enabled() items = [PyRSS2Gen.RSSItem( title='Episode %d' % n, enclosure=PyRSS2Gen.Enclosure('http://example.com/%d.mp3' % n, 42, 'audio/mpeg' ) ) for n in [1, 2, 3]] items.append(PyRSS2Gen.RSSItem(title='Not an episode')) rss = PyRSS2Gen.RSS2('title', 'link', 'description', items=items) httpretty.register_uri(httpretty.GET, url, body=rss.to_xml())
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 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 __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 gallery_rss(self, 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) items = [] for img, full_title in list(zip(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': full_title.split('"')[-2] if full_title else '', 'link': make_url(img), 'guid': rss.Guid(img, False), 'pubDate': self.image_date(img), 'enclosure': rss.Enclosure(make_url(img), img_size, mimetypes.guess_type(img)[0]), } items.append(rss.RSSItem(**args)) rss_obj = utils.ExtendedRSS2( title=title, link=make_url(permalink), description='', lastBuildDate=datetime.datetime.now(), items=items, generator='Nikola <http://getnikola.com/>', language=lang) 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 codecs.open(output_path, "wb+", "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 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 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
print(listDir) lm = list( map(lambda x: list(map(lambda k: x + '/' + k, os.listdir(x))), listDir)) print("lm:{}\n *********************".format(lm)) listDir = reduce(lambda x, y: x + y, lm) files = list( filter( lambda x: path.splitext(x)[ 1] in [".MP3", ".mp3", ".M4V", ".m4v", '.mp4', ".MP4", ".mov"], listDir + os.listdir(dir))) files.sort(key=_cmp) myItems = [ (rss.RSSItem(title=n, description='', enclosure=rss.Enclosure(url + ':' + str(port) + '/' + esc(n), 0, "audio/mpeg"))) for n in files ] myItems.reverse() feed = rss.RSS2(title=path.basename(path.abspath(dir)), link="http://unnotigkeit.ya.ru", description="", lastBuildDate=datetime.datetime.now(), items=myItems) feed.write_xml( open((dir + '/' + path.basename(path.abspath(dir)) + ".xml"), "w"), "utf-8") print(url + ':' + str(port) + '/' + esc(path.basename(path.abspath(dir))) + ".xml") import http.server
if not (x == y): raise AssertionError( (x, y) ) class RecordingHandler: def __init__(self): self.events = [] def startElement(self, tag, d): self.events.append( ("SE", tag, d) ) def characters(self, text): self.events.append( ("C", text) ) def endElement(self, tag): self.events.append( ("EE", tag) ) def publish_it(obj): h = RecordingHandler() obj.publish(h) return h.events obj = PyRSS2Gen.Enclosure("http://example.com", 5, "text/plain") EQ(publish_it(obj), [("SE", "enclosure", {"url": "http://example.com", "length": "5", "type": "text/plain"}), ("EE", "enclosure"), ]) obj = PyRSS2Gen.Guid("ABCDEF", False) EQ(publish_it(obj), [("SE", "guid", {"isPermaLink": "false"}), ("C", "ABCDEF"), ("EE", "guid"), ])
import PyRSS2Gen as RSS2 import feedparser import re # dan lebatard, Best of and Local shows infeed = 'http://espn.go.com/espnradio/podcast/feeds/itunes/podCast?id=9941853' outfeed = 'rss.xml' pattern = 'Best|Local' d = feedparser.parse(infeed) rss = RSS2.RSS2(title=d.feed['title'], link=d.feed['links'][0]['href'], description=d.feed['summary'], items=[ RSS2.RSSItem( title=post['title'], link=post['link'], description=post['summary'], pubDate=post['published'], enclosure=RSS2.Enclosure(post['links'][1]['href'], post['links'][1]['length'], post['links'][1]['type']), ) for post in d.entries if re.search(pattern, post.title) ]) rss.write_xml(open(outfeed, "w"))
def generateRSS( rootNode, indent=2 ): """Generate an OPML/XML tree from OutlineNode rootNode. parameters: filepath - unused since file writing has been factored out indent - if > 0 indent with indent spaces per level return etree.Element of rootNode """ valid_RSSChannel = ( "title", "link", "description", "language", "copyright", "managingEditor", "webMaster", "pubDate", "lastBuildDate", "categories", "generator", "docs", "cloud", "ttl", "image", "rating", "textInput", "skipHours", "skipDays", "items") valid_RSSItems = ( "title", "link", "description", "author", "categories", "comments", "enclosure", "guid", "pubDate", "source" ) backTranslator = { 'subtitle': 'description', 'title': 'title', 'published': 'pubDate', 'id': 'guid' } now = str(datetime.datetime.now()) now = now[:19] now = now.replace(" ", "_") # unused creator = CactusVersion.document_creator + " on %s." % (now,) # defaults head_d = { 'title': "No Channel Title", 'description': "No Channel description.", 'link': ""} headOP = rootNode.findFirstChildWithName_( "head" ) if headOP: for headsub in headOP.children: name = headsub.name name = backTranslator.get(name, name) if name in valid_RSSChannel: value = headsub.getValueDict() if name == 'cloud': cloud = PyRSS2Gen.Cloud( value.get('domain', ""), value.get('port', ""), value.get('path', ""), value.get('registerProcedure', ""), value.get('protocol', "")) head_d[ 'cloud' ] = cloud elif name == 'image': image = PyRSS2Gen.Image( value.get('href', ""), value.get('title', ""), value.get('link', ""), value.get('width', None), value.get('height', None), value.get('description', None)) head_d[ 'image' ] = image else: if len(value) == 1: head_d[name] = value.values()[0] else: head_d[name] = value print "HEAD:" pp(head_d) body_l = [] bodyOP = rootNode.findFirstChildWithName_( "body" ) if bodyOP: for bodysub in bodyOP.children: name = bodysub.name value = bodysub.getValueDict() d = {'title': "No Item Title", 'description': "No Item description."} for key in value: v = value[key] k = backTranslator.get(key, key) if k == "summary": k = "description" if k in valid_RSSItems: if k == 'enclosure': url, rest = value[key].split('<<<') length, type_ = rest.split(';', 1) try: length = int(length) except ValueError, err: if kwlog: print "BOGUS ENCLOSURE LENGTH: %s" % repr(length) length = 0 enc = PyRSS2Gen.Enclosure( url, length, type_) d[k] = enc else: # TODO: check for type here; dicts and lists may be bad d[ k ] = v #value[key] if type(d[ k ]) in (list, dict, tuple): print "\ngenerateRSS() type error.\n" #print "ITEM:" #pp( d ) body_l.append( PyRSS2Gen.RSSItem( **d ) )
youtube_description = youtube_info['description'] if not youtube_description: youtube_description = "" if len(youtube_description) > 0 and youtube_description[-1] != ' ': youtube_description = youtube_description + ' ' item_dict['description'] = conf['video_description'].format( youtube_description=youtube_description.encode('utf-8'), video_location=(" / ".join(description)).encode('utf-8'), pretty_length=pretty_length.encode('utf-8'), duration=youtube_info['duration_str'].encode('utf-8'), **conf) item_dict['enclosure'] = PyRSS2Gen.Enclosure(url=urlparse.urljoin( conf['url_base'], base_filename), length=length, type=conf['mimetype']) items.append(PyRSS2Gen.RSSItem(**item_dict)) if conf["reverse"]: items.reverse() rss = PyRSS2Gen.RSS2(title=conf["podcast_title"].format(**conf), link=args.course_url, description=conf["podcast_description"].format(**conf), lastBuildDate=datetime.datetime.now(), items=items, managingEditor="edX Learning Sciences") ## Write output to a file data = StringIO.StringIO()
br.set_handle_refresh(mechanize._http.HTTPRefreshProcessor(), max_time=1) res = br.open(podbean_feed_url) soup = BeautifulSoup(res.read(), features='html5lib') posts = soup.find_all('div', attrs={'class': 'post'}) podcast_feed = [] for post in posts: if post.find('div', attrs={'class': 'premium-btn-block'}): post_title = filter(lambda x: x in string.printable, ''.join(post.find('h2').string)) post_date = post.find('p', attrs={'class': 'post-info'}).get_text() post_date = parse(post_date, fuzzy=True) post_audio = PyRSS2Gen.Enclosure(post.find('div', attrs={'class': 'pbplayerBox theme13'})['data-uri'], '300000000', 'audio/mpeg') post_permlink = post.find_all('a', href=True)[0]['href'] post_soup = BeautifulSoup(br.open(post_permlink).read(), features='html5lib') post_description_html = post_soup.find('div', attrs={'class': 'entry'}) post_description_html.find(('div'), attrs={'class': 'podPress_content'}).decompose() post_description = bleach.clean(str(post_description_html), tags=['a', 'abbr', 'acronym', 'b', 'blockquote', 'code', 'em', 'i', 'li', 'ol', 'strong', 'ul', 'p'], strip=True).strip() podcast_feed.append((post_title, post_audio, post_description, post_date, post_permlink)) rss = PyRSS2Gen.RSS2( title='Unofficial Zomia ONE Premium Feed',
upload_date = info["upload_date"] or "00000000" thumbnail_url = info["thumbnail"] or "https://i.ytimg.com/vi/%s/hqdefault.jpg" % info["id"] episodes.append(PyRSS2Gen.RSSItem( title = title, link = orig_url, description = "<p>%s • %s.%s.%s</p> <p><a href=\"%s\"><img src=\"%s\"></a></p>" % ( html.escape(author), upload_date[6:8], upload_date[4:6], upload_date[0:4], html.escape(orig_url), html.escape(thumbnail_url) ), author = author, enclosure = PyRSS2Gen.Enclosure( url = URL + "/" + mp3_name, type = "audio/mpeg", length = 0 ), guid = orig_url, pubDate = info_time )) print("Episode: " + title) rss = PyRSS2Gen.RSS2( title = "YouTube", link = "", description = "", image = PyRSS2Gen.Image( url = "https://via.placeholder.com/720/272727/f00?text=YT", title = "YouTube",
response = urllib.request.urlopen(request) list_page = response.read().decode("utf-8") page_json = json.loads(list_page) programs = page_json["programs"] item_list = [] for program in programs: temp_item = PyRSS2Gen.RSSItem( title = program["name"], link = program_url+str(program["id"]), description = program["description"], pubDate = datetime.datetime.fromtimestamp(int(int(program["createTime"])/1000)), guid = "netease_"+str(program["id"]), enclosure = PyRSS2Gen.Enclosure( url = audio_url+str(program["mainSong"]["id"])+".mp3", length = program["mainSong"]["bMusic"]["size"], type = "audio/mpeg" ) ) item_list.append(temp_item); rss = PyRSS2Gen.RSS2( title = info["name"], link = radio_url+radio_id, description = info["desc"], language = "zh_CN", image = PyRSS2Gen.Image( url = info["picUrl"], title = info["name"], link = radio_url+radio_id ),
def ReadFromTextFile(self, txtFileName): if not os.path.lexists(txtFileName): print "WARNING: Item text file does not exist. Empty Item created." return fileLines = file(txtFileName, 'r').readlines() # Process each line in the data file lineNum = 0 for line in fileLines: lineNum = lineNum + 1 try: lineList = [x.strip() for x in line.split("=", 1)] # Skip comment and blank lines if (lineList[0].startswith("#") or (lineList[0] == "")): continue # Detect badly formed item lines if (lineList[1] == ''): raise Exception, "no valid 'name = value' pair" # GIUD element if lineList[0] == 'guid': self.guid = PyRSS2Gen.Guid(lineList[1]) # ENCLOSURE element elif lineList[0] == 'enclosure': if self.enclosureList is None: self.enclosureList = [] s = [x.strip() for x in lineList[1].split(",")] self.enclosureList.append( PyRSS2Gen.Enclosure(s[0], int(s[1]), s[2])) # CUSTOMELEMENT element # These elements may vary based on the 'type' defined in the config # file, so this may be a bit tricky... elif lineList[0] == 'customElement': # Create self.customElementList if necessary. Should be since we're # reading from a file... if self.customElementList is None: self.customElementList = [] # Tease out element name (name, value) = [x.strip() for x in lineList[1].split(",", 1)] # If we know the parent feed, we understand the types of the # custom elements... if self.parentFeed is not None: type = self.parentFeed.customEltDefNameHash[name].type # If the type is a complex type, we need to build a value object # and pass it along so that custom XML publish methods can be called if (type == 'point'): (lat, lon) = [x.strip() for x in value.split(",")] value = cePoint(float(lat), float(lon)) elif (type == 'envelope'): ### FIXME - future support for georss envelope custom element pass # Single value types are just passed along to be included as # strings in the XML self.customElementList.append(CustomElement(name, value)) # Extents element elif lineList[0] == 'extents': s = lineList[1].split(",") self.extents = Extents(float(s[0]), float(s[1]), float(s[2]), float(s[3])) # ExtentsPoly element elif lineList[0] == 'extentsPoly': s = lineList[1].split(",") if (len(s) / 2 == len(s) / 2.0): listLatLon = [(float(s[i]), float(s[i + 1])) for i in range(0, len(s), 2)] if self.simplifyPologons: self.extents = ExtentsPoly(listLatLon, self.simplifyPolygons, self.polyDistThresh, self.polyMaxPoints) else: self.extents = ExtentsPoly(listLatLon, simplifyPolygons=False) # All datetime object elements elif ((lineList[0] == 'acquisitionStartDate') or (lineList[0] == 'acquisitionEndDate') or (lineList[0] == 'acquisitionStartTime') or (lineList[0] == 'acquisitionEndTime') or (lineList[0] == 'pubDate')): s = [int(x.strip()) for x in lineList[1].split(":")] dtEvalStr = ("datetime.datetime(" + ", ".join([str(x) for x in s]) + ")") # We are standardizing on Date, not Time special case patch (YUCK) if ((lineList[0] == 'acquisitionStartTime') or (lineList[0] == 'acquisitionEndTime')): lineList[0] = lineList[0].replace('Time', 'Date') # Write it into the Dictionary... self.__dict__[lineList[0]] = eval(dtEvalStr) # All other simple single string elements else: self.__dict__[lineList[0]] = lineList[1] except Exception, inst: print "WARNING: Badly formed Item text file line..." print " Exception: %s" % inst print " %d: %s" % (lineNum, line.strip()) print " Line skipped."
def on_task_exit(self, task, config): """Store finished / downloaded entries at exit""" if not rss2gen: raise plugin.PluginWarning( 'plugin make_rss requires PyRSS2Gen library.') config = self.prepare_config(config) # when history is disabled, remove everything from backlog on every run (a bit hackish, rarely useful) if not config['history']: log.debug('disabling history') for item in task.session.query(RSSEntry).filter( RSSEntry.file == config['file']).all(): task.session.delete(item) # save entries into db for RSS generation for entry in task.accepted: rss = RSSEntry() try: rss.title = entry.render(config['title']) except RenderError as e: log.error( 'Error rendering jinja title for `%s` falling back to entry title: %s', entry['title'], e, ) rss.title = entry['title'] for field in config['link']: if field in entry: rss.link = entry[field] break try: template = get_template(config['template'], scope='task') except ValueError as e: raise plugin.PluginError('Invalid template specified: %s' % e) try: rss.description = render_from_entry(template, entry) except RenderError as e: log.error( 'Error while rendering entry %s, falling back to plain title: %s', entry, e) rss.description = entry['title'] + ' - (Render Error)' rss.file = config['file'] if 'rss_pubdate' in entry: rss.published = entry['rss_pubdate'] rss.enc_length = entry['size'] if 'size' in entry else None rss.enc_type = entry['type'] if 'type' in entry else None # TODO: check if this exists and suggest disabling history if it does since it shouldn't happen normally ... log.debug('Saving %s into rss database', entry['title']) task.session.add(rss) if not rss2gen: return # don't generate rss when learning if task.options.learn: return db_items = (task.session.query(RSSEntry).filter( RSSEntry.file == config['file']).order_by( RSSEntry.published.desc()).all()) # make items rss_items = [] for db_item in db_items: add = True if config['items'] != -1: if len(rss_items) > config['items']: add = False if config['days'] != -1: if (datetime.datetime.today() - datetime.timedelta(days=config['days']) > db_item.published): add = False if add: # add into generated feed hasher = hashlib.sha1() hasher.update(db_item.title.encode('utf8')) hasher.update(db_item.description.encode('utf8')) hasher.update(db_item.link.encode('utf8')) guid = base64.urlsafe_b64encode( hasher.digest()).decode('ascii') guid = PyRSS2Gen.Guid(guid, isPermaLink=False) gen = { 'title': db_item.title, 'description': db_item.description, 'link': db_item.link, 'pubDate': db_item.published, 'guid': guid, } if db_item.enc_length is not None and db_item.enc_type is not None: gen['enclosure'] = PyRSS2Gen.Enclosure( db_item.link, db_item.enc_length, db_item.enc_type) log.trace('Adding %s into rss %s', gen['title'], config['file']) rss_items.append(PyRSS2Gen.RSSItem(**gen)) else: # no longer needed task.session.delete(db_item) # make rss rss = PyRSS2Gen.RSS2( title=config.get('rsstitle', 'FlexGet'), link=config.get('rsslink', 'http://flexget.com'), description=config.get('rssdesc', 'FlexGet generated RSS feed'), lastBuildDate=datetime.datetime.utcnow() if config['timestamp'] else None, items=rss_items, ) # don't run with --test if task.options.test: log.info('Would write rss file with %d entries.', len(rss_items)) return # write rss fn = os.path.expanduser(config['file']) with io.open(fn, 'wb') as file: try: log.verbose('Writing output rss to %s', fn) rss.write_xml(file, encoding=config['encoding']) except LookupError: log.critical('Unknown encoding %s', config['encoding']) return except IOError: # TODO: plugins cannot raise PluginWarnings in terminate event .. log.critical('Unable to write %s', fn) return