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 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']
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 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 main():
session = vk.Session()
api = vk.API(session)
group_id = '96469126'
group_info = api.groups.getById(group_ids=group_id, fields=['description', 'site', 'name', 'photo', 'gid'])
assert len(group_info) == 1
group_info = group_info[0]
url = 'http://vk.com/club{}'.format(group_info['gid'])
# a = api.wall.get(owner_id=-1 * group_info['gid'])
#
# with open('out', 'wb') as fio:
# pickle.dump(a, fio)
with open('out', 'rb') as fio:
data = pickle.loads(fio.read())
assert len(data) > 1
fg = FeedGenerator()
fg.id(url)
fg.title(_(group_info['name']))
fg.description(_(group_info['description']))
fg.logo(group_info['photo'])
site_url = group_info.get('site', url) if group_info.get('site', url) else url
fg.link(href=_(site_url))
fg.link(href=_(site_url), rel='self')
fg.link(href=_(site_url), rel='alternate')
fg.author({'name': 'Alexander Sapronov', 'email': '*****@*****.**'})
fg.webMaster('[email protected] (Alexander Sapronov)')
pat = re.compile(r"#(\w+)")
for x in data[1:]:
post_link = "{}?w=wall-{}_{}".format(url, group_info['gid'], x['id'])
e = fg.add_entry()
# text = x.get('text', '').replace('<br>', '\n')
text = x.get('text', '')
e.description(_(text))
e.author({'name': _(get_author_name(api, x.get('from_id')))})
e.id(post_link)
e.link(href=_(post_link))
e.link(href=_(post_link), rel='alternate')
tags = pat.findall(text)
title = x.get('text', '')
for tag in tags:
e.category(term=_(tag))
title = title.replace('#{}'.format(tag), '')
title = re.sub('<[^<]+?>', ' ', title)
title = textwrap.wrap(title, width=80)[0]
e.title(_(title.strip()))
fg.rss_file('rss.xml')
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')
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 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)
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 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 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 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 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_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 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 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 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 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 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')
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 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 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 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 feedgen():
with lite.connect(db) as conn:
conn.row_factory = dict_factory
#conn.row_factory = lite.Row
query = ("select * from podcast_items order by date(pubdate) DESC;")
cursor = conn.cursor()
cursor.execute(query)
data = cursor.fetchall()
# now process to xml:
fg = FeedGenerator()
fg.title('Teaching Podcast - Open Door')
fg.description('''We are a family of sojourners learning to walk in the way of Jesus for the good of the world (www.opendooreastbay.com)''')
fg.load_extension('podcast')
fg.language('en-US')
fg.link(href='http://podcast.opendooreastbay.com/', rel='self', type="application/rss+xml")
fg.podcast.itunes_author('Open Door East Bay')
fg.podcast.itunes_category('Religion & Spirituality')
fg.podcast.itunes_image('http://static1.squarespace.com/static/54c9a274e4b0d8961be0d970/t/555bb45ee4b051f7c699813d/1436299699944/1500w/od-emblem-blue.jpg')
fg.podcast.itunes_subtitle('Open Door Teachings')
fg.podcast.itunes_summary('''We are a family of sojourners learning to walk in the way of Jesus for the good of the world (www.opendooreastbay.com)''')
fg.podcast.itunes_explicit('no')
fg.podcast.itunes_owner(name='Open Door East Bay', email='*****@*****.**')
fg.podcast.itunes_new_feed_url('http://podcast.opendooreastbay.com') #to move itunes feed to a new url
fg.link(href='http://www.opendooreastbay.com', rel='alternate')
for item in data:
fe = fg.add_entry()
fe.id(item['enclosure_url'])
fe.podcast.itunes_author(item['itunes_author'])
fe.podcast.itunes_subtitle(item['itunes_subtitle'])
fe.podcast.itunes_explicit(item['itunes_explicit'])
fe.podcast.itunes_image(item['itunes_image'])
fe.podcast.itunes_duration(item['itunes_duration'])
fe.published(item['pubDate'])
fe.link(href=item['link'], rel='enclosure')
fe.title(item['title'])
fe.description(item['itunes_subtitle'])
fe.enclosure(item['enclosure_url'], item['enclosure_length'], item['enclosure_type'])
fg.rss_str(pretty=True)
fg.rss_file('podcast.xml')
print "wrote xml!"
return "wrote xml!"
def generateRss(fileList, directoryPath, baseUrl):
fg = FeedGenerator()
fg.load_extension('podcast')
#Setup Feed
fg.title(Config.podcastTitle)
baseUrl = Config.baseUrl
feed = baseUrl + '/rss'
fg.link(href=feed)
fg.description(Config.podcastDescription)
fg.language('en')
mainImage = baseUrl + '/files?filename=' + Config.mainImage
fg.image(mainImage)
#using Technology as other tags like Christianity wont validate
fg.podcast.itunes_category('Technology', 'Podcasting')
fg.podcast.itunes_owner(name=Config.ownerName, email=Config.ownerEmail)
#Setup episodes
for i in fileList:
fe = fg.add_entry()
mp3 = directoryPath + i['title']
# for local files
# stat = os.stat(mp3)
# size = os.path.getsize(mp3)
# mp3File = baseUrl + '/files?filename=' + i['title']
# fe.enclosure(mp3File, str(size) , 'audio/mp3')
fe.enclosure(i['url'], str(i['size']), 'audio/mp3')
fe.title(i['title'])
descriptionText = 'Authors: ' + i['authors']
fe.description(descriptionText)
link = baseUrl + '/files?filename=' + i['title']
fg.link(href=i['url'])
fe.podcast.itunes_explicit('no')
image = baseUrl + '/files?filename=' + Config.mainImage
fe.podcast.itunes_image(image)
#Save Rss
fg.rss_str(pretty=True)
saveLocation = directoryPath + 'podcast.xml'
fg.rss_file(saveLocation)
def notices_feed(feed_type):
if feed_type not in ["atom", "rss"]:
flask.abort(404)
url_root = flask.request.url_root
base_url = flask.request.base_url
feed = FeedGenerator()
feed.generator("Feedgen")
feed.id(url_root)
feed.copyright(
f"{datetime.now().year} Canonical Ltd. "
"Ubuntu and Canonical are registered trademarks of Canonical Ltd.")
feed.title("Ubuntu security notices")
feed.description("Recent content on Ubuntu security notices")
feed.link(href=base_url, rel="self")
def feed_entry(notice, url_root):
_id = notice.id
title = f"{_id}: {notice.title}"
description = notice.details
published = notice.published
notice_path = flask.url_for(".notice", notice_id=notice.id).lstrip("/")
link = f"{url_root}{notice_path}"
entry = FeedEntry()
entry.id(link)
entry.title(title)
entry.description(description)
entry.link(href=link)
entry.published(f"{published} UTC")
entry.author({"name": "Ubuntu Security Team"})
return entry
notices = (db_session.query(Notice).order_by(desc(
Notice.published)).limit(10).all())
for notice in notices:
feed.add_entry(feed_entry(notice, url_root), order="append")
payload = feed.atom_str() if feed_type == "atom" else feed.rss_str()
return flask.Response(payload, mimetype="text/xml")
def _build_feed(self):
router = Router(self._config)
fp = filterPlaceholders
fg = FeedGenerator()
fg.id(self._config.site_prefix)
fg.title(self._config.site_name)
fg.author({
'name': fp(self._config.author),
'email': fp(self._config.email)
})
fg.link(href=self._config.site_prefix, rel='alternate')
fg.logo(fp(self._config.site_logo))
fg.subtitle(fp(self._config.description))
fg.description(fp(self._config.description) or ' ')
fg.language(fp(self._config.language))
fg.lastBuildDate(moment.now().locale(self._config.locale).date)
fg.pubDate(moment.now().locale(self._config.locale).date)
for post in self._posts[:10]:
meta = post.meta
fe = fg.add_entry()
fe.title(meta['title'])
fe.link(href=router.gen_permalink_by_meta(meta))
fe.guid(router.gen_permalink_by_meta(meta), True)
fe.pubDate(meta['date'].date)
fe.author({
'name': meta['author'],
'uri': fp(self._config.author_homepage),
'email': fp(self._config.email)
})
fe.content(post.parsed)
if not os.path.exists(
unify_joinpath(self._config.build_dir, 'feed/atom')):
os.makedirs(unify_joinpath(self._config.build_dir, 'feed/atom'))
fg.rss_file(unify_joinpath(self._config.build_dir, 'feed/index.xml'))
fg.rss_file(unify_joinpath(self._config.build_dir, 'feed/index.html'))
fg.atom_file(
unify_joinpath(self._config.build_dir, 'feed/atom/index.xml'))
fg.atom_file(
unify_joinpath(self._config.build_dir, 'feed/atom/index.html'))
def get_rss_by_show_id(self, show_id):
show = self.get_show_by_show_id(show_id)
if show is None:
warnings.warn("get_show_by_show_id({}) returned None".format(show_id))
return None
eps = self.get_episodes_by_show_id(show_id)
if eps is None:
warnings.warn("get_episodes_by_show_id({}) returned None".format(show_id))
fg = FeedGenerator()
fg.load_extension("podcast")
fg.id(show_id)
fg.title(show["name"])
if "href" in show:
fg.link(href=show["href"], rel="via")
if "images" in show and show["images"]:
fg.logo(show["images"][0]["url"])
if "languages" in show and show["languages"]:
fg.language(show["languages"][0])
fg.description(show.get("description", None))
for ep in eps:
if "external_urls" not in ep or not ep["external_urls"]:
continue
url = None
for key, value in ep["external_urls"].items():
if url is None or not key == "spotify":
url = value
fe = fg.add_entry(order="append")
fe.title(ep["name"])
fe.id(ep["id"])
fe.description(ep.get("description", None))
fe.link(href=url)
try:
published = datetime_parse(ep["release_date"])
if published.tzinfo is None:
published = published.astimezone(timezone.utc)
fe.published(published)
except Exception:
pass
if "duration_ms" in ep:
fe.podcast.itunes_duration(int(ep["duration_ms"] / 1000))
return fg.rss_str(pretty=True)
def generate_feed(key: str, title: str, description: str, link: str):
feed = FeedGenerator()
feed.title(title)
feed.description(description)
feed.link(href=link)
feed.language("en")
appids = db.redis_conn.zrevrange(key, 0, 10, withscores=True)
apps = [(db.get_json_key(f"apps:{appid[0]}"), appid[1])
for appid in appids]
for app, timestamp in reversed(apps):
# sanity check: if index includes an app, but apps:ID is null, skip it
if not app:
continue
# sanity check: if application doesn't have the name field, skip it
if not app.get("name"):
continue
entry = feed.add_entry()
entry.title(app["name"])
entry.link(href=f"https://flathub.org/apps/details/{app['id']}")
timestamp = int(timestamp)
entry_date = datetime.utcfromtimestamp(timestamp).strftime(
"%a, %d %b %Y %H:%M:%S")
entry.pubDate(f"{entry_date} UTC")
content = [
'<img src="https://dl.flathub.org/repo/appstream/x86_64/icons/128x128/{}.png">'
.format(app["id"]),
f"<p>{app['summary']}</p>",
]
if description := app.get("description"):
content.append(f"<p>{description}</p>")
content.append("<h3>Additional information:</h3>")
content.append("<ul>")
if developer_name := app.get("developer_name"):
content.append(f"<li>Developer: {developer_name}</li>")
def rss():
fg = FeedGenerator()
fg.title('CloudWalk DevSecOps test')
fg.description('A RSS Feed for HTTP and TCP service')
fg.docs('')
fg.generator('')
fg.link(href='http://example.com')
with open('log.txt') as f:
for line in f.readlines():
info = line.replace('\n', '').split(';')
fe = fg.add_entry()
fe.title(f"{info[1]}")
fe.pubDate(f"{info[0]} GTM-3")
fe.description(f"server: {info[2]} port:{info[3]}")
response = make_response(fg.rss_str())
response.headers.set('Content-type', 'application/rss+xml')
return response
class Feed:
# create the feed
def __init__(self, url):
self.feed = FeedGenerator()
self.feed.title("Comic Subs")
self.feed.link(href=url)
self.feed.description("The Comics Subscription Feed")
# add a chapter to the feed
def add_chapter(self, chapter):
fe = self.feed.add_entry()
fe.title(chapter.title)
fe.guid(chapter.url)
fe.link(href=chapter.url)
fe.pubdate(chapter.published.replace(tzinfo=utc))
# return the feed's rss
def rss(self):
return self.feed.rss_str()
def saveFeed(listings, title, path):
url = githubRepoURL + title + ".xml"
# Create a feed generator
fg = FeedGenerator()
# Create the feed's title
fg.id(url)
fg.title(title)
fg.author({'name': 'Ben Snell'})
fg.description("NYC 2BR Apartment Listings in " + title)
fg.link(href=url, rel='alternate')
fg.language('en')
time = datetime.now().strftime('%Y-%m-%d %H:%M:%S') + "-05:00"
fg.pubDate(time)
fg.updated(time)
for apt in listings:
e = fg.add_entry()
e.id(apt[0])
e.title("$" + apt[1] + " // " + apt[4])
e.link(href=apt[0])
text = ""
if apt[5] != "":
imgs = apt[5].split(" ")
for i in range(len(imgs)):
text += "<img src=\"" + imgs[i] + "\" /> "
if i == 0:
text += "<p>" + apt[8] + "</p>"
else:
text += "<p>" + apt[8] + "</p>"
e.content(type="html", content=text)
# This doesn't seem to work:
e.pubDate(datetime2RSSString(clDate(apt[2])))
e.updated(datetime2RSSString(clDate(apt[2])))
fg.atom_str(pretty=True)
fg.atom_file(path)
def rss():
'''
Reference - https://old.reddit.com/r/flask/comments/evjcc5/question_on_how_to_generate_a_rss_feed/
'''
# Default Parameters
params = {'limit': 5, 'blacklist': list(), 'threshold': 0.8}
if 'limit' in request.args:
params['limit'] = int(request.args.get('limit'))
if 'nowords' in request.args:
params['blacklist'] = literal_eval(request.args.get('nowords'))
if 'similar' in request.args:
params['blacklist'] = (float(request.args.get('similar'))
if float(request.args.get('similar')) <= 1 else
0.8)
fg = FeedGenerator()
fg.title('Hacker News - Best')
fg.description('Created for personal use by Parth Parikh')
fg.link(href='https://pncnmnp.github.io')
UTC = tz.gettz('UTC')
articles = get_news(params)
for article in articles:
fe = fg.add_entry()
fe.title(article['title'])
try:
fe.link(href=article['url'])
except:
fe.link(href=HN_LINK.format(str(article['id'])))
fe.guid(str(article['id']), permalink=False)
fe.author(name=article['by'])
fe.published(datetime.datetime.fromtimestamp(article['time'], tz=UTC))
response = make_response(fg.rss_str())
response.headers.set('Content-Type', 'application/rss+xml')
return response
def all_top_posts():
url = 'http://localhost:2015/votes/all/top/{num}'
url = url.format(num = 25)
headers = {'content-type': 'application/json'}
r = requests.get(url, headers=headers)
print(str(r.status_code)+ "<<<-----======")
data = r.json()
post_id = data['data']
fg = FeedGenerator()
fg.id(url)
fg.title('Microservice - view all top posts')
fg.link( href=url, rel='alternate' )
fg.description('The 25 top posts to any community')
fg.language('en')
for i in post_id:
print("Does it break here?")
url = 'http://localhost:2015/posts/all/post/{id}'
url = url.format(id = i)
headers = {'content-type': 'application/json'}
r = requests.get(url, headers=headers)
print("Or Here?")
data = r.json()
post_info = data['data']
fe = fg.add_entry()
fe.id(post_info['post_id'])
fe.author({'name': post_info['author'], 'email':""})
fe.title(post_info['title'])
fe.description(post_info['community'])
date = datetime.fromtimestamp(post_info['date'])
date = date.replace(tzinfo=pytz.utc)
print(date)
fe.published(date)
fe.content(content=post_info['text'])
if 'url' in post_info:
fe.source(url=post_info['url'], title=post_info['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 user_rss(service, id):
cursor = get_cursor()
query = "SELECT * FROM posts WHERE \"user\" = %s AND service = %s "
params = (id, service)
query += "ORDER BY added desc "
query += "LIMIT 10"
cursor.execute(query, params)
results = cursor.fetchall()
cursor3 = get_cursor()
query3 = "SELECT * FROM lookup WHERE id = %s AND service = %s"
params3 = (id, service)
cursor3.execute(query3, params3)
results3 = cursor.fetchall()
name = results3[0]['name'] if len(results3) > 0 else ''
fg = FeedGenerator()
fg.title(name)
fg.description('Feed for posts from ' + name + '.')
fg.id(f'http://{request.headers.get("host")}/{service}/user/{id}')
fg.link(href=f'http://{request.headers.get("host")}/{service}/user/{id}')
fg.generator(generator='Kemono')
fg.ttl(ttl=40)
for post in results:
fe = fg.add_entry()
fe.title(post['title'])
fe.id(
f'http://{request.headers.get("host")}/{service}/user/{id}/post/{post["id"]}'
)
fe.link(
href=
f'http://{request.headers.get("host")}/{service}/user/{id}/post/{post["id"]}'
)
fe.content(content=post["content"])
fe.pubDate(pytz.utc.localize(post["added"]))
response = make_response(fg.atom_str(pretty=True), 200)
response.headers['Content-Type'] = 'application/rss+xml'
return response
def make_csdn_rss():
fg = FeedGenerator()
fg.id('http://blog.csdn.net')
fg.title(u'CSDN 博客频道')
fg.author({
'name': 'pfchai',
})
fg.link(href='http://blog.csdn.net', rel='self')
fg.description(u"csdn 首页博客")
csdn = CSDN()
for item in csdn.get_item():
fe = fg.add_entry()
fe.id(item['link'])
fe.title(item['title'])
fe.author({'name': item['author']})
fe.description(item['description'])
fe.content(item['description'])
return fg
def feed(feed_id):
user = get_user_by_feed(feed_id)
if user:
generator = FeedGenerator()
generator.id(str(feed_id))
generator.title("Vulnfeed Feed")
generator.description('Vulnfeed data in RSS form')
generator.link(href=request.url)
generator.language('en')
for scored_item in user.last_scored_list:
entry = generator.add_entry()
entry.id(scored_item['report']['id'])
entry.title(scored_item['report']['title'])
entry.description(scored_item['report']['contents'])
entry.link(href=scored_item['report']['link'])
return generator.rss_str(pretty=True)
else:
return "Not found"
def gen_feed():
fg = FeedGenerator()
fg.id(f"{ID}")
fg.title(f"{USERNAME} notes")
fg.author({"name": USERNAME, "email": "*****@*****.**"})
fg.link(href=ID, rel="alternate")
fg.description(f"{USERNAME} notes")
fg.logo(ME.get("icon", {}).get("url"))
fg.language("en")
for item in DB.activities.find({
"box": Box.OUTBOX.value,
"type": "Create"
},
limit=50):
fe = fg.add_entry()
fe.id(item["activity"]["object"].get("url"))
fe.link(href=item["activity"]["object"].get("url"))
fe.title(item["activity"]["object"]["content"])
fe.description(item["activity"]["object"]["content"])
return fg
def index_rss():
if current_user.is_authenticated:
links = trending_links(current_user.subscribed_feed_ids)
else:
links = trending_links(current_app.config["DEFAULT_FEEDS"])
paginated_ids, _, _ = paginate(links, 30)
links = Link.by_ids(paginated_ids)
# TODO maybe do through fake feed (that's what reddit does and it actually makes sense)
fg = FeedGenerator()
fg.id("https://localhost:5000/")
fg.title("Newsfeed")
fg.link(href="http://localhost:5000/", rel="self")
fg.description("Global news agrregator!")
fg.language("en")
for entry in rss_entries(links):
fg.add_entry(entry)
return fg.rss_str(pretty=True)
def rss(self, name):
cherrypy.response.headers['Content-Type'] = 'application/rss+xml'
fg = FeedGenerator()
cursor.execute(
"SELECT * FROM RSS WHERE source = %s ORDER BY filedate DESC;",
(name, ))
fg.id(config.get('Options', 'rss_url') + name)
fg.title(config.get(name, 'rss_title'))
fg.description(config.get(name, 'rss_desc'))
fg.link(href=config.get('Options', 'rss_url') + name, rel='alternate')
for row in cursor:
fe = fg.add_entry()
fe.id('https://drive.google.com/uc?id=' + row[1] +
'&export=download')
fe.title(
config.get(name, 'feed_entry_prepend') + row[2] +
config.get(name, 'feed_entry_postpend'))
fe.description(row[2] + ' - https://drive.google.com/uc?id=' +
row[1] + '&export=download')
return fg.rss_str(pretty=True)
def get_blog_cn(url, bucket, key):
blogs = requests.get(url)
fg = FeedGenerator()
fg.title('AWS Blog RSS')
fg.link(href='https://aws.amazon.com/blogs')
fg.description('AWS Blog RSS')
for blog in blogs.json()['items']:
if blog['additionalFields']['slug'] == 'all': continue
fe = fg.add_entry()
fe.link(href=blog['additionalFields']['link'])
fe.title(blog['additionalFields']['title'])
fe.id(blog['id'])
fe.description(blog['additionalFields']['slug'])
fe.pubDate(blog['additionalFields']['modifiedDate'])
response = upload_to_s3(fg, bucket, key)
return response
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 saveFeed(listings, title, path):
url = githubRepoURL + title + ".xml"
# Create a feed generator
fg = FeedGenerator()
# Create the feed's title
fg.id(url)
fg.title(title)
fg.author({'name': 'Ben Snell'})
fg.description("Art Show Open Call Opportunities")
fg.link(href=url, rel='alternate')
fg.language('en')
time = datetime.now().strftime('%Y-%m-%d %H:%M:%S') + "-05:00"
fg.pubDate(time)
fg.updated(time)
for item in listings:
e = fg.add_entry()
e.id(item["ID"])
# Get a clearer title
thisTitle = getShortDate(item["Application Deadline"]) + item["Title"]
e.title(thisTitle)
# for key, value in item.items():
# print(key, value);
# print(item["url"])
# if "url" in item:
e.link(href=item["url"])
text = getHtmlFormattedListing(item)
e.content(type="html", content=text)
# This doesn't seem to work:
# e.pubDate( datetime2RSSString(clDate(apt[2])) )
# e.updated( datetime2RSSString(clDate(apt[2])) )
fg.atom_str(pretty=True)
fg.atom_file(path)
def __init__(self):
feeds = RssFetch.get_feeds()
fg = FeedGenerator()
fg.title("Sascha's Reader's Digest")
fg.link(href='https://www.sascha-curth.de', rel='alternate')
fg.description('These news catched my attention.')
for item in sorted(feeds,
key=lambda k: k['FEED_PUBLISHED'],
reverse=False):
fe = fg.add_entry()
fe.id(str(item['id']))
fe.title(item['FEED_TITLE'])
fe.link(href=item['FEED_LINK'], rel="alternate")
author = '{"email": "%s", "name":"%s" }' % (item['FEED_NAME'],
item['rss_link'])
author = json.loads(author)
fe.author(author)
fe.pubDate(pytz.utc.localize(item['FEED_PUBLISHED']))
fe.description(str(item['description']))
sorted_fg = sorted(feeds,
key=lambda k: k['FEED_PUBLISHED'],
reverse=True)
fg.rss_file('static/readers_digest_rss.xml')
s3 = boto3.resource('s3')
s3.meta.client.upload_file(CONFIG.get("AWS", "sourcefile"),
CONFIG.get("AWS", "bucket"),
CONFIG.get("AWS", "targetfile"))
client = boto3.client('cloudfront')
response = client.create_invalidation(
DistributionId=CONFIG.get("AWS", "distribution"),
InvalidationBatch={
'Paths': {
'Quantity': 1,
'Items': ['/readers_digest_rss.xml'],
},
'CallerReference': str(time()).replace(".", "")
})
print(response)
def _generate_feed(self):
feed = FeedGenerator()
feed.load_extension('podcast')
feed.podcast.itunes_author(self.author)
feed.podcast.itunes_category(self.category)
feed.podcast.itunes_explicit(self.is_explicit)
feed.podcast.itunes_image(f'{self.logo_uri}.{self.JPG_FILE_EXTENSION}')
feed.podcast.itunes_owner(name=self.author, email=self.email)
feed.podcast.itunes_subtitle(self.subtitle)
feed.podcast.itunes_summary(self.description)
feed.author(name=self.author, email=self.email)
feed.description(self.description)
feed.language(self.language)
feed.link(href=self.website, rel='alternate')
feed.logo(self.logo_uri)
feed.subtitle(self.subtitle)
feed.title(self.name)
return feed
def lt3():
news = scrapper.get_lt3_news()
fg = FeedGenerator()
fg.title(news['title'])
fg.description(news['description'])
fg.link(href=news['link'])
for article in news['articles']:
fe = fg.add_entry()
fe.title(article['title'])
fe.link(href=article['link'])
fe.description(article['description'])
fe.guid(article['link'], permalink=True)
fe.author(name=article['author'])
fe.pubDate(article['pubDate'])
res = flask.make_response(fg.rss_str())
res.headers.set('Content-Type', 'application/xml')
return res
def render_feed(feed_id: str, plugin: Plugin, options: GlobalOptions,
base_url: str):
feed = plugin.get_feed(feed_id)
fg = FeedGenerator()
fg.load_extension('podcast')
fg.title(feed.title)
fg.description(feed.description)
fg.link(href=feed.link, rel='alternate')
fg.image(options.icon or feed.image)
fg.id(feed.feed_id)
for item in reversed(feed.items):
fe = fg.add_entry()
fe.id(item.item_id)
fe.title(item.title)
fe.description(item.description)
fe.pubDate(item.date)
fe.podcast.itunes_image(item.image)
fe.enclosure(generate_url(item, plugin, options, base_url),
item.content_length, item.content_type)
return fg.rss_str(pretty=True) if options.format == 'rss' else fg.atom_str(
pretty=True)
def rss():
fg = FeedGenerator()
fg.title('Feed title')
fg.description('Feed Description')
# Orignal link
#fg.link(href='https://neighborly-client-v1.azurewebsites.net/')
#Andrew's link
fg.link(href='https://myneighborlyapiv1.azurewebsites.net/')
response = requests.get(settings.API_URL + '/getAdvertisements')
ads = response.json()
for a in ads:
fe = fg.add_entry()
fe.title(a.title)
fe.description(a.description)
response = make_response(fg.rss_str())
response.headers.set('Content-Type', 'application/rss+xml')
return response
def rss(name: str, _id: str):
fg = FeedGenerator()
events_link = event_base_link(actor_name=name, actor_id=_id)
fg.id(events_link)
fg.title(name + "のイベント・ライブ情報一覧")
fg.description(name + "のイベント・ライブ情報一覧")
fg.link(href=events_link, rel='alternate')
fg.language("ja")
for event in cached_events(actor_name=name,
actor_id=_id,
events_cache=EVENTS_CACHE):
fe = fg.add_entry()
fe.id(event._id)
fe.link(href=event_link(event._id))
fe.title(f"{event.year}/{event.month}/{event.day} {event.title}")
fe.pubDate(
datetime(year=event.year,
month=event.month,
day=event.day,
tzinfo=pytz.timezone("Asia/Tokyo")))
return fg.rss_str(pretty=True)
def feed(posts: Tuple[Post], kind: str) -> FeedGenerator:
log.debug('generating %s feed', kind)
fg = FeedGenerator()
fg.title('beepb00p')
fg.author(name='karlicoss', email='*****@*****.**')
# TODO better description?
fg.description('feed')
bb = lambda x: f'https://beepb00p.xyz{x}'
fg.id(bb(f'/{kind}.xml'))
fg.link(rel='self', href=bb(f'/{kind}.xml'))
fg.link(href=bb(''))
if len(posts) > 0:
dates = (p.date for p in posts)
fg.updated(
max(tz.localize(d) if d is not None else throw() for d in dates))
# eh, apparnetly in adds items to the feed from bottom to top...
for post in reversed(posts):
fe = fg.add_entry()
# not sure why id() doesn't allow to set permalink=True
fe.guid(bb(post.url), permalink=True)
fe.link(href=bb(post.url))
fe.title(post.title)
# TOOD FIXME meh.
d = post.date
assert d is not None
td = tz.localize(d)
fe.published(td)
fe.updated(td)
# TODO meh, later use proper update date...
#
# TODO use type=text/html for comparisons?
# TODO meh
if post.upid == 'infra_diagram':
content = "Sorry, this post contains a huge diagram and isn't RSS friendly. It's best viewed on the website"
else:
content = post.body
fe.content(content, type='html')
return fg
def slack_history_to_feedgen(history):
fg = FeedGenerator()
fg.title(CONFIG["Feed"]["title"])
fg.id(CONFIG["Feed"]["id"])
fg.link(CONFIG["Feed"]["link"])
fg.description(CONFIG["Feed"]["description"])
for message in history["messages"]:
message_id = message.get(
"client_msg_id", f'{message.get("user")}--{message.get("ts")}')
fe = fg.add_entry()
fe.id(message_id)
title = None
summary = None
link = []
for file in message.get("files", []):
title = title or file.get("title", None)
link_href = file.get("url_private", None)
link_rel = "alternate"
link.append(dict(href=link_href, rel=link_rel, title=title))
for attachment in message.get("attachments", []):
title = title or attachment.get("title", None)
summary = summary or attachment.get("text", None)
link_href = attachment.get("from_url", None)
link_rel = "alternate"
link.append(dict(href=link_href, rel=link_rel, title=title))
fe.title(title or "Untitled")
fe.summary(summary)
fe.content(message["text"])
fe.link(link)
return fg
def generate_feed(input_file, output_file):
fg = FeedGenerator()
fg.load_extension('podcast', rss=True)
## RSS tags
# Required
fg.title(TITLE)
fg.link(href=LINK)
fg.description(DESCRIPTION)
# Optional
fg.language('en')
fg.image(url=IMAGE_URL, title=TITLE, link=LINK)
fg.ttl(720)
fg.webMaster(CONTACT['name'])
now = datetime.datetime.now()
tz = pytz.timezone('Europe/Amsterdam')
fg.pubDate(tz.localize(now))
# iTunes
fg.podcast.itunes_author('Dan LeBatard')
fg.podcast.itunes_category(itunes_category='Sports & Recreation',
itunes_subcategory='Professional')
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'])
# Add items
items = read_items(input_file)
for item in items:
fe = fg.add_entry()
## RSS tags
fe.id(item['guid'])
fe.title(item['title'])
fe.description(item['description'])
fe.enclosure(item['link'], 0, 'audio/mpeg')
fe.pubdate(item['pubDate'])
# Finish off the file
fg.rss_str(pretty=True)
fg.rss_file(output_file)
def make_feed(entries, yargs):
"""Take a list of (datetime, feedgen.entry)s and the program arguments
and create a feed file."""
from feedgen.feed import FeedGenerator
fg = FeedGenerator()
# metadata
fg.id(yargs.feed_link)
fg.title(yargs.feed_title)
fg.description(
yargs.feed_description if yargs.feed_description else yargs.feed_title)
fg.link(href=yargs.feed_link)
# entries
for ts, e in entries:
fg.add_entry(e)
# output
if yargs.feed_type == "RSS":
fg.rss_file(yargs.feed_path)
elif yargs.feed_type == "Atom":
fg.atom_file(yargs.feed_path)
