Django comes with a high-level sitemap-generating framework that makes\ncreating sitemap XML files easy.
\nA sitemap is an XML file on your website that tells search-engine indexers how\nfrequently your pages change and how «important» certain pages are in relation\nto other pages on your site. This information helps search engines index your\nsite.
\nThe Django sitemap framework automates the creation of this XML file by letting\nyou express this information in Python code.
\nIt works much like Django’s syndication framework. To create a sitemap, just write a\nSitemap class and point to it in your\nURLconf.
To install the sitemap app, follow these steps:
\nAdd 'django.contrib.sitemaps' to your INSTALLED_APPS\nsetting.
Make sure your TEMPLATES setting contains a DjangoTemplates\nbackend whose APP_DIRS options is set to True. It’s in there by\ndefault, so you’ll only need to change this if you’ve changed that setting.
Make sure you’ve installed the\nsites framework.
(Note: The sitemap application doesn’t install any database tables. The only\nreason it needs to go into INSTALLED_APPS is so that the\nLoader() template\nloader can find the default templates.)
To activate sitemap generation on your Django site, add this line to your\nURLconf:
\nfrom django.contrib.sitemaps.views import sitemap\n\nurl(r'^sitemap\\.xml$', sitemap, {'sitemaps': sitemaps},\n name='django.contrib.sitemaps.views.sitemap')\nThis tells Django to build a sitemap when a client accesses /sitemap.xml.
The name of the sitemap file is not important, but the location is. Search\nengines will only index links in your sitemap for the current URL level and\nbelow. For instance, if sitemap.xml lives in your root directory, it may\nreference any URL in your site. However, if your sitemap lives at\n/content/sitemap.xml, it may only reference URLs that begin with\n/content/.
The sitemap view takes an extra, required argument: {'sitemaps': sitemaps}.\nsitemaps should be a dictionary that maps a short section label (e.g.,\nblog or news) to its Sitemap class\n(e.g., BlogSitemap or NewsSitemap). It may also map to an instance of\na Sitemap class (e.g.,\nBlogSitemap(some_var)).
Sitemap classesLink to this heading#A Sitemap class is a simple Python\nclass that represents a «section» of entries in your sitemap. For example,\none Sitemap class could represent\nall the entries of your Weblog, while another could represent all of the\nevents in your events calendar.
In the simplest case, all these sections get lumped together into one\nsitemap.xml, but it’s also possible to use the framework to generate a\nsitemap index that references individual sitemap files, one per section. (See\nCreating a sitemap index below.)
Sitemap classes must subclass\ndjango.contrib.sitemaps.Sitemap. They can live anywhere in your codebase.
Let’s assume you have a blog system, with an Entry model, and you want your\nsitemap to include all the links to your individual blog entries. Here’s how\nyour sitemap class might look:
from django.contrib.sitemaps import Sitemap\nfrom blog.models import Entry\n\nclass BlogSitemap(Sitemap):\n changefreq = "never"\n priority = 0.5\n\n def items(self):\n return Entry.objects.filter(is_draft=False)\n\n def lastmod(self, obj):\n return obj.pub_date\nNote:
\nchangefreq and priority are class\nattributes corresponding to <changefreq> and <priority> elements,\nrespectively. They can be made callable as functions, as\nlastmod was in the example.
items() is simply a method that returns a list of\nobjects. The objects returned will get passed to any callable methods\ncorresponding to a sitemap property (location,\nlastmod, changefreq, and\npriority).
There is no location method in this example, but you\ncan provide it in order to specify the URL for your object. By default,\nlocation() calls get_absolute_url() on each object\nand returns the result.
Sitemap class referenceLink to this heading#A Sitemap class can define the following methods/attributes:
Required. A method that returns a list of objects. The framework\ndoesn’t care what type of objects they are; all that matters is that\nthese objects get passed to the location(),\nlastmod(), changefreq() and\npriority() methods.
Optional. Either a method or attribute.
\nIf it’s a method, it should return the absolute path for a given object\nas returned by items().
If it’s an attribute, its value should be a string representing an\nabsolute path to use for every object returned by\nitems().
In both cases, «absolute path» means a URL that doesn’t include the\nprotocol or domain. Examples:
\nGood: '/foo/bar/'
Bad: 'example.com/foo/bar/'
Bad: 'https://example.com/foo/bar/'
If location isn’t provided, the framework will call\nthe get_absolute_url() method on each object as returned by\nitems().
To specify a protocol other than 'http', use\nprotocol.
Optional. Either a method or attribute.
\nIf it’s a method, it should take one argument – an object as returned\nby items() – and return that object’s last-modified\ndate/time as a datetime.
If it’s an attribute, its value should be a datetime\nrepresenting the last-modified date/time for every object returned by\nitems().
If all items in a sitemap have a lastmod, the sitemap\ngenerated by views.sitemap() will have a Last-Modified\nheader equal to the latest lastmod. You can activate the\nConditionalGetMiddleware to make\nDjango respond appropriately to requests with an If-Modified-Since\nheader which will prevent sending the sitemap if it hasn’t changed.
Optional. Either a method or attribute.
\nIf it’s a method, it should take one argument – an object as returned\nby items() – and return that object’s change\nfrequency as a string.
If it’s an attribute, its value should be a string representing the\nchange frequency of every object returned by items().
Possible values for changefreq, whether you use a\nmethod or attribute, are:
'always'
'hourly'
'daily'
'weekly'
'monthly'
'yearly'
'never'
Optional. Either a method or attribute.
\nIf it’s a method, it should take one argument – an object as returned\nby items() – and return that object’s priority as\neither a string or float.
If it’s an attribute, its value should be either a string or float\nrepresenting the priority of every object returned by\nitems().
Example values for priority: 0.4, 1.0. The\ndefault priority of a page is 0.5. See the sitemaps.org\ndocumentation for more.
Optional.
\nThis attribute defines the protocol ('http' or 'https') of the\nURLs in the sitemap. If it isn’t set, the protocol with which the\nsitemap was requested is used. If the sitemap is built outside the\ncontext of a request, the default is 'http'.
Optional.
\nThis attribute defines the maximum number of URLs included on each page\nof the sitemap. Its value should not exceed the default value of\n50000, which is the upper limit allowed in the Sitemaps protocol.
Optional.
\nA boolean attribute that defines if the URLs of this sitemap should\nbe generated using all of your LANGUAGES. The default is\nFalse.
The sitemap framework provides a convenience class for a common case:
\nThe django.contrib.sitemaps.GenericSitemap class allows you to\ncreate a sitemap by passing it a dictionary which has to contain at least\na queryset entry. This queryset will be used to generate the items\nof the sitemap. It may also have a date_field entry that\nspecifies a date field for objects retrieved from the queryset.\nThis will be used for the lastmod attribute in the\ngenerated sitemap. You may also pass priority and\nchangefreq keyword arguments to the\nGenericSitemap constructor to specify\nthese attributes for all URLs.
Here’s an example of a URLconf using\nGenericSitemap:
from django.conf.urls import url\nfrom django.contrib.sitemaps import GenericSitemap\nfrom django.contrib.sitemaps.views import sitemap\nfrom blog.models import Entry\n\ninfo_dict = {\n 'queryset': Entry.objects.all(),\n 'date_field': 'pub_date',\n}\n\nurlpatterns = [\n # some generic view using info_dict\n # ...\n\n # the sitemap\n url(r'^sitemap\\.xml$', sitemap,\n {'sitemaps': {'blog': GenericSitemap(info_dict, priority=0.6)}},\n name='django.contrib.sitemaps.views.sitemap'),\n]\nOften you want the search engine crawlers to index views which are neither\nobject detail pages nor flatpages. The solution is to explicitly list URL\nnames for these views in items and call reverse() in\nthe location method of the sitemap. For example:
# sitemaps.py\nfrom django.contrib import sitemaps\nfrom django.urls import reverse\n\nclass StaticViewSitemap(sitemaps.Sitemap):\n priority = 0.5\n changefreq = 'daily'\n\n def items(self):\n return ['main', 'about', 'license']\n\n def location(self, item):\n return reverse(item)\n\n# urls.py\nfrom django.conf.urls import url\nfrom django.contrib.sitemaps.views import sitemap\n\nfrom .sitemaps import StaticViewSitemap\nfrom . import views\n\nsitemaps = {\n 'static': StaticViewSitemap,\n}\n\nurlpatterns = [\n url(r'^$', views.main, name='main'),\n url(r'^about/$', views.about, name='about'),\n url(r'^license/$', views.license, name='license'),\n # ...\n url(r'^sitemap\\.xml$', sitemap, {'sitemaps': sitemaps},\n name='django.contrib.sitemaps.views.sitemap')\n]\nThe sitemap framework also has the ability to create a sitemap index that\nreferences individual sitemap files, one per each section defined in your\nsitemaps dictionary. The only differences in usage are:
You use two views in your URLconf: django.contrib.sitemaps.views.index()\nand django.contrib.sitemaps.views.sitemap().
The django.contrib.sitemaps.views.sitemap() view should take a\nsection keyword argument.
Here’s what the relevant URLconf lines would look like for the example above:
\nfrom django.contrib.sitemaps import views\n\nurlpatterns = [\n url(r'^sitemap\\.xml$', views.index, {'sitemaps': sitemaps}),\n url(r'^sitemap-(?P<section>.+)\\.xml$', views.sitemap, {'sitemaps': sitemaps},\n name='django.contrib.sitemaps.views.sitemap'),\n]\nThis will automatically generate a sitemap.xml file that references\nboth sitemap-flatpages.xml and sitemap-blog.xml. The\nSitemap classes and the sitemaps\ndict don’t change at all.
You should create an index file if one of your sitemaps has more than 50,000\nURLs. In this case, Django will automatically paginate the sitemap, and the\nindex will reflect that.
\nIf you’re not using the vanilla sitemap view – for example, if it’s wrapped\nwith a caching decorator – you must name your sitemap view and pass\nsitemap_url_name to the index view:
from django.contrib.sitemaps import views as sitemaps_views\nfrom django.views.decorators.cache import cache_page\n\nurlpatterns = [\n url(r'^sitemap\\.xml$',\n cache_page(86400)(sitemaps_views.index),\n {'sitemaps': sitemaps, 'sitemap_url_name': 'sitemaps'}),\n url(r'^sitemap-(?P<section>.+)\\.xml$',\n cache_page(86400)(sitemaps_views.sitemap),\n {'sitemaps': sitemaps}, name='sitemaps'),\n]\nIf you wish to use a different template for each sitemap or sitemap index\navailable on your site, you may specify it by passing a template_name\nparameter to the sitemap and index views via the URLconf:
from django.contrib.sitemaps import views\n\nurlpatterns = [\n url(r'^custom-sitemap\\.xml$', views.index, {\n 'sitemaps': sitemaps,\n 'template_name': 'custom_sitemap.html'\n }),\n url(r'^custom-sitemap-(?P<section>.+)\\.xml$', views.sitemap, {\n 'sitemaps': sitemaps,\n 'template_name': 'custom_sitemap.html'\n }, name='django.contrib.sitemaps.views.sitemap'),\n]\nThese views return TemplateResponse\ninstances which allow you to easily customize the response data before\nrendering. For more details, see the TemplateResponse documentation.
When customizing the templates for the\nindex() and\nsitemap() views, you can rely on the\nfollowing context variables.
The variable sitemaps is a list of absolute URLs to each of the sitemaps.
The variable urlset is a list of URLs that should appear in the\nsitemap. Each URL exposes attributes as defined in the\nSitemap class:
changefreq
item
lastmod
location
priority
The item attribute has been added for each URL to allow more flexible\ncustomization of the templates, such as Google news sitemaps. Assuming\nSitemap’s items() would return a list of items with\npublication_data and a tags field something like this would\ngenerate a Google News compatible sitemap:
<?xml version="1.0" encoding="UTF-8"?>\n<urlset\n xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"\n xmlns:news="http://www.google.com/schemas/sitemap-news/0.9">\n{% spaceless %}\n{% for url in urlset %}\n <url>\n <loc>{{ url.location }}</loc>\n {% if url.lastmod %}<lastmod>{{ url.lastmod|date:"Y-m-d" }}</lastmod>{% endif %}\n {% if url.changefreq %}<changefreq>{{ url.changefreq }}</changefreq>{% endif %}\n {% if url.priority %}<priority>{{ url.priority }}</priority>{% endif %}\n <news:news>\n {% if url.item.publication_date %}<news:publication_date>{{ url.item.publication_date|date:"Y-m-d" }}</news:publication_date>{% endif %}\n {% if url.item.tags %}<news:keywords>{{ url.item.tags }}</news:keywords>{% endif %}\n </news:news>\n </url>\n{% endfor %}\n{% endspaceless %}\n</urlset>\nYou may want to «ping» Google when your sitemap changes, to let it know to\nreindex your site. The sitemaps framework provides a function to do just\nthat: django.contrib.sitemaps.ping_google().
ping_google() takes an optional argument, sitemap_url,\nwhich should be the absolute path to your site’s sitemap (e.g.,\n'/sitemap.xml'). If this argument isn’t provided,\nping_google() will attempt to figure out your\nsitemap by performing a reverse looking in your URLconf.
ping_google() raises the exception\ndjango.contrib.sitemaps.SitemapNotFound if it cannot determine your\nsitemap URL.
One useful way to call ping_google() is from a model’s save()\nmethod:
from django.contrib.sitemaps import ping_google\n\nclass Entry(models.Model):\n # ...\n def save(self, force_insert=False, force_update=False):\n super(Entry, self).save(force_insert, force_update)\n try:\n ping_google()\n except Exception:\n # Bare 'except' because we could get a variety\n # of HTTP-related exceptions.\n pass\nA more efficient solution, however, would be to call ping_google() from a\ncron script, or some other scheduled task. The function makes an HTTP request\nto Google’s servers, so you may not want to introduce that network overhead\neach time you call save().
manage.pyLink to this heading#Once the sitemaps application is added to your project, you may also\nping Google using the ping_google management command:
python manage.py ping_google [/sitemap.xml]\n