Python AtomFeed.to_string方法代码示例

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import to_string [as 别名]
def feed(name):
    if current_app.config.get('PRIVATE_WIKI') and current_user.is_anonymous:
        return current_app.login_manager.unauthorized()
    cname = to_canonical(name)
    wiki_name = current_app.config['SITE_TITLE']
    start = 0
    length = int(request.args.get('length', 20))

    the_feed = AtomFeed(
        title="{} - Recent changes for page '{}'".format(wiki_name, cname),
        url=url_for('wiki.page', name=cname, _external=True),
        id="{}_pagefeed_{}".format(to_canonical(wiki_name), cname),
        feed_url=url_for('wiki.feed', name=cname, _external=True),
        generator=("Realms wiki", 'https://github.com/scragg0x/realms-wiki', __version__)
    )

    page = g.current_wiki.get_page(cname)
    items = list(itertools.islice(page.history, start, start + length))  # type: list[dict]

    for item in items:
        the_feed.add(
            title="Commit '{}'".format(item['sha']),
            content=item['message'],
            url=url_for('wiki.commit', name=name, sha=item['sha'], _external=True),
            id="{}/{}".format(item['sha'], cname),
            author=item['author'],
            updated=datetime.fromtimestamp(item['time'])
        )

    response = make_response((the_feed.to_string(), {'Content-type': 'application/atom+xml; charset=utf-8'}))
    response.add_etag()
    return response.make_conditional(request)

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import to_string [as 别名]
def test_feedparser_authors():
    for test in tests:
        if test.skip:
            continue

        feed = AtomFeed(title="Test Feed", feed_url="http://testfeed.com")

        entry = FeedEntry(
            title="Test Entry",
            url="http://testfeed.com/testentry",
            updated=datetime.utcnow(),
            content="Test Entry",
            author=test.namestring,
        )

        feed.entries.append(entry)

        rss = feed.to_string()

        parsed = feedparser.parse(rss)

        assert parsed.entries is not None
        assert len(parsed.entries) == 1

        assert len(parsed.entries[0].authors) == len(test.expected)

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import to_string [as 别名]
def compute_atom_feed(request):
    feed = AtomFeed(
             title     = catonmat_title,
             subtitle  = catonmat_subtitle,
             feed_url  = 'http://www.catonmat.net/feed',
             url       = 'http://www.catonmat.net',
             author    = peteris,
             icon      = 'http://www.catonmat.net/favicon.ico',
             generator = ('catonmat blog', 'http://www.catonmat.net', 'v1.0')
           )

             # TODO: logo='http://www.catonmat.net/)

    pages = session. \
              query(Page). \
              join(Rss). \
              order_by(Rss.publish_date.desc()). \
              limit(config.rss_items). \
              all()

    for page in pages:
        feed.add(title        = page.title,
                 content      = page.parsed_content,
                 content_type = 'html',
                 author       = peteris,
                 url          = 'http://www.catonmat.net' + page.request_path,
                 id           = page.page_id,
                 updated      = page.last_update,
                 published    = page.rss_page.publish_date)

    return feed.to_string()

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import to_string [as 别名]
    def generate_feed(artifact):
        feed = AtomFeed(
            title=title or 'Feed',
            subtitle=unicode(subtitle or ''),
            subtitle_type=hasattr(subtitle, '__html__') and 'html' or 'text',
            feed_url=feed_url,
            url=embed_url,
            id=get_id(ctx.env.project.id + 'lektor')
        )

        for item in items:
            feed.add(
                get_item_title(item, item_title_field),
                get_item_body(item, item_body_field),
                xml_base=url_to(item, external=True),
                url=url_to(item, external=True),
                content_type='html',
                id=get_id(u'%slektor/%s' % (
                    ctx.env.project.id,
                    item['_path'].encode('utf-8'),
                )),
                author=get_item_author(item, item_author_field),
                updated=get_item_updated(item, item_date_field))

        with artifact.open('wb') as f:
            f.write(feed.to_string().encode('utf-8') + '\n')

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import to_string [as 别名]
def build_feed():
    feed = AtomFeed(current_app.config['SITE_NAME'],
                    feed_url=current_app.config['DOMAIN'] + 'rss.xml',
                    url=current_app.config['DOMAIN'],
                    subtitle=current_app.config['SUBTITLE'],
                    author=current_app.config['AUTHOR'],
                    updated=datetime.datetime.now())

    entries = Entry.get_all_published()

    for _entry in entries:
        time = datetime.datetime.strptime(_entry['date'], '%Y-%m-%d %H:%M:%S')

        feed.add(unicode(_entry['title']),
                 unicode(markdown(_entry['content'])),
                 content_type='html',
                 author=current_app.config['AUTHOR'],
                 published=time,
                 updated=time,
                 id=current_app.config['DOMAIN'] + _entry['slug'] + '/',
                 url=current_app.config['DOMAIN'] + 'posts/' + _entry['slug'] + '/'
                 )

    with codecs.open(BASE_DIR + '/rss.xml', 'w', 'utf-8-sig') as f:
        f.write(feed.to_string())

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import to_string [as 别名]
 def feed(self, feed_title, title, content, url, published=None, summary=None,
          enclosure=None, media_thumbnail=None):
     feed = AtomFeed(feed_title, feed_url=WP_FEED_URL)
     tz = pytz.timezone(faker.timezone())
     published = published or faker.date_time(tzinfo=tz)
     kwargs = {
         'content_type': 'html',
         'author': faker.name(),
         'url': url,
         'updated': faker.date_time_between(start_date=published, tzinfo=tz),
         'published': published
     }
     if summary:
         kwargs['summary'] = summary
     if enclosure:
         kwargs['links'] = [{
             'type': enclosure['type'],
             'href': enclosure['url'],
             'rel': 'enclosure',
             'length': faker.pyint(),
         }]
     feed.add(title, content, **kwargs)
     out = feed.to_string()
     if media_thumbnail:
         el = '<media:thumbnail url="{0}" />'.format(media_thumbnail)
         out = out.replace('<feed', '<feed xmlns:media="http://search.yahoo.com/mrss/"')
         out = out.replace('</entry>', '{0}</entry>'.format(el))
     return out

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import to_string [as 别名]
def build_feed():
    feed = AtomFeed(SITE_NAME,
                    feed_url=DOMAIN + 'rss.xml',
                    url=DOMAIN,
                    subtitle=SUBTITLE,
                    author=AUTHOR,
                    updated=datetime.datetime.now())

    entries = Entry.get_all_published()

    for _entry in entries:
        time = datetime.datetime.strptime(_entry['date'], '%Y-%m-%d %H:%M:%S')

        feed.add(unicode(_entry['title']),
                 unicode(markdown(_entry['content'])),
                 content_type='html',
                 author=AUTHOR,
                 published=time,
                 updated=time,
                 id=DOMAIN + _entry['slug'] + '/',
                 url=DOMAIN + 'posts/' +  _entry['slug'] + '/'
                 )

    with codecs.open('./ghpages/rss.xml', 'w', 'utf-8-sig') as f:
        f.write(feed.to_string())

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import to_string [as 别名]
    def build_artifact(self, artifact):
        ctx = get_ctx()
        feed_source = self.source
        page = feed_source.parent

        feed = AtomFeed(
            title=page.record_label + u' — Pallets Project',
            feed_url=url_to(feed_source, external=True),
            url=url_to('/blog', external=True),
            id=get_id(ctx.env.project.id)
        )

        for item in page.children.order_by(
            '-pub_date', '-pub_order', 'title'
        ).limit(10):
            item_author = item['author']

            feed.add(
                item['title'],
                text_type(item['body']),
                xml_base=url_to(item, external=True),
                url=url_to(item, external=True),
                content_type='html',
                id=get_id(u'%s/%s' % (
                    ctx.env.project.id,
                    item['_path'].encode('utf-8'))),
                author=item_author,
                updated=datetime(*item['pub_date'].timetuple()[:3]))

        with artifact.open('wb') as f:
            f.write(feed.to_string().encode('utf-8'))

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import to_string [as 别名]
    def build_artifact(self, artifact):
        ctx = get_ctx()
        feed_source = self.source
        blog = feed_source.parent

        summary = get(blog, feed_source.blog_summary_field) or ''
        subtitle_type = ('html' if hasattr(summary, '__html__') else 'text')
        blog_author = unicode(get(blog, feed_source.blog_author_field) or '')
        generator = ('Lektor Atom Plugin',
                     'https://github.com/ajdavis/lektor-atom',
                     pkg_resources.get_distribution('lektor-atom').version)

        project_id = ctx.env.load_config().base_url
        if not project_id:
            project_id = ctx.env.project.id
        feed = AtomFeed(
            title=feed_source.feed_name,
            subtitle=unicode(summary),
            subtitle_type=subtitle_type,
            author=blog_author,
            feed_url=url_to(feed_source, external=True),
            url=url_to(blog, external=True),
            id=get_id(project_id),
            generator=generator)

        if feed_source.items:
            # "feed_source.items" is a string like "site.query('/blog')".
            expr = Expression(ctx.env, feed_source.items)
            items = expr.evaluate(ctx.pad)
        else:
            items = blog.children

        if feed_source.item_model:
            items = items.filter(F._model == feed_source.item_model)

        order_by = '-' + feed_source.item_date_field
        items = items.order_by(order_by).limit(int(feed_source.limit))

        for item in items:
            item_author_field = feed_source.item_author_field
            item_author = get(item, item_author_field) or blog_author

            feed.add(
                get_item_title(item, feed_source.item_title_field),
                get_item_body(item, feed_source.item_body_field),
                xml_base=url_to(item, external=True),
                url=url_to(item, external=True),
                content_type='html',
                id=get_id(u'%s/%s' % (
                    project_id,
                    item['_path'].encode('utf-8'))),
                author=item_author,
                updated=get_item_updated(item, feed_source.item_date_field))

        with artifact.open('wb') as f:
            f.write(feed.to_string().encode('utf-8'))

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import to_string [as 别名]
def latest_posts():
	feed = AtomFeed('Libcoffee.net', feed_url=request.url, url=request.url_root)
	for p in Post.objects_published().order('-created_at')[:POSTS_PER_PAGE]:
		feed.add(p.title, unicode(p.__html__()),
				content_type='html',
				author=p.author.nickname(),
				url=p.absolute_url(external=True),
				updated=p.updated_at,
				published=p.created_at)
	return Response(feed.to_string(), mimetype='application/atom+xml')

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import to_string [as 别名]
def atom_feed():
    feed = AtomFeed(current_app.config.get('SITE_NAME', "My Site"),
                    feed_url=request.url, url=request.host_url,
                    subtitle=current_app.config.get('SITE_SUBTITLE', None))
    for post in posts:
        entry = _generate_entry(post)
        feed.add(entry)
    resp = make_response(feed.to_string())
    resp.mimetype = "application/atom+xml"
    return resp

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import to_string [as 别名]
def blog_feed():
    feed = AtomFeed('Recent Articles',
                    feed_url=request.url, url=request.url_root)
    posts = Blog.query.order_by(Blog.timestamp.desc()).all()
    for post in posts:
        feed.add(post.title, unicode(post.data),
                 content_type='html',
                 url=post.get_url(),
                 updated=post.timestamp)
    return Response(feed.to_string(), mimetype='text/xml')

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import to_string [as 别名]
def render_feed(ctx, posts):
    base_url = ctx.get('rootpath') + 'feed.xml'
    feed = AtomFeed("My Blog", feed_url=base_url,
                    url=ctx.get('rootpath'),
                    subtitle="My example blog for a feed test.")

    for post in posts[0:10]:
        feed.add(post.get('title'), post.html, content_type='html',
                 author=post.get('author', 'None'), url=base_url + post.url_path, id=base_url + post.url_path,
                 updated=post.get('date'), published=post.get('date'))

    return feed.to_string()

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import to_string [as 别名]
def download_atom():
    feed = AtomFeed(title='Mes bookmarks',
                    feed_url='xxx',
                    url='http://www.markme.com')

    for bookmark in mongo.db.bookmarks.find({'user._id': ObjectId(current_user.get_id())}):
        feed.add(id=bookmark['_id'], title=bookmark['title'], content=bookmark['description'],
                 content_type='text', updated=bookmark['published'],
                 links=[dict(href=bookmark['url']), dict(via=bookmark['referrer'])],
                 categories=[dict(term=tag, label=tag) for tag in bookmark['tags']],
                 author=dict(name=current_user.nickname, nickname=current_user.nickname, email=current_user.email))

    return send_file(StringIO(feed.to_string().encode('utf-8')), attachment_filename='bookmarks.xml', as_attachment=True, mimetype='application/atom+xml')

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import to_string [as 别名]
def atom_feed():
    feeds = current_app.config['FEEDS']

    feed = AtomFeed('The City of Myles', feed_url=request.url,
                    url=request.url_root)

    entries = get_feed_entries(feeds)[:20]

    for entry in entries:
        feed.add(entry.title, entry.description, context_type='html',
                 author=entry.publisher, url=entry.link,
                 published=entry.published, updated=entry.updated)

    return Response(feed.to_string(), mimetype="application/xml")