Django comes with a high-level syndication-feed-generating framework that makes creating RSS and Atom feeds easy. RSS and Atom are both XML-based formats you can use to provide automatically updating feeds of your site\u2019s content. Read more about RSS here, and get information on Atom here.<\/p>\n
To create any syndication feed, all you have to do is write a short Python class. You can create as many feeds as you want. Django also comes with a lower-level feed-generating API. Use this if you want to generate feeds outside of a Web context, or in some other lower-level way.<\/p>\n
The high-level feed-generating framework is supplied by the Feed class. To create a feed, write a Feed class and point to an instance of it in your URLconf.<\/p>\n
Feed Classes<\/strong> – A Feed class is a Python class that represents a syndication feed. A feed can be simple (e.g., a site news feed, or a basic feed displaying the latest entries of a blog) or more complex (e.g., a feed displaying all the blog entries in a particular category, where the category is variable). Feed classes subclass django.contrib.syndication.views.Feed. They can live anywhere in your codebase. Instances of Feed classes are views which can be used in your URLconf.<\/p>\n A Simple Example<\/strong> – This simple example, taken from a hypothetical police beat news site describes a feed of the latest five news items:<\/p>\n from django.contrib.syndication.views import Feed class LatestEntriesFeed(Feed): def items(self): def item_title(self, item): def item_description(self, item): # item_link is only needed if NewsItem has no get_absolute_url method. To connect a URL to this feed, put an instance of the Feed object in your URLconf. For example:<\/p>\n from django.conf.urls import url urlpatterns = [ Note:<\/p>\n One thing is left to do. In an RSS feed, each <item> has a <title>, <link> and <description>. We need to tell the framework what data to put into those elements.<\/p>\n For the contents of <title> and <description>, Django tries calling the methods item_title() and item_description() on the Feed class. They are passed a single parameter, item, which is the object itself. These are optional; by default, the unicode representation of the object is used for both.<\/p>\n If you want to do any special formatting for either the title or description, Django templates can be used instead. Their paths can be specified with the title_template and description_template attributes on the Feed class. The templates are rendered for each item and are passed two template context variables:<\/p>\n See \u201ca complex example\u201d below that uses a description template. from mysite.models import Article class ArticlesFeed(Feed): def items(self): def get_context_data(self, **kwargs): And the template:<\/p>\n Something about {{ foo }}: {{ obj.description }}<\/p>\n The behavior of get_context_data() mimics that of generic views \u2013 you\u2019re supposed to call super() to retrieve context data from the parent class, add your data and return the modified dictionary.<\/p>\n To specify the contents of <link>, you have two options. For each item in items(), Django first tries calling the item_link() method on the Feed class. In a similar way to the title and description, it\u2019s passed a single parameter \u2013 item. If that method doesn\u2019t exist, Django tries executing a get_absolute_url() method on that object.<\/p>\n Both get_absolute_url() and item_link() should return the item\u2019s URL as a normal Python string. As with get_absolute_url(), the result of item_link() will be included directly in the URL, so you are responsible for doing all necessary URL quoting and conversion to ASCII inside the method itself.<\/p>\n A Complex Example<\/strong> – The framework also supports more complex feeds, via arguments. For example, a website could offer an RSS feed of recent crimes for every police beat in a city. It\u2019d be silly to create a separate Feed class for each police beat; that would violate the DRY principle and would couple data to programming logic.<\/p>\n Instead, the syndication framework lets you access the arguments passed from your URLconf so feeds can output items based on information in the feed\u2019s URL. The police beat feeds could be accessible via URLs like this:<\/p>\n These can be matched with a URLconf line such as:<\/p>\n url(r’^beats\/(?P[0-9]+)\/rss\/$’, BeatFeed()),<\/p>\n Like a view, the arguments in the URL are passed to the get_object() method along with the request object. Here\u2019s the code for these beat-specific feeds:<\/p>\n from django.contrib.syndication.views import FeedDoesNotExist class BeatFeed(Feed): def get_object(self, request, beat_id): def title(self, obj): def link(self, obj): def description(self, obj): def items(self, obj): To generate the feed\u2019s <title>, <link> and <description>, Django uses the title(), link() and description() methods.<\/p>\n In the previous example, they were simple string class attributes, but this example illustrates that they can be either strings or methods. For each of title, link and description, Django follows this algorithm:<\/p>\n Also note that items() also follows the same algorithm \u2013 first, it tries items(obj), then items(), then finally an items class attribute (which should be a list). We are using a template for the item descriptions. It can be very simple:<\/p>\n {{ obj.description }}<\/p>\n However, you are free to add formatting as desired. The ExampleFeed class below gives full documentation on methods and attributes of Feed classes.<\/p>\n Specifying the Type of Feed – By default, feeds produced in this framework use RSS 2.0. To change that, add a feed_type attribute to your Feed class, like so:<\/p>\n from django.utils.feedgenerator import Atom1Feed<\/p>\n class MyFeed(Feed): Note that you set feed_type to a class object, not an instance. Currently available feed types are:<\/p>\n django.utils.feedgenerator.Rss201rev2Feed (RSS 2.01. Default.) Enclosures<\/strong> – To specify enclosures, such as those used in creating podcast feeds, use the item_enclosure_url, item_enclosure_length and item_enclosure_mime_type hooks.<\/p>\n Language<\/strong> – Feeds created by the syndication framework automatically include the appropriate <language> tag (RSS 2.0) or xml:lang attribute (Atom). This comes directly from your LANGUAGE_CODE setting.<\/p>\n urls<\/strong> – The link method\/attribute can return either an absolute path (e.g. \/blog\/) or a URL with the fully-qualified domain and protocol (e.g. http:\/\/www.example.com\/blog\/). If link doesn\u2019t return the domain, the syndication framework will insert the domain of the current site, according to your SITE_ID setting. Atom feeds require a <link rel=”self”> that defines the feed\u2019s current location. The syndication framework populates this automatically, using the domain of the current site according to the SITE_ID setting.<\/p>\n Publishing Atom and RSS Feeds in Tandem – Some developers like to make available both Atom and RSS versions of their feeds. That\u2019s easy to do with Django: Just create a subclass of your Feed class and set the feed_type to something different. Then update your URLconf to add the extra versions. Here\u2019s a full example:<\/p>\n from django.contrib.syndication.views import Feed class RssSiteNewsFeed(Feed): def items(self): class AtomSiteNewsFeed(RssSiteNewsFeed): In this example, the RSS feed uses a description while the Atom feed uses a subtitle. That\u2019s because Atom feeds don\u2019t provide for a feed-level description, but they do provide for a subtitle. If you provide a description in your Feed class, Django will not automatically put that into the subtitle element, because a subtitle and description are not necessarily the same thing. Instead, you should define a subtitle attribute.<\/p>\n In the above example, we simply set the Atom feed\u2019s subtitle to the RSS feed\u2019s description, because it\u2019s quite short already. And the accompanying URLconf:<\/p>\n from django.conf.urls import url urlpatterns = [ Behind the scenes, the high-level RSS framework uses a lower-level framework for generating feeds\u2019 XML. This framework lives in a single module: django\/utils\/feedgenerator.py. You use this framework on your own, for lower-level feed generation. You can also create custom feed generator subclasses for use with the feed_type Feed option.<\/p>\n SyndicationFeed classes<\/strong> – The feedgenerator module contains a base class:<\/p>\n Each of these three classes knows how to render a certain type of feed as XML. They share this interface: There\u2019s also a bunch of other optional keywords:<\/p>\n Any extra keyword arguments you pass to __init__ will be stored in self.feed for use with custom feed generators. All parameters should be Unicode objects, except categories, which should be a sequence of Unicode objects.<\/p>\n SyndicationFeed.add_item()<\/strong> – Add an item to the feed with the given parameters.<\/p>\n Required keyword arguments are:<\/p>\n Optional keyword arguments are:<\/p>\n SyndicationFeed.write()<\/strong> – Outputs the feed in the given encoding to outfile, which is a file-like object.<\/p>\n SyndicationFeed.writeString()<\/strong> – Returns the feed as a string in the given encoding. For example, to create an Atom 1.0 feed and print it to standard output:<\/p>\n >> from django.utils import feedgenerator If you need to produce a custom feed format, you\u2019ve got a couple of options. If the feed format is totally custom, you\u2019ll want to subclass SyndicationFeed and completely replace the write() and writeString() methods. However, if the feed format is a spin-off of RSS or Atom (i.e. GeoRSS, Apple\u2019s iTunes podcast format etc.), you\u2019ve got a better choice.<\/p>\n These types of feeds typically add extra elements and\/or attributes to the underlying format, and there are a set of methods that SyndicationFeed calls to get these extra attributes. Thus, you can subclass the appropriate feed generator class (Atom1Feed or Rss201rev2Feed) and extend these call-backs. They are:<\/p>\n SyndicationFeed.root_attributes(self, )<\/strong> – Return a dict of attributes to add to the root feed element (feed\/channel).<\/p>\n SyndicationFeed.add_root_elements(self, handler)<\/strong> – Callback to add elements inside the root feed element (feed\/channel). handler is an XMLGenerator from Python\u2019s built-in SAX library; you\u2019ll call methods on it to add to the XML document in process.<\/p>\n
\nfrom django.core.urlresolvers import reverse
\nfrom policebeat.models import NewsItem<\/p>\n
\ntitle = “Police beat site news”
\nlink = “\/sitenews\/”
\ndescription = “Updates on changes and additions to police beat central.”<\/p>\n
\nreturn NewsItem.objects.order_by(‘-pub_date’)[:5]\n
\nreturn item.title<\/p>\n
\nreturn item.description<\/p>\n
\ndef item_link(self, item):
\nreturn reverse(‘news-item’, args=[item.pk])<\/p>\n
\nfrom myproject.feeds import LatestEntriesFeed<\/p>\n
\n# …
\nurl(r’^latest\/feed\/$’, LatestEntriesFeed()),
\n# …
\n]\n\n
\n
\nThere is also a way to pass additional information to title and description templates, if you need to supply more than the two variables mentioned before. You can provide your implementation of get_context_data method in your Feed subclass. For example:<\/p>\n
\nfrom django.contrib.syndication.views import Feed<\/p>\n
\ntitle = “My articles”
\ndescription_template = “feeds\/articles.html”<\/p>\n
\nreturn Article.objects.order_by(‘-pub_date’)[:5]\n
\ncontext = super(ArticlesFeed, self).get_context_data(**kwargs)
\ncontext[‘foo’] = ‘bar’
\nreturn context<\/p>\n\n
\nitem: the current item. For backward compatibility reasons, the name of this context variable is {{ obj }}.<\/li>\n\n
\nfrom django.shortcuts import get_object_or_404<\/p>\n
\ndescription_template = ‘feeds\/beat_description.html’<\/p>\n
\nreturn get_object_or_404(Beat, pk=beat_id)<\/p>\n
\nreturn “Police beat central: Crimes for beat %s” % obj.beat<\/p>\n
\nreturn obj.get_absolute_url()<\/p>\n
\nreturn “Crimes recently reported in police beat %s” % obj.beat<\/p>\n
\nreturn Crime.objects.filter(beat=obj).order_by(‘-crime_date’)[:30]\n\n
\nfeed_type = Atom1Feed<\/p>\n
\ndjango.utils.feedgenerator.RssUserland091Feed (RSS 0.91.)
\ndjango.utils.feedgenerator.Atom1Feed (Atom 1.0.)<\/p>\n
\nfrom policebeat.models import NewsItem
\nfrom django.utils.feedgenerator import Atom1Feed<\/p>\n
\ntitle = “Police beat site news”
\nlink = “\/sitenews\/”
\ndescription = “Updates on changes and additions to police beat central.”<\/p>\n
\nreturn NewsItem.objects.order_by(‘-pub_date’)[:5]\n
\nfeed_type = Atom1Feed
\nsubtitle = RssSiteNewsFeed.description<\/p>\n
\nfrom myproject.feeds import RssSiteNewsFeed, AtomSiteNewsFeed<\/p>\n
\n# …
\nurl(r’^sitenews\/rss\/$’, RssSiteNewsFeed()),
\nurl(r’^sitenews\/atom\/$’, AtomSiteNewsFeed()),
\n# …
\n]\nThe Low-Level Framework<\/h3>\n
\n
\nSyndicationFeed.init() – Initialize the feed with the given dictionary of metadata, which applies to the entire feed. Required keyword arguments are:<\/p>\n\n
\n
\n
\n
\nExtra keyword arguments will be stored for custom feed generators. All parameters, if given, should be Unicode objects, except:<\/li>\n
\n>>> from datetime import datetime
\n>>> f = feedgenerator.Atom1Feed(
\n… title=”My Weblog”,
\n… link=”http:\/\/www.example.com\/”,
\n… description=”In which I write about what I ate today.”,
\n… language=”en”,
\n… author_name=”Myself”,
\n… feed_url=”http:\/\/example.com\/atom.xml”)
\n>>> f.add_item(title=”Hot dog today”,
\n… link=”http:\/\/www.example.com\/entries\/1\/”,
\n… pubdate=datetime.now(),
\n… description=”<p>Today I had a Vienna Beef hot dog. It was pink, plump and per\\
\nfect.<\/p>”)
\n>>> print(f.writeString(‘UTF-8’))
\n<?xml version=”1.0″ encoding=”UTF-8″?>
\n<feed xmlns=”http:\/\/www.w3.org\/2005\/Atom” xml:lang=”en”>
\n…
\n<\/feed><\/p><\/blockquote>\nCustom feed generators<\/h3>\n