class TestExtensionSyndication(unittest.TestCase):
SYN_NS = {'sy': 'http://purl.org/rss/1.0/modules/syndication/'}
def setUp(self):
self.fg = FeedGenerator()
self.fg.load_extension('syndication')
self.fg.title('title')
self.fg.link(href='http://example.com', rel='self')
self.fg.description('description')
def test_update_period(self):
for period_type in ('hourly', 'daily', 'weekly', 'monthly', 'yearly'):
self.fg.syndication.update_period(period_type)
root = etree.fromstring(self.fg.rss_str())
a = root.xpath('/rss/channel/sy:UpdatePeriod',
namespaces=self.SYN_NS)
assert a[0].text == period_type
def test_update_frequency(self):
for frequency in (1, 100, 2000, 100000):
self.fg.syndication.update_frequency(frequency)
root = etree.fromstring(self.fg.rss_str())
a = root.xpath('/rss/channel/sy:UpdateFrequency',
namespaces=self.SYN_NS)
assert a[0].text == str(frequency)
def test_update_base(self):
base = '2000-01-01T12:00+00:00'
self.fg.syndication.update_base(base)
root = etree.fromstring(self.fg.rss_str())
a = root.xpath('/rss/channel/sy:UpdateBase', namespaces=self.SYN_NS)
assert a[0].text == base
def export_feed(self, output):
fg = FeedGenerator()
fg.load_extension('podcast')
fg.podcast.itunes_category('Religion & Spirituality', 'Christianity')
fg.podcast.itunes_image("%s/icon.png" % URL_BASE)
fg.title('JW.ORG Magazines')
fg.description('Combined Feed of Watchtower (public), Watchtower (study), and Awake! in English from jw.org.')
fg.link(href="%s/%s" % (URL_BASE, output), rel='self')
manifest = self._load()
entries = []
for lang, mnemonics in manifest.items():
for mnemonic, issues in mnemonics.items():
for issue, data in issues.items():
entries.append((issue, data))
for issue, entry in sorted(entries, key=lambda i: i[0], reverse=True):
fe = fg.add_entry()
fe.id( entry['hash'] )
fe.title( entry['title'] )
fe.description( entry['title'] )
fe.published( pytz.utc.localize( entry['created_on'] ) )
url = "%s/%s" % (URL_BASE, os.path.basename(entry['file']))
mime = 'audio/mpeg'
fe.enclosure(url, str(entry['duration']), mime)
fe.link(href=url, type=mime)
fg.rss_str(pretty=True)
fg.rss_file(os.path.join(CACHE_DIR, output))
def _filter_fb_rss_feeed(url):
parsed_feed = feedparser.parse(url)
filtered_entries = filter(
lambda x: ' shared a link: "' in x.title, parsed_feed.entries)
fg = FeedGenerator()
fg.id('https://fb-notifications-to-pocket.herokuapp.com/')
fg.title('Facebook Notifications to Pocket')
fg.author({'name': 'Pankaj Singh', 'email': '*****@*****.**'})
fg.description(
'''Filter FB notifications which contain a link and generate a new rss feed which will be used by IFTTT''')
fg.link(href='https://fb-notifications-to-pocket.herokuapp.com/')
for entry in filtered_entries:
root = etree.HTML(entry.summary_detail.value)
title = entry.title.split(" shared a link: ")[1].strip()[1:-2]
author_name = entry.title.split(" shared a link: ")[0].strip()
url = urlparse.parse_qs(
urlparse.urlparse(root.findall(".//a")[-1].attrib["href"]).query)["u"][0]
title = get_title_for_url(url) or title
fe = fg.add_entry()
fe.id(entry.id)
fe.link(href=url)
fe.published(entry.published)
fe.author({'name': author_name})
fe.title(title)
return fg.atom_str(pretty=True)
def build_rss_feeds(blog_posts):
feed = FeedGenerator()
feed.load_extension("media", rss=True, atom=True)
base = "https://whotracks.me"
for post in blog_posts:
if post["publish"]:
entry = feed.add_entry()
entry.id(f'{base}/blog/{post["filename"]}.html')
entry.title(post["title"])
entry.link(link={"href": f"{base}/blog/{post['filename']}.html"})
entry.author({"name": post["author"]})
entry.pubDate(
datetime.strptime(post["date"],
"%Y-%m-%d").replace(tzinfo=timezone("CET")))
entry.description(post["subtitle"])
entry.media.thumbnail(
url=f'https://whotracks.me/static/img/{post["header_img"]}')
feed.title("WhoTracksMe blog")
feed.description("By the tech teams at Cliqz and Ghostery")
feed.link(link={"href": f"{base}/blog.html"})
feed.id("wtm")
feed.language("en")
feed.logo(f"{base}/static/img/who-tracksme-logo.png")
feed.rss_file("_site/blog/feed.xml")
def GET(self):
cherrypy.response.headers["Access-Control-Allow-Origin"] = "*"
fg = FeedGenerator()
#TODO create icon
# fg.icon('http://www.det.ua.pt')
fg.id(config.get('rss','id'))
fg.title(config.get('rss','title'))
fg.subtitle(config.get('rss','subtitle'))
fg.description(config.get('rss','description'))
fg.author({'name': config.get('rss','author_name'), 'email':config.get('rss','author_email')})
fg.language(config.get('rss','language'))
fg.link(href=config.get('rss','href'), rel='related')
client = EmailClient()
for msgn in reversed(client.listBox(config.get('imap','mailbox'))[:config.getint('rss','maxitems')]):
cherrypy.log("RSS Entry: "+msgn)
em = client.getEMail(msgn)
entry = fg.add_entry()
entry.title(em['subject'])
entry.author({'name': em['From']['name'], 'email': em['From']['email']})
entry.guid(config.get("main","baseurl")+'news/'+msgn)
entry.link({'href':config.get("main","baseurl")+'news/'+msgn, 'rel':'alternate'})
entry.pubdate(em['date'])
entry.content(em['body'])
return fg.rss_str(pretty=True)
def _gen_rss(event):
"""Generate RSS feed file and place in bucket when file uploaded to S3"""
region = os.getenv('BUCKET_REGION')
s3 = boto3.resource('s3')
sbucket = s3.Bucket(event.bucket)
dbucket = s3.Bucket(os.getenv('RSS_BUCKET'))
fg = FeedGenerator()
fg.title('Lesscast Uploads')
fg.description('Created by lesscast')
fg.link(href='https://{}.s3.{}.amazonaws.com/rss.xml'.format(
dbucket.name, region))
fg.load_extension('podcast')
fg.podcast.itunes_category('Technology', 'Podcasting')
keyfunc = operator.attrgetter('last_modified')
iterator = filter(_get_valid_files, sbucket.objects.all())
for objsum in sorted(iterator, key=keyfunc):
app.log.info('Adding %s to feed', objsum.key)
pub_url = 'https://{}.s3.{}.amazonaws.com/{}'.format(
sbucket.name, region, objsum.key)
obj = objsum.Object()
acl = obj.Acl()
acl.put(ACL='public-read')
fe = fg.add_entry()
fe.id(pub_url)
fe.link(href=pub_url)
fe.title(os.path.basename(obj.key.rstrip('.mp3')))
fe.description('added by lesscast')
fe.enclosure(pub_url, 0, 'audio/mpeg')
rss_content = fg.rss_str(pretty=True)
dbucket.put_object(ACL='public-read', Key='rss.xml', Body=rss_content)
app.log.info('Complete')
def getcomments():
req = requests.get('http://localhost/article',
json={"count": 10},
auth=('*****@*****.**', 'adminpassword'))
value = req.json()
fg = FeedGenerator()
fg.title('A full feed')
fg.link(href='http://localhost/feed/summary/comments')
fg.subtitle('This is a cool feed!')
fg.language('en')
for x in value:
split = x.get('articles_url', '').split('/')
reqcomment = requests.get('http://localhost/comment/get/' + split[2],
json={"count": 30},
auth=('*****@*****.**', 'adminpassword'))
fe = fg.add_entry()
fe.content(x.get('articles_url', ''))
if reqcomment.status_code == 200:
for v in reqcomment.json():
fe.category(term=v)
else:
fe.category(term="None")
fg.rss_file('comments.xml')
return "YOUR COMMENTS WAS CREATED comments.xml", 200
def podcast_feed():
logo_url = url_for("static", filename="wpclogo_big.png", _external=True)
fg = FeedGenerator()
fg.load_extension('podcast')
fg.podcast.itunes_category('Technology', 'Podcasting')
fg.podcast.itunes_image(logo_url)
fg.author({'name': 'Nathan Kellert', 'email': '*****@*****.**'})
fg.link(href='http://watchpeoplecode.com/podcast_feed.xml', rel='self')
fg.title('WPC Coders Podcast')
fg.description('WPC Coders Podcast is a weekly peek into the lives of developers and the WatchPeopleCode community. Our goal is to keep our listeners entertained by giving them new and interesting insights into our industry as well as awesome things happening within our own community. Here, you can expect hear about some of the latest news, tools, and opportunities for developers in nearly every aread of our industry. Most importantly, we hope to have some fun and a few laughs in ways only other nerds know how.') # NOQA
episodes = [('ep1.mp3', 'Episode 1', datetime(2015, 02, 21, 23), 'Learn all about the WPC hosts, and where we came from in Episode 1!'),
('ep2.mp3', 'Episode 2', datetime(2015, 02, 28, 23), 'This week we cover your news, topics and questions in episode 2!'),
('ep3.mp3', 'Episode 3', datetime(2015, 03, 07, 23), "On todays podcast we talk to WatchPeopleCode's founder Alex Putilin. Hear about how the reddit search engine thousands watched him write. Also, hear the inside scoop of how WatchPeopleCode got started!"), # NOQA
('ep4.mp3', 'Episode 4', datetime(2015, 03, 14, 23), "This week we talk to FreeCodeCamps Quincy Larson(http://www.freecodecamp.com) about their project that combines teaching new developers how to code and completing projects for non-profits! Lets find out how this group of streamers code with a cause!")] # NOQA
for epfile, eptitle, epdate, epdescription in episodes[::-1]:
epurl = "https://s3.amazonaws.com/wpcpodcast/{}".format(epfile)
fe = fg.add_entry()
fe.id(epurl)
fe.title(eptitle)
fe.description(epdescription)
fe.podcast.itunes_image(logo_url)
fe.pubdate(epdate.replace(tzinfo=pytz.UTC))
fe.enclosure(epurl, 0, 'audio/mpeg')
return Response(response=fg.rss_str(pretty=True),
status=200,
mimetype='application/rss+xml')
def generate_feed(page=1):
feed = FeedGenerator()
feed.id("https://pub.dartlang.org/feed.atom")
feed.title("Pub Packages for Dart")
feed.link(href="https://pub.dartlang.org/", rel="alternate")
feed.link(href="https://pub.dartlang.org/feed.atom", rel="self")
feed.description("Last Updated Packages")
feed.author({"name": "Dart Team"})
i = 1
pager = QueryPager(int(page), "/feed.atom?page=%d",
Package.all().order('-updated'),
per_page=10)
for item in pager.get_items():
i += 1
entry = feed.add_entry()
for author in item.latest_version.pubspec.authors:
entry.author({"name": author[0]})
entry.title("v" + item.latest_version.pubspec.get("version") +\
" of " + item.name)
entry.link(link={"href": item.url, "rel": "alternate",
"title": item.name})
entry.id(
"https://pub.dartlang.org/packages/" + item.name + "#" +\
item.latest_version.pubspec.get("version"))
entry.description(
item.latest_version.pubspec
.get("description", "Not Available"))
readme = item.latest_version.readme
if not readme is None:
entry.content(item.latest_version.readme.render(), type='html')
else:
entry.content("<p>No README Found</p>", type='html')
return feed
def write_podcast(show, podcast_dir, base_public_url, showlocal_tz):
"""Create the podcast file."""
fg = FeedGenerator()
fg.load_extension('podcast')
url = "{}{}.xml".format(base_public_url, show.id)
fg.id(url.split('.')[0])
fg.title(show.name)
fg.image(show.image_url)
fg.description(show.description)
fg.link(href=url, rel='self')
# collect all mp3s for the given show
all_mp3s = glob.glob(os.path.join(podcast_dir, "{}_*.mp3".format(show.id)))
for filepath in all_mp3s:
filename = os.path.basename(filepath)
mp3_date = _get_date_from_mp3_path(filepath, showlocal_tz)
mp3_size = os.stat(filepath).st_size
mp3_url = base_public_url + filename
mp3_id = filename.split('.')[0]
title = "Programa del {0:%d}/{0:%m}/{0:%Y}".format(mp3_date)
# build the rss entry
fe = fg.add_entry()
fe.id(mp3_id)
fe.pubdate(mp3_date)
fe.title(title)
fe.enclosure(mp3_url, str(mp3_size), 'audio/mpeg')
fg.rss_str(pretty=True)
fg.rss_file(os.path.join(podcast_dir, '{}.xml'.format(show.id)))
def latestRss(userID):
userID = userID.lower()
shows = {}
episodes = []
today = date.today().strftime('%Y-%m-%d')
for showID in series.getUserShowList(userID):
shows[showID] = series.getShowInfo(userID, showID, withEpisodes=True, onlyUnseen=True)
episodes.extend((showID, episode) for episode in shows[showID]['episodes'] if episode['airdate'] and airdateKey(episode['airdate']) < today)
episodes.sort(key=episodeAirdateKey, reverse=True)
feed = FeedGenerator()
feed.id(userID)
feed.title('%s\'s shows' % userID)
feed.description('Unseen episodes')
feed.link(href=request.url_root)
feed.language('en')
for showID, episode in episodes:
entry = feed.add_entry()
entry.id('%s/%s' % (showID, episode['episode_id']))
entry.title('%s S%02dE%02d: %s' % (shows[showID]['name'], episode['season'], episode['episode'], episode['title']))
return feed.rss_str(pretty=True)
class Feeder():
def __init__( self, url, title='', feedURL='' ):
scraper = None
if url.startswith( "https://twitter.com/" ):
scraper = TwitterScraper( url )
if title == '':
title = "Twitter: @" + url.split('/')[3]
elif url.startswith( "http://www.lindwurm-linden.de/termine" ):
scraper = LindwurmScraper( url )
if title == '':
title = "Lindwurm: Termine"
else:
raise UnsupportedService( "No scraper found for this URL." )
self.feed = FeedGenerator()
self.feed.id( url )
self.feed.title( title )
self.feed.author( { "name": url } )
if feedURL != '':
self.feed.link( href=feedURL, rel='self' )
for entry in scraper.entries:
fe = self.feed.add_entry()
fe.id( entry['url'] )
fe.title( entry['title'] )
fe.link( href=entry['url'], rel='alternate' )
fe.content( entry['text'] )
def GetAtom( self ):
return self.feed.atom_str( pretty=True ).decode()
class TestExtensionTorrent(unittest.TestCase):
def setUp(self):
self.fg = FeedGenerator()
self.fg.load_extension('torrent')
self.fg.title('title')
self.fg.link(href='http://example.com', rel='self')
self.fg.description('description')
def test_podcastEntryItems(self):
fe = self.fg.add_item()
fe.title('y')
fe.torrent.filename('file.xy')
fe.torrent.infohash('123')
fe.torrent.contentlength('23')
fe.torrent.seeds('1')
fe.torrent.peers('2')
fe.torrent.verified('1')
assert fe.torrent.filename() == 'file.xy'
assert fe.torrent.infohash() == '123'
assert fe.torrent.contentlength() == '23'
assert fe.torrent.seeds() == '1'
assert fe.torrent.peers() == '2'
assert fe.torrent.verified() == '1'
# Check that we have the item in the resulting XML
ns = {'torrent': 'http://xmlns.ezrss.it/0.1/dtd/'}
root = etree.fromstring(self.fg.rss_str())
filename = root.xpath('/rss/channel/item/torrent:filename/text()',
namespaces=ns)
assert filename == ['file.xy']
class TestExtensionDc(unittest.TestCase):
def setUp(self):
self.fg = FeedGenerator()
self.fg.load_extension('dc')
self.fg.title('title')
self.fg.link(href='http://example.com', rel='self')
self.fg.description('description')
def test_entryLoadExtension(self):
fe = self.fg.add_item()
try:
fe.load_extension('dc')
except ImportError:
pass # Extension already loaded
def test_elements(self):
for method in dir(self.fg.dc):
if method.startswith('dc_'):
m = getattr(self.fg.dc, method)
m(method)
assert m() == [method]
self.fg.id('123')
assert self.fg.atom_str()
assert self.fg.rss_str()
def get_feed(query, title, description, link, image):
"""Get an RSS feed from the results of a query to the YouTube API."""
service = _get_youtube_client()
videos = service.search().list(part='snippet', **query, order='date',
type='video', safeSearch='none').execute()
fg = FeedGenerator()
fg.load_extension('podcast')
fg.title(title)
fg.description(description)
fg.link(href=link, rel='alternate')
fg.image(image)
youtube_plugin = get_plugin_from_settings()
for video in videos['items']:
try:
video_url = youtube_plugin.extract_link(
"https://www.youtube.com/watch?v=" + video['id']['videoId'])
except PluginException:
continue
fe = fg.add_entry()
fe.id(video['id']['videoId'])
fe.title(video['snippet']['title'])
fe.description(video['snippet']['description'])
fe.pubdate(dateutil.parser.parse(video['snippet']['publishedAt']))
fe.podcast.itunes_image(video['snippet']['thumbnails']['high']['url'])
video_info = requests.head(video_url)
fe.enclosure(video_url, video_info.headers['Content-Length'],
video_info.headers['Content-Type'])
return fg.rss_str(pretty=True)
def render_atom(self):
fg = FeedGenerator()
fg.id(self.site_url)
fg.title(self.site_title)
fg.link(href = self.site_url,rel = 'alternate')
fg.link(href = self.site_url + 'atom.xml',rel = 'self')
fg.language('zh-cn')
link_list = ArticleManager.sharedManager().link_list()
for link in link_list:
article = ArticleManager.sharedManager().article_for_link(link)
if not article:
continue
fe = fg.add_entry()
fe.id(article.article_link)
fe.link(link = {'href':self.site_url + article.article_link})
fe.title(article.article_title)
fe.description(article.article_subtitle or '')
fe.author(name = article.author or '',
email = article.author_email or '')
d = datetime.strptime(article.article_publish_date,'%Y-%m-%d')
pubdate = datetime(year = d.year, month = d.month, day = d.day,tzinfo = UTC(8))
fe.pubdate(pubdate)
article.render_content_html()
fe.content(content = article._content_html,
type = 'html')
atom_feed = fg.atom_str(pretty = True)
return atom_feed
def score_by_community(Community):
post = r"http://*****:*****@csu.fullerton.edu'} )
fe.link( href=each["URLResource"], rel='alternate' )
fe.content(each["Community"])
temp+=1
break
rssfeed = fg.rss_str(pretty=True)
return rssfeed
class YoutubeFeed:
ydl_opts = {
'format': 'bestaudio/best',
'outtmpl': '%(id)s.%(ext)s',
'postprocessors': [{
'key': 'FFmpegExtractAudio',
'preferredcodec': 'mp3',
'preferredquality': '192',
}]
}
def __init__(self, name):
self.name = name
self.ydl = youtube_dl.YoutubeDL(self.ydl_opts)
self.fg = FeedGenerator()
self.fg.title(name)
self.fg.author({"name": "Youtube Audio Feed", "email": ""})
self.fg.link(href="http://www.foo.bar.baz.com", rel="alternate")
self.fg.description("Personalized Youtube audio feed")
self.fg.generator("")
self.fg.docs("")
def add_video(self, url):
info = self.ydl.extract_info(url, download=True)
entry = self.fg.add_entry()
entry.id(info['id'])
entry.title(info['title'])
entry.description(info['description'])
entry.enclosure(info['id'] + ".mp3", str(info['duration']), 'audio/mpeg')
def save(self):
self.fg.rss_file(name + '.xml')
class RssHistory(View):
"""RSS History Page Controller"""
@redirect_if_not_installed
def get(self, request):
self.__correlation_id = request.META["X-Correlation-ID"] if "X-Correlation-ID" in request.META else ""
self.__fg = FeedGenerator()
self.__context = Context()
self.__option_entity = OptionEntity()
self.__context.autoload_options()
self.__context.push({
"page_title": self.__context.get("app_name", os.getenv("APP_NAME", "Silverback")),
"is_authenticated": request.user and request.user.is_authenticated
})
self.__fg.id('http://silverbackhq.org')
self.__fg.title('Some Testfeed')
self.__fg.author({'name': 'John Doe', 'email': '*****@*****.**'})
self.__fg.link(href='http://example.com', rel='alternate')
self.__fg.logo('http://ex.com/logo.jpg')
self.__fg.subtitle('This is a cool feed!')
self.__fg.link(href='http://silverbackhq.org/test.atom', rel='self')
self.__fg.language('en')
return HttpResponse(self.__fg.atom_str(), content_type='text/xml')
def get_feed(atom=False):
fg = FeedGenerator()
domain = get_domain()
items = get_posts({"limit": "10"}, full=True)["results"]
fg.id("http://%s/"%domain)
fg.title("Blog do MatrUFSC2")
fg.description("Feed do blog do MatrUFSC2, onde noticias e novos recursos sao anunciados primeiro!")
fg.language('pt-BR')
fg.link({"href":"/blog/feed","rel":"self"})
fg.updated(items[0]["posted_at"].replace(tzinfo=pytz.UTC))
for item in items:
entry = fg.add_entry()
entry.title(item["title"])
tree = html.fromstring(item["summary"])
cleaner = Cleaner(allow_tags=[])
tree = cleaner.clean_html(tree)
text = tree.text_content()
entry.description(text, True)
entry.link({"href":item["link"],"rel":"self"})
entry.content(item["body"])
entry.published(item["posted_at"].replace(tzinfo=pytz.UTC))
entry.updated(item["posted_at"].replace(tzinfo=pytz.UTC))
entry.category({"label": item["category"]["title"], "term": item["category"]["slug"]})
entry.id(item["id"])
if atom:
return fg.atom_str(pretty=True)
else:
return fg.rss_str(pretty=True)
def feed():
"""
Generate atom feed
"""
entries = parse_posts(0, C.feed_count)
fg = FeedGenerator()
fg.id(str(len(entries)))
fg.title(C.title)
fg.subtitle(C.subtitle)
fg.language(C.language)
fg.author(dict(name=C.author, email=C.email))
fg.link(href=C.root_url, rel='alternate')
fg.link(href=make_abs_url(C.root_url, 'feed'), rel='self')
for entry in entries:
fe = fg.add_entry()
fe.id(entry.get('url'))
fe.title(entry.get('title'))
fe.published(entry.get('date'))
fe.updated(entry.get('updated') or entry.get('date'))
fe.link(href=make_abs_url(C.root_url, entry.get('url')), rel='alternate')
fe.author(dict(name=entry.get('author'), email=entry.get('email')))
fe.content(entry.get('body'))
atom_feed = fg.atom_str(pretty=True)
return atom_feed
def build_feed(self):
"Build the feed given our existing URL"
# Get all the episodes
page_content = str(requests.get(self.url).content)
parser = BassdriveParser()
parser.feed(page_content)
links = parser.get_links()
# And turn them into something usable
fg = FeedGenerator()
fg.id(self.url)
fg.title(self.title)
fg.description(self.title)
fg.author({'name': self.dj})
fg.language('en')
fg.link({'href': self.url, 'rel': 'alternate'})
fg.logo(self.logo)
for link in links:
fe = fg.add_entry()
fe.author({'name': self.dj})
fe.title(link[0])
fe.description(link[0])
fe.enclosure(self.url + link[1], 0, 'audio/mpeg')
# Bassdrive always uses date strings of
# [yyyy.mm.dd] with 0 padding on days and months,
# so that makes our lives easy
date_start = link[0].find('[')
date_str = link[0][date_start:date_start+12]
published = datetime.strptime(date_str, '[%Y.%m.%d]')
fe.pubdate(UTC.localize(published))
fe.guid((link[0]))
return fg
def create_podcast_from_channel(url, podcast_root_url, items_to_process):
feed = feedparser.parse(url)
fg = FeedGenerator()
fg.load_extension('podcast')
fg.title(feed['channel']['title'])
fg.link(href=feed['channel']['href'], rel='alternate')
fg.description('Audio tracks from YouTube Channel "{}"'.format(feed['channel']['title']))
# fg.image(url=feed.image.href, width=feed.image.width, height=feed.image.height)
output_dir = '/y2p/output'
for item in feed['items'][:items_to_process]:
sys.stdout.write(item['link'] + '\n')
our_id = hashlib.md5(item['link'].encode()).hexdigest()
audio_fname = our_id + '.m4a'
audio_fullpath = os.path.join(output_dir, audio_fname)
if not os.path.exists(audio_fullpath):
create_audio_file(audio_fullpath, our_id, item['link'])
p_entry = fg.add_entry()
p_entry.id(item['id'])
p_entry.title(item['title'])
p_entry.description(item['summary'])
p_entry.enclosure(podcast_root_url + '/' + audio_fname, 0, 'audio/m4a')
p_entry.published(item['published'])
fg.rss_str(pretty=True)
fg.rss_file(os.path.join(output_dir, 'feed.xml'))
def all_recent_posts():
url = 'http://localhost:2015/posts/all/recent/{num}'
url = url.format(num = 25)
headers = {'content-type': 'application/json'}
r = requests.get(url, headers=headers)
data = r.json()
final_data = data['data']
fg = FeedGenerator()
fg.id(url)
fg.title('Microservice - view all')
fg.link( href=url, rel='alternate' )
fg.description('The 25 most recent posts to any community')
fg.language('en')
#This is genating the RSS feeds
for i in final_data:
fe = fg.add_entry()
fe.id(i['post_id'])
fe.author({'name': i['author'], 'email':""})
fe.title(i['title'])
fe.description(i['community'])
date = datetime.fromtimestamp(i['date'])
date = date.replace(tzinfo=pytz.utc)
print(date)
fe.published(date)
fe.content(content=i['text'])
if 'url' in i:
fe.source(url=i['url'], title=i['title'])
rssfeed = fg.rss_str(pretty=True) # Get the RSS feed as string
resp = flask.Response(rssfeed, mimetype='text/xml', status = 200, content_type = 'application/rss+xml; charset=UTF-8')
return resp
def create_feed(self):
"""
replace results by info
#results keys
_type entries id title uploader uploader_id uploader_url extractor webpage_url webpage_url_basename extractor_key
"""
fg = FeedGenerator()
fg.load_extension('podcast')
fg.podcast.itunes_category('Podcasting')
fg.title(self.infos['title'])
fg.description('none')
fg.link(href=self.args.podcast_url, rel='self')
for item in self.infos['entries']:
"""
#infos['entries'] keys
id uploader uploader_id uploader_url channel_id channel_url upload_date license creator title alt_title thumbnail description categories tags subtitles automatic_captions duration
"""
fe = fg.add_entry()
fe.id(item['id'])
fe.title(item['title'])
fe.description(item['description'])
item_full_path = self.args.podcast_url + '/' + self.infos[
'title'] + '/' + item['title'] + '.mp3'
fe.enclosure(item_full_path, str(item['duration']), 'audio/mpeg')
fg.rss_str(pretty=True)
# create folder of feed if it doesn't exists
os.makedirs(self.args.dir + '/' + self.infos['title'], exist_ok=True)
fg.rss_file(self.args.dir + '/' + self.infos['title'] + '/podcast.xml')
return True
def generateFeeds(buffered, meta):
utc = pytz.utc
fg = FeedGenerator()
fg.id(meta['id'])
fg.title(meta['title'])
fg.author(meta['author'])
fg.subtitle(meta['subtitle'])
fg.link(href=meta['link'], rel='self')
fg.language(meta['language'])
for tweet in buffered:
fe = fg.add_entry()
fe.id(tweet['url'].decode('utf-8'))
fe.published(
utc.localize(tweet['created_at']).astimezone(
pytz.timezone(locale)))
#fe.guid(tweet['url'].decode('utf-8'))
fe.link(href=tweet['url'].decode('utf-8'), rel='alternate')
fe.title(tweet['readable_title'])
fe.description(tweet['readable_article'])
try:
fe.author({
'name':
'',
'email':
tweet['user_name'].decode('utf-8') + ": " +
tweet['text'].decode('utf-8')
})
except Exception, e:
logger.error(e)
fe.author({'name': 'a', 'email': '*****@*****.**'})
def build():
global fg
fg = FeedGenerator()
fg.title(parser.get('technowatch', 'name'))
fg.language('en')
fg.description(parser.get('technowatch', 'name'))
fg.link(href=parser.get('technowatch', 'link'), rel='alternate')
# Cleaning stories if too much
if len(known_stories) > int(parser.get('technowatch', 'cache_max')):
clean()
# Sorting stories by crawled date
for item in sorted(known_stories.values(), key=operator.itemgetter('crawledDate'), reverse=True):
fe = fg.add_entry()
fe.link(href=item['url'], rel='alternate')
fe.title("[" + item['type'] + "] " + item['title'])
fe.category({
'label': item['type'],
'term': item['type']
})
fe.author({'name': item['by']})
fe.description(item['desc'])
fe.pubdate(item['crawledDate'])
# Caching RSS building
pickle.dump(known_stories, open(cust_path + "/technowatch.data", "wb"))
if parser.get('wsgi', 'activated') == "True":
fg.rss_file(cust_path + '/static/rss.xml')
if parser.get('ftp', 'activated') == "True":
upload()
def __call__(self, value, system):
feed = FeedGenerator()
feed.id(system["request"].url)
feed.title(value["title"])
feed.description("Log Cabin")
feed.link(rel="self", href=system["request"].url)
feed.language("en")
if system["renderer_name"] == "atom":
feed.link([{
"rel": "alternate",
"type": content_type,
"href": url
} for content_type, url in system["request"].extensions])
for entry in value["entries"]:
feed.add_entry(entry)
system["request"].response.headers[
"Content-type"] = extension_content_types[
system["renderer_name"]] + "; charset=UTF-8"
if system["renderer_name"] == "rss":
return feed.rss_str(pretty=True)
else:
return feed.atom_str(pretty=True)
def makeRss(self):
fg = FeedGenerator()
fg.load_extension('podcast')
fg.id('http://hypecast.blackmad.com/' + self.mode)
fg.title('Hype Machine Robot Radio: ' + self.mode)
fg.author( {'name':'David Blackmad','email':'*****@*****.**'} )
fg.logo('http://dump.blackmad.com/the-hype-machine.jpg')
fg.language('en')
fg.link(href='http://hypecast.blackmad.com/' + self.mode)
fg.description('Hype Machine Robot Radio: ' + self.mode)
description = ' <br/>'.join(['%s. %s' % (index + 1, self.mk_song_id(s)) for index, s in enumerate(self.songs)])
fe = fg.add_entry()
fe.title(self.track_name)
fe.description(description)
fe.id(self.filename)
# add length
print(self.relative_dir)
print(self.filename)
fe.enclosure(url = 'http://hypecast.blackmad.com/%s' % (self.filename), type="audio/mpeg")
rss_str = fg.rss_str()
newItem = ET.fromstring(rss_str)[0].find('item')
out = open(self.get_filename('xml'), 'w')
out.write(ET.tostring(newItem))
out.close()
self.updateRss()
def generateFeed(urls, query, search_engine):
"""
Generates RSS feed from the given urls
:param urls: List of URL. Each entry contains url, title, short description
:param feed_title: Title of the feed
:param feed_link: Link of the feed
:param feed_descr: Short description of feed
"""
# google as search engine
if search_engine == 0:
feed = google_feed
# duckduckgo as search engine
elif search_engine == 1:
feed = duckduckgo_feed
elif search_engine == 2:
feed = bing_feed
elif search_engine == 3:
feed = askcom_feed
fg = FeedGenerator()
fg.title(feed[0])
fg.link(href=feed[1], rel='alternate')
fg.description(feed[2] % query)
for url in urls:
fe = fg.add_entry()
fe.title(url[0])
fe.link({'href': url[1], 'rel': 'alternate'})
fe.description(url[2])
print(fg.rss_str(pretty=True))
def gen_feed(user, base_url, path, debug=False):
# Create feed
feed = FeedGenerator()
feed.id(urlparse.urljoin(base_url, user + '.xml'))
feed.title('Snapchat story for ' + user)
feed.link(href=urlparse.urljoin(base_url, user + '.xml'), rel='self')
feed.language('en')
feed.description('Snapchat media')
# Iterate through files in path, sort by unix timestamp (newest first), then add to feed
files = sorted(os.listdir(path), reverse=True)
for filename in files:
split = filename.split('~')
if split[0] != user:
continue
if os.path.splitext(filename)[1] in ['.mp4', '.jpg']:
entry = feed.add_entry()
entry.id(urlparse.urljoin(base_url, filename))
entry.link(href=urlparse.urljoin(base_url, filename))
entry.title(filename)
# Write feed to disk
feed.rss_file(os.path.join(path, user + '.xml'))
date = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
if debug:
print('{0} Regenerated {1}'.format(
date, urlparse.urljoin(base_url, user + '.xml')))
def serialize_category_atom(category, url, user, event_filter):
"""Export the events in a category to Atom
:param category: The category to export
:param url: The URL of the feed
:param user: The user who needs to be able to access the events
:param event_filter: A SQLalchemy criterion to restrict which
events will be returned. Usually something
involving the start/end date of the event.
"""
query = (Event.query.filter(Event.category_chain_overlaps(
category.id), ~Event.is_deleted, event_filter).options(
load_only('id', 'category_id', 'start_dt', 'title', 'description',
'protection_mode', 'access_key'),
subqueryload('acl_entries')).order_by(Event.start_dt))
events = [e for e in query if e.can_access(user)]
feed = FeedGenerator()
feed.id(url)
feed.title('Indico Feed [{}]'.format(category.title))
feed.link(href=url, rel='self')
for event in events:
entry = feed.add_entry(order='append')
entry.id(event.external_url)
entry.title(event.title)
entry.summary(unicode(event.description))
entry.link(href=event.external_url)
entry.updated(event.start_dt)
return BytesIO(feed.atom_str(pretty=True))
def setUp(self):
fg = FeedGenerator()
self.feedId = 'http://example.com'
self.title = 'Some Testfeed'
fg.id(self.feedId)
fg.title(self.title)
fg.link(href='http://lkiesow.de', rel='alternate')[0]
fg.description('...')
fe = fg.add_entry()
fe.id('http://lernfunk.de/media/654321/1')
fe.title('The First Episode')
fe.content(u'…')
# Use also the different name add_item
fe = fg.add_item()
fe.id('http://lernfunk.de/media/654321/1')
fe.title('The Second Episode')
fe.content(u'…')
fe = fg.add_entry()
fe.id('http://lernfunk.de/media/654321/1')
fe.title('The Third Episode')
fe.content(u'…')
self.fg = fg
def write_podcast(show, podcast_dir, base_public_url, showlocal_tz):
"""Create the podcast file."""
fg = FeedGenerator()
fg.load_extension('podcast')
url = "{}{}.xml".format(base_public_url, show.id)
fg.id(url.split('.')[0])
fg.title(show.name)
fg.image(show.image_url)
fg.description(show.description)
fg.link(href=url, rel='self')
# collect all mp3s for the given show
all_mp3s = glob.glob(os.path.join(podcast_dir, "{}_*.mp3".format(show.id)))
for filepath in all_mp3s:
filename = os.path.basename(filepath)
mp3_date = _get_date_from_mp3_path(filepath, showlocal_tz)
mp3_size = os.stat(filepath).st_size
mp3_url = base_public_url + filename
mp3_id = filename.split('.')[0]
title = "Programa del {0:%d}/{0:%m}/{0:%Y}".format(mp3_date)
# build the rss entry
fe = fg.add_entry()
fe.id(mp3_id)
fe.pubdate(mp3_date)
fe.title(title)
fe.enclosure(mp3_url, str(mp3_size), 'audio/mpeg')
fg.rss_str(pretty=True)
fg.rss_file(os.path.join(podcast_dir, '{}.xml'.format(show.id)))
def posts_by_score_community():
vote = "http://*****:*****@csu.fullerton.edu'} )
fe.link( href=post["URLResource"], rel='alternate' )
# fe.content({'content':post["Content"], 'src':'http://localhost:5000/posts/all', 'type':post["CDATA"]} )
fe.description(post["Community"])
i+=1
break
rssfeed = fg.rss_str(pretty=True)
return rssfeed
def init_feed() -> None:
"""
This function initialises the RSS feed with the
correct attributes.
"""
log.debug("Initialising the feed...")
global fg
try:
fg = FeedGenerator()
# Setup [root] feed attributes
fg.id("https://www.dagzure.com/dynamics_feed.xml")
fg.title("Dynamics 365 Feeds")
fg.generator("SingleRSS/v1.0.1")
fg.link(href="https://www.dagzure.com/dynamics_feed.xml", rel="self")
fg.subtitle("Combined feed for RSS feeds")
fg.language('en')
except:
log.error("Error initialising the feed!")
sys.exit(1)
log.debug("Feed initialised!")
return None
def generate_feed(output_file, exclude_highlights=True):
# Parse RSS feed
d = feedparser.parse(ESPN_RSS_FEED)
IMAGE_URL = d.feed.image["href"]
# RSS feed generation
fg = FeedGenerator()
fg.load_extension("podcast", rss=True)
## RSS tags
# Required
fg.title(d.feed.title)
fg.link(href="https://github.com/aaearon/lebatard-show-rss")
fg.description(d.feed.description)
# Optional
fg.language(d.feed.language)
fg.image(IMAGE_URL)
fg.subtitle(d.feed.subtitle)
# iTunes
fg.podcast.itunes_author(d.feed.author)
fg.podcast.itunes_category(itunes_category=d.feed.category)
fg.podcast.itunes_image(itunes_image=IMAGE_URL)
fg.podcast.itunes_explicit(itunes_explicit="clean")
fg.podcast.itunes_owner(name=CONTACT["name"], email=CONTACT["email"])
tz = pytz.timezone("America/Los_Angeles")
for e in d.entries:
if exclude_highlights and episode_duration_string_to_int(e["itunes_duration"]) > 3600:
pass
else:
fe = fg.add_entry()
fe.id(e.id)
fe.title(e.title)
fe.description(e.description)
fe.enclosure(url=e.enclosures[0]["href"], length=e.enclosures[0]["length"], type=e.enclosures[0]["type"])
fe.podcast.itunes_summary(e.description)
fe.podcast.itunes_subtitle(e.description)
fe.podcast.itunes_duration(e["itunes_duration"])
dt = datetime.fromtimestamp(time.mktime(e.published_parsed))
date = tz.localize(dt)
# Local hour
if "Show: " in e.title:
fe.published(date)
elif "Hour 1" in e.title:
fe.published(date + timedelta(hours=1))
elif "Hour 2" in e.title:
fe.published(date + timedelta(hours=2))
elif "Hour 3" in e.title:
fe.published(date + timedelta(hours=3))
else:
fe.published(date + timedelta(hours=-1))
fg.rss_str(pretty=True)
fg.rss_file(output_file)
def generate_rss_from_articles(feed_settings, articles):
"""
Creates a FeedGenerator feed from a set of feed_entries.
:param feed_settings: a feed_settings object containing
:param articles:
:return:
"""
# create the feed
output_feed = FeedGenerator()
# add metadata to the feed
# TODO this feels like it can be done without output_rss on every line but...Python newbie
output_feed.title(feed_settings.title)
output_feed.author(feed_settings.author)
output_feed.link(href=feed_settings.source_page_url, rel='alternate')
output_feed.link(href=feed_settings.output_url, rel='self')
output_feed.logo(feed_settings.logo_img_url)
output_feed.subtitle(feed_settings.subtitle)
output_feed.language(feed_settings.language)
# output_rss.id(UM_SOMETHING)
# add each feed item
for article in articles:
feed_entry_added = output_feed.add_entry()
feed_entry_added.id(article.link) # ATOM
# guid for RSS?
feed_entry_added.link(href=article.link, rel='alternate') # ATOM
feed_entry_added.title(article.title)
feed_entry_added.description(article.description)
# feed_entry_added.link(article.link)
return output_feed
def getcontent():
req = requests.get('http://localhost/article/content',
json={"count": 10},
auth=('*****@*****.**', 'adminpassword'))
value = req.json()
fg = FeedGenerator()
fg.title('A full feed')
fg.link(href='http://localhost/feed/summary/content')
fg.subtitle('This is a cool feed!')
fg.language('en')
for x in value:
fe = fg.add_entry()
fe.content(x.get('articles_content', ''))
if x.get('articles_tags', '') != 'null':
for v in x.get('articles_tags', ''):
fe.category(term='Tag: ' + v)
else:
fe.category(term='Tag: None')
if type(x.get('articles_comments', '')) == type(None):
count = '0'
else:
count = str(len(x.get('articles_comments', '')))
fe.category(term='Comment Count: ' + count)
fg.rss_file('content.xml')
return "YOUR CONTENT WAS CREATED content.xml", 200
def run(folder, url):
from feedgen.feed import FeedGenerator
fg = FeedGenerator()
head, tail = os.path.split(folder)
title = tail.decode("utf-8")
fg.id(str(uuid.uuid4()))
fg.title(title)
fg.link(href="{0}/rss.xml".format(url), rel="self")
fg.description(u"Audiobook `{0}` generated with rssbook".format(title))
fg.load_extension("podcast")
for item in sorted(os.listdir(folder)):
if os.path.splitext(item)[1] == ".mp3":
get_node(os.path.join(folder, item))
fullpath = os.path.join(folder, item)
fe = fg.add_entry()
fe.id(str(uuid.uuid4()))
fe.title(title)
fe.description(item)
fe.link(
href="{0}/{1}".format(url, item), rel="enclosure", type="audio/mpeg", length=str(os.stat(fullpath).st_size)
)
fg.rss_file(os.path.join(folder, "rss.xml"))
def build_artifact(self, artifact):
ctx = get_ctx()
feed_source = self.source
page = feed_source.parent
fg = FeedGenerator()
fg.id(get_id(ctx.env.project.id))
fg.title(page.record_label + u" — Pallets Project")
fg.link(href=url_to("/blog", external=True))
fg.link(href=url_to(feed_source, external=True), rel="self")
for item in page.children.order_by('-pub_date', '-pub_order',
'title').limit(10):
fe = fg.add_entry()
fe.title(item["title"])
fe.content(text_type(item["body"]), type="html")
fe.link(href=url_to(item, external=True))
fe.id(
get_id(u"{}/{}".format(ctx.env.project.id,
item["_path"].encode("utf-8"))))
fe.author(name=item["author"])
updated = datetime(*item["pub_date"].timetuple()[:3])
updated = updated.isoformat() + "Z" if not updated.tzinfo else ""
fe.updated(updated)
with artifact.open('wb') as f:
f.write(fg.atom_str(pretty=True))
def rss():
config = public_app.config['feed']
fg = FeedGenerator()
fg.id('%s/blog' % Config.BASE_URL)
fg.title(config['title'])
fg.author( {'name': config['author'],'email': config['email']} )
fg.description(config['desc'])
fg.link( href=Config.BASE_URL, rel='alternate' )
query = {
'id': { '$regex': 'blog' },
'current': True,
'meta.hide': { '$ne': True }
}
posts = db.pages.find(query).sort('meta.created', -1)[:20]
for post in posts:
fe = fg.add_entry()
fe.title(post['meta']['title'])
if 'author' in post['meta']:
fe.author( {'name': post['meta']['author'],'email': config['email']} )
else:
fe.author( {'name': config['author'],'email': config['email']} )
fe.description(do_truncate(post['content'], 300))
fe.link(href="%s/%s" % (Config.BASE_URL, post['id']), rel='alternate')
fe.pubdate(utc.localize(post['meta']['created']))
fe.content(post['content'])
response.headers['Content-Type'] = 'application/rss+xml'
return fg.rss_str(pretty=True)
class TestExtensionSyndication(unittest.TestCase):
SYN_NS = {'sy': 'http://purl.org/rss/1.0/modules/syndication/'}
def setUp(self):
self.fg = FeedGenerator()
self.fg.load_extension('syndication')
self.fg.title('title')
self.fg.link(href='http://example.com', rel='self')
self.fg.description('description')
def test_update_period(self):
for period_type in ('hourly', 'daily', 'weekly', 'monthly', 'yearly'):
self.fg.syndication.update_period(period_type)
root = etree.fromstring(self.fg.rss_str())
a = root.xpath('/rss/channel/sy:UpdatePeriod',
namespaces=self.SYN_NS)
assert a[0].text == period_type
def test_update_frequency(self):
for frequency in (1, 100, 2000, 100000):
self.fg.syndication.update_frequency(frequency)
root = etree.fromstring(self.fg.rss_str())
a = root.xpath('/rss/channel/sy:UpdateFrequency',
namespaces=self.SYN_NS)
assert a[0].text == str(frequency)
def test_update_base(self):
base = '2000-01-01T12:00+00:00'
self.fg.syndication.update_base(base)
root = etree.fromstring(self.fg.rss_str())
a = root.xpath('/rss/channel/sy:UpdateBase', namespaces=self.SYN_NS)
assert a[0].text == base
def feed(column_id):
api = Api(column_id)
with request.urlopen(api.info) as stream:
result = stream.read().decode('utf-8')
if not result:
return '', 404
info = json.loads(result)
with request.urlopen(api.posts) as stream:
result = stream.read().decode('utf-8')
entries = json.loads(result)
fg = FeedGenerator()
fg.id(str(entries[0]['slug']))
fg.title(info['name'])
fg.language('zh_CN')
fg.icon(info['avatar']['template'].replace('{id}', info['avatar']['id']).replace('{size}', 's'))
fg.logo(info['avatar']['template'].replace('{id}', info['avatar']['id']).replace('{size}', 'l'))
fg.description(info['intro'])
fg.author(dict(name=info['creator']['name']))
fg.link(href=api.base_url + info['url'], rel='alternate')
for entry in entries:
fe = fg.add_entry()
fe.id(entry['url'])
fe.title(entry['title'])
fe.published(entry['publishedTime'])
fe.updated(entry['publishedTime'])
fe.author(dict(name=entry['author']['name']))
fe.link(href=api.base_url + entry['url'], rel='alternate')
fe.content(entry['content'])
return fg.atom_str(pretty=True)
def gen_feed(endpoint):
# Make sure we have somewhere to save the files
if not os.path.isdir('./gen'):
print('There is no gen directory. Create ./gen')
# Uses parse_dir.py to get the books and files
books = parse_dir.getbooks_r('./audiobooks')
for (book, files) in books:
# Creates a new feed for each book
fg = FeedGenerator()
fg.load_extension('podcast')
fg.podcast.itunes_category('Audiobook')
for (file_name, file_path) in files:
# the 1: removes the period because the base dir is ./audiobooks
url = endpoint + file_path[1:]
fe = fg.add_entry()
fe.id(url)
fe.title(file_name)
fe.description(file_name)
fe.enclosure(requote_uri(url), str(os.path.getsize(file_path)), 'audio/mpeg')
fg.title(book)
fg.link(href=endpoint, rel='self')
fg.description(book)
fg.rss_str(pretty=True)
# Saves the file
rss_file_path = os.path.join('./gen/', book + '.xml')
ensure_dir(rss_file_path)
logging.info("generate feed: %s" % rss_file_path)
fg.rss_file(rss_file_path)
def generate_rss_feed(repo, filename, me):
generator = FeedGenerator()
generator.id(repo.html_url)
generator.title(f"RSS feed of {repo.owner.login}'s {repo.name}")
generator.author(
{"name": os.getenv("GITHUB_NAME"), "email": os.getenv("GITHUB_EMAIL")}
)
generator.link(href=repo.html_url)
generator.link(
href=f"https://raw.githubusercontent.com/{repo.full_name}/master/{filename}",
rel="self",
)
for issue in repo.get_issues():
if not issue.body or not is_me(issue, me) or issue.pull_request:
continue
item = generator.add_entry(order="append")
item.id(issue.html_url)
item.link(href=issue.html_url)
item.title(issue.title)
item.published(issue.created_at.strftime("%Y-%m-%dT%H:%M:%SZ"))
for label in issue.labels:
item.category({"term": label.name})
body = "".join(c for c in issue.body if _valid_xml_char_ordinal(c))
item.content(CDATA(marko.convert(body)), type="html")
generator.atom_file(filename)
def feed():
root_url = request.url_root.rstrip("/")
home_full_url = root_url + url_for(".index")
feed_full_url = root_url + url_for(".feed")
site = app.config["SITE_INFO"]
site_tz = s2tz(site["timezone"]) or timezone(timedelta())
# set feed info
feed_gen = FeedGenerator()
feed_gen.id(home_full_url)
feed_gen.title(site.get("title", ""))
feed_gen.subtitle(site.get("subtitle", ""))
if "author" in site:
feed_gen.author(name=site["author"])
feed_gen.link(href=home_full_url, rel="alternate")
feed_gen.link(href=feed_full_url, rel="self")
# add feed entries
posts = load_posts(meta_only=True)[:10]
for i in range(len(posts)):
p = load_post(posts[i]["filename"])
if not p:
continue
feed_entry = feed_gen.add_entry()
feed_entry.id(root_url + p["url"])
feed_entry.link(href=root_url + p["url"])
feed_entry.title(p["title"])
feed_entry.content(p["content"])
feed_entry.published(p["created"].replace(tzinfo=site_tz))
feed_entry.updated(
p.get("updated", p["created"]).replace(tzinfo=site_tz))
if "author" in p:
feed_entry.author(name=p["author"])
# make http response
resp = make_response(feed_gen.atom_str(pretty=True))
resp.content_type = "application/atom+xml; charset=utf-8"
return resp
def generate_feed(data):
fg = FeedGenerator()
fg.id(blog_root)
fg.title(blog_title)
fg.author({"name": my_name})
fg.link(href=blog_root)
fg.description("Programming, socialism, and Buddhism.")
fg.language("en")
for entry in data:
url = site_root + entry["href"]
# This causes every post to have a pubDate of midnight MST,
# but since I don't keep track of the actual time, it's
# close enough.
published = datetime.strptime(
str(entry["created"]) + "--07:00", "%Y-%m-%d-%z")
fe = fg.add_entry()
fe.id(url)
fe.title(entry["title"])
fe.link(href=url)
fe.author({"name": my_name})
fe.description(entry["body"])
fe.pubDate(published)
fg.rss_file("rss.xml")
class Rss:
def __init__(self, title='', link='', logo='', description='none'):
self.title = title
self.fg = FeedGenerator()
self.fg.load_extension('podcast')
self.fg.title(title)
self.fg.description(description)
self.fg.link(href=link, rel='alternate')
self.fg.generator('rss-it')
if logo:
self.fg.logo(logo)
def add_video(self, link, title, pubdate, description=''):
fe = self.fg.add_entry()
fe.id(link)
fe.title(title)
fe.description(description)
fe.pubDate(pubdate)
mimetype = 'audio/mpeg'
if link.endswith('.m4a'):
mimetype = 'audio/mp4'
# add more formats if needed (usually works with audio/mpeg by default)
fe.enclosure(link, '0', mimetype)
def export(self):
return self.fg.rss_str(pretty=True)
def setUp(self):
fg = FeedGenerator()
self.feedId = 'http://example.com'
self.title = 'Some Testfeed'
fg.id(self.feedId)
fg.title(self.title)
fg.link(href='http://lkiesow.de', rel='alternate')[0]
fg.description('...')
fe = fg.add_entry()
fe.id('http://lernfunk.de/media/654321/1')
fe.title('The First Episode')
fe.content(u'…')
# Use also the different name add_item
fe = fg.add_item()
fe.id('http://lernfunk.de/media/654321/1')
fe.title('The Second Episode')
fe.content(u'…')
fe = fg.add_entry()
fe.id('http://lernfunk.de/media/654321/1')
fe.title('The Third Episode')
fe.content(u'…')
self.fg = fg
def generate(app, category, torrents):
"""
generate an rss feed from category with torrents as results
if category is None this feed is for all categories
"""
feed = FeedGenerator()
if category:
url = util.fullSiteURL(app, 'feed', '{}.rss'.format(category))
else:
url = util.fullSiteURL(app, 'feed', 'all.rss')
feed.link(href=url, rel="self")
feed.id(url)
if category:
title = "new {} torrents on index ex invisibilis".format(category)
else:
title = "new torrents on index ex invisibilis"
feed.title(title)
feed.description(title)
feed.author({"name": "anonymous"})
feed.language("en")
for torrent in torrents:
item = feed.add_entry()
url = util.fullSiteURL(app, torrent.downloadURL())
item.id(torrent.infohash)
item.link(href=url)
item.title(torrent.title)
item.description(torrent.summary(100))
return feed
def export_feed(self, output):
fg = FeedGenerator()
fg.load_extension('podcast')
fg.podcast.itunes_category('Religion & Spirituality', 'Christianity')
fg.podcast.itunes_image("%s/icon.png" % URL_BASE)
fg.title('JW.ORG Magazines')
fg.description(
'Combined Feed of Watchtower (public), Watchtower (study), and Awake! in English from jw.org.'
)
fg.link(href="%s/%s" % (URL_BASE, output), rel='self')
manifest = self._load()
entries = []
for lang, mnemonics in manifest.items():
for mnemonic, issues in mnemonics.items():
for issue, data in issues.items():
entries.append((issue, data))
for issue, entry in sorted(entries, key=lambda i: i[0], reverse=True):
fe = fg.add_entry()
fe.id(entry['hash'])
fe.title(entry['title'])
fe.description(entry['title'])
fe.published(pytz.utc.localize(entry['created_on']))
url = "%s/%s" % (URL_BASE, os.path.basename(entry['file']))
mime = 'audio/mpeg'
fe.enclosure(url, str(entry['duration']), mime)
fe.link(href=url, type=mime)
fg.rss_str(pretty=True)
fg.rss_file(os.path.join(CACHE_DIR, output))
def gen_feed(user, base_url, path, debug=False):
# Create feed
feed = FeedGenerator()
feed.id(urlparse.urljoin(base_url, user + '.xml'))
feed.title('Snapchat story for ' + user)
feed.link( href=urlparse.urljoin(base_url, user + '.xml'), rel='self' )
feed.language('en')
feed.description('Snapchat media')
# Iterate through files in path, sort by unix timestamp (newest first), then add to feed
files = sorted(os.listdir(path), reverse=True)
for filename in files:
split = filename.split('~')
if split[0] != user:
continue
if os.path.splitext(filename)[1] in ['.mp4', '.jpg']:
entry = feed.add_entry()
entry.id(urlparse.urljoin(base_url, filename))
entry.link(href=urlparse.urljoin(base_url, filename))
entry.title(filename)
# Write feed to disk
feed.rss_file(os.path.join(path, user + '.xml'))
date = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
if debug:
print('{0} Regenerated {1}'.format(date, urlparse.urljoin(base_url,
user + '.xml')))
def get(self):
# self.write("Hello, world")
#
# print(page.content)
p1 = Scrapper.ScrapeWebSite(
'http://www.londonstockexchange.com/exchange/prices-and-markets/stocks/indices/constituents-indices.html?index=UKX&industrySector=&page=1'
)
p2 = Scrapper.ScrapeWebSite(
'http://www.londonstockexchange.com/exchange/prices-and-markets/stocks/indices/constituents-indices.html?index=UKX&industrySector=&page=2'
)
p3 = Scrapper.ScrapeWebSite(
'http://www.londonstockexchange.com/exchange/prices-and-markets/stocks/indices/constituents-indices.html?index=UKX&industrySector=&page=3'
)
p4 = Scrapper.ScrapeWebSite(
'http://www.londonstockexchange.com/exchange/prices-and-markets/stocks/indices/constituents-indices.html?index=UKX&industrySector=&page=4'
)
p5 = Scrapper.ScrapeWebSite(
'http://www.londonstockexchange.com/exchange/prices-and-markets/stocks/indices/constituents-indices.html?index=UKX&industrySector=&page=5'
)
p6 = Scrapper.ScrapeWebSite(
'http://www.londonstockexchange.com/exchange/prices-and-markets/stocks/indices/constituents-indices.html?index=UKX&industrySector=&page=6'
)
shares = p1 + p2 + p3 + p4 + p5 + p6
fg = FeedGenerator()
fg.title("Footsie Shares")
fg.link(href='http://localhost:5000', rel='alternate')
fg.description('FTSE prices from last 15 mintues.')
for s in shares:
fe = fg.add_entry()
s.get_rss_item(fe)
self.write(fg.rss_str())
def feed(self, feed_title, title, content, url, published=None, summary=None,
enclosure=None, media_thumbnail=None):
feed = FeedGenerator()
feed.title(feed_title)
feed.description(faker.sentence())
feed.link({'href': WP_FEED_URL})
entry = feed.add_entry()
entry.title(title)
entry.link({'href': url})
entry.author(name=faker.name())
entry.content(content, type="cdata")
if summary:
entry.description(summary)
if enclosure:
entry.enclosure(url=enclosure['url'],
type=enclosure['type'],
length=str(faker.pyint()))
if media_thumbnail:
feed.load_extension('media')
entry.media.thumbnail({'url': media_thumbnail})
tz = pytz.timezone(faker.timezone())
published = published or faker.date_time(tzinfo=tz)
entry.published(published)
entry.updated(faker.date_time_between(start_date=published, tzinfo=tz))
return feed.rss_str().decode('utf8')
def recent_releases(organization_name=None):
"""Generates a feed for the releases of an organization."""
organization = Organization.query.filter(
Organization.name == organization_name).first()
if organization is None:
abort(404)
fg = FeedGenerator()
fg.id(
url_for(
"organization_bp.recent_releases",
organization_name=organization.name,
_external=True,
))
fg.title(f"Recent releases for {organization.name}")
fg.link(href=request.url, rel="self")
for project in organization.projects:
for release in project.releases:
fe = fg.add_entry()
fe.id(f"{release.project.name} {release.version}")
fe.title(f"{release.project.name} {release.version}")
fe.description(release.changes)
fe.link(href=release.release_url)
fe.updated(release.published_at.replace(tzinfo=timezone.utc))
fe.published(release.published_at.replace(tzinfo=timezone.utc))
atomfeed = fg.atom_str(pretty=True)
return atomfeed
def generate_rss(language, since):
url = "{0}?since={1}".format(language["url"], since)
file_name = "github_trends_{0}_{1}.rss".format(language["key"], since)
title = "GitHub Trends - {0} - {1}".format(language["name"], since.capitalize())
print(url)
page = requests.get(url)
tree = html.fromstring(page.content)
lis = tree.cssselect("ol.repo-list li")
fg = FeedGenerator()
fg.title(title)
fg.link(href="http://github-trends.ryotarai.info/rss/{0}".format(file_name))
fg.description(title)
index = 1
for li in lis:
a = li.cssselect("h3 a")[0]
description = ""
ps = li.cssselect("p")
if len(ps) > 0:
description = ps[0].text_content().strip()
fe = fg.add_entry()
fe.link(href="https://github.com{0}".format(a.get("href")))
fe.title("{0} (#{1} - {2} - {3})".format(
a.text_content().strip().replace(" / ", "/"),
index,
language["name"],
since.capitalize(),
))
fe.description(description)
index += 1
rssfeed = fg.rss_str(pretty=True)
s3.Object(bucket, 'rss/{0}'.format(file_name)).put(Body=rssfeed, ContentType="application/xml")
def generate_feed_from_episodes(episodes):
fg = FeedGenerator()
fg.load_extension('podcast')
fg.id('http://dannyshaw.github.io/podcast-feeds')
fg.title('Seinfeld Complete Audio')
fg.link(href='http://dannyshaw.github.io/podcast-feeds', rel='alternate')
fg.subtitle('I\'ve seen them enough, audio is all I need.')
fg.link(
href=
'https://raw.githubusercontent.com/dannyshaw/podcast-feeds/master/podcast-feeds/seinfeld.xml',
rel='self')
fg.language('en')
for index, ep in enumerate(episodes):
file_size = getsize(join(FILES, ep))
fe = fg.add_entry()
fe.id(f'https://s3.amazonaws.com/danny.podcasts.seinfeld/{ep}')
fe.title(ep)
fe.description(ep)
pub_date = datetime(1999, 1, 1, tzinfo=timezone.utc) + timedelta(index)
fe.pubDate(pub_date)
fe.link(href=f'https://s3.amazonaws.com/danny.podcasts.seinfeld/{ep}')
fe.enclosure(f'https://s3.amazonaws.com/danny.podcasts.seinfeld/{ep}',
f'{file_size}', 'audio/mpeg')
fg.rss_str(pretty=True)
fg.rss_file('seinfeld.xml')
def main():
client = moduleSocial.connectTumblr()
posts = client.posts('fernand0')
fg = FeedGenerator()
fg.id(posts['blog']['url'])
fg.title(posts['blog']['title'])
fg.author( {'name':posts['blog']['name'],'email':'*****@*****.**'} )
fg.link( href=posts['blog']['url'], rel='alternate' )
fg.subtitle('Alternate feed due to Tumblr GDPR restrictions')
fg.language('en')
print(len(posts['posts']))
for i in range(len(posts['posts'])):
fe = fg.add_entry()
print(posts['posts'][i]['post_url'])
if 'title' in posts['posts'][i]:
title = posts['posts'][i]['title']
print('T', posts['posts'][i]['title'])
else:
title = posts['posts'][i]['summary'].split('\n')[0]
print('S', posts['posts'][i]['summary'].split('\n')[0])
fe.title(title)
fe.link(href=posts['posts'][i]['post_url'])
fe.id(posts['posts'][i]['post_url'])
print(fg.atom_file('/var/www/html/elmundoesimperfecto/tumblr.xml'))
sys.exit()
def generateFeeds(buffered, meta):
utc = pytz.utc
fg = FeedGenerator()
fg.id(meta['id'])
fg.title(meta['title'])
fg.author(meta['author'])
fg.subtitle(meta['subtitle'])
fg.link( href=meta['link'], rel='self' )
fg.language(meta['language'])
for tweet in buffered:
fe = fg.add_entry()
fe.id(tweet['url'].decode('utf-8'))
fe.published(utc.localize(tweet['created_at']).astimezone(pytz.timezone(locale)))
#fe.guid(tweet['url'].decode('utf-8'))
fe.link(href=tweet['url'].decode('utf-8'), rel='alternate')
fe.title(tweet['readable_title'])
fe.description(tweet['readable_article'])
try:
fe.author({'name': '', 'email':tweet['user_name'].decode('utf-8') + ": " + tweet['text'].decode('utf-8')})
except Exception, e:
logger.error(e)
fe.author({'name': 'a', 'email':'*****@*****.**'})
