def gen_feed(runtime):
print "Generate feed.atom.."
posts = runtime.posts
conf = runtime.conf
charset = runtime.charset
feed = AtomFeed(
title=conf["blog"]["name"],
subtitle=conf["blog"]["description"],
feed_url=conf["blog"]["url"]+"/feed.atom",
url=conf["blog"]["url"],
author=conf["author"]["name"]
)
# gen the first 10 posts
for post in posts[:10]:
feed.add(
title=post.title,
content=post.html,
content_type="html",
author=conf["author"]["name"],
url=conf["blog"]["url"]+"/"+post.out,
updated=post.update_at
)
open("feed.atom", "w").write(feed.to_string().encode(charset))
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.contains([int(category.getId())]),
~Event.is_deleted,
event_filter)
.options(load_only('id', 'start_dt', 'title', 'description', 'protection_mode'),
subqueryload('acl_entries'))
.order_by(Event.start_dt))
events = [e for e in query if e.can_access(user)]
feed = AtomFeed(feed_url=url, title='Indico Feed [{}]'.format(to_unicode(category.getTitle())))
for event in events:
feed.add(title=event.title,
summary=unicode(event.description), # get rid of RichMarkup
url=url_for('event.conferenceDisplay', confId=event.id, _external=True),
updated=event.start_dt)
return BytesIO(feed.to_string().encode('utf-8'))
def get_index(self, user, head):
restype = get_restype(self.request)
if restype == 'default':
pages = WikiPage.get_index(user)
page_group = groupby(pages, lambda p: title_grouper(p.title))
html = template(self.request, 'wiki_sp_index.html',
{'page_group': page_group})
self.response.headers['Content-Type'] = 'text/html; charset=utf-8'
set_response_body(self.response, html, head)
elif restype == 'atom':
pages = WikiPage.get_index(None)
config = WikiPage.get_config()
host = self.request.host_url
url = "%s/sp.index?_type=atom" % host
feed = AtomFeed(title="%s: title index" %
config['service']['title'],
feed_url=url,
url="%s/" % host,
author=config['admin']['email'])
for page in pages:
feed.add(title=page.title,
content_type="html",
author=page.modifier,
url='%s%s' % (host, page.absolute_url),
updated=page.updated_at)
self.response.headers['Content-Type'] = 'text/xml; charset=utf-8'
set_response_body(self.response, feed.to_string(), head)
else:
self.abort(400, 'Unknown type: %s' % restype)
def get_changes(self, user, head):
restype = get_restype(self.request)
rendered = None
if restype == 'default':
if rendered is None:
pages = WikiPage.get_changes(user)
rendered = template(self.request, 'wiki_sp_changes.html',
{'pages': pages})
self.response.headers['Content-Type'] = 'text/html; charset=utf-8'
set_response_body(self.response, rendered, head)
elif restype == 'atom':
if rendered is None:
pages = WikiPage.get_changes(None, 3, include_body=True)
config = WikiPage.get_config()
host = self.request.host_url
url = "%s/sp.changes?_type=atom" % host
feed = AtomFeed(title="%s: changes" % config['service']['title'],
feed_url=url,
url="%s/" % host,
author=config['admin']['email'])
for page in pages:
feed.add(title=page.title,
content_type="html",
content=page.rendered_body,
author=page.modifier,
url='%s%s' % (host, page.absolute_url),
updated=page.updated_at)
rendered = feed.to_string()
self.response.headers['Content-Type'] = 'text/xml; charset=utf-8'
set_response_body(self.response, rendered, head)
else:
self.abort(400, 'Unknown type: %s' % restype)
def render_output(self):
_feed_global = {
'author': self.flourish.site_config['author'],
'title': self.flourish.site_config['title'],
'url': self.flourish.site_config['base_url'],
'feed_url': '%s%s' % (
self.flourish.site_config['base_url'],
self.current_url,
),
}
_feed = AtomFeed(**_feed_global)
for _object in self.source_objects:
entry = {
'title': _object.title,
'content': _object.body,
'content_type': 'html',
'url': _object.absolute_url,
'published': _object.published,
'updated': _object.published,
'author': self.flourish.site_config['author'],
}
if 'author' in _object:
entry['author'] = _object.author
if 'updated' in _object:
entry['updated'] = _object.updated
_feed.add(**entry)
return _feed.to_string()
def publish(self):
feed = AtomFeed(title=self.title,
id=self.link,
url=self.link,
icon=self.icon,
updated=self.updated)
for date, summary in sorted(self.new_entries, reverse=True):
entry_link = self.link + '#' + date.strftime('%Y-%m-%d')
updated = date + datetime.timedelta(hours=23, minutes=59, seconds=59)
title = "Digest for " + date.strftime('%Y-%m-%d')
if self.prefix:
title = '[' + self.prefix + '] ' + title
if self.suffix:
title = title + ' [' + self.suffix + ']'
feed.add(title=title,
id=entry_link,
content=summary,
content_type='html',
url=entry_link,
updated=updated)
self.xml = feed.to_string()
def get_sp_index(self, user, head):
restype = self._get_restype()
if restype == "default":
pages = WikiPage.get_index(user)
page_group = groupby(pages, lambda p: title_grouper(p.title))
html = self._template("wiki_sp_index.html", {"page_group": page_group})
self.response.headers["Content-Type"] = "text/html; charset=utf-8"
self._set_response_body(html, head)
elif restype == "atom":
pages = WikiPage.get_index(None)
config = WikiPage.yaml_by_title(".config")
host = self.request.host_url
url = "%s/sp.index?_type=atom" % host
feed = AtomFeed(
title="%s: title index" % config["service"]["title"],
feed_url=url,
url="%s/" % host,
author=config["admin"]["email"],
)
for page in pages:
feed.add(
title=page.title,
content_type="html",
author=page.modifier,
url="%s%s" % (host, page.absolute_url),
updated=page.updated_at,
)
self.response.headers["Content-Type"] = "text/xml; charset=utf-8"
self._set_response_body(feed.to_string(), head)
else:
self.abort(400, "Unknown type: %s" % restype)
def generate_atom_feed():
striplist = sorted(get_striplist())
last_five_strips = reversed(striplist[-5:])
feed = AtomFeed(
title="Gone with the Blastwave",
subtitle="Unofficial feed for the GWTB comics.",
feed_url="https://github.com/Bystroushaak/gwtb_atom_generator",
url="http://www.blastwave-comic.com/",
author="Bystroushaak")
for comic_id, title in last_five_strips:
image_link = image_link_from_comic_number(comic_id)
date = get_date_from_image(image_link)
feed.add(
title=title,
# content="Body of my post",
# content_type="text",
author='GWTB',
url='http://www.blastwave-comic.com/index.php?p=comic&nro=%d' %
comic_id,
updated=date)
return feed.to_string()
def render(self, data, media_type, **options):
title = u'Novi\u010dar'
# I'm sure this could be done better...
page_url = settings.LOCAL_URL + "#!/latest"
if "query" in data:
query = data["query"]
if isinstance(query, unicode):
query = query.encode("utf8")
urlencoded_query = urllib.quote(query)
page_url += "#" + urlencoded_query
url = settings.LOCAL_URL + '/v1/news/latest/?q=' + urlencoded_query
title = data["query"].strip() + " - " + title
else:
url = settings.LOCAL_URL + '/v1/news/latest/'
# It would be nice to know time of last crawl, so that the "updated"
# field for the feed could be set.
feed = AtomFeed(title=title,
url=page_url,
feed_url=url)
if 'results' in data:
self.add_feed_items(feed, data['results'])
return feed.to_string()
def get_index(self, user, head):
restype = get_restype(self.request)
if restype == 'default':
pages = WikiPage.get_index(user)
page_group = groupby(pages,
lambda p: title_grouper(p.title))
html = template(self.request, 'wiki_sp_index.html',
{'page_group': page_group})
self.response.headers['Content-Type'] = 'text/html; charset=utf-8'
set_response_body(self.response, html, head)
elif restype == 'atom':
pages = WikiPage.get_index(None)
config = WikiPage.get_config()
host = self.request.host_url
url = "%s/sp.index?_type=atom" % host
feed = AtomFeed(title="%s: title index" % config['service']['title'],
feed_url=url,
url="%s/" % host,
author=config['admin']['email'])
for page in pages:
feed.add(title=page.title,
content_type="html",
author=page.modifier,
url='%s%s' % (host, page.absolute_url),
updated=page.updated_at)
self.response.headers['Content-Type'] = 'text/xml; charset=utf-8'
set_response_body(self.response, feed.to_string(), head)
else:
self.abort(400, 'Unknown type: %s' % restype)
def get_changes(self, user, head):
restype = get_restype(self.request)
rendered = None
if restype == 'default':
if rendered is None:
pages = WikiPage.get_changes(user)
rendered = template(self.request, 'wiki_sp_changes.html',
{'pages': pages})
self.response.headers['Content-Type'] = 'text/html; charset=utf-8'
set_response_body(self.response, rendered, head)
elif restype == 'atom':
if rendered is None:
pages = WikiPage.get_changes(None, 3, include_body=True)
config = WikiPage.get_config()
host = self.request.host_url
url = "%s/sp.changes?_type=atom" % host
feed = AtomFeed(title="%s: changes" %
config['service']['title'],
feed_url=url,
url="%s/" % host,
author=config['admin']['email'])
for page in pages:
feed.add(title=page.title,
content_type="html",
content=page.rendered_body,
author=page.modifier,
url='%s%s' % (host, page.absolute_url),
updated=page.updated_at)
rendered = feed.to_string()
self.response.headers['Content-Type'] = 'text/xml; charset=utf-8'
set_response_body(self.response, rendered, head)
else:
self.abort(400, 'Unknown type: %s' % restype)
def notification_feed():
url = 'http://office.dju.kr/postg/board/board1.htm'
resp = session.get(url)
tree = html.fromstring(resp.content.decode(resp.apparent_encoding))
table = tree.xpath('//*/table//table//table//table//table[2]')[0]
feed = AtomFeed(title='DJU postg notification',
url='http://localhost/',
author='Kjwon15')
for tr in table.xpath('tr[position() mod 2 = 1 and position() != last()]'):
number = tr.xpath('td[1]')[0].text_content().strip()
title = tr.xpath('td[2]')[0].text_content().strip()
is_new = bool(tr.xpath('td[2]')[0].xpath('img'))
author = tr.xpath('td[3]')[0].text_content().strip()
date = tr.xpath('td[4]')[0].text_content().strip()
date = datetime.strptime(date, '%Y-%m-%d')
link = url + tr.xpath('td[2]/a')[0].attrib['href']
feed.add(title='{}{} {}'.format(number, ' [new]' if is_new else '',
title),
author=author,
url=link,
updated=date)
return feed.to_string()
def _feed(self, *args, **kwargs):
host = cherrypy.request.base
atom = AtomFeed(title=self.blog_title, url=host,
feed_url=cherrypy.url(),
author=self.author)
for post in self.listing():
atom.add(title=post["title"],
url=host + post["path"],
author=self.author,
content_type="html",
content=post["html"],
updated=post["date"])
return atom.to_string()
def _feed(self, *args, **kwargs):
host = cherrypy.request.base
atom = AtomFeed(title=self.blog_title,
url=host,
feed_url=cherrypy.url(),
author=self.author)
for post in self.listing():
atom.add(title=post["title"],
url=host + post["path"],
author=self.author,
content_type="html",
content=post["html"],
updated=post["date"])
return atom.to_string()
def render_atom(req, title, path, pages, include_content=False, use_published_date=False):
config = WikiPage.get_config()
host = req.get_host()
title = '%s: %s' % (config['service']['title'], title)
url = "%s/%s?_type=atom" % (host, path)
feed = AtomFeed(title=title, feed_url=url, url="%s/" % host, author=config['admin']['email'])
for page in pages:
feed.add(title=page.title,
content_type="html",
content=(page.rendered_body if include_content else ""),
author=page.modifier,
url='%s%s' % (host, page.absolute_url),
updated=(page.published_at if use_published_date else page.updated_at))
return feed.to_string()
def _execute(self, fossils):
results = fossils["results"]
if type(results) != list:
results = [results]
feed = AtomFeed(title="Indico Feed", feed_url=fossils["url"])
for fossil in results:
feed.add(
title=unicodeOrNone(fossil["title"]),
summary=unicodeOrNone(fossil["description"]),
url=fossil["url"],
updated=fossil["startDate"], # ugh, but that's better than creationDate
)
return feed.to_string()
def _execute(self, fossils):
results = fossils['results']
if type(results) != list:
results = [results]
feed = AtomFeed(title='Indico Feed', feed_url=fossils['url'])
for fossil in results:
feed.add(
title=unicodeOrNone(fossil['title']),
summary=unicodeOrNone(fossil['description']),
url=fossil['url'],
updated=fossil[
'startDate'] # ugh, but that's better than creationDate
)
return feed.to_string()
def output():
print('\n [::: Writing output :::]\n')
out_dir = site.root['output']
for post in site.posts.values():
path = os.path.join(out_dir, post.Url)
os.makedirs(os.path.dirname(path), exist_ok=True)
with open(path, 'w') as f:
f.write(post.content)
print(path)
for f in site.files:
path_split = f.split(site.root['content'])
if len(path_split) == 1: # Doesn't split
continue
file_path = path_split[-1]
file_path = file_path[1:] # Cut first '/'
path = os.path.join(out_dir, file_path)
print(path)
os.makedirs(os.path.dirname(path), exist_ok=True)
if os.path.exists(path):
os.remove(path)
shutil.copy(f, path)
# Generate feed
feed = AtomFeed(title=site.info['title'],
feed_url=site.info['url'] + '/feed',
url=site.info['url'],
author=site.info['author'])
for post in site.posts.values():
if post.Layout == 'post':
feed.add(title=post.Title,
content=post.html,
content_type="html",
author=post.Author,
url=post.Url,
updated=post.Date)
with open(os.path.join(site.root['output'], 'feed'), 'w') as feed_file:
feed_file.write(feed.to_string())
# Update cache
with open(os.path.join(site.root['output'], site.cache_name),
'wb') as cache_file:
pickle.dump(site.posts, cache_file)
def _execute(self, fossils):
results = fossils['results']
if not isinstance(results, list):
results = [results]
feed = AtomFeed(title='Indico Feed', feed_url=fossils['url'])
for fossil in results:
feed.add(
title=to_unicode(fossil['title']) or None,
summary=to_unicode(fossil['description']) or None,
url=fossil['url'],
updated=_deserialize_date(
fossil['startDate']
) # ugh, but that's better than creationDate
)
return feed.to_string()
def output():
print('\n [::: Writing output :::]\n')
out_dir = site.root['output']
for post in site.posts.values():
path = os.path.join(out_dir, post.Url)
os.makedirs(os.path.dirname(path), exist_ok = True)
with open(path, 'w') as f:
f.write(post.content)
print(path)
for f in site.files:
path_split = f.split(site.root['content'])
if len(path_split) == 1: # Doesn't split
continue
file_path = path_split[-1]
file_path = file_path[1:] # Cut first '/'
path = os.path.join(out_dir, file_path)
print(path)
os.makedirs(os.path.dirname(path), exist_ok = True)
if os.path.exists(path):
os.remove(path)
shutil.copy(f, path)
# Generate feed
feed = AtomFeed(title = site.info['title'],
feed_url = site.info['url'] + '/feed',
url = site.info['url'],
author = site.info['author'])
for post in site.posts.values():
if post.Layout == 'post':
feed.add(title = post.Title,
content = post.html,
content_type = "html",
author = post.Author,
url = post.Url,
updated = post.Date)
with open(os.path.join( site.root['output'],'feed'), 'w') as feed_file:
feed_file.write(feed.to_string())
# Update cache
with open(os.path.join(site.root['output'], site.cache_name), 'wb') as cache_file:
pickle.dump(site.posts, cache_file)
def _execute(self, fossils):
results = fossils['results']
if type(results) != list:
results = [results]
feed = AtomFeed(
title='Indico Feed',
feed_url=fossils['url']
)
for fossil in results:
feed.add(
title=unicodeOrNone(fossil['title']),
summary=unicodeOrNone(fossil['description']),
url=fossil['url'],
updated=fossil['startDate'] # ugh, but that's better than creationDate
)
return feed.to_string()
def index(req):
forumurl = "writeme" # replace with e.g. "https://forums.factorio.com/viewforum.php?f=3"
if forumurl == "writeme":
req.status = mod_python.apache.HTTP_INTERNAL_SERVER_ERROR
return "The admin for this script needs to manually set the 'forumurl' parameter in the source code"
baseurl = get_baseurl(forumurl);
soup = get_soup(forumurl)
forumtitle = get_forumtitle(soup)
#generate feed
feed = AtomFeed(title=forumtitle,
url=forumurl,
icon=get_favicon(soup, baseurl))
#Add forum topics
for a in soup.findAll("a", { "class" : "topictitle" }):
datestring = a.parent.contents[-1]
datematch = re.match('^ » (.*?)\s*$', datestring, re.M)
datestring_trimmed = datematch.group(1)
published = updated = dateutil.parser.parse(datestring_trimmed)
author_a = a.parent.find("a", { "class" : "username-coloured"})
if author_a:
author = author_a.string
else:
author = "(author not found)"
#phpBB generates a unique new session id (sid) for each forum
#download, and adds this to all urls. This will make feed
#readers interpret each link as unique each time it polls. So we
#need to remove the sid=...
url = baseurl + "/" + a["href"]
url = re.sub('&sid=[0-9a-f]+','', url)
feed.add(title=a.string,
url=url,
published=published,
updated=updated,
author=author,
)
return feed.to_string()
class HackernewsPipeline(object):
output_filename = "hackernews100.atom"
def __init__(self):
dispatcher.connect(self.spider_opened, signal=signals.spider_opened)
dispatcher.connect(self.spider_closed, signal=signals.spider_closed)
self.existing_feed = feedparser.parse(self.output_filename)
def spider_opened(self, spider):
self.feed = AtomFeed(
title = "Hacker News >100",
subtitle = "Hacker News over 100 points",
feed_url = "http://feeds.dannysu.com/hackernews100.atom",
url = "http://news.ycombinator.com/over?points=100"
)
def spider_closed(self, spider):
f = codecs.open(self.output_filename, 'w', 'utf-8')
f.write(self.feed.to_string())
def process_item(self, item, spider):
found = False
for entry in self.existing_feed['entries']:
if entry.link == item['link']:
item['body'] = entry.content[0].value
found = True
if not found:
body = ""
if not item['link'].endswith('.pdf'):
html = urllib.urlopen(item['link']).read()
body = Document(html).summary()
item['body'] = '<a href="' + item['comment'] + '">HN Comments</a><br>' + body
self.feed.add(
url = item['link'],
title = item['title'],
content = item['body'],
content_type = "html",
updated=datetime.datetime.utcnow()
)
return item
def rss(dmp):
url = config['site'][:-1] if config['site'].endswith('/') else config['site']
feed = AtomFeed(title=config['title'],
feed_url=url + "/feed",
url=url,
author=config['author'])
feed_dict = OrderedDict(sorted(dmp.archive.items(), reverse=True))
#current_date = datetime.now().strftime('%Y-%m-%d')
try:
for x in xrange(10):
feed.add(title=feed_dict.items()[x][1]['title'],
content=feed_dict.items()[x][1]['content'],
content_type="html",
author=config['author'],
url=url + feed_dict.items()[x][0],
updated=datetime.strptime(feed_dict.items()[x][1]['date'], '%Y-%m-%d')
)
except IndexError:
pass
save(os.path.join(config['output'], config['feed']), feed.to_string())
def atom(request):
"""Display atom feed
"""
feed = AtomFeed(title="Alternativebit",
subtitle="Alternativebit",
feed_url="http://www.alternativebit.fr/atom",
url="http://alternativebit.fr",
author="Ninja Trappeur")
session = dbSession()
query = session.query(Article).order_by(desc('id'))[0:14]
session.close()
for article in query:
feed.add(title=article.title,
content=article.content,
content_type="html",
author=article.author,
url="http://www.alternativebit.fr/article/{0}".format(article.id),
updated=article.date)
return Response(feed.to_string())
def hn100():
feed = AtomFeed(
title = "Hacker News >100",
subtitle = "Hacker News over 100 points",
feed_url = "http://feeds.dannysu.com/hackernews100.atom",
url = "http://news.ycombinator.com/over?points=100"
)
entries = Entry.query.all()
regex = re.compile(r"HN Comments.*", re.DOTALL)
for entry in entries:
feed.add(
url = entry.link,
title = entry.title,
content = regex.sub("HN Comments</a></br></body></html>", entry.body),
content_type = "html",
updated=datetime.datetime.utcnow()
)
return Response(feed.to_string(), mimetype='application/atom+xml')
def note_feed():
from pyatom import AtomFeed
site_url = '://'.join(request.urlparts[:2])
author = app_config.get('feed.author')
db_session = Session()
notes = db_session.query(Note).order_by(Note.created_at.desc()).limit(10).all()
feed = AtomFeed(title=app_config.get('feed.title'),
subtitle=app_config.get('feed.subtitle'),
feed_url=site_url + app.get_url('note-feed'),
url=site_url + app.get_url('note-list'),
author=author)
for note in notes:
feed.add(title=note.title,
content=strip_cut(note.text),
content_type="html",
author=author,
url=site_url + app.get_url('note-details', note_id=note.id),
updated=note.created_at)
response.add_header('Content-Type', 'application/atom+xml')
return feed.to_string()
def _render_posts_atom(self, title, pages):
host = self.request.host_url
config = WikiPage.yaml_by_title(".config")
if title is None:
feed_title = "%s: posts" % config["service"]["title"]
url = "%s/sp.posts?_type=atom" % host
else:
feed_title = title
url = "%s/%s?_type=atom" % (WikiPage.title_to_path(title), host)
feed = AtomFeed(title=feed_title, feed_url=url, url="%s/" % host, author=config["admin"]["email"])
for page in pages:
feed.add(
title=page.title,
content_type="html",
content=page.rendered_body,
author=page.modifier,
url="%s%s" % (host, page.absolute_url),
updated=page.published_at,
)
return feed.to_string()
def note_feed():
from pyatom import AtomFeed
site_url = '://'.join(request.urlparts[:2])
author = app_config.get('feed.author')
db_session = Session()
notes = db_session.query(Note).order_by(
Note.created_at.desc()).limit(10).all()
feed = AtomFeed(title=app_config.get('feed.title'),
subtitle=app_config.get('feed.subtitle'),
feed_url=site_url + app.get_url('note-feed'),
url=site_url + app.get_url('note-list'),
author=author)
for note in [n for n in notes if not n.is_draft]:
feed.add(title=note.title,
content=strip_cut(note.text),
content_type="html",
author=author,
url=site_url + app.get_url('note-details', note_id=note.id),
updated=note.created_at)
response.add_header('Content-Type', 'application/atom+xml')
return feed.to_string()
def getCurrentData():
feed = AtomFeed(title=u"PSO2 予告緊急RSS",
subtitle=u"【非公式】PSO2の予告緊急を近い順に表示するよ",
feed_url=u"http://sakaki2700.dip.jp/pso2rss",
url=u"http://pso2.jp/players/news/?mode=event",
author=u"")
conn = sqlite3.connect(db_path)
sql = "select * from events where time > datetime('now', '+9 hours') order by time limit 10;".decode("utf-8")
cursor = conn.cursor()
cursor.execute(sql)
for row in cursor:
feed.add(title=u"【"+row[0]+u"】"+row[1],
content=row[2],
content_type=u"html",
author=u"pso2",
url=u"http://pso2.jp/players/news/?mode=event",
updated=datetime.utcnow())
return feed.to_string().encode("utf-8")
def atom(request):
"""Display atom feed
"""
feed = AtomFeed(title="Alternativebit",
subtitle="Alternativebit",
feed_url="http://www.alternativebit.fr/atom",
url="http://alternativebit.fr",
author="Ninja Trappeur")
session = dbSession()
query = session.query(Article).order_by(desc('id'))[0:14]
session.close()
for article in query:
feed.add(title=article.title,
content=article.content,
content_type="html",
author=article.author,
url="http://www.alternativebit.fr/article/{0}".format(
article.id),
updated=article.date)
return Response(feed.to_string())
def render_posts_atom(req, title, pages):
host = req.host_url
config = WikiPage.get_config()
if title is None:
feed_title = '%s: posts' % config['service']['title']
url = "%s/sp.posts?_type=atom" % host
else:
feed_title = title
url = "%s/%s?_type=atom" % (WikiPage.title_to_path(title), host)
feed = AtomFeed(title=feed_title,
feed_url=url,
url="%s/" % host,
author=config['admin']['email'])
for page in pages:
feed.add(title=page.title,
content_type="html",
content=page.rendered_body,
author=page.modifier,
url='%s%s' % (host, page.absolute_url),
updated=page.published_at)
return feed.to_string()
def render_posts_atom(req, title, pages):
host = req.host_url
config = WikiPage.get_config()
if title is None:
feed_title = '%s: posts' % config['service']['title']
url = "%s/sp.posts?_type=atom" % host
else:
feed_title = title
url = "%s/%s?_type=atom" % (WikiPage.title_to_path(title), host)
feed = AtomFeed(title=feed_title,
feed_url=url,
url="%s/" % host,
author=config['admin']['email'])
for page in pages:
feed.add(title=page.title,
content_type="html",
content=page.rendered_body,
author=page.modifier,
url='%s%s' % (host, page.absolute_url),
updated=page.published_at)
return feed.to_string()
def __makeFeedsForOverview(forge, pagekey, posts, url):
if forge.settingFor('address'):
filename = 'atom.xml'
relpath = url + '/' + filename
feedurl = forge.settingFor('address') + '/' + relpath
pagedef = forge.pageInfoFor(pagekey)
feed = AtomFeed(title=pagedef['title'],
subtitle=pagedef['subtitle'],
feed_url=feedurl,
url=url,
author=pagedef['author'])
for postdef in posts:
feed.add(title=postdef['title'],
content=str(postdef['soup']),
content_type='xhtml',
author=postdef['author'],
url=forge.settingFor('address') +
makePostUrl(pagedef, postdef),
updated=datetime.fromisoformat(postdef['date']))
return {relpath: feed.to_string()}
else:
return {}
def feed(self):
db.reset_queries()
url = ''.join(['https://' if self.is_secure() else 'http://', self.get_host()])
feed = AtomFeed(
title = 'The VitalVas',
url = url,
feed_url = ''.join([url, reverse('feed')]),
author = {
'name': 'VitalVas',
'email': '*****@*****.**'
},
)
for item in Article.objects.filter(publish=True).filter(published__lt=datetime.now())[:5]:
feed.add(
title = item.title,
content = cut_preview(item.html_compile),
content_type = 'html',
author = 'VitalVas',
url = ''.join([url, item.get_absolute_url()]),
updated = item.updated,
)
return HttpResponse(feed.to_string(), content_type='text/xml')
def news_feed():
feed = AtomFeed("Jazzband News Feed",
feed_url=request.url,
url=request.url_root,
generator=None)
for page in news_pages:
if page.path == "index":
continue
published = page.meta.get("published", None)
updated = page.meta.get("updated", published)
summary = page.meta.get("summary", None)
feed.add(
title=page.meta["title"],
content=str(page.html),
content_type="html",
summary=summary,
summary_type="text",
author=page.meta.get("author", None),
url=full_url(url_for("content.news", path=page.path)),
updated=updated,
published=published,
)
return Response(feed.to_string(), mimetype="application/atom+xml")
def render_atom(req,
title,
path,
pages,
include_content=False,
use_published_date=False):
config = WikiPage.get_config()
host = req.host_url
title = '%s: %s' % (config['service']['title'], title)
url = "%s/%s?_type=atom" % (host, path)
feed = AtomFeed(title=title,
feed_url=url,
url="%s/" % host,
author=config['admin']['email'])
for page in pages:
feed.add(title=page.title,
content_type="html",
content=(page.rendered_body if include_content else ""),
author=page.modifier,
url='%s%s' % (host, page.absolute_url),
updated=(page.published_at
if use_published_date else page.updated_at))
return feed.to_string()
def render_feed(articles):
feed = AtomFeed(
title='words from a colons',
feed_url=DOMAIN + FEED_URL,
url=DOMAIN + ROOT,
author=AUTHOR,
)
feed_item_template = get_template('feed_item.html')
for article in articles:
context = Context({'article': article})
feed.add(
title=article.title,
content=feed_item_template.render(context),
content_type='html',
author=AUTHOR,
url=DOMAIN + article.absolute_url,
updated=article.meta['date'],
)
return feed.to_string()
def atom_feed(request):
feed = AtomFeed(
title=request.registry.settings['site_name'],
feed_url=request.route_url('atom_feed'),
url=request.route_url('view_all'),
author=request.registry.settings['site_name'] # will do for now
)
articles = DBSession.query(Article).order_by(
Article.date_published.desc()).filter_by(
is_published=True) # TODO: limit x
for article in articles:
content = format_article(article)
feed.add(content['title'],
content['body'],
url=article.get_url(request),
updated=article.updated,
published=article.date_published)
return Response(
body=feed.to_string(),
content_type='application/atom+xml',
)
def generate_feed(posts, subtitle='', url="https://sowingseasons.com/feed.atom"):
logger.info('generate_feed(%s)' % url)
feed = AtomFeed(
title="SowingSeasons",
title_type="text",
subtitle="takes awhile to grow anything. %s" % subtitle,
subtitle_type="text",
feed_url=url,
url="https://sowingseasons.com",
author="Blake VandeMerwe",
icon="/static/img/ico_black.png",
logo="/static/img/logo.png",
rights="MIT LICENSE",
rights_type="text",
generator=("PyAtom", "https://github.com/sramana/pyatom", "1.4")
)
for post in posts.results:
post = DotDict(post)
feed.add(
title=post.title,
title_type="text",
content=fn_markdown(post.content),
content_type="html",
summary=post.summary,
summary_type="text",
url='https://sowingseasons.com' + document_slug(post),
updated=post.modified,
author="Blake VandeMerwe",
published=post.modified,
rights="MIT LICENSE",
rights_type="text"
)
return feed.to_string()
def get(self, username):
developer = findDeveloperByUsername(username)
if not developer:
self.response.set_status(404)
self.renderResponse('errors/404.html')
return
snippets = findSnipsByDeveloperId(developer['developer_id'])
from pyatom import AtomFeed
import datetime
feed = AtomFeed(
title='%s\'s code snippets' % developer['username'],
subtitle='(most recent code snippets from this developer)',
feed_url=buildUrl('dev-feed',
username=developer['username'],
_full=True),
url=buildUrl('dev-username',
username=developer['username'],
_full=True),
author=developer['username'])
for snip in snippets:
feed.add(
title=snip['title'],
content=snip['description'],
content_type='html',
author=developer['username'],
url=buildUrl('snip-index',
lang=snip['lang'],
cat=snip['cat'],
title=snip['sanitized_title']),
updated=snip['creation_date'] # datetime.datetime.utcnow()
)
self.response.headers['Content-type'] = 'text/xml;charset=utf-8'
self.response.write(feed.to_string())
def get_sp_changes(self, user, head):
restype = self._get_restype()
email = user.email() if user is not None else "None"
rendered = None
if restype == "default":
if rendered is None:
pages = WikiPage.get_changes(user)
rendered = self._template("wiki_sp_changes.html", {"pages": pages})
self.response.headers["Content-Type"] = "text/html; charset=utf-8"
self._set_response_body(rendered, head)
elif restype == "atom":
if rendered is None:
pages = WikiPage.get_changes(None, 3, include_body=True)
config = WikiPage.yaml_by_title(".config")
host = self.request.host_url
url = "%s/sp.changes?_type=atom" % host
feed = AtomFeed(
title="%s: changes" % config["service"]["title"],
feed_url=url,
url="%s/" % host,
author=config["admin"]["email"],
)
for page in pages:
feed.add(
title=page.title,
content_type="html",
content=page.rendered_body,
author=page.modifier,
url="%s%s" % (host, page.absolute_url),
updated=page.updated_at,
)
rendered = feed.to_string()
self.response.headers["Content-Type"] = "text/xml; charset=utf-8"
self._set_response_body(rendered, head)
else:
self.abort(400, "Unknown type: %s" % restype)
# create RSS feed
feed = AtomFeed(title="Proyectos de Ley",
subtitle=u'del Congreso de la República del Perú',
feed_url="http://myurl.com/feed",
url="http://myurl.com",
author="Me")
html_files = glob.glob(os.path.join("pdf", "*html"))
data_file = codecs.open("proyectos_data.json", "r", "utf-8")
data = json.loads(data_file.read())
data_file.close()
for i in html_files:
title = i.replace("pdf/", "")
title = title.replace(".html", "")
title = title.replace("_", "/")
for json in data:
if json['numero_proyecto'] == title:
content = json['titulo'] + "<br />"
content += "autores: " + json['congresistas']
feed.add(title=title,
content=content,
content_type="html",
author="Me",
url="http://myurl.com/" + i,
updated=datetime.datetime.utcnow())
f = codecs.open("feed.xml", "w", "utf-8")
f.write(feed.to_string())
f.close()
log = str(rss[7]) + " || " + str(rss[6]) + " || " + title
try:
subprocess.check_output('echo "%s" >> %s' % (log.replace("\"","\\\""), logFile), shell=True)
except:
pass
feedNew.add(title=title,
content=content,
content_type="html",
author=author,
url=link,
updated=dateUpdated)
numFeedOld = len(feedOld["items"])
numFeedNew = len(feedparser.parse(feedNew.to_string())["items"])
for i in range(0, maxEntry - numFeedNew):
try:
content = fixStr(feedOld["items"][i]["content"])
dateUpdated = datetime.datetime.strptime(feedOld["items"][i]['updated'],'%Y-%m-%dT%H:%M:%SZ')
feedNew.add(
title=feedOld["items"][i]["title"],
content=content,
content_type="html",
author=feedOld["items"][i]["author"],
url=feedOld["items"][i]["link"],
updated=dateUpdated)
except:
pass
if (i == (numFeedOld - 1)):
break
subprocess.check_output(
'echo "%s" >> %s' %
(log.replace("\"", "\\\""), logFile),
shell=True)
except:
pass
feedNew.add(title=title,
content=content,
content_type="html",
author=author,
url=link,
updated=dateUpdated)
numFeedOld = len(feedOld["items"])
numFeedNew = len(feedparser.parse(feedNew.to_string())["items"])
#lay tin cu
for i in range(0, maxEntry - numFeedNew):
if (i >= len(feedOld["items"])):
break
try:
content = fixStr(feedOld["items"][i]["content"])
except:
content = feedOld["items"][i]["title"]
dateUpdated = datetime.datetime.strptime(
feedOld["items"][i]['updated'], '%Y-%m-%dT%H:%M:%SZ')
feedNew.add(title=feedOld["items"][i]["title"],
content=content,
content_type="html",
author=feedOld["items"][i]["author"],
url=feedOld["items"][i]["link"],
link = "http://translate.google.com.vn/translate?sl=" + lang[1] + "&tl=en&prev=_t&hl=en&ie=UTF-8&eotf=1&u=" + urllib.quote_plus(link)
log = str(rss[7]) + " || " + str(rss[6]) + " || " + title
try:
subprocess.check_output('echo "%s" >> %s' % (log.replace("\"","\\\""), logFile), shell=True)
except:
pass
feedA.add(title=title,
content=rss[5],
content_type="html",
author=author,
url=link,
updated=dateUpdated)
numFeedOrg = len(feed["items"])
numFeedA = len(feedparser.parse(feedA.to_string())["items"])
if (numFeedA < maxEntry) and numFeedOrg > 0:
for itemTmp in feed["items"]:
#print itemTmp['updated']
try:
content = itemTmp["content"]
except:
content = ""
dateUpdated = datetime.datetime.strptime(itemTmp['updated'],'%Y-%m-%dT%H:%M:%SZ')
#print dateUpdated
feedA.add(
title=itemTmp["title"],
content=content,
content_type="html",
author=itemTmp["author"],
url=itemTmp["link"],
try:
subprocess.check_output('echo "%s" >> %s' %
(log.replace("\"", "\\\""), logFile),
shell=True)
except:
pass
feedA.add(title=title,
content=rss[5],
content_type="html",
author=author,
url=link,
updated=dateUpdated)
numFeedOrg = len(feed["items"])
numFeedA = len(feedparser.parse(feedA.to_string())["items"])
if (numFeedA < maxEntry) and numFeedOrg > 0:
for itemTmp in feed["items"]:
#print itemTmp['updated']
try:
content = itemTmp["content"]
except:
content = ""
dateUpdated = datetime.datetime.strptime(
itemTmp['updated'], '%Y-%m-%dT%H:%M:%SZ')
#print dateUpdated
feedA.add(title=itemTmp["title"],
content=content,
content_type="html",
author=itemTmp["author"],
url=itemTmp["link"],
js = error.read()
req.status = mod_python.apache.HTTP_INTERNAL_SERVER_ERROR
if js is None:
gerror = ""
else:
gerror = " Error returned by googleapis.com: " + js;
return "Failed to fetch playlist items from Google. Your Google developer key is invalid, or Google is down"
decoded = json.loads(js)
items = items + decoded["items"]
if 'nextPageToken' in decoded:
url = base_url+"&pageToken="+decoded["nextPageToken"]
else:
break
#generate feed
feed = AtomFeed(title=channelTitle+": " + playlistTitle,
url="https://www.youtube.com/playlist?list="+playlistId)
#add items to feed
for episode in items:
s = episode["snippet"]
#For whatever reason, YouTube includes private videos in the results. Which you cannot watch. Remove them.
if s["title"] != "Private video":
feed.add(title=s["title"],
url="https://youtube.com/watch?v="+s["resourceId"]["videoId"],
published=parser.parse(s["publishedAt"]),
updated=parser.parse(s["publishedAt"]),
author=channelTitle,
)
return feed.to_string()
def render_string(self):
feed = AtomFeed(**self.doc)
return feed.to_string()
from pyatom import AtomFeed
import datetime
feed = AtomFeed(title="My Blog",
subtitle="My example blog for a feed test.",
feed_url="http://example.org/feed",
url="http://example.org",
author="Me")
# Do this for each feed entry
feed.add(title="My Post",
content="Body of my post",
content_type="html",
author="Me",
url="http://example.org/entry1",
updated=datetime.datetime.utcnow())
print(feed.to_string())
# create RSS feed
feed = AtomFeed(title="Proyectos de Ley",
subtitle=u'del Congreso de la República del Perú',
feed_url = "http://myurl.com/feed",
url = "http://myurl.com",
author = "Me")
html_files = glob.glob(os.path.join("pdf", "*html"))
data_file = codecs.open("proyectos_data.json", "r", "utf-8")
data = json.loads(data_file.read())
data_file.close()
for i in html_files:
title = i.replace("pdf/", "")
title = title.replace(".html", "")
title = title.replace("_", "/")
for json in data:
if json['numero_proyecto'] == title:
content = json['titulo'] + "<br />"
content += "autores: " + json['congresistas']
feed.add(title = title,
content = content,
content_type = "html",
author = "Me",
url = "http://myurl.com/" + i,
updated=datetime.datetime.utcnow())
f = codecs.open("feed.xml", "w", "utf-8")
f.write(feed.to_string())
f.close()
def render_string(self):
feed = AtomFeed(**self.doc)
return feed.to_string()
from pyatom import AtomFeed
import datetime
feed = AtomFeed(title="My Blog",
subtitle="My example blog for a feed test.",
feed_url="http://example.org/feed",
url="http://example.org",
author="Me")
# Do this for each feed entry
feed.add(title="My Post",
content="Body of my post",
content_type="html",
author="Me",
url="http://example.org/entry1",
updated=datetime.datetime.utcnow())
print feed.to_string()
def generate(self):
'''Generate the whole static site.
Iterates through all existing s2 pages, rendering and writing
them (and copying all common files along).
It also generates the toc, a sitemap, and the atom feed
etc. (in the future it should handle tags and categories)
'''
if self._dirs['base'] == None or not self._tree_ready:
#there's NO base here or up the chain
raise ValueError #cannot generate!
# wipe www dir & recreate
self._wipe_www_dir() #copy common files
#shutil.copytree(self.dirs['common'],
# os.path.join(self.dirs['www'],"common"))
slist = glob.glob(os.path.join(self.dirs['common'], "*"))
for fo in slist:
rfn = os.path.split(fo)[1]
if os.path.isdir(fo):
shutil.copytree(fo, os.path.join(self.dirs['www'], rfn))
else:
shutil.copy(fo, self.dirs['www'])
# init atom file
title = self.site_config['site_title']
if title == '':
title = "<No title>"
feed = AtomFeed(title=title,
subtitle=self.site_config['site_subtitle'],
feed_url=os.path.join(self.site_config['site_url'],
"atom.xml"),
url=self.site_config['site_url'],
author=self.site_config['default_author'])
themes_to_copy = [] # full paths!
generated_page_info = []
for slug in self._pages_to_generate(
): #this list of pages is in reverse chrono order
p = s2page.Page(self, slug, isslug=True)
generated_page_info.append({
'slug': p.slug,
'title': p.title,
'date': p.creation_date,
'in_toc': p.in_toc
})
t = p.theme_path
if not t in themes_to_copy:
themes_to_copy.append(t)
# wipe destination.
self._wipe_www_page(slug)
pg_content = p.generate() #generate page
# add atom entry
try:
cdd = datetime.strptime(
p.creation_date,
'%Y-%m-%d') # feed.add needs the dat in datetime format
except:
print "Wrong date format in page '%s'. It should be YYYY-MM-DD." % p.slug
print "Site Generation stopped!! correct the date and generate again."
self._wipe_www_dir()
sys.exit()
feed.add(title=p.title,
content=pg_content,
content_type="html",
author=p.author,
url=os.path.join(self.site_config['site_url'],
"atom.xml"),
updated=cdd)
# copy themes
wthemesdir = os.path.join(self.dirs['www'], "themes")
os.mkdir(wthemesdir)
for d in themes_to_copy:
dname = os.path.split(d)[1]
destpath = os.path.join(wthemesdir, dname)
shutil.copytree(d, destpath)
# delete tpl files
ttr = glob.glob(os.path.join(destpath, "*tpl"))
for f in ttr:
os.remove(f)
# write atom file
atomfile = codecs.open(os.path.join(self.dirs['www'], "atom.xml"),
"w",
encoding="utf-8",
errors="xmlcharrefreplace")
atomfile.write(feed.to_string())
atomfile.close()
# create front page/s
#print "generated_page_info for gf ",generated_page_info
ff = self.site_config['fixed_frontpage']
if ff != None and ff != '':
self._set_fixed_frontpage(ff)
else:
self.generate_front(generated_page_info)
self._generate_site_map(generated_page_info)